// FICHIER : Loi_iso_elas.cp
// CLASSE : Loi_iso_elas


// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL  : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.



# include <iostream>
using namespace std;  //introduces namespace std
#include <math.h>
#include <stdlib.h>
#include "Sortie.h"
#include "TypeConsTens.h"
#include "ConstMath.h"
#include "CharUtil.h"

#include "Loi_iso_elas2D_D.h"

#include "Enum_TypeQuelconque.h"
#include "TypeQuelconqueParticulier.h"


// mise à jour de la liste des grandeurs quelconques internes
void Loi_iso_elas2D_D::SaveResulLoi_iso_elas2D_D::Mise_a_jour_map_type_quelconque()
 { map <  EnumTypeQuelconque , TypeQuelconque, std::less < EnumTypeQuelconque> >::iterator il
      ,ilfin=map_type_quelconque.end();
   for (il=map_type_quelconque.begin();il != ilfin;il++)
     {EnumTypeQuelconque enu = (*il).first;
       switch (enu)
        {case E_YOUNG:
          { Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                   map_type_quelconque[E_YOUNG].Grandeur_pointee());
            *(tyTQ.ConteneurDouble()) = E;
            break;
          };
         case NU_YOUNG:
          { Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                         map_type_quelconque[NU_YOUNG].Grandeur_pointee());
            *(tyTQ.ConteneurDouble()) = nu;
            break;
          };
         default: break; // sinon rien
        };
      }
 };

// ========== fin des fonctions pour la classe de sauvegarde des résultats =========

Loi_iso_elas2D_D::Loi_iso_elas2D_D () :  // Constructeur par defaut
  Loi_comp_abstraite(ISOELAS2D_D,CAT_MECANIQUE,2),E(-ConstMath::trespetit),nu(-2.*ConstMath::trespetit)
  ,E_temperature(NULL),cas_calcul(0),E_nD(NULL),nu_nD(NULL)
    {// --- on remplit avec les grandeurs succeptible d'être utilisées
     // acces à listdeTouslesQuelc_dispo_localement
     list <EnumTypeQuelconque >& list_tousQuelc =  ListdeTouslesQuelc_dispo_localement();
     list_tousQuelc.push_back(E_YOUNG);
     list_tousQuelc.push_back(NU_YOUNG);
     // on supprime les doublons localement
     list_tousQuelc.sort(); // on ordonne la liste
     list_tousQuelc.unique(); // suppression des doublons
    };

		// Contructeur fonction du E et du nu
Loi_iso_elas2D_D::Loi_iso_elas2D_D(const double& EE,const double& nunu):
	  Loi_comp_abstraite(ISOELAS2D_D,CAT_THERMO_MECANIQUE,2),E(EE),nu(nunu)
   ,E_temperature(NULL),cas_calcul(0),E_nD(NULL),nu_nD(NULL)
   {// --- on remplit avec les grandeurs succeptible d'être utilisées
    // acces à listdeTouslesQuelc_dispo_localement
    list <EnumTypeQuelconque >& list_tousQuelc =  ListdeTouslesQuelc_dispo_localement();
    list_tousQuelc.push_back(E_YOUNG);
    list_tousQuelc.push_back(NU_YOUNG);
    // on supprime les doublons localement
    list_tousQuelc.sort(); // on ordonne la liste
    list_tousQuelc.unique(); // suppression des doublons
   };

// Constructeur de copie
Loi_iso_elas2D_D::Loi_iso_elas2D_D (const Loi_iso_elas2D_D& loi) :
   Loi_comp_abstraite(loi),E(loi.E),nu(loi.nu)
	,E_temperature(loi.E_temperature)
 ,E_nD(loi.E_nD),nu_nD(loi.nu_nD)
	,cas_calcul(loi.cas_calcul)
	 {// on regarde s'il s'agit d'une courbe locale ou d'une courbe globale
	  if (E_temperature != NULL)
	   if (E_temperature->NomCourbe() == "_")
        {// comme il s'agit d'une courbe locale on la redéfinie (sinon pb lors du destructeur de loi)
         string non_courbe("_");   
         E_temperature = Courbe1D::New_Courbe1D(*loi.E_temperature);
        };
    // idem pour les fonctions nD
    if (E_nD != NULL)
     if (E_nD->NomFonction() == "_")
         {// comme il s'agit d'une fonction locale on la redéfinie (sinon pb lors du destructeur de loi)
          string non_courbe("_");
          E_nD = Fonction_nD::New_Fonction_nD(*loi.E_nD);
         };
    if (nu_nD != NULL)
     if (nu_nD->NomFonction() == "_")
         {// comme il s'agit d'une fonction locale on la redéfinie (sinon pb lors du destructeur de loi)
          string non_courbe("_");
          nu_nD = Fonction_nD::New_Fonction_nD(*loi.nu_nD);
         };
    // --- on remplit avec les grandeurs succeptible d'être utilisées
    // acces à listdeTouslesQuelc_dispo_localement
    list <EnumTypeQuelconque >& list_tousQuelc =  ListdeTouslesQuelc_dispo_localement();
    list_tousQuelc.push_back(E_YOUNG);
    list_tousQuelc.push_back(NU_YOUNG);
    // on supprime les doublons localement
    list_tousQuelc.sort(); // on ordonne la liste
    list_tousQuelc.unique(); // suppression des doublons
   };

Loi_iso_elas2D_D::~Loi_iso_elas2D_D ()
  // Destructeur
  { if (E_temperature != NULL)
      if (E_temperature->NomCourbe() == "_") delete E_temperature;
     if (E_nD != NULL)
         if (E_nD->NomFonction() == "_") delete E_nD;
     if (nu_nD != NULL)
         if (nu_nD->NomFonction() == "_") delete nu_nD;
   };


// Lecture des donnees de la classe sur fichier
void Loi_iso_elas2D_D::LectureDonneesParticulieres (UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D
                                             ,LesFonctions_nD& lesFonctionsnD)
  { // on regarde si le module d'young est thermo dépendant
    string nom_class_methode("Loi_iso_elas2D_D::LectureDonneesParticulieres");
    if(strstr(entreePrinc->tablcar,"thermo_dependant_")!=0)
     { string nom; thermo_dependant=true;
       *(entreePrinc->entree) >> nom;
       if (nom != "thermo_dependant_") 
         { cout << "\n erreur en lecture de la thermodependance, on aurait du lire le mot cle thermo_dependant_"
                << " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
           entreePrinc->MessageBuffer("**erreur**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
          }
       // lecture de la loi d'évolution du module d'young en fonction de la température
       *(entreePrinc->entree) >>  nom;    
       // on regarde si la courbe existe, si oui on récupère la référence 
       if (lesCourbes1D.Existe(nom)) 
         { E_temperature = lesCourbes1D.Trouve(nom);
          }
       else
        { // sinon il faut la lire maintenant
          string non_courbe("_");   
          E_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
          // lecture de la courbe
          E_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
         } 
      }
    // sinon on regarde si le module d'young dépend d'une fonction nD
    else if(strstr(entreePrinc->tablcar,"E_fonction_nD:")!=0)
     { string nom;
       string mot_cle1="E=";
       string mot_cle2="E_fonction_nD:";

       // on passe le mot clé générique
       bool lec = entreePrinc->Lecture_et_verif_mot_cle(nom_class_methode,mot_cle1);
       // on lit le nom de la fonction
       string nom_fonct;
       lec = lec && entreePrinc->Lecture_mot_cle_et_string(nom_class_methode,mot_cle2,nom_fonct);
       if (!lec )
          { entreePrinc->MessageBuffer("**erreur02 en lecture**  "+mot_cle2);
            throw (UtilLecture::ErrNouvelleDonnee(-1));
            Sortie(1);
          };
       // maintenant on définit la fonction
       if (lesFonctionsnD.Existe(nom_fonct))
         {E_nD = lesFonctionsnD.Trouve(nom_fonct);
         }
       else
         {// sinon il faut la lire maintenant
          string non("_");
          E_nD = Fonction_nD::New_Fonction_nD(non, Id_Nom_Fonction_nD(nom_fonct));
          // lecture de la courbe
          E_nD->LectDonnParticulieres_Fonction_nD (non,entreePrinc);
          // maintenant on vérifie que la fonction est utilisable
          if (E_nD->NbComposante() != 1 )
           { cout << "\n erreur en lecture, la fonction " << nom_fonct
                  << " est une fonction vectorielle a   " << E_nD->NbComposante()
                  << " composante alors qu'elle devrait etre scalaire ! "
                  << " elle n'est donc pas utilisable !! ";
             string message("\n**erreur03** \n"+nom_class_methode+"(...");
             entreePrinc->MessageBuffer(message);
             throw (UtilLecture::ErrNouvelleDonnee(-1));
             Sortie(1);
           };
         };
       // on regarde si la fonction nD intègre la température
       const Tableau <Ddl_enum_etendu>& tab_enu = E_nD->Tab_enu_etendu();
       if (tab_enu.Contient(TEMP))
         thermo_dependant=true;
     }
    //  sinon si le module d'Young n'a pas été lue, on le récupère en version scalaire
    else
     { // lecture du module d'young 
       *(entreePrinc->entree) >> E ;
      }; 

    // lecture du coefficient de poisson
    // on regarde si le coefficient de poisson dépend d'une fonction nD
    if(strstr(entreePrinc->tablcar,"nu_fonction_nD:")!=0)
     { string nom;
       string mot_cle1="nu=";
       string mot_cle2="nu_fonction_nD:";

       // on passe le mot clé générique
       bool lec = entreePrinc->Lecture_et_verif_mot_cle(nom_class_methode,mot_cle1);
       // on lit le nom de la fonction
       string nom_fonct;
       lec = lec && entreePrinc->Lecture_mot_cle_et_string(nom_class_methode,mot_cle2,nom_fonct);
       if (!lec )
          { entreePrinc->MessageBuffer("**erreur04 en lecture**  "+mot_cle2);
            throw (UtilLecture::ErrNouvelleDonnee(-1));
            Sortie(1);
          };
        // maintenant on définit la fonction
        if (lesFonctionsnD.Existe(nom_fonct))
         {nu_nD = lesFonctionsnD.Trouve(nom_fonct);
         }
        else
         {// sinon il faut la lire maintenant
          string non("_");
          nu_nD = Fonction_nD::New_Fonction_nD(non, Id_Nom_Fonction_nD(nom_fonct));
          // lecture de la courbe
          nu_nD->LectDonnParticulieres_Fonction_nD (non,entreePrinc);
          // maintenant on vérifie que la fonction est utilisable
          if (nu_nD->NbComposante() != 1 )
           { cout << "\n erreur en lecture, la fonction " << nom_fonct
                  << " est une fonction vectorielle a   " << nu_nD->NbComposante()
                  << " composante alors qu'elle devrait etre scalaire ! "
                  << " elle n'est donc pas utilisable !! ";
             string message("\n**erreur05** \n"+nom_class_methode+"(...");
             entreePrinc->MessageBuffer(message);
             throw (UtilLecture::ErrNouvelleDonnee(-1));
             Sortie(1);
           };
         };
       // on regarde si la fonction nD intègre la température
       const Tableau <Ddl_enum_etendu>& tab_enu = nu_nD->Tab_enu_etendu();
       if (tab_enu.Contient(TEMP))
         thermo_dependant=true;
       }
    else // sinon on lit la valeur scalaire
     {*(entreePrinc->entree) >> nu;};

    // on regarde si le calcul est éventuellement uniquement déviatorique
    cas_calcul = 0;   // par défaut
    if (strstr(entreePrinc->tablcar,"seule_deviatorique")!=NULL)
                 {cas_calcul=1;};
    // idem pour la partie sphérique
    if (strstr(entreePrinc->tablcar,"seule_spherique")!=NULL)
       {if (cas_calcul == 1) {cas_calcul=0;} else {cas_calcul = 2;};};
	 
    // appel au niveau de la classe mère
    Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire
                 (*entreePrinc,lesFonctionsnD);

    };
// affichage de la loi
void Loi_iso_elas2D_D::Affiche() const 
  { if(thermo_dependant)
     { cout << "\n loi de comportement isoelastique 2D deformations planes  thermodependante"
            << " courbe E=f(T): " << E_temperature->NomCourbe() <<" ";
       if ( E_temperature->NomCourbe() == "_") E_temperature->Affiche(); 
      }
    else if (E_nD != NULL)
     {cout << "\n loi de comportement 2D deformations planes isoelastique avec E fonction nD:  ";
      cout << "E_fonction_nD:" << " ";
      if (E_nD->NomFonction() != "_")
           cout << E_nD->NomFonction();
      else
           E_nD->Affiche();
     }
    else
     { cout << " \n loi de comportement isoelastique 2D deformations planes" 
         << " E = " << E ;
      };   

   // puis le coefficient de Poisson
   if (nu_nD != NULL)
    {cout << ", nu_fonction_nD:" << " ";
     if (nu_nD->NomFonction() != "_")
          cout << nu_nD->NomFonction();
     else
          nu_nD->Affiche();
    }
   else
    { cout << " nu= " << nu ;
    };

    // indicateur de cas de calcul
    if (cas_calcul != 0)
    	{ if (cas_calcul == 1)
    	   {cout << " calcul uniquement deviatorique ";}
    	  else if (cas_calcul == 2)
    	   {cout << " calcul uniquement spherique ";}
    	  else
    	   {cout << " cas de calcul mal defini !! ";}; 
    	}
    cout << endl;
    // appel de la classe mère
    Loi_comp_abstraite::Affiche_don_classe_abstraite();
  };
            
// affichage et definition interactive des commandes particulières à chaques lois
void Loi_iso_elas2D_D::Info_commande_LoisDeComp(UtilLecture& entreePrinc)
 {  ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
	   cout << "\n definition standart (rep o) ou exemples exhaustifs (rep n'importe quoi) ? ";
	   string rep = "_";
    // procédure de lecture avec prise en charge d'un retour chariot
    rep = lect_return_defaut(true,"o");

    if (E == -ConstMath::trespetit) 
      { // on initialise à une valeur arbitraire
        E = 210000;}
    if (nu == -2.*ConstMath::trespetit) 
      { // on initialise à une valeur arbitraire
        nu = 0.3;}
    sort << "\n# .......  loi de comportement isoelastique 2D, deformation planes ........"
         << "\n#    module d'young :   coefficient de poisson "
         << "\n " << setprecision(6) << E << "  " << setprecision(6) << nu << endl;
	   if ((rep != "o") && (rep != "O" ) && (rep != "0") )
      { // cas d'une loi thermo dépendante
        sort << "\n# 1) ............  loi de comportement 2D, deformation planes themodependante........................."
         << "\n#:   definition de la courbe donnant l'evolution du module d'young en fonction de la temperature :"
         << "\n#:   suivi de la definition du coefficient de poisson (independant de la temperature)            :"
         << "\n#:...............................................................................................:"
         << "\n#      thermo_dependant_            courbe1   " << "  " << setprecision(6) << nu <<"\n" 
         << "\n#   NB: courbe1 est le nom d'une courbe deja defini, on peut egalement definir directement une"
         << "\n#   nouvelle courbe apres le mot cle thermo_dependant_ puis la courbe sans nom de reference   "
         << "\n#  2) .................. dependance a une fonction nD ......................"
         << "\n#  Le module d'Young et le coefficient de Poisson peuvent au choix dependre d'une fonction nD.  "
         << "\n#  Dans ce cas E ne doit pas avoir ete declare thermodependant, mais on peut inclure une"
         << "\n#  thermo-dependance dans la fonction nD, idem pour nu "
         << "\n#  Exemple pour E : "
         << "\n#  E= E_fonction_nD: fonction_1 "
         << "\n#  "
         << "\n#  Exemple pour nu : "
         << "\n#  nu= nu_fonction_nD: fonction_2 "
         << "\n#  "
         << "\n#  La declaration des fonctions suit la meme logique que pour les courbes 1D "
         << "\n#  "
         << "\n#  3) .................. partitionnement du tenseur des contraintes ......................"
         << "\n#   Il est possible  d'indiquer que l'on souhaite calculer seulement la partie spherique de la loi"
         << "\n#   pour cela on met le mot cle: seule_spherique a la fin des donnees sur la meme ligne   "
         << "\n#   D'une maniere identique il est possible d'indiquer que l'on souhaite calculer seulement la partie"
         << "\n#   la partie deviatorique de la loi, pour cela on met le mot cle: seule_deviatorique   "
         << endl;
       };
         
    // appel de la classe mère
    Loi_comp_abstraite::Info_commande_don_LoisDeComp(entreePrinc);     
  };  		  	  

// test si la loi est complete
int Loi_iso_elas2D_D::TestComplet()
    { int ret = LoiAbstraiteGeneral::TestComplet();
      if (!thermo_dependant)
       {if ((E == -ConstMath::trespetit) && (E_nD == NULL))
         { cout << " \n le module d'young n'est pas defini pour  la loi " << Nom_comp(id_comp)
                << '\n';
           ret = 0;
         };
        }
      else
       {if ((E_temperature == NULL) && (E_nD == NULL) && (nu_nD == NULL))
         { cout << "\n cas d'une loi thermo dependante, la courbe E=f(T) n'est pas defini !! "; ret = 0;};
        };   
      if ((nu == -2.*ConstMath::trespetit) && (nu_nD == NULL))
       { cout << " \n le coefficient de poisson n'est pas défini pour  la loi " << Nom_comp(id_comp)
              << '\n';
         ret = 0;
       };
      // test du cas de calcul
      if ((cas_calcul < 0) || (cas_calcul > 2)) 
      	{ cout << "\n l'indicateur de calcul cas_calcul= " << cas_calcul << " n'est pas correcte "
      	       << "\n ceci pour la Loi_iso_elas2D_D";
      	  Affiche();
      	  ret = 0;     
      	}
                
       return ret; 
    }; 

// récupération des grandeurs particulière (hors ddl )
// correspondant à liTQ
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
void Loi_iso_elas2D_D::Grandeur_particuliere
              (bool absolue, List_io<TypeQuelconque>& liTQ,Loi_comp_abstraite::SaveResul * saveDon,list<int>& decal) const
 { // tout d'abord on récupère le conteneur
   SaveResulLoi_iso_elas2D_D & save_resul = *((SaveResulLoi_iso_elas2D_D*) saveDon);
   // ici on est en 3D et les grandeurs sont par principe en absolue, donc la variable absolue ne sert pas
   // on passe en revue la liste
   List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end();
   list<int>::iterator idecal=decal.begin();
   for (itq=liTQ.begin();itq!=itqfin;itq++,idecal++)
     {TypeQuelconque& tipParticu = (*itq); // pour simplifier
      if (tipParticu.EnuTypeQuelconque().Nom_vide()) // veut dire que c'est un enum pur
       switch (tipParticu.EnuTypeQuelconque().EnumTQ())
       {  case E_YOUNG:
           // a) ----- cas du module d'Young actuelle
            { Tab_Grandeur_scalaire_double& tyTQ
                   = *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
              tyTQ(1+(*idecal))=save_resul.E;
              (*idecal)++; break;
            }
          case NU_YOUNG:
           // b) ----- cas du coef de Poisson actuel
            { Tab_Grandeur_scalaire_double& tyTQ
                  = *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
              tyTQ(1+(*idecal))=save_resul.nu;
              (*idecal)++; break;
            }
           // 1) -----cas du module de compressibilité dépendant de la température
           case MODULE_COMPRESSIBILITE:
            { Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
              tyTQ(1+(*idecal))=save_resul.E/(3.*(1.-2.*save_resul.nu));(*idecal)++;
              break;
            }
           case MODULE_CISAILLEMENT:
            { Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
              tyTQ(1+(*idecal))=save_resul.E/(2.*(1.+save_resul.nu));(*idecal)++;
              break;
            }

          default: ;// on ne fait rien
       };

     };
};

// récupération de la liste de tous les grandeurs particulières
// ces grandeurs sont ajoutées à la liste passées en paramètres
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
void Loi_iso_elas2D_D::ListeGrandeurs_particulieres(bool absolue,List_io<TypeQuelconque>& liTQ) const
 { // ici on est en 3D et les grandeurs sont par principe en absolue, donc la variable absolue ne sert pas
   Tableau <double> tab_1(1);
   Tab_Grandeur_scalaire_double grand_courant(tab_1);
   // def d'un type quelconque représentatif à chaque grandeur
   // a priori ces grandeurs sont défini aux points d'intégration identique à la contrainte par exemple
   // enu_ddl_type_pt est définit dans la loi Abtraite générale
   //on regarde si ce type d'info existe déjà: si oui on augmente la taille du tableau, si non on crée
   // a) $$$ cas du module d'Young actuelle
   {List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
    for (itq=liTQ.begin();itq!=itqfin;itq++)
      if ((*itq).EnuTypeQuelconque() == E_YOUNG)
       { Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
         int taille = tyTQ.Taille()+1;
         tyTQ.Change_taille(taille); nexistePas = false;
       };
    if (nexistePas)
      {TypeQuelconque typQ1(E_YOUNG,enu_ddl_type_pt,grand_courant);
       liTQ.push_back(typQ1);
      };
   };
   // b) $$$ cas du coefficient de Poisson actuel
   {List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
    for (itq=liTQ.begin();itq!=itqfin;itq++)
      if ((*itq).EnuTypeQuelconque() == NU_YOUNG)
       { Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
         int taille = tyTQ.Taille()+1;
         tyTQ.Change_taille(taille); nexistePas = false;
       };
    if (nexistePas)
      {TypeQuelconque typQ1(NU_YOUNG,enu_ddl_type_pt,grand_courant);
       liTQ.push_back(typQ1);
      };
   };
   //  $$$ cas de MODULE_COMPRESSIBILITE: intéressant quand il dépend de la température
   {List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
    for (itq=liTQ.begin();itq!=itqfin;itq++)
      if ((*itq).EnuTypeQuelconque() == MODULE_COMPRESSIBILITE)
        { Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
          int taille = tyTQ.Taille()+1;
          tyTQ.Change_taille(taille); nexistePas = false;
        };
    if (nexistePas)
      {TypeQuelconque typQ1(MODULE_COMPRESSIBILITE,enu_ddl_type_pt,grand_courant);
         liTQ.push_back(typQ1);
      };
    };
    //  $$$ cas de MODULE_CISAILLEMENT: intéressant quand il dépend de la température
    {List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
     for (itq=liTQ.begin();itq!=itqfin;itq++)
       if ((*itq).EnuTypeQuelconque() == MODULE_CISAILLEMENT)
         { Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
           int taille = tyTQ.Taille()+1;
           tyTQ.Change_taille(taille); nexistePas = false;
        };
     if (nexistePas)
       {TypeQuelconque typQ2(MODULE_CISAILLEMENT,enu_ddl_type_pt,grand_courant);
        liTQ.push_back(typQ2);
      };
    };

 };


	   //----- lecture écriture de restart -----
	   // cas donne le niveau de la récupération
       // = 1 : on récupère tout
       // = 2 : on récupère uniquement les données variables (supposées comme telles)
void Loi_iso_elas2D_D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
                                             ,LesFonctions_nD& lesFonctionsnD)
	{ string toto,nom; 
   if (cas == 1)
    { ent >> toto >> thermo_dependant >> toto;
      // tout d'abord la lecture de E
      int type =0;
      ent >> type;
      switch (type)
       { case 1 :
           {ent >> nom;
            if (nom != " fonction_temperature ")
                { cout << "\n erreur en lecture de la fonction temperature, on attendait "
                       << " fonction_temperature et on a lue " << nom
                       << "\n Loi_iso_elas2D_D::Lecture_base_info_loi(...";
                  Sortie(1);
                };
              E_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,E_temperature);
            break;
           };
         case 2 :
           {ent >> nom;
            if (nom != " E_fonction_nD: ")
                { cout << "\n erreur en lecture de la fonction nD, on attendait "
                       << " E_fonction_nD: et on a lue " << nom
                       << "\n Loi_iso_elas2D_D::Lecture_base_info_loi(...";
                  Sortie(1);
                };
              E_nD = lesFonctionsnD.Lecture_pour_base_info(ent,cas,E_nD);
            break;
           };
         case 3 :
           {ent >> E;
            break;
           };
         default: cout << "\n erreur type " << type << " non prevu, pour l'instant, les types "
                       << " reconnus sont uniquement: 1 c-a-d E fonction temperature, 2 E fonction nD,  "
                       << " 3 E une valeur fixe "
                       << "\n Loi_iso_elas2D_D::Lecture_base_info_loi(...";
                  Sortie(1);
                  break;
       };

      // le coeff de poisson
      ent >> toto >> type;
      switch (type)
       { case 2 :
           {ent >> nom;
            if (nom != " nu_fonction_nD: ")
                { cout << "\n erreur en lecture de la fonction nD, on attendait "
                       << " nu_fonction_nD: et on a lue " << nom
                       << "\n Loi_iso_elas2D_D::Lecture_base_info_loi(...";
                  Sortie(1);
                };
              nu_nD = lesFonctionsnD.Lecture_pour_base_info(ent,cas,nu_nD);
            break;
           };
         case 3 :
           {ent >> nu;
            break;
           };
         default: cout << "\n erreur type " << type << " non prevu, pour l'instant, les types "
                       << " reconnus sont uniquement:  2 nu fonction nD,  "
                       << " 3 nu une valeur fixe "
                       << "\n Loi_iso_elas2D_D::Lecture_base_info_loi(...";
                  Sortie(1);
                  break;
       };

      // indicateur pour les calculs partielles
      string type_de_calcul;
      ent >> nom >> type_de_calcul ;
      if (type_de_calcul == "seul_deviatorique")
        {cas_calcul=1;}
      else if (type_de_calcul == "seul_spherique")
        {cas_calcul=2;}
      else
        {cas_calcul=0;}
      // l'indicateur pour les calculs partielles
    //      ent >> nom >> cas_calcul ;
     };   // --- fin de if (cas == 1), on ne fait rien dans les autres cas: rien n'a sauvegarder
	  // appel de la classe mère
	  Loi_comp_abstraite::Lecture_don_base_info(ent,cas,lesRef,lesCourbes1D,lesFonctionsnD); 	 
 };
       // cas donne le niveau de sauvegarde
       // = 1 : on sauvegarde tout
       // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Loi_iso_elas2D_D::Ecriture_base_info_loi(ofstream& sort,const int cas)
   { if (cas == 1) 
       { sort << " ISOELAS2D_D " << thermo_dependant << " module Young: " ;
         // tout d'abord le module d'Young
         if (E_temperature != NULL)
           {sort << " 1 fonction_temperature ";
            LesCourbes1D::Ecriture_pour_base_info(sort,cas,E_temperature);
           }
         else if (E_nD != NULL)
           {sort << " 2 E_fonction_nD: " << " ";
            LesFonctions_nD::Ecriture_pour_base_info(sort, cas,E_nD);
           }
         else
           { sort << " 3 " << E ; };
         // puis nu
         sort << " nu_type_et_val= ";
         if (nu_nD != NULL)
           {sort << " 2 nu_nD: " << " ";
            LesFonctions_nD::Ecriture_pour_base_info(sort, cas,nu_nD);
           }
         else
           { sort << " 3 " << nu ; };
         // indicateur de cas de calcul
         if (cas_calcul != 0)
          { if (cas_calcul == 1)
             {sort << "\n seul_deviatorique ";}
            else if (cas_calcul == 2)
             {sort << " seul_spherique ";}
            else
             {sort << " cas_de_calcul_mal_defini ";};
          };
        };
	// appel de la classe mère
    Loi_comp_abstraite::Ecriture_don_base_info(sort,cas);  
	};
// calcul d'un module d'young équivalent à la loi pour un chargement nul
double Loi_iso_elas2D_D::Module_young_equivalent(Enum_dure temps,const Deformation & def,SaveResul * saveDon)
    {  // on récupère le conteneur
       SaveResulLoi_iso_elas2D_D & save_resul = *((SaveResulLoi_iso_elas2D_D*) saveDon);
       double E_sortie=E; // init
       bool recup = false;
       switch (temps)
        {
         case TEMPS_t : // on utilise les grandeurs stockées à t
            if (save_resul.E_t != (-ConstMath::trespetit))
             {E_sortie= save_resul.E_t;recup = true;}
            break;
         case TEMPS_tdt : // on utilise les grandeurs stockées à tdt
            if (save_resul.E != (-ConstMath::trespetit))
              {E_sortie= save_resul.E;recup = true;}
            break;
              
         case TEMPS_0 : // rien n'a été calculé
           recup = false;
        };
       // dans tous les autres cas on utilise soit les fonctions
       // si elles existent sinon on concerve les valeurs par défaut
       if (!recup)
       {//on essaie un calcul
        // cas des courbes d'évolution
        if (E_temperature != NULL)
         { double  tempera = def.DonneeInterpoleeScalaire(TEMP,temps);
           E_sortie = E_temperature->Valeur(tempera);
         }
        else if (E_nD != NULL)
         // là il faut calcul la fonction nD
         {
           // ici on utilise les variables connues aux pti, ou calculées à partir de
           // on commence par récupérer les conteneurs des grandeurs à fournir
           List_io <Ddl_enum_etendu>& li_enu_scal = E_nD->Li_enu_etendu_scalaire();
           List_io <TypeQuelconque >& li_quelc = E_nD->Li_equi_Quel_evolue();

           // on initialise les grandeurs du tableau pour les valeurs numériques
           Tableau <double> val_ddl_enum(li_enu_scal.size(),0.);
           // init par défaut des types quelconques
           List_io <TypeQuelconque >::iterator il,ilfin=li_quelc.end();
           for (il = li_quelc.begin();il != ilfin; il++)
              (*il).Grandeur_pointee()->InitParDefaut();

           // calcul de la valeur et retour dans tab_ret
           Tableau <double> & tab_val
                   = E_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
           #ifdef MISE_AU_POINT
           if (tab_val.Taille() != 1)
              { cout << "\nErreur : la fonction nD relative au module d'Young "
                     << " doit calculer un scalaire or le tableau de retour est de taille "
                     << tab_val.Taille() << " ce n'est pas normal !\n";
                cout << " Loi_iso_elas2D_D::Module_compressibilite_equivalent(..\n";
                Sortie(1);
              };
           #endif
           // on récupère le premier élément du tableau uniquement
           E_sortie = tab_val(1);
         };
       };
      
      return  E_sortie;
     };

// récupération d'un module de compressibilité équivalent à la loi pour un chargement nul
// il s'agit ici de la relation -pression = sigma_trace/3. = module de compressibilité * I_eps
double Loi_iso_elas2D_D::Module_compressibilite_equivalent(Enum_dure temps,const Deformation & def,SaveResul * saveDon)

    { // compte tenu du fait que l'on ne connait pas la métrique etc... on ramène le module en cours
      
      // on récupère le conteneur
      SaveResulLoi_iso_elas2D_D & save_resul = *((SaveResulLoi_iso_elas2D_D*) saveDon);
      
      double E_sortie=E;double nu_sortie=nu; // init
      bool recup = false;
      switch (temps)
       {
        case TEMPS_t : // on utilise les grandeurs stockées à t
           if (save_resul.E_t != (-ConstMath::trespetit))
            {E_sortie= save_resul.E_t;recup = true;}
           break;
        case TEMPS_tdt : // on utilise les grandeurs stockées à tdt
           if (save_resul.E != (-ConstMath::trespetit))
             {E_sortie= save_resul.E;recup = true;}
           break;
             
        case TEMPS_0 : // rien n'a été calculé
          recup = false;
       };
      // dans tous les autres cas on utilise soit les fonctions
      // si elles existent sinon on concerve les valeurs par défaut
      if (!recup)
        {//on essaie un calcul
         // cas des courbes d'évolution
         if (E_temperature != NULL)
          { double  tempera = def.DonneeInterpoleeScalaire(TEMP,temps);
            E_sortie = E_temperature->Valeur(tempera);
          }
         else if (E_nD != NULL)
          // là il faut calcul la fonction nD
          {
            // ici on utilise les variables connues aux pti, ou calculées à partir de
            // on commence par récupérer les conteneurs des grandeurs à fournir
            List_io <Ddl_enum_etendu>& li_enu_scal = E_nD->Li_enu_etendu_scalaire();
            List_io <TypeQuelconque >& li_quelc = E_nD->Li_equi_Quel_evolue();

            // on initialise les grandeurs du tableau pour les valeurs numériques
            Tableau <double> val_ddl_enum(li_enu_scal.size(),0.);
            // init par défaut des types quelconques
            List_io <TypeQuelconque >::iterator il,ilfin=li_quelc.end();
            for (il = li_quelc.begin();il != ilfin; il++)
               (*il).Grandeur_pointee()->InitParDefaut();

            // calcul de la valeur et retour dans tab_ret
            Tableau <double> & tab_val
                    = E_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
            #ifdef MISE_AU_POINT
            if (tab_val.Taille() != 1)
               { cout << "\nErreur : la fonction nD relative au module d'Young "
                      << " doit calculer un scalaire or le tableau de retour est de taille "
                      << tab_val.Taille() << " ce n'est pas normal !\n";
                 cout << " Loi_iso_elas2D_D::Module_compressibilite_equivalent(..\n";
                 Sortie(1);
               };
            #endif
            // on récupère le premier élément du tableau uniquement
            E_sortie = tab_val(1);
          };
        };
        
      // idem pour nu
      recup = false;
      switch (temps)
       {
        case TEMPS_t : // on utilise les grandeurs stockées à t
           if (save_resul.nu_t != (-2.*ConstMath::trespetit))
            {nu_sortie= save_resul.nu_t;recup = true;}
           break;
        case TEMPS_tdt : // on utilise les grandeurs stockées à tdt
           if (save_resul.nu != (-2.*ConstMath::trespetit))
             {nu_sortie= save_resul.nu;recup = true;}
           break;
             
        case TEMPS_0 : // rien n'a été calculé
          recup = false;
       };
      // dans tous les autres cas on utilise soit les fonctions
      // si elles existent sinon on concerve les valeurs par défaut
      if (!recup)
        {//on essaie un calcul
         if (nu_nD != NULL)
          // là il faut calcul la fonction nD
          {
            // ici on utilise les variables connues aux pti, ou calculées à partir de
            // on commence par récupérer les conteneurs des grandeurs à fournir
            List_io <Ddl_enum_etendu>& li_enu_scal = nu_nD->Li_enu_etendu_scalaire();
            List_io <TypeQuelconque >& li_quelc = nu_nD->Li_equi_Quel_evolue();

            // on initialise les grandeurs du tableau pour les valeurs numériques
            Tableau <double> val_ddl_enum(li_enu_scal.size(),0.);
            // init par défaut des types quelconques
            List_io <TypeQuelconque >::iterator il,ilfin=li_quelc.end();
            for (il = li_quelc.begin();il != ilfin; il++)
               (*il).Grandeur_pointee()->InitParDefaut();

            // calcul de la valeur et retour dans tab_ret
            Tableau <double> & tab_val
                    = nu_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
            #ifdef MISE_AU_POINT
            if (tab_val.Taille() != 1)
               { cout << "\nErreur : la fonction nD relative au coefficient de Poisson "
                      << " doit calculer un scalaire or le tableau de retour est de taille "
                      << tab_val.Taille() << " ce n'est pas normal !\n";
                 cout << " Loi_iso_elas2D_D::Module_compressibilite_equivalent(..\n";
                 Sortie(1);
               };
            #endif
            // on récupère le premier élément du tableau uniquement
            nu_sortie = tab_val(1);
          };
        };

      // retour du module
      double K= E_sortie/(3.*(1.-2.*nu_sortie));
      return K;
    };
  
// insertion des conteneurs ad hoc concernant le stockage de grandeurs quelconques
// passée en paramètre, dans le save result: ces conteneurs doivent être valides
// c-a-d faire partie de listdeTouslesQuelc_dispo_localement
void Loi_iso_elas2D_D::Insertion_conteneur_dans_save_result(SaveResul * sr)
 {
    // récup de la liste de stockage
    list <EnumTypeQuelconque >& listlocale = ListQuelc_mis_en_acces_localement();
    // on spécialise saveresult
    SaveResulLoi_iso_elas2D_D & save_resul = *((SaveResulLoi_iso_elas2D_D*) sr);
  
    // -- autre stockage éventuel en fonction des grandeurs quelconques demandées par d'autres lois
    List_io <EnumTypeQuelconque>::iterator jk,jkfin = listlocale.end();
    for (jk=listlocale.begin();jk != jkfin;jk++)
      {EnumTypeQuelconque enu = *jk;
       switch (enu)
        {case E_YOUNG: case NU_YOUNG:
            { // on crée le conteneur ad hoc pour le passage d'info
              // def d'un conteneur de grandeurs quelconques, initialisée à 0
              Grandeur_scalaire_double grand_courant(0.);
              TypeQuelconque typQ1(enu,EPS11,grand_courant);
              save_resul.map_type_quelconque[enu]=(typQ1);
              break;
            }
         default:
            cout << "\n *** erreur on demande l'acces  a : "
                 << NomTypeQuelconque(enu)
                 << " or celui-ci n'est pas dispo pour la loi ";
            this->Affiche();
            cout << " revoir la mise en donnees ! " << endl;
            Sortie(1);
        };
     };
 
 };
 
// activation du stockage de grandeurs quelconques qui pourront ensuite être récupéré
// via le conteneur SaveResul, si la grandeur n'existe pas ici, aucune action
void Loi_iso_elas2D_D::Activation_stockage_grandeurs_quelconques(list <EnumTypeQuelconque >& listEnuQuelc)
 {  // récup de la liste de stockage
    list <EnumTypeQuelconque >& listlocale = ListQuelc_mis_en_acces_localement();
    // on parcours la liste des grandeurs à activer
    // et on remplit la liste locale
    list <EnumTypeQuelconque >::iterator il, ilfin = listEnuQuelc.end();
    for (il = listEnuQuelc.begin();il != ilfin; il++)
//    for (EnumTypeQuelconque enu : listEnuQuelc)
     // on ne remplit que s'il s'agit d'une grandeur qui peut-être accessible
     {switch (*il)
       {case E_YOUNG : case NU_YOUNG:
          listlocale.push_back(*(il));
          break;
        default: ;  // pour les autres cas on ne fait rien
       };
     };
  
    // on supprime les doublons localement
    listlocale.sort(); // on ordonne la liste
    listlocale.unique(); // suppression des doublons
  
 };


// ---------------------------- methode propre a la loi -----------------------
        // calcul de la contrainte sigma33
 double Loi_iso_elas2D_D::Sig33BH(TenseurBB & 	epsBB_,TenseurHH & gijHH_)
 {   
    #ifdef MISE_AU_POINT
    if  (Permet_affichage() > 3)
      {cout << "\n  --- loi de comportement iso elas 2D D  Calcul Sig33BH  --- ";
       Signature_pti_encours(cout);
      };
    if (epsBB_.Dimension() != 2)
       { cout << "\nErreur : la dimension devrait etre 2 !\n";
      cout << " Loi_iso_elas2D_D::Sig33BH(\n";
      Sortie(1);
    };
    #endif
    
    const Tenseur2BB & epsBB = *((Tenseur2BB*) &epsBB_); // passage en dim 2
    const Tenseur2HH & gijHH = *((Tenseur2HH*) &gijHH_); //   "      "  "  "

    Tenseur2BH  epsBH = epsBB * gijHH;  // deformation en mixte
    
    // l'idée ici est d'utiliser les grandeurs de la loi déjà calculées et stockées
    // compte tenu du fait que l'on ne connait pas la métrique etc...
  
    // on récupère le conteneur
    SaveResulLoi_iso_elas2D_D & save_res_en_cours = *((SaveResulLoi_iso_elas2D_D*) saveResul);
    
    double E_actu=save_res_en_cours.E;
    double nu_actu = save_res_en_cours.nu;
    
    if ((E_actu==0.) && (nu_actu ==0.))
      {cout << "\n *** attention, dans le calcul de Sig33BH, E et nu n'ont pas ete encore "
            << " stockees on retient les valeurs initiales par defaut de la loi ";
       nu_actu = nu;
       E_actu = E;
      }

    // calcul du coefficient
    double coef1 = E_actu/((1.-2.*nu_actu)*3.);
    // calcul du deviateur des deformations
    double Ieps = epsBH.Trace();
    double  sig33BH = (Ieps * coef1) ; // le resultat
    return sig33BH;
 };


 // ========== codage des METHODES VIRTUELLES  protegees:================
        // calcul des contraintes à t+dt
void Loi_iso_elas2D_D::Calcul_SigmaHH (TenseurHH& ,TenseurBB& ,DdlElement & ,
             TenseurBB & ,TenseurHH & ,BaseB& ,BaseH& ,TenseurBB&  epsBB_,
             TenseurBB&  ,TenseurBB&  ,
		  	 TenseurHH & gijHH_,Tableau <TenseurBB *>& ,double& ,double& ,
		  	  TenseurHH & sigHH_
		  	 ,EnergieMeca & energ,const EnergieMeca & 
		  	 ,double& module_compressibilite,double&  module_cisaillement
		  	 ,const Met_abstraite::Expli_t_tdt& ex)
 {   
   #ifdef MISE_AU_POINT	 	 
   if (Permet_affichage() > 3)
     {cout << "\n ---- Loi_iso_elas2D_D::Calcul_SigmaHH ---- ";
      Signature_pti_encours(cout);
     };
   if (epsBB_.Dimension() != 2)
      { cout << "\nErreur : la dimension devrait etre 2 !\n";
     cout << " Loi_iso_elas2D_D::Calcul_SigmaHH\n";
     Sortie(1);
   };
   #endif
   const Tenseur2BB & epsBB = *((Tenseur2BB*) &epsBB_); // passage en dim 2
   const Tenseur2HH & gijHH = *((Tenseur2HH*) &gijHH_); //   "      "  "  "
   Tenseur2HH & sigHH = *((Tenseur2HH*) &sigHH_);  //   "      "  "  "

   // opération de transmission de la métrique
   const Met_abstraite::Impli* ex_impli = NULL;
   const Met_abstraite::Expli_t_tdt* ex_expli_tdt = &ex;
   const Met_abstraite::Umat_cont* ex_expli = NULL;

   Tenseur2BH  epsBH = epsBB * gijHH;  // deformation en mixte
   // calcul éventuel des paramètres de la loi
   if (E_temperature != NULL) {E = E_temperature->Valeur(*temperature);}
   else if (E_nD != NULL)
    // là il faut calculer la fonction nD
    { // on utilise la méthode générique de loi abstraite
      list <SaveResul*> list_save; // inter pour l'appel de la fonction
      list_save.push_back(saveResul);
      Tableau <double> & tab_val = Loi_comp_abstraite::Loi_comp_Valeur_FnD_Evoluee
          (E_nD,1 // une seule valeur attendue en retour
           ,ex_impli,ex_expli_tdt,ex_expli
           ,NULL
           ,NULL
           ,&list_save
          );
/*      // ici on utilise les variables connues aux pti, ou calculées à partir de
      // on commence par récupérer les conteneurs des grandeurs à fournir
      List_io <Ddl_enum_etendu>& li_enu_scal = E_nD->Li_enu_etendu_scalaire();
      List_io <TypeQuelconque >& li_quelc = E_nD->Li_equi_Quel_evolue();
      bool absolue = true; // on se place systématiquement en absolu
      // on va utiliser la méhode Valeur_multi_interpoler_ou_calculer
      // pour les grandeurs strictement scalaire
      Tableau <double> val_ddl_enum(Valeur_multi_interpoler_ou_calculer
                   (absolue,TEMPS_tdt,li_enu_scal,ex_impli,ex_expli_tdt,ex_expli,NULL)
                                     );
      // on utilise la méthode Valeurs_Tensorielles_interpoler_ou_calculer
      // pour les Coordonnees et Tenseur
      Valeurs_Tensorielles_interpoler_ou_calculer
                    (absolue,TEMPS_tdt,li_quelc,ex_impli,ex_expli_tdt,ex_expli,NULL);
      // calcul de la valeur et retour dans tab_ret
      Tableau <double> & tab_val = E_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
      #ifdef MISE_AU_POINT
      if (tab_val.Taille() != 1)
         { cout << "\nErreur : la fonction nD relative au module d'Young "
                << " doit calculer un scalaire or le tableau de retour est de taille "
                << tab_val.Taille() << " ce n'est pas normal !\n";
           cout << " Loi_iso_elas2D_D::Calcul_SigmaHH\n";
           Sortie(1);
         };
      #endif
      */
      // on récupère le premier élément du tableau uniquement
      E = tab_val(1);
    };
   // cas de nu
   if (nu_nD != NULL)
    // là il faut calcul la fonction nD
    { // on utilise la méthode générique de loi abstraite
      list <SaveResul*> list_save; // inter pour l'appel de la fonction
      list_save.push_back(saveResul);
      Tableau <double> & tab_val = Loi_comp_abstraite::Loi_comp_Valeur_FnD_Evoluee
          (nu_nD,1 // une seule valeur attendue en retour
           ,ex_impli,ex_expli_tdt,ex_expli
           ,NULL
           ,NULL
           ,&list_save
          );
/*      // ici on utilise les variables connues aux pti, ou calculées à partir de
      // on commence par récupérer les conteneurs des grandeurs à fournir
      List_io <Ddl_enum_etendu>& li_enu_scal = nu_nD->Li_enu_etendu_scalaire();
      List_io <TypeQuelconque >& li_quelc = nu_nD->Li_equi_Quel_evolue();
      bool absolue = true; // on se place systématiquement en absolu
      // on va utiliser la méhode Valeur_multi_interpoler_ou_calculer
      // pour les grandeurs strictement scalaire
       Tableau <double> val_ddl_enum(Valeur_multi_interpoler_ou_calculer
                   (absolue,TEMPS_tdt,li_enu_scal,ex_impli,ex_expli_tdt,ex_expli,NULL)
                                     );
      // on utilise la méthode Valeurs_Tensorielles_interpoler_ou_calculer
      // pour les Coordonnees et Tenseur
      Valeurs_Tensorielles_interpoler_ou_calculer
                    (absolue,TEMPS_tdt,li_quelc,ex_impli,ex_expli_tdt,ex_expli,NULL);
      // calcul de la valeur et retour dans tab_ret
      Tableau <double> & tab_val = nu_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
      #ifdef MISE_AU_POINT
      if (tab_val.Taille() != 1)
         { cout << "\nErreur : la fonction nD relative au coefficient de Poisson "
                << " doit calculer un scalaire or le tableau de retour est de taille "
                << tab_val.Taille() << " ce n'est pas normal !\n";
           cout << " Loi_iso_elas2D_D::Calcul_SigmaHH\n";
           Sortie(1);
         };
      #endif
      */
      // on récupère le premier élément du tableau uniquement
      nu = tab_val(1);
    };
  
   // sauvegarde des paramètres matériau
   SaveResulLoi_iso_elas2D_D & save_resul = *((SaveResulLoi_iso_elas2D_D*) saveResul);
   save_resul.E = E;
   save_resul.nu = nu;

   // calcul des coefficients
   double coef1 = (E*nu)/((1.-2.*nu)*(1+nu));
   double coef2 = E/(1.+ nu);
   module_compressibilite = E/(3.*(1.-2.*nu));
   module_cisaillement = coef2/2.;
   // calcul du deviateur des deformations
   double Ieps = epsBH.Trace();
   Tenseur2BH  sigBH;
   switch (cas_calcul)
     { case 0: // calcul normal (tous les termes)
     	{ sigBH = (Ieps * coef1) * IdBH2 + coef2 * epsBH ; // contrainte en mixte
     	  sigHH = gijHH * sigBH; // en deux fois contravariants
     	  break;	
     	}
       case 1: // calcul de la partie déviatorique seule
     	{ sigBH = coef2 * (epsBH - (Ieps/3.)*IdBH2); // contrainte en mixte
     	  sigHH = gijHH * sigBH; // en deux fois contravariants
     	  break;	
     	}
       case 2: // calcul de la partie sphérique seule
     	{ sigBH = (Ieps * (coef1 + coef2/3.))*IdBH2; // contrainte en mixte
     	  sigHH = gijHH * sigBH; // en deux fois contravariants
     	  break;	
     	}
       default:
       	{ cout << "\n erreur l'indicateur cas_calcul= " << cas_calcul << " n'a pas une valeur correcte !! "
       	       << "\n Loi_iso_elas2D_D::Calcul_SigmaHH (.... ";
       	  Sortie(1);     
       	}	
     };

    // traitement des énergies
    energ.Inita(0.); 
    energ.ChangeEnergieElastique(0.5 * (sigHH && epsBB));
    
    #ifdef MISE_AU_POINT
    if  (Permet_affichage() > 3)
      {Signature_pti_encours(cout);
       cout << "\n";
       if (E_temperature != NULL)
         {cout << " E temperature= " << E ;}
       else if (E_nD != NULL)
         {cout << " E fctnD= " << E;};
       if (nu_nD != NULL)
         {cout << " nu fctnD= " << nu;}
       cout << " module_compressibilite= " << module_compressibilite
            << " module cisaillement= " << module_cisaillement
            << " ener_elas= " << energ.EnergieElastique()
            << flush;
      };
    if  (Permet_affichage() > 4)
      cout << "\n Ieps = " << Ieps << " Isig= " << sigBH.Trace();
    #endif
    
    LibereTenseur();
 };
        
        // calcul des contraintes a t+dt et de ses variations  
void Loi_iso_elas2D_D::Calcul_DsigmaHH_tdt (TenseurHH& ,TenseurBB& ,DdlElement & tab_ddl
            ,BaseB& ,TenseurBB & ,TenseurHH & ,
            BaseB& ,Tableau <BaseB> & ,BaseH& ,Tableau <BaseH> & ,
            TenseurBB & epsBB_tdt,Tableau <TenseurBB *>& d_epsBB
//				,TenseurBB & ,TenseurBB & ,TenseurHH & gijHH_tdt,
            ,TenseurBB & delta_epsBB,TenseurBB & gijBB_tdt,TenseurHH & gijHH_tdt,
		    Tableau <TenseurBB *>& d_gijBB_tdt,
		  	Tableau <TenseurHH *>& d_gijHH_tdt,double& ,double& ,
		  	Vecteur& ,TenseurHH& sigHH_tdt,Tableau <TenseurHH *>& d_sigHH
		  	,EnergieMeca & energ,const EnergieMeca & 
		  	,double& module_compressibilite,double&  module_cisaillement
		  	,const Met_abstraite::Impli& ex)
 {
   #ifdef MISE_AU_POINT	 	 
   if (Permet_affichage() > 3)
     {cout << "\n ---- Loi_iso_elas2D_D::Calcul_DsigmaHH_tdt ---- ";
      Signature_pti_encours(cout);
     };
   if (epsBB_tdt.Dimension() != 2)
     { cout << "\nErreur : la dimension devrait etre 2 !\n";
       cout << " Loi_iso_elas2D_D::Calcul_DsigmaHH_tdt\n";
       Sortie(1);
     };
   if (tab_ddl.NbDdl() != d_gijBB_tdt.Taille())
      { cout << "\nErreur : le nb de ddl est != de la taille de d_gijBB_tdt  !\n";
        cout << " Loi_iso_elas1D::Calcul_SDsigmaHH_tdt\n";
        Sortie(1);
      };
   #endif

   const Tenseur2BB & epsBB = *((Tenseur2BB*) &epsBB_tdt); // passage en dim 2
   const Tenseur2HH & gijHH = *((Tenseur2HH*) &gijHH_tdt); //   "      "  "  "
   Tenseur2HH & sigHH = *((Tenseur2HH*) &sigHH_tdt);  //   "      "  "  "

   // opération de transmission de la métrique
   const Met_abstraite::Impli* ex_impli = &ex;
   const Met_abstraite::Expli_t_tdt* ex_expli_tdt = NULL;
   const Met_abstraite::Umat_cont* ex_expli = NULL;

   // calcul éventuel des paramètres de la loi
   if (E_temperature != NULL) {E = E_temperature->Valeur(*temperature);}
   else if (E_nD != NULL)
    // là il faut calcul la fonction nD
    { // on utilise la méthode générique de loi abstraite
      list <SaveResul*> list_save; // inter pour l'appel de la fonction
      list_save.push_back(saveResul);
      Tableau <double> & tab_val = Loi_comp_abstraite::Loi_comp_Valeur_FnD_Evoluee
          (E_nD,1 // une seule valeur attendue en retour
           ,ex_impli,ex_expli_tdt,ex_expli
           ,NULL
           ,NULL
           ,&list_save
          );
/*      // ici on utilise les variables connues aux pti, ou calculées à partir de
      // on commence par récupérer les conteneurs des grandeurs à fournir
      List_io <Ddl_enum_etendu>& li_enu_scal = E_nD->Li_enu_etendu_scalaire();
      List_io <TypeQuelconque >& li_quelc = E_nD->Li_equi_Quel_evolue();
      bool absolue = true; // on se place systématiquement en absolu
      // on va utiliser la méhode Valeur_multi_interpoler_ou_calculer
      // pour les grandeurs strictement scalaire
       Tableau <double> val_ddl_enum(Valeur_multi_interpoler_ou_calculer
                   (absolue,TEMPS_tdt,li_enu_scal,ex_impli,ex_expli_tdt,ex_expli,NULL)
                                     );
      // on utilise la méthode Valeurs_Tensorielles_interpoler_ou_calculer
      // pour les Coordonnees et Tenseur
      Valeurs_Tensorielles_interpoler_ou_calculer
                    (absolue,TEMPS_tdt,li_quelc,ex_impli,ex_expli_tdt,ex_expli,NULL);
      // calcul de la valeur et retour dans tab_ret
      Tableau <double> & tab_val = E_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
      #ifdef MISE_AU_POINT
      if (tab_val.Taille() != 1)
         { cout << "\nErreur : la fonction nD relative au module d'Young "
                << " doit calculer un scalaire or le tableau de retour est de taille "
                << tab_val.Taille() << " ce n'est pas normal !\n";
           cout << " Loi_iso_elas2D_D::Calcul_SigmaHH\n";
           Sortie(1);
         };
      #endif
      */
      // on récupère le premier élément du tableau uniquement
      E = tab_val(1);
    };
   // cas de nu
   if (nu_nD != NULL)
    // là il faut calcul la fonction nD
    { // on utilise la méthode générique de loi abstraite
      list <SaveResul*> list_save; // inter pour l'appel de la fonction
      list_save.push_back(saveResul);
      Tableau <double> & tab_val = Loi_comp_abstraite::Loi_comp_Valeur_FnD_Evoluee
          (nu_nD,1 // une seule valeur attendue en retour
           ,ex_impli,ex_expli_tdt,ex_expli
           ,NULL
           ,NULL
           ,&list_save
          );
/*      // ici on utilise les variables connues aux pti, ou calculées à partir de
      // on commence par récupérer les conteneurs des grandeurs à fournir
      List_io <Ddl_enum_etendu>& li_enu_scal = nu_nD->Li_enu_etendu_scalaire();
      List_io <TypeQuelconque >& li_quelc = nu_nD->Li_equi_Quel_evolue();
      bool absolue = true; // on se place systématiquement en absolu
      // on va utiliser la méhode Valeur_multi_interpoler_ou_calculer
      // pour les grandeurs strictement scalaire
       Tableau <double> val_ddl_enum(Valeur_multi_interpoler_ou_calculer
                   (absolue,TEMPS_tdt,li_enu_scal,ex_impli,ex_expli_tdt,ex_expli,NULL)
                                     );
      // on utilise la méthode Valeurs_Tensorielles_interpoler_ou_calculer
      // pour les Coordonnees et Tenseur
      Valeurs_Tensorielles_interpoler_ou_calculer
                    (absolue,TEMPS_tdt,li_quelc,ex_impli,ex_expli_tdt,ex_expli,NULL);
      // calcul de la valeur et retour dans tab_ret
      Tableau <double> & tab_val = nu_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
      #ifdef MISE_AU_POINT
      if (tab_val.Taille() != 1)
         { cout << "\nErreur : la fonction nD relative au coefficient de Poisson "
                << " doit calculer un scalaire or le tableau de retour est de taille "
                << tab_val.Taille() << " ce n'est pas normal !\n";
           cout << " Loi_iso_elas2D_D::Calcul_SigmaHH\n";
           Sortie(1);
         };
      #endif
      */
      // on récupère le premier élément du tableau uniquement
      nu = tab_val(1);
    };
    
   // sauvegarde des paramètres matériau
   SaveResulLoi_iso_elas2D_D & save_resul = *((SaveResulLoi_iso_elas2D_D*) saveResul);
   save_resul.E = E;
   save_resul.nu = nu;

   // cas du tenseur des contraintes
   Tenseur2BH  epsBH = epsBB * gijHH;  // deformation en mixte
   // calcul des coefficients
   double coef1 = (E*nu)/((1.-2.*nu)*(1+nu));
   double coef2 = E/(1.+ nu);
   module_compressibilite = E/(3.*(1.-2.*nu));
   module_cisaillement = 0.5 * coef2;
   // calcul du deviateur des deformations
   double Ieps = epsBH.Trace();
   Tenseur2BH sigBH;
   double untiers=1./3.;
   switch (cas_calcul)
     { case 0: // calcul normal (tous les termes)
     	{ sigBH = (Ieps * coef1) * IdBH2 + coef2 * epsBH ; // contrainte en mixte
     	  break;	
     	}
       case 1: // calcul de la partie déviatorique seule
     	{ sigBH = coef2 * (epsBH - (Ieps*untiers)*IdBH2); // contrainte en mixte
     	  break;	
     	}
       case 2: // calcul de la partie sphérique seule
     	{ sigBH = (Ieps * (coef1 + coef2*untiers))*IdBH2; // contrainte en mixte
     	  break;	
     	}
       default:
       	{ cout << "\n erreur l'indicateur cas_calcul= " << cas_calcul << " n'a pas une valeur correcte !! "
       	       << "\n Loi_iso_elas2D_D::Calcul_DsigmaHH_tdt (.... ";
       	  Sortie(1);     
       	}	
     };
   sigHH = gijHH * sigBH;  // en deux fois contravariant
//----------------- debug
//    const Tenseur2BB & gijBB = *((Tenseur2BB*) &gijBB_tdt); // passage en dim 3
//cout << "\n epsBB="<<epsBB << " gijBB_tdt= " << gijBB << " gijHH_tdt= " << gijHH<<" ";
//cout << "\n sighh="<<sigHH<<" ";
//----------- fin debug        
//----------------- debug
//cout << "\n epsBB="<<epsBB<<" ";
//cout << "\n sighh="<<sigHH<<" ";
//----------- fin debug        
    
   // traitement des énergies
   energ.Inita(0.);
   energ.ChangeEnergieElastique(0.5 * (sigHH && epsBB));

   
   #ifdef MISE_AU_POINT
   if  (Permet_affichage() > 3)
     {Signature_pti_encours(cout);
      cout << "\n";
      if (E_temperature != NULL)
        {cout << " E temperature= " << E ;}
      else if (E_nD != NULL)
        {cout << " E fctnD= " << E;};
      if (nu_nD != NULL)
        {cout << " nu fctnD= " << nu;}
      cout << " module_compressibilite= " << module_compressibilite
           << " module cisaillement= " << module_cisaillement
           << " ener_elas= " << energ.EnergieElastique()
           << flush;
     };
   if  (Permet_affichage() > 4)
     cout << "\n Ieps = " << Ieps << " Isig= " << sigBH.Trace();
   #endif

   // cas le la variation du tenseur des contraintes
   int nbddl = d_gijBB_tdt.Taille();
       
   for (int i = 1; i<= nbddl; i++)
     { // on fait de faire uniquement une égalité d'adresse et de ne pas utiliser
       // le constructeur d'ou la profusion d'* et de ()
       Tenseur2HH & dsigHH = *((Tenseur2HH*) (d_sigHH(i)));  // passage en dim 2
       const Tenseur2HH & dgijHH = *((Tenseur2HH*)(d_gijHH_tdt(i))) ; // pour simplifier l'ecriture
       const Tenseur2BB & depsBB = *((Tenseur2BB *) (d_epsBB(i))); //    "
       // pour chacun des ddl on calcul les tenseurs derivees
       Tenseur2BH depsBH =  epsBB * dgijHH  + depsBB * gijHH ;
       double dIeps = depsBH.Trace();
       switch (cas_calcul)
        { case 0: // calcul normal (tous les termes)
     	   { dsigHH = dgijHH * sigBH + gijHH *  
                ((dIeps * coef1) * IdBH2 + coef2 * depsBH);
     	     break;	
     	   }
          case 1: // calcul de la partie déviatorique seule
     	   { dsigHH = dgijHH * sigBH + gijHH *
                      coef2 * (depsBH - (dIeps*untiers)*IdBH2);
     	     break;	
     	   }
          case 2: // calcul de la partie sphérique seule
     	   { dsigHH = dgijHH * sigBH + gijHH *
                      ((dIeps * (coef1 + coef2*untiers))*IdBH2);
     	     break;	
     	   }
        };
////----------------- debug
//  if ((i==2) || (i==5))
//    {cout << "\n dsighh("<<i<<")="<<dsigHH<<" "
//	       << " dgijHH= " << dgijHH << " depsBB= " << depsBB ;
//	  };
//----------- fin debug        
		};  
    LibereTenseur(); 
 };