// FICHIER : Iso_elas_expo1D.cp
// CLASSE : Iso_elas_expo1D


// 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 "Debug.h"

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


#include "Iso_elas_expo1D.h"
#include "MathUtil.h"

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


// mise à jour de la liste des grandeurs quelconques internes
void Iso_elas_expo1D::SaveResulIso_elas_expo1D::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 =========
Iso_elas_expo1D::Iso_elas_expo1D () :  // Constructeur par defaut
  Loi_comp_abstraite(ISO_ELAS_ESPO1D,CAT_MECANIQUE,1),E(-ConstMath::trespetit)
  ,nu(-2.*ConstMath::trespetit)
  ,f_coefficient(NULL)
  ,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
Iso_elas_expo1D::Iso_elas_expo1D (const Iso_elas_expo1D& loi) :
	Loi_comp_abstraite(loi),E(loi.E),nu(loi.nu)
   ,f_coefficient(Courbe1D::New_Courbe1D(*(loi.f_coefficient)))
   ,E_nD(loi.E_nD),nu_nD(loi.nu_nD)
	{if (f_coefficient != NULL)
	   if (f_coefficient->NomCourbe() == "_")
        {// comme il s'agit d'une courbe locale on la redéfinie (sinon pb lors du destructeur de loi)
         string non_courbe("_");   
         f_coefficient = Courbe1D::New_Courbe1D(*loi.f_coefficient);
        };
  // 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

	};

Iso_elas_expo1D::~Iso_elas_expo1D ()
// Destructeur 
{ if (f_coefficient != NULL)
    if (f_coefficient->NomCourbe() == "_") delete f_coefficient;
  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 Iso_elas_expo1D::LectureDonneesParticulieres 
                (UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D,LesFonctions_nD& lesFonctionsnD)
  { string nom_class_methode("Iso_elas_expo1D::LectureDonneesParticulieres");
    // lecture du module d'young et du coefficient de poisson
    if(strstr(entreePrinc->tablcar,"E=")== NULL)
      { cout << "\n erreur en lecture du module d'young "
             << " on attendait la chaine : E= ";
        cout << "\n Iso_elas_expo1D::LectureDonneesParticulieres  "
             << "(UtilLecture * entreePrinc) " << endl ;
        entreePrinc->MessageBuffer("   ");
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);
      }
    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
       string nom;
       *(entreePrinc->entree) >> nom >> E ;
       if (nom != "E=")
         { cout << "\n erreur en lecture, on attendait le mot cle E= "
                << " et on a lue  " << nom;
           string message("\n**erreur04** \n"+nom_class_methode+"(...");
           entreePrinc->MessageBuffer(message);
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);
         };
     };

    // 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;
       }
    //  sinon si le coefficient de Poisson n'a pas été lue, on le récupère en version scalaire
    else
     { string nom;
       *(entreePrinc->entree) >> nom >> nu ;
       if (nom != "nu=")
         { cout << "\n erreur en lecture, on attendait le mot cle nu= "
                << " et on a lue  " << nom;
           string message("\n**erreur04** \n"+nom_class_methode+"(...");
           entreePrinc->MessageBuffer(message);
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);
         };
     };

    string nom,toto;
    *(entreePrinc->entree) >> nom >> E >> nom >> nu;
    
    // lecture de la courbe de coefficient multiplicatif
    entreePrinc->NouvelleDonnee();  // lecture d'une nouvelle ligne
    if(strstr(entreePrinc->tablcar,"f_coefficient")== NULL)
         { cout << "\n erreur en lecture de la courbe de coefficient multiplicatif "
                << " on devait avoir la presence de la chaine : f_coefficient"
              ;
           cout << "\n Iso_elas_expo1D::LectureDonneesParticulieres  "
                << "(UtilLecture * entreePrinc) " << endl ;
           entreePrinc->MessageBuffer("   ");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);          
          }
    *(entreePrinc->entree) >> toto >> nom; 
    // on regarde si la courbe existe, si oui on récupère la référence 
    if (lesCourbes1D.Existe(nom)) 
      { f_coefficient = lesCourbes1D.Trouve(nom);
        }
    else
     { // sinon il faut la lire maintenant   
       string non_courbe("_");   
       f_coefficient = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
       // lecture de la courbe
       f_coefficient->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
      } 
    // appel au niveau de la classe mère
    Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire
                 (*entreePrinc,lesFonctionsnD);

   };
// affichage de la loi
void Iso_elas_expo1D::Affiche()  const 
  { cout << " \n loi de comportement isoelastique non lineaire 1D " ;
    if (E_nD != NULL)
     {cout << "E_fonction_nD:" << " ";
      if (E_nD->NomFonction() != "_")
           cout << E_nD->NomFonction();
      else
           E_nD->Affiche();
     }
    else
     { cout << " 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 ;
     };
    cout << " \n fonction multiplicative " ;
    f_coefficient->Affiche();    
    // appel de la classe mère
    Loi_comp_abstraite::Affiche_don_classe_abstraite();
  };
            
// affichage et definition interactive des commandes particulières à chaques lois
void Iso_elas_expo1D::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");

    sort << "\n# --------------------------------------------------------------------"
         << "\n# |.......  loi de comportement isoelastique non lineaire 1D ........|"
         << "\n# |      module d'young :   coefficient de poisson                   |"
         << "\n# --------------------------------------------------------------------"
         << "\n E= " << setprecision(6) << E << " nu= " << setprecision(6) << nu ;
    if ((rep != "o") && (rep != "O" ) && (rep != "0") )
      {sort << "\n#   .................. dependance a une fonction nD ......................"
            << "\n#  Le module d'Young et le coefficient de Poisson peuvent au choix dependre d'une fonction nD.  "
            << "\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#  ";
      
       sort << "\n#    .. definition de la courbe multiplicative .. "
            << "\n#       f_coefficient   courbe1    # exemple d'une courbe qui existe déjà"
            << "\n#           exemple d'une courbe defini a la suite "
            << "\n#   f_coefficient COURBEPOLYLINEAIRE_1_D"
            << "\n#         Debut_des_coordonnees_des_points"
            << "\n#                 Coordonnee dim= 2 0. 1. "
            << "\n#                 Coordonnee dim= 2 1. 2. "
            << "\n#         Fin_des_coordonnees_des_points  "
            << "\n#   .. fin de la definition de la courbe multiplicative..  ";
     };
    sort << endl;
    // appel de la classe mère
    Loi_comp_abstraite::Info_commande_don_LoisDeComp(entreePrinc);     
  };  		  	  

// test si la loi est complete
int Iso_elas_expo1D::TestComplet()
    { int ret = LoiAbstraiteGeneral::TestComplet();
      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;
        };
     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;
      };
    if ( f_coefficient == NULL)
      { cout << " \n la fonction de coefficient multiplicatif n'est pas défini pour  la loi "
             << Nom_comp(id_comp)
             << '\n';
        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 Iso_elas_expo1D::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
   SaveResulIso_elas_expo1D & save_resul = *((SaveResulIso_elas_expo1D*) saveDon);
   // ici on est en 1D 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 Iso_elas_expo1D::ListeGrandeurs_particulieres(bool absolue,List_io<TypeQuelconque>& liTQ) const
 { // ici on est en 1D 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 Iso_elas_expo1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
                                             ,LesFonctions_nD& lesFonctionsnD)
  { string toto,nom;
    if (cas == 1)
     { ent >> toto >>  toto ;
       // tout d'abord la lecture de E
       int type =0;
       ent >> type;
       switch (type)
        { 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 Iso_elas_expo1D::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:  2 E fonction nD,  "
                        << " 3 E une valeur fixe "
                        << "\n Iso_elas_expo1D::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 Iso_elas_expo1D::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 Iso_elas_expo1D::Lecture_base_info_loi(...";
                   Sortie(1);
                   break;
        };

       // la courbe de coefficient multiplicatif
       ent >> toto;
       if (toto != "fonction_multiplicative")
        { cout << "\n erreur en lecture de la fonction epsilon, on attendait fonction_multiplicative et on a lue " << toto
               << "\n Iso_elas_expo1D::Lecture_base_info_loi(...";
          Sortie(1);
         };
       f_coefficient = lesCourbes1D.Lecture_pour_base_info(ent,cas,f_coefficient);
     }
    // 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 Iso_elas_expo1D::Ecriture_base_info_loi(ofstream& sort,const int cas)
  { if (cas == 1) 
     { sort << "\nISO_ELAS_ESPO1D: module Young:";
       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 ; };
       // la courbe de coefficient multiplicatif
       sort << " \n fonction_multiplicative "; 
       LesCourbes1D::Ecriture_pour_base_info(sort,cas,f_coefficient);
      }
	// 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 Iso_elas_expo1D::Module_young_equivalent(Enum_dure temps,const Deformation & def,SaveResul * saveDon)
    {  // on récupère le conteneur
       SaveResulIso_elas_expo1D & save_resul = *((SaveResulIso_elas_expo1D*) saveDon);
       double Efinale=0.;
       switch (temps)
        {case TEMPS_0 : // rien n'a été calculé on essaie un calcul
            {// cas des courbes d'évolution
             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 << " Iso_elas_expo1D::Module_compressibilite_equivalent(..\n";
                     Sortie(1);
                   };
                #endif
                // on récupère le premier élément du tableau uniquement
                Efinale = tab_val(1);
               };
              double val_fonc = f_coefficient->Valeur(0.);
              if ((isinf(val_fonc))||( isnan(val_fonc)))
                 {cout << "\n -- Iso_elas_expo1D::Module_young_equivalent(.. ";
                  Signature_pti_encours(cout);
                  cout << "\n *** erreur: la fonction renvoie un nan ou infinie ! ";
                  throw ErrNonConvergence_loiDeComportement();
                 };
              Efinale *= val_fonc;
              break;
             }
         case TEMPS_t : // on utilise les grandeurs stockées à t
              {Efinale= save_resul.E_t;
               break;
              }
         case TEMPS_tdt : // on utilise les grandeurs stockées à tdt
              {Efinale= save_resul.E;
               break;
              }
        };
      
      return  Efinale;
     };

// 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 Iso_elas_expo1D::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
      SaveResulIso_elas_expo1D & save_resul = *((SaveResulIso_elas_expo1D*) saveDon);
      
      double Efinale=0.;double nufinale=0.;
      switch (temps)
       {case TEMPS_0 : // rien n'a été calculé on essaie un calcul
           {// cas des courbes d'évolution
            if (E_nD != NULL)
             // là il faut calculer 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 << " Iso_elas_expo1D::Module_compressibilite_equivalent(..\n";
                    Sortie(1);
                  };
               #endif
               // on récupère le premier élément du tableau uniquement
               Efinale = tab_val(1);
              };
              
            // cas de nu
            if (nu_nD != NULL)
             // là il faut calculer 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 << " Iso_elas_expo1D::Module_compressibilite_equivalent(..\n";
                    Sortie(1);
                  };
               #endif
               // on récupère le premier élément du tableau uniquement
               nufinale = tab_val(1);
             };
             
            double val_fonc = f_coefficient->Valeur(0.);
            if ((isinf(val_fonc))||( isnan(val_fonc)))
               {cout << "\n -- Iso_elas_expo1D::Module_compressibilite_equivalent(.. ";
                Signature_pti_encours(cout);
                cout << "\n *** erreur: la fonction renvoie un nan ou infinie ! ";
                throw ErrNonConvergence_loiDeComportement();
               };
            Efinale *= val_fonc;
              
            break;
           }
        case TEMPS_t : // on utilise les grandeurs stockées à t
             {Efinale= save_resul.E_t;
              nufinale= save_resul.nu_t;
              break;
             }
        case TEMPS_tdt : // on utilise les grandeurs stockées à tdt
             {Efinale= save_resul.E;
              nufinale= save_resul.nu;
              break;
             }
       };

      // retour du module
      double K= Efinale/(3.*(1.-2.*nufinale));
      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 Iso_elas_expo1D::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
     SaveResulIso_elas_expo1D & save_resul = *((SaveResulIso_elas_expo1D*) 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 Iso_elas_expo1D::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
  
 };



 // ========== codage des METHODES VIRTUELLES  protegees:================
        // calcul des contraintes a t+dt
void Iso_elas_expo1D::Calcul_SigmaHH (TenseurHH& ,TenseurBB& ,DdlElement & tab_ddl,
             TenseurBB & ,TenseurHH & ,BaseB& ,BaseH& ,TenseurBB&  epsBB_,
             TenseurBB& delta_epsBB_, TenseurBB&  ,
		  	 TenseurHH & gijHH_,Tableau <TenseurBB *>& d_gijBB_,double& ,double& ,
		  	  TenseurHH & sigHH_
		  	,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double&  module_cisaillement
		  	,const Met_abstraite::Expli_t_tdt& ex )
 {   
   #ifdef MISE_AU_POINT	 	 
	 if (epsBB_.Dimension() != 1)
	    { cout << "\nErreur : la dimension devrait etre 1 !\n";
		  cout << " Iso_elas_expo1D::Calcul_SigmaHH\n";
		  Sortie(1);
		};
	 if (tab_ddl.NbDdl() != d_gijBB_.Taille())
	    { cout << "\nErreur : le nb de ddl est != de la taille de d_gijBB_  !\n";
		  cout << " Iso_elas_expo1D::Calcul_SigmaHH\n";
		  Sortie(1);
		};
		
    #endif
    const Tenseur1BB & epsBB = *((Tenseur1BB*) &epsBB_); // passage en dim 1
    const Tenseur1HH & gijHH = *((Tenseur1HH*) &gijHH_); //   "      "  "  "
    const Tenseur1BB & delta_epsBB = *((Tenseur1BB*) &delta_epsBB_); // passage en dim 1
    Tenseur1HH & sigHH = *((Tenseur1HH*) &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;

    Tenseur1BH  epsBH =  epsBB * gijHH;
    double val_fonc = f_coefficient->Valeur(Dabs(epsBH(1,1)));
    if ((isinf(val_fonc))||( isnan(val_fonc)))
      {cout << "\n -- Iso_elas_expo1D::Calcul_DsigmaHH_tdt(.. ";
       Signature_pti_encours(cout);
       cout << "\n *** erreur: la fonction renvoie un nan ou infinie ! ";
       throw ErrNonConvergence_loiDeComportement();
      };
    
    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 << " Iso_elas_expo1D::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 << " Iso_elas_expo1D::Calcul_SigmaHH\n";
            Sortie(1);
          };
       #endif
       */
       // on récupère le premier élément du tableau uniquement
       nu = tab_val(1);
     };
    
    double E_finale = (E  * val_fonc);
    // sauvegarde des paramètres matériau
    SaveResulIso_elas_expo1D & save_resul = *((SaveResulIso_elas_expo1D*) saveResul);
    save_resul.E = E_finale;
    save_resul.nu = nu;
    
    Tenseur1BH  sigBH =  E_finale * epsBH;
    sigHH = gijHH * sigBH;   

    module_compressibilite = E_finale /(3.*(1.-2.*nu));
    module_cisaillement = 0.5 * E_finale /(2.*(1+nu));
    // traitement des énergies
    EnergieMeca deltat_ener; // init à 0. des énergies
    deltat_ener.ChangeEnergieElastique(0.5 * (sigHH && delta_epsBB));
    // mise à jour des énergies
    energ = deltat_ener+energ_t;
       
    if (Permet_affichage() > 4)
     { cout << "\n -- Iso_elas_expo1D::Calcul_DsigmaHH_tdt(.. ";
       Signature_pti_encours(cout);
       cout << " epsBB(1,1)= "<< epsBB(1,1)
            << " epsBH(1,1)= "<< epsBH(1,1)
            << " gijHH(1,1)= "<< gijHH(1,1)
            << " x= epsb= "<< Dabs(epsBH(1,1));
       if (E_nD != NULL)
         {cout << " E fctnD= " << E;};
       if (nu_nD != NULL)
         {cout << " nu fctnD= " << nu;}
       cout << " E_finale = " << E_finale
            << " sigBH(1,1)= " << sigBH(1,1)
            << " sigHH(1,1)= " << sigHH(1,1)
            << " module_compressibilite= " << module_compressibilite
            << " module cisaillement= " << module_cisaillement
            << " ener_elas= " << energ.EnergieElastique()
            << flush;
     };

    LibereTenseur(); 
 };
        
        // calcul des contraintes a t+dt et de ses variations  
void Iso_elas_expo1D::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 & delta_epsBB_
		          ,TenseurBB & ,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 & energ_t
            ,double& module_compressibilite,double&  module_cisaillement
		  	       ,const Met_abstraite::Impli&  ex)
 {
   #ifdef MISE_AU_POINT	 	 
	 if (epsBB_tdt.Dimension() != 1)
	    { cout << "\nErreur : la dimension devrait etre 1 !\n";
		  cout << " Iso_elas_expo1D::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 << " Iso_elas_expo1D::Calcul_SDsigmaHH_tdt\n";
		  Sortie(1);
		};
    #endif
    const Tenseur1BB & epsBB = *((Tenseur1BB*) &epsBB_tdt); // passage en dim 1
    const Tenseur1HH & gijHH = *((Tenseur1HH*) &gijHH_tdt); //   "      "  "  "
    const Tenseur1BB & delta_epsBB = *((Tenseur1BB*) &delta_epsBB_); // passage en dim 1
    Tenseur1HH & sigHH = *((Tenseur1HH*) &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;

    Tenseur1BH  epsBH =  epsBB * gijHH;
//    Tenseur1BH  sigBH  = (E  * (1.-alpha* pow(epsBH(1,1),ixn))) * epsBH;
    double epsb = Dabs(epsBH(1,1)); // l'invariant
    Courbe1D::ValDer valder_ver = f_coefficient->Valeur_Et_derivee(epsb); // valeur et dérivée
    
    if ((isinf(valder_ver.valeur))||( isnan(valder_ver.valeur)))
      {cout << "\n -- Iso_elas_expo1D::Calcul_DsigmaHH_tdt(.. ";
       Signature_pti_encours(cout);
       cout << "\n *** erreur: la fonction renvoie un nan ou infinie ! ";
       throw ErrNonConvergence_loiDeComportement();
      };
    
    if ((isinf(valder_ver.derivee))||( isnan(valder_ver.derivee)))
      {cout << "\n -- Iso_elas_expo1D::Calcul_DsigmaHH_tdt(.. ";
       Signature_pti_encours(cout);
       cout << "\n *** erreur: la fonction renvoie une derivee nan ou infinie ! ";
       throw ErrNonConvergence_loiDeComportement();
      };
    
    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 << " Iso_elas_expo1D::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 << " Iso_elas_expo1D::Calcul_SigmaHH\n";
            Sortie(1);
          };
       #endif
       */
       // on récupère le premier élément du tableau uniquement
       nu = tab_val(1);
     };



    Tenseur1BH  sigBH  = (E  * valder_ver.valeur) * epsBH;
    sigHH = gijHH * sigBH;

    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 ()
       Tenseur1HH & dsigHH = *((Tenseur1HH*) (d_sigHH(i)));  // passage en dim 1
       const Tenseur1BB & dgijBB =  *((Tenseur1BB*)(d_gijBB_tdt(i)));  // passage en dim 1
       const Tenseur1HH & dgijHH = *((Tenseur1HH*)(d_gijHH_tdt(i))) ; // pour simplifier l'ecriture
       const Tenseur1BB & depsBB = *((Tenseur1BB *) (d_epsBB(i))); //    "
       Tenseur1BH  depsBH =  depsBB * gijHH_tdt + epsBB_tdt * dgijHH;
       
     
       dsigHH = dgijHH * sigBH
//               + (gijHH  * depsBH) *( E * (1.  - alpha * (ixn+1) * pow(epsBH(1,1),ixn)));
               + (gijHH  * depsBH) * E * (valder_ver.valeur + epsb*valder_ver.derivee);
     };

    module_compressibilite = (E  * valder_ver.valeur)/(3.*(1.-2.*nu));
    module_cisaillement = 0.5 * (E  * valder_ver.valeur)/(2.*(1+nu));
    // traitement des énergies
    EnergieMeca deltat_ener; // init à 0. des énergies
    deltat_ener.ChangeEnergieElastique(0.5 * (sigHH && delta_epsBB));
    // mise à jour des énergies
    energ = deltat_ener+energ_t;
    if (Permet_affichage() > 4)
     { cout << "\n -- Iso_elas_expo1D::Calcul_DsigmaHH_tdt(.. ";
       Signature_pti_encours(cout);
       cout << " epsBB(1,1)= "<< epsBB(1,1)
            << " epsBH(1,1)= "<< epsBH(1,1)
            << " gijHH(1,1)= "<< gijHH(1,1)
            << " x= epsb= "<< epsb
            << " fct(x) = " << valder_ver.valeur;
       if (E_nD != NULL)
         {cout << " E fctnD= " << E;};
       if (nu_nD != NULL)
         {cout << " nu fctnD= " << nu;}
       cout << " E_finale = " << (E  * valder_ver.valeur)
            << " sigBH(1,1)= " << sigBH(1,1)
            << " sigHH(1,1)= " << sigHH(1,1)
            << " module_compressibilite= " << module_compressibilite
            << " module cisaillement= " << module_cisaillement
            << " ener_elas= " << energ.EnergieElastique()
            << flush;
     };


    LibereTenseur(); 
 };