// FICHIER : Hypo_hooke2D_C.cc
// CLASSE : Hypo_hooke2D_C


// 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 "ParaGlob.h"
#include "ConstMath.h"
#include "TypeQuelconqueParticulier.h"
#include "CharUtil.h"


#include "Hypo_hooke2D_C.h"

// constructeur  par défaut à ne pas utiliser
Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C() :
 Kc(0.),Kc_t(0.),mu(0.),mu_t(0.),epsBH33(0.),epsBH33_t(0.),eps_cumulBB(),eps_cumulBB_t()
  { cout << "\n erreur, le constructeur par defaut ne doit pas etre utilise !"
         << "\n Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C()";
    Sortie(1);
  };

// le constructeur courant
Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C
                        (SaveResul* ):
 Kc(0.),Kc_t(0.),mu(0.),mu_t(0.),epsBH33(0.),epsBH33_t(0.),eps_cumulBB(),eps_cumulBB_t()
  { };

// constructeur de copie
Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C
                                         (const Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C& sav ):
 Kc(sav.Kc),Kc_t(sav.Kc_t),mu(sav.mu),mu_t(sav.mu_t)
 ,epsBH33(sav.epsBH33),epsBH33_t(sav.epsBH33_t)
 ,eps_cumulBB(sav.eps_cumulBB),eps_cumulBB_t(sav.eps_cumulBB_t)
  { };
         // destructeur
Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::~SaveResul_Hypo_hooke2D_C()
  { };


     //============= lecture écriture dans base info ==========

// 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 Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::Lecture_base_info
                                                 (ifstream& ent,const int cas)
  {  // ici toutes les données sont toujours a priori variables
     // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas
     string toto; ent >> toto;
     #ifdef MISE_AU_POINT
      if (toto != "HYPO_E_ISO_2D_C")
          { cout << "\n erreur en lecture du conteneur pour la loi de contrainte plane generique, on a lue: "<<toto
                 << " au lieu de HYPO_E_ISO_2D_C  "
                 << " \n Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::Lecture_base_info(..";
            Sortie(1);
          }
     #endif
   
     // lecture des données de la loi
     ent  >> toto >> Kc >> toto >> mu;
     ent >> toto >> epsBH33>> toto >> eps_cumulBB;
     epsBH33_t = epsBH33;eps_cumulBB_t = eps_cumulBB;
  };

// def d'une instance de données spécifiques, et initialisation
Hypo_hooke2D_C::SaveResul *  Hypo_hooke2D_C::New_et_Initialise()
   { // on crée éventuellement le conteneur pour la loi
     SaveResul* le_SaveResul = NULL; 
     // on ramène la bonne instance
     Hypo_hooke2D_C::SaveResul * retour =  new SaveResul_Hypo_hooke2D_C(le_SaveResul);
     // insertion éventuelle de conteneurs de grandeurs quelconque
     Insertion_conteneur_dans_save_result(retour);
     // retour
     return retour;   
   };

// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::Ecriture_base_info
                                                 (ofstream& sort,const int cas)
   {  // ici toutes les données sont toujours a priori variables
      // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas
      sort << "\n HYPO_E_ISO_2D_C  ";
      // données de la loi
      sort << "\n  Kc= "<< Kc << " mu= " << mu;
      sort << " epsBH33= "<<epsBH33
           << " eps_cumulBB= "<<eps_cumulBB
           << " ";
  };

// affichage à l'écran des infos
void Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::Affiche() const
   { cout << "\n SaveResul_Hypo_hooke2D_C: " ;
     cout <<"\n  Kc= "<< Kc << " mu= " << mu ;
     cout << "\n  epsBH33= " << epsBH33 << " eps_cumulBB= " << eps_cumulBB << " ";
     cout << "\n .. fin SaveResul_Hypo_hooke2D_C:.. \n" ;
   };

         // ---- récupération d'information: spécifique à certaine classe dérivée
double Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::Deformation_plastique()
   { cout << "\n pour l'instant cette option n'est pas implante dans le cas d'une loi"
          << "\n contrainte plane quelconque "
          << "\n double Loi_comp_abstraite::SaveResul_Hypo_hooke2D_C::Deformation_plastique()";
     Sortie(1);
     return 0.; // pour taire le warning, mais on ne passe jamais là
   };

//changement de base de toutes les grandeurs internes tensorielles stockées
// beta(i,j) represente les coordonnees de la nouvelle base naturelle gpB dans l'ancienne gB
// gpB(i) = beta(i,j) * gB(j), i indice de ligne, j indice de colonne
// gpH(i) = gamma(i,j) * gH(j)
void Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::ChBase_des_grandeurs(const Mat_pleine& beta,const Mat_pleine& gamma)
{ // on ne s'intéresse qu'aux grandeurs tensorielles
  // cas de la déformation cumulée associée au type d'intégration
  eps_cumulBB.ChBase(beta);
  eps_cumulBB_t.ChBase(beta);
};

// mise à jour de la liste des grandeurs quelconques internes
void Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::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 MODULE_COMPRESSIBILITE:
          { Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                   map_type_quelconque[MODULE_COMPRESSIBILITE].Grandeur_pointee());
            *(tyTQ.ConteneurDouble()) = Kc/3.;
            break;
          };
         case MODULE_CISAILLEMENT:
          { Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                   map_type_quelconque[MODULE_CISAILLEMENT].Grandeur_pointee());
            *(tyTQ.ConteneurDouble()) = mu;
            break;
          };
         case DEF_EPAISSEUR:
          { Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                   map_type_quelconque[DEF_EPAISSEUR].Grandeur_pointee());
            *(tyTQ.ConteneurDouble()) = epsBH33;
            break;
          };
         case DEF_ASSO_LOI:
          { Grandeur_TenseurBB& tyTQ= *((Grandeur_TenseurBB*)
                         map_type_quelconque[DEF_ASSO_LOI].Grandeur_pointee());
            if (ParaGlob::Dimension() == 3) // il faut alors affecter en le 2D au 3D
              {tyTQ.RefConteneurTenseur().Affectation_trans_dimension(eps_cumulBB,true);
              }
            else // cas même dimension
              {tyTQ.RefConteneurTenseur() = eps_cumulBB;
              };
            break;
          };
         default: break; // sinon rien
        };
      }
 };


//================================================================================================


Hypo_hooke2D_C::Hypo_hooke2D_C () :  // Constructeur par defaut
  Loi_comp_abstraite(HYPO_ELAS2D_C,CAT_THERMO_MECANIQUE,2),mu(-ConstMath::trespetit)
  ,Kc(-ConstMath::tresgrand),compress_thermophysique(false)
  ,mu_temperature(NULL),Kc_temperature(NULL),type_derive(-1),cas_calcul(0)
  ,mu_IIeps(NULL),Kc_IIeps(NULL)
  ,mu_nD(NULL),Kc_nD(NULL)
     { };
	

// Constructeur de copie
Hypo_hooke2D_C::Hypo_hooke2D_C (const Hypo_hooke2D_C& loi) :
	Loi_comp_abstraite(loi),mu(loi.mu),Kc(loi.Kc),compress_thermophysique(false)
    ,mu_temperature(loi.mu_temperature),Kc_temperature(loi.Kc_temperature)
    ,mu_IIeps(loi.mu_IIeps),Kc_IIeps(loi.Kc_IIeps)
    ,mu_nD(loi.mu_nD),Kc_nD(loi.Kc_nD)
    ,type_derive(loi.type_derive)
	,cas_calcul(loi.cas_calcul)
	 { // on regarde s'il s'agit d'une courbe locale ou d'une courbe globale
	   if (mu_temperature != NULL)
	      if (mu_temperature->NomCourbe() == "_") 
	         mu_temperature = Courbe1D::New_Courbe1D(*(loi.mu_temperature));
	   if (Kc_temperature != NULL)
       if (Kc_temperature->NomCourbe() == "_")
            Kc_temperature = Courbe1D::New_Courbe1D(*(loi.Kc_temperature));;
    if (mu_IIeps != NULL)
       if (mu_IIeps->NomCourbe() == "_")
          mu_IIeps = Courbe1D::New_Courbe1D(*(loi.mu_IIeps));;
    if (Kc_IIeps != NULL)
       if (Kc_IIeps->NomCourbe() == "_")
          Kc_IIeps = Courbe1D::New_Courbe1D(*(loi.Kc_IIeps));;
    // idem pour les fonctions nD
    if (mu_nD != NULL)
     if (mu_nD->NomFonction() == "_")
         {// comme il s'agit d'une fonction locale on la redéfinie (sinon pb lors du destructeur de loi)
          string non_courbe("_");
          mu_nD = Fonction_nD::New_Fonction_nD(*loi.mu_nD);
         };
    if (Kc_nD != NULL)
     if (Kc_nD->NomFonction() == "_")
         {// comme il s'agit d'une fonction locale on la redéfinie (sinon pb lors du destructeur de loi)
          string non_courbe("_");
          Kc_nD = Fonction_nD::New_Fonction_nD(*loi.Kc_nD);
         };
	  };

Hypo_hooke2D_C::~Hypo_hooke2D_C ()
// Destructeur 
{ if (mu_temperature != NULL)
      if (mu_temperature->NomCourbe() == "_") delete mu_temperature;
  if (Kc_temperature != NULL)
      if (Kc_temperature->NomCourbe() == "_") delete Kc_temperature;
  if (mu_IIeps != NULL)
      if (mu_IIeps->NomCourbe() == "_") delete mu_IIeps;
  if (Kc_IIeps != NULL)
      if (Kc_IIeps->NomCourbe() == "_") delete Kc_IIeps;
  if (mu_nD != NULL)
      if (mu_nD->NomFonction() == "_") delete mu_nD;
  if (Kc_nD != NULL)
      if (Kc_nD->NomFonction() == "_") delete Kc_nD;

  };

// Lecture des donnees de la classe sur fichier
void Hypo_hooke2D_C::LectureDonneesParticulieres (UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D
               ,LesFonctions_nD& lesFonctionsnD)
  { string nom;
    string nom_class_methode("Hypo_hooke2D_C::LectureDonneesParticulieres");
    // lecture de la compressibilité instantanée
    *(entreePrinc->entree) >> nom ;
    #ifdef MISE_AU_POINT
    if (nom != "Kc=")
       { cout << "\n erreur en lecture de la loi de HYPO_ELAS2D_C, on attendait Kc= suivi d'un nombre "
              << " ou du mot cle Kc_thermo_dependant_ et ensuite une courbe ";
         entreePrinc->MessageBuffer("**erreur1 Hypo_hooke2D_C::LectureDonneesParticulieres (...**");
         throw (UtilLecture::ErrNouvelleDonnee(-1));
         Sortie(1);
         }
    #endif
    
    // gestion d'erreur de syntaxe non permise
    if(((strstr(entreePrinc->tablcar,"Kc_thermo_dependant_")!=0) ||
        (strstr(entreePrinc->tablcar,"Kc_fonction_nD:")!=0)
       )
       &&
       (strstr(entreePrinc->tablcar,"Kc_avec_compressibilite_externe")!=0)
      )
       { cout << "\n erreur en lecture de la loi de HYPO_ELAS2D_C, il n'est pas possible d'avoir une compressibilite externe "
              << " et une compressibilite thermo_dependante simultanement: incoherent !! ";
         entreePrinc->MessageBuffer("**erreur1 Hypo_hooke2D_C::LectureDonneesParticulieres (...**");
         throw (UtilLecture::ErrNouvelleDonnee(-1));
         Sortie(1);
       };
    
    // on regarde si Kc  est thermo dépendant
    if(strstr(entreePrinc->tablcar,"Kc_thermo_dependant_")!=0)
      { thermo_dependant=true; *(entreePrinc->entree) >> nom;
          if (nom != "Kc_thermo_dependant_") 
           { cout << "\n erreur en lecture de la thermodependance de Kc, on aurait du lire le mot cle Kc_thermo_dependant_"
                  << " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
             entreePrinc->MessageBuffer("**erreur2 Hypo_hooke2D_C::LectureDonneesParticulieres (...**");
             throw (UtilLecture::ErrNouvelleDonnee(-1));
             Sortie(1);     
            }
          // lecture de la loi d'évolution de Kc 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))  { Kc_temperature = lesCourbes1D.Trouve(nom);}
          else { // sinon il faut la lire maintenant
             string non_courbe("_");   
             Kc_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
             // lecture de la courbe
             Kc_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
               } 
         // prepa du flot de lecture
         entreePrinc->NouvelleDonnee(); 
      }
    // sinon on regarde si la compressibilité sera fourni en externe  
    else if (strstr(entreePrinc->tablcar,"Kc_avec_compressibilite_externe")!=0)
      {*(entreePrinc->entree) >>  nom;
       compress_thermophysique=true;
      }
    // sinon on regarde si le module  dépend d'une fonction nD
    else if(strstr(entreePrinc->tablcar,"Kc_fonction_nD:")!=0)
     { string nom;
       string mot_cle2="Kc_fonction_nD:";

       // on lit le nom de la fonction
       string nom_fonct;
       bool 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))
         {Kc_nD = lesFonctionsnD.Trouve(nom_fonct);
         }
       else
         {// sinon il faut la lire maintenant
          string non("_");
          Kc_nD = Fonction_nD::New_Fonction_nD(non, Id_Nom_Fonction_nD(nom_fonct));
          // lecture de la courbe
          Kc_nD->LectDonnParticulieres_Fonction_nD (non,entreePrinc);
          // maintenant on vérifie que la fonction est utilisable
          if (Kc_nD->NbComposante() != 1 )
           { cout << "\n erreur en lecture de Kc, la fonction " << nom_fonct
                  << " est une fonction vectorielle a   " << Kc_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 = Kc_nD->Tab_enu_etendu();
       if (tab_enu.Contient(TEMP))
         thermo_dependant=true;
       // prepa du flot de lecture
       entreePrinc->NouvelleDonnee();
     }
    // sinon c'est directement le module que l'on lit
    else
     { // lecture du coeff 
          *(entreePrinc->entree) >> Kc ;
     };
     
    // on regarde si le module  dépend du deuxième invariant
    if(strstr(entreePrinc->tablcar,"Kc_IIeps_")!=0)
     { // on vérifie que Kc_avec_compressibilite_externe n'est pas valide car dans ce cas
       // la dépendance au deuxième invariant de la déformation n'est pas valide
       if (compress_thermophysique)
         { cout << "\n erreur on ne peut pas avoir Kc_avec_compressibilite_externe "
                << " et Kc dependant du deuxieme invariant d'epsilon, ";
           entreePrinc->MessageBuffer("**erreur5 Hypo_hooke2D_C::LectureDonneesParticulieres (...**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
          }
       // si tout est ok on lit
       *(entreePrinc->entree) >> nom;
       if (nom != "Kc_IIeps_") 
         { cout << "\n erreur en lecture de la dependance de Kc au deuxieme invariant d'epsilon, "
                << " on aurait du lire le mot cle Kc_IIeps_"
                << " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
           entreePrinc->MessageBuffer("**erreur6 Hypo_hooke2D_C::LectureDonneesParticulieres (...**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
          }
       // lecture de la loi d'évolution en fonction du deuxième invariant
       *(entreePrinc->entree) >>  nom;    
       // on regarde si la courbe existe, si oui on récupère la référence 
       if (lesCourbes1D.Existe(nom)) 
         { Kc_IIeps = lesCourbes1D.Trouve(nom);
         }
       else
        { // sinon il faut la lire maintenant
          string non_courbe("_");   
          Kc_IIeps = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
          // lecture de la courbe
          Kc_IIeps->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
         } 
       // prepa du flot de lecture
       if(strstr(entreePrinc->tablcar,"fin_loi_HYPO_ELAS2D_C")==0) entreePrinc->NouvelleDonnee(); 
     };
     
    
    // ---- lecture du coef de cisaillement instantané 
    *(entreePrinc->entree) >> nom; 
    if (nom != "mu=") 
      { cout << "\n erreur en lecture du coef de cisaillement instantane , on aurait du lire le mot mu=";
        entreePrinc->MessageBuffer("**erreur3 Hypo_hooke2D_C::LectureDonneesParticulieres (...**");
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);
      };
    // on regarde si le cisaillement  est thermo dépendante
    if(strstr(entreePrinc->tablcar,"mu_thermo_dependant_")!=0)
     { thermo_dependant=true;
       *(entreePrinc->entree) >> nom;
       if (nom != "mu_thermo_dependant_") 
         { cout << "\n erreur en lecture de la thermodependance de mu, on aurait du lire le mot cle mu_thermo_dependant_"
                << " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
           entreePrinc->MessageBuffer("**erreur3 Hypo_hooke2D_C::LectureDonneesParticulieres (...**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
          }
       // lecture de la loi d'évolution 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)) 
         { mu_temperature = lesCourbes1D.Trouve(nom);
          }
       else
        { // sinon il faut la lire maintenant
          string non_courbe("_");   
          mu_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
          // lecture de la courbe
          mu_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
         } 
       // prepa du flot de lecture
       if(strstr(entreePrinc->tablcar,"fin_loi_HYPO_ELAS2D_C")==0) entreePrinc->NouvelleDonnee(); 
      }
    // sinon on regarde si mu dépend d'une fonction nD
    else if(strstr(entreePrinc->tablcar,"mu_fonction_nD:")!=0)
     { string nom;
       string mot_cle1="mu=";
       string mot_cle2="mu_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;
       bool 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))
         {mu_nD = lesFonctionsnD.Trouve(nom_fonct);
         }
       else
         {// sinon il faut la lire maintenant
          string non("_");
          mu_nD = Fonction_nD::New_Fonction_nD(non, Id_Nom_Fonction_nD(nom_fonct));
          // lecture de la courbe
          mu_nD->LectDonnParticulieres_Fonction_nD (non,entreePrinc);
          // maintenant on vérifie que la fonction est utilisable
          if (mu_nD->NbComposante() != 1 )
           { cout << "\n erreur en lecture de f , la fonction " << nom_fonct
                  << " est une fonction vectorielle a   " << mu_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 = mu_nD->Tab_enu_etendu();
       if (tab_enu.Contient(TEMP))
         thermo_dependant=true;
       // prepa du flot de lecture
       entreePrinc->NouvelleDonnee();
     }
    else
     { // sinon lecture de mu
       *(entreePrinc->entree) >> mu ;
      };
    // on regarde si le cisaillement  dépend du deuxième invariant
    if(strstr(entreePrinc->tablcar,"mu_IIeps_")!=0)
     { *(entreePrinc->entree) >> nom;
       if (nom != "mu_IIeps_") 
         { cout << "\n erreur en lecture de la dependance de mu au deuxieme invariant d'epsilon, "
                << " on aurait du lire le mot cle mu_IIeps_"
                << " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
           entreePrinc->MessageBuffer("**erreur4 Hypo_hooke2D_C::LectureDonneesParticulieres (...**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
          }
       // lecture de la loi d'évolution en fonction du deuxième invariant
       *(entreePrinc->entree) >>  nom;    
       // on regarde si la courbe existe, si oui on récupère la référence 
       if (lesCourbes1D.Existe(nom)) 
         { mu_IIeps = lesCourbes1D.Trouve(nom);
          }
       else
        { // sinon il faut la lire maintenant
          string non_courbe("_");   
          mu_IIeps = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
          // lecture de la courbe
          mu_IIeps->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
         } 
       // prepa du flot de lecture
       if(strstr(entreePrinc->tablcar,"fin_loi_HYPO_ELAS2D_C")==0) entreePrinc->NouvelleDonnee(); 
     };
       
    // ---- on regarde ensuite si le type de dérivée est indiqué
    string toto;
    if (strstr(entreePrinc->tablcar,"type_derivee")!=NULL)
     { // lecture du type
       *(entreePrinc->entree) >> toto >> type_derive;
       if ((type_derive!=0)&&(type_derive!=-1)&&(type_derive!=1))
         { cout << "\n le type de derivee indique pour la loi de Hypo_hooke2D_C:  "<< type_derive
                << " n'est pas acceptable (uniquement -1 ou 0 ou 1), on utilise le type par defaut (-1)"
                << " qui correspond à la derivee de Jauman";
           type_derive = -1;
          }
     }
    // 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;};};
    // prepa du flot de lecture
    if(strstr(entreePrinc->tablcar,"fin_loi_HYPO_ELAS2D_C")==0) entreePrinc->NouvelleDonnee(); 
    // appel au niveau de la classe mère
    Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire
                 (*entreePrinc,lesFonctionsnD);
    // si fct nD on prépare l'accès éventuel à des grandeurs locales
    Verif_et_preparation_acces_grandeurs_locale();

    };
    
// affichage de la loi
void Hypo_hooke2D_C::Affiche() const 
  { cout << " \n loi de comportement HYPO_ELAS 2D_C ";
    
    if (Kc_temperature != NULL) { cout << " coef Kc thermo dependant " 
                                        << " courbe Kc=f(T): " << Kc_temperature->NomCourbe() <<" ";}
    else if(compress_thermophysique) { cout << " compressibilite calculee avec une loi thermophysique " ;}
    else if (Kc_nD != NULL)
     {cout << "\n compressibilite calculee avec une fonction nD:  ";
      cout << "Kc_fonction_nD:" << " ";
      if (Kc_nD->NomFonction() != "_")
           cout << Kc_nD->NomFonction();
      else
           Kc_nD->Affiche();
     }
    else                     { cout << " coef  Kc= " << Kc ;}

    if ( Kc_IIeps != NULL) { cout << " compressibilite dependant multiplicativement du deuxieme invariant d'epsilon  "
                                  << " courbe Kc_final=Kc*f(eps:eps): " << Kc_IIeps->NomCourbe() <<" ";};
    if ( mu_temperature != NULL) { cout << " cisaillement thermo dependant "
                                        << " courbe mu=f(T): " << mu_temperature->NomCourbe() <<" ";}
    else if (mu_nD != NULL)
     {cout << "\n fonction f calculee avec une fonction nD:  ";
      cout << "f_fonction_nD:" << " ";
      if (mu_nD->NomFonction() != "_")
           cout << mu_nD->NomFonction();
      else
           mu_nD->Affiche();
     }
    else                       { cout << " cisaillement mu= " << mu ;}
    if ( mu_IIeps != NULL) { cout << " cisaillement dependant multiplicativement du deuxieme invariant d'epsilon  "
                                        << " courbe mu_final=mu*f(eps:eps): " << mu_IIeps->NomCourbe() <<" ";};
    switch (type_derive)
     { case -1: cout << ", et derivee de jauman pour la contrainte" << endl;break;
       case 0: cout << ", et derivee de lee deux fois covariantes pour la contrainte" << endl; break; 
       case 1: cout << ", et derivee de lee deux fois contravariantes pour la contrainte" << endl; break;
      }    
    // 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 Hypo_hooke2D_C::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 (Kc == -ConstMath::tresgrand) 
      { // on initialise à une valeur arbitraire
        Kc = 10.;}
    if (mu == -ConstMath::trespetit) 
      { // on initialise à une valeur arbitraire
        mu = 0.15;}
    sort << "\n# .........................  loi de comportement HYPO_ELAS 2D_C ......................."
         << "\n# | coef compressibilite    |  coef cisaillement | type de derivee objective utilisee |"
         << "\n# |      instantane         |       instantane   | pour le calcul de la contrainte    |"
         << "\n# |         Kc              |              mu    |type_derivee  (facultatif)          |"
         << "\n#......................................................................................"
         << "\n      Kc=     " << setprecision(8) << Kc << "  mu=       " << setprecision(8) << mu 
         << " type_derivee  " << type_derive     
         << "\n                fin_loi_HYPO_ELAS2D_C         " << endl;
    if ((rep != "o") && (rep != "O" ) && (rep != "0") )
      {sort
           << "\n# --------- type de derivee ----------"
           << "\n# le type de derivee est optionnel: = -1 -> derivee de Jauman (valeur par defaut), "
           << "\n# = 0 -> derivee deux fois covariantes , "
           << "\n# = 1 -> derivee deux fois contravariantes"
           << "\n# dans le cas ou l'on veut une valeur differente de la valeur par defaut"
           << "\n# il faut mettre le mot cle"
           << "\n# <type_derivee> suivi de la valeur -1 ou 0 ou 1"
           << "\n# ";
      sort << "\n# --------- Kc calcule via une loi thermophysique ---------"
           << "\n# pour le module de compressibilite: Kc, il est possible d'indiquer que"
           << "\n# le module sera fourni "
           << "\n# par une loi thermophysique (celle associee au meme element), pour ce faire"
           << "\n# on indique uniquement: "
           << "\n# Kc=  Kc_avec_compressibilite_externe "
           << "\n# NB: ensuite aucune autre info concernant Kc ne doit etre fournie. "
           << "\n# ";
      sort << "\n# ------- dependance explicite a la temperature ----------"
           << "\n# \n# chacun des 2 parametres materiau Kc et mu "
           << "\n# peut etre remplace par une fonction dependante de la temperature "
           << "\n#  (sauf si le cas Kc_avec_compressibilite_externe est actif, si oui "
           << "\n#   aucune info complementaire ne peut-etre fournie pour Kc) "
           << "\n# pour ce faire on utilise un mot cle puis une nom de courbe ou la courbe"
           << "\n# directement comme avec  les autre loi de comportement "
           << "\n# exemple pour Kc:          Kc=   Kc_thermo_dependant_   courbe3  "
           << "\n# exemple pour f:           mu=   mu_thermo_dependant_   courbe2  "
           << "\n# IMPORTANT: a chaque fois qu'il y a une thermodependance, il faut passer une ligne "
           << "\n# apres la description de la grandeur thermodependante, mais pas de passage "
           << "\n# a la ligne si ce n'est pas thermo dependant"
           << "\n# "
           << "\n# -------- dependance a une fonction nD -------------"
           << "\n#  Kc et mu peuvent au choix dependre d'une fonction nD.  "
           << "\n#  Dans ce cas Kc et mu ne doivent pas avoir ete declare thermodependant, "
           << "\n#  mais on peut inclure une thermo-dependance dans la fonction nD,  "
           << "\n#  Exemple pour Kc : "
           << "\n#  Kc= Kc_fonction_nD: fonction_1 "
           << "\n#  "
           << "\n#  Exemple pour mu : "
           << "\n#  mu= mu_fonction_nD: fonction_2 "
           << "\n#  "
           << "\n#  La declaration des fonctions suit la meme logique que pour les courbes 1D "
           << "\n#  "
           << "\n# -------- dependance directe a (Eps:Eps) -------------"
           << "\n# il est également possible de definir un facteur multiplicatif pour Kc et mu "
           << "\n# fonction explicite du deuxieme invariant  de la deformation = (Eps:Eps) "
           << "\n# = eps_1^1 * eps_1^1 + eps_2^2 * eps_2^2 "
           << "\n# Ceci permet d'obtenir une evolution finale non lineaire dont l'operateur tangent"
           << "\n# prend en compte les variations de la deformation."
           << "\n# pour cela on indique le mot cle Kc_IIeps_ suivi  du nom d'une courbe"
           << "\n# suivi d'un passage a la ligne."
           << "\n# Exemple de declaration d'un Kc thermo dependant et fonction "
           << "\n# egalement du deuxieme invariant "
           << "\n#       Kc=   Kc_thermo_dependant_   courbe2 "
           << "\n#       Kc_IIeps_ courbe5 "
           << "\n# "
           << "\n# Exemple de declaration d'un Kc non thermo-dependant,  "
           << "\n#  mais fonction  du deuxieme invariant"
           << "\n#       Kc=   10000    Kc_IIeps_ courbe4 "
           << "\n# "
           << "\n# NB: 1) on peut cumuler une dependance a une fonction nD et une dependance "
           << "\n#     explicite multiplicative a (Eps:Eps)"
           << "\n#     2) a la fin de la definition de Kc_IIeps_ , il faut passer une ligne "
           << "\n# "
           << "\n# de la meme maniere on peut definir un facteur multiplicatif pour mu "
           << "\n# fonction du deuxieme  invariant  de la deformation = (Eps:Eps) . "
           << "\n# pour cela on indique le mot cle mu_IIeps_  suivi du nom d'une "
           << "\n# courbe suivi d'un passage a la ligne"
           << "\n# Exemple de declaration d'un mu thermo dependant et fonction egalement "
           << "\n# du deuxieme invariant "
           << "\n#       mu=   mu_thermo_dependant_   courbe2 "
           << "\n#       mu_IIeps_ courbe4 "
           << "\n# "
           << "\n# Exemple de declaration d'un mu non thermo-dependant, mais fonction  "
           << "\n# du deuxieme invariant "
           << "\n#       mu=   1200    mu_IIeps_ courbe4 "
           << "\n# "
           << "\n# NB: 1) comme pour Kc, on peut cumuler une dependance a une fonction nD et  "
           << "\n#     une dependance explicite multiplicative a (Eps:Eps)"
           << "\n#     2) a la fin de la definition de mu_IIeps_ , il faut passer une ligne "
           << "\n# "
           << "\n# "
           << "\n# NB: pour toutes les definition de courbe ou de fct nD il est aussi possible"
           << "\n# d'introduire directement la courbe a la place de son nom, comme pour "
           << "\n# toutes les autres lois "
           << "\n#";
      sort << "\n# ------- restriction partie spherique ou deviatorique ----------"
           << "\n#   Il est ensuite possible  d'indiquer que l'on souhaite calculer "
           << "\n#   seulement la partie spherique de la loi"
           << "\n#   pour cela on met le mot cle: seule_spherique a la fin des donnees "
           << "\n#   sur la meme ligne que le dernier enreg  "
           << "\n#   D'une maniere identique il est possible d'indiquer que l'on souhaite "
           << "\n#   calculer seulement la partie  deviatorique de la loi, "
           << "\n#   pour cela on met le mot cle: seule_deviatorique   "
           << "\n# "
           << "\n# "
           << "\n# ----------- fin des parametres --------"
           << "\n#   la derniere ligne doit contenir uniquement le mot cle:     "
           << "\n#           fin_loi_HYPO_ELAS2D_C "
           << "\n#  ";
         };

     sort << endl;
    // appel de la classe mère
    Loi_comp_abstraite::Info_commande_don_LoisDeComp(entreePrinc);     
  };  		  	  

// test si la loi est complete
int Hypo_hooke2D_C::TestComplet()
    { int ret = LoiAbstraiteGeneral::TestComplet();
      if (!compress_thermophysique &&((Kc_temperature == NULL) && (Kc == -ConstMath::tresgrand))    && (Kc_nD == NULL)
         )
       { cout << " \n le coef de compressibilite instantane n'est pas defini pour  la loi " << Nom_comp(id_comp)
              << '\n';
         ret = 0;
       }                
      if ((mu_temperature == NULL) && (mu == -ConstMath::trespetit)
          && (mu_nD == NULL)
         )
       { cout << " \n le coef de cisaillement instantane mu n'est pas defini 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 Hypo_hooke2D_C";
      	  Affiche();
      	  ret = 0;     
      	}
      return ret; 
    }; 
	 
//----- 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 Hypo_hooke2D_C::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
                                             ,LesFonctions_nD& lesFonctionsnD)
  { string nom; 
	   if (cas == 1)
	    { ent >> nom;
	      if (nom != "HYPO_ELAS2D_C")
	        { cout << "\n erreur en lecture de la loi : Hypo_hooke2D_C, on attendait le mot cle : HYPO_ELAS2D_C "
	               << "\n Hypo_hooke2D_C::Lecture_base_info_loi(...";
	          Sortie(1);
	        };
	      // ensuite normalement il n'y a pas de pb de lecture puisque c'est écrit automatiquement (sauf en debug)
	      ent >> nom >> type_derive;
       int test; // sert pour le test des courbes
       // compressibilité
       ent >> nom >>  compress_thermophysique ;
       if (!compress_thermophysique)
        { ent  >> test;
          switch (test)
           {case 1: // cas d'une valeur numérique
             ent >> Kc; break;
            case 2: // cas d'une fonction nD
             {ent >> nom ;
              if (nom != " Kc_fonction_nD: ")
                { cout << "\n erreur en lecture de la fonction nD, on attendait "
                       << " Kc_fonction_nD: et on a lue " << nom
                       << "\n Hypo_hooke2D_C::Lecture_base_info_loi(...";
                  Sortie(1);
                };
              Kc_nD = lesFonctionsnD.Lecture_pour_base_info(ent,cas,Kc_nD);
              break;
             }
            case 3: // cas d'une fonction_Kc_temperature
             {ent >> nom;
              if (nom != " fonction_Kc_temperature ")
                { cout << "\n erreur en lecture de la fonction Kc_temperature, on attendait "
                       << " fonction_Kc_temperature et on a lue " << nom
                       << "\n Hypo_hooke2D_C::Lecture_base_info_loi(...";
                  Sortie(1);
                };
              Kc_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,Kc_temperature);
              break;
             }
           default:
             { cout << "\n erreur en lecture de Kc, on attendait un nombre 1,2 ou 3 "
                    << " et on a lue " << test
                    << "\n Hypo_hooke2D_C::Lecture_base_info_loi(...";
               Sortie(1);
             };
          };

        // dépendance multiplicative à IIeps éventuelle
        ent >> nom >> test;
        if (!test)
         { if (Kc_IIeps != NULL) {if (Kc_IIeps->NomCourbe() == "_")
              delete Kc_IIeps; Kc_IIeps = NULL;};
         }
        else
         { ent >> nom; Kc_IIeps = lesCourbes1D.Lecture_pour_base_info(ent,cas,Kc_IIeps); };
       };

       // cisaillement
        ent >> nom >> test;

        switch (test)
         {case 1: // cas d'une valeur numérique
           ent >> mu; break;
          case 2: // cas d'une fonction nD
           {ent >> nom ;
            if (nom != " mu_fonction_nD: ")
              { cout << "\n erreur en lecture de la fonction nD, on attendait "
                     << " mu_fonction_nD: et on a lue " << nom
                     << "\n Hypo_hooke2D_C::Lecture_base_info_loi(...";
                Sortie(1);
              };
            mu_nD = lesFonctionsnD.Lecture_pour_base_info(ent,cas,mu_nD);
            break;
           }
          case 3: // cas d'une fonction_mu_temperature
           {ent >> nom;
            if (nom != " fonction_mu_temperature ")
              { cout << "\n erreur en lecture de la fonction mu_temperature, on attendait "
                     << " fonction_mu_temperature et on a lue " << nom
                     << "\n Hypo_hooke2D_C::Lecture_base_info_loi(...";
                Sortie(1);
              };
            mu_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,mu_temperature);
            break;
           }
         default:
           { cout << "\n erreur en lecture de mu, on attendait un nombre 1,2 ou 3 "
                  << " et on a lue " << test
                  << "\n Hypo_hooke2D_C::Lecture_base_info_loi(...";
             Sortie(1);
           };
        };
        
        // dépendance multiplicative à IIeps éventuelle
        ent >> nom >> test;
        if (!test)
         { if (mu_IIeps != NULL) {if (mu_IIeps->NomCourbe() == "_")
              delete mu_IIeps; mu_IIeps = NULL;};
         }
        else
         { ent >> nom; mu_IIeps = lesCourbes1D.Lecture_pour_base_info(ent,cas,mu_IIeps); };

        // indicateur pour les calculs partielles
        ent >> nom >> cas_calcul ;
        // si fct nD on prépare l'accès éventuel à des grandeurs locales
        Verif_et_preparation_acces_grandeurs_locale();
	   } 
	   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 Hypo_hooke2D_C::Ecriture_base_info_loi(ofstream& sort,const int cas)
{ if (cas == 1)
   { sort << " HYPO_ELAS2D_C " << " type_derivee " << type_derive << " " ;
     sort << "\n  compressibilite ";
     sort << " compress_thermophysique= " << compress_thermophysique << " ";
     if (!compress_thermophysique)
      {if ((Kc_temperature == NULL)&&(Kc_nD == NULL))
        { sort << " 1 " << " " << Kc << " ";}
       else if (Kc_nD != NULL)
         {sort << " 2 Kc_fonction_nD: " << " ";
          LesFonctions_nD::Ecriture_pour_base_info(sort, cas,Kc_nD);
         }
       else
         { sort << " 3 " << " fonction_Kc_temperature ";
           LesCourbes1D::Ecriture_pour_base_info(sort,cas,Kc_temperature);
         };
       if (Kc_IIeps == NULL)
         { sort << " " << false << " " ;}
       else
         { sort << " " << true << " Kc_IIeps ";
           LesCourbes1D::Ecriture_pour_base_info(sort,cas,Kc_IIeps);
         };
      };

     sort << "\n  cisaillement ";
     if ((mu_temperature == NULL) && (mu_nD == NULL))
       { sort << " 1 " << mu << " ";}
     else if (mu_nD != NULL)
       {sort << " 2 mu_fonction_nD: " << " ";
        LesFonctions_nD::Ecriture_pour_base_info(sort, cas,mu_nD);
       }
     else
       {sort << " 3 " << " fonction_mu_temperature ";
        LesCourbes1D::Ecriture_pour_base_info(sort,cas,mu_temperature);
       };
     if (mu_IIeps == NULL)
       {sort << " " << false << " " ;}
     else
       {sort << " " << true << " fonction_epseps ";
        LesCourbes1D::Ecriture_pour_base_info(sort,cas,mu_IIeps);
       };
        
     // indicateur pour les calculs partielles
     sort << " cas_calcul " << cas_calcul << " "; 
   }
  // appel de la classe mère
  Loi_comp_abstraite::Ecriture_don_base_info(sort,cas);
  };

// récupération de la dernière déformation d'épaisseur calculée: cette déformaion n'est utile que pour des lois en contraintes planes ou doublement planes
// - pour les lois 3D : retour d'un nombre très grand, indiquant que cette fonction est invalide
// - pour les lois 2D def planes: retour de 0
// les infos nécessaires à la récupération de la def, sont stockées dans saveResul
// qui est le conteneur spécifique au point où a été calculé la loi
double Hypo_hooke2D_C::Eps33BH(SaveResul * saveResul) const
{ // tout d'abord on récupère le conteneur
  SaveResul_Hypo_hooke2D_C & save_resul = *((SaveResul_Hypo_hooke2D_C*) saveResul);
  return save_resul.epsBH33;
};

// récupération de la variation relative d'épaisseur calculée: h/h0
//  cette variation n'est utile que pour des lois en contraintes planes
// - pour les lois 3D : retour d'un nombre très grand, indiquant que cette fonction est invalide
// - pour les lois 2D def planes: retour de 0
// les infos nécessaires à la récupération , sont stockées dans saveResul
// qui est le conteneur spécifique au point où a été calculé la loi
double Hypo_hooke2D_C::HsurH0(SaveResul * saveResul) const
{ // tout d'abord on récupère le conteneur
  SaveResul_Hypo_hooke2D_C & save_resul = *((SaveResul_Hypo_hooke2D_C*) saveResul);
  // On considère qu'il s'agit d'une def logarithmique ... au cas où
  // d'autre part normalement epsBH33 à la même valeur en mixte et en absolu
  return exp(save_resul.epsBH33);
};

// 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 Hypo_hooke2D_C::Grandeur_particuliere
              (bool absolue,List_io<TypeQuelconque>& liTQ,Loi_comp_abstraite::SaveResul * saveDon ,list<int>& decal) const
 {// on passe en revue la liste
  List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end();
  SaveResul_Hypo_hooke2D_C & save_resul = *((SaveResul_Hypo_hooke2D_C*) saveDon);
  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())
      { // 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
          if (Kc_temperature != NULL) {tyTQ(1+(*idecal))=Kc_temperature->Valeur(*temperature)/3.;}
          else {tyTQ(1+(*idecal))=save_resul.Kc/3.;(*idecal)++;};
          break;
         }
        case MODULE_CISAILLEMENT:
        { Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
          if (mu_temperature != NULL){tyTQ(1+(*idecal))=mu_temperature->Valeur(*temperature);}
          else {tyTQ(1+(*idecal))=save_resul.mu;(*idecal)++;};
          break;
         }
       //  -----cas de la déformation d'épaisseur à t
       case DEF_EPAISSEUR:
        { Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
          tyTQ(1+(*idecal)) = save_resul.epsBH33;(*idecal)++;
          break;
        };
       case DEF_ASSO_LOI:
        { Tab_Grandeur_TenseurBB& tyTQ= *((Tab_Grandeur_TenseurBB*) (*itq).Grandeur_pointee()); // pour simplifier
          if (ParaGlob::Dimension() == 3) // il faut alors affecter le 2D au 3D
            {tyTQ(1+(*idecal)).Affectation_trans_dimension(save_resul.eps_cumulBB,true);
            }
          else // cas même dimension
            {tyTQ(1+(*idecal)) = save_resul.eps_cumulBB;
            };
          (*idecal)++;
          break;
        }
         
       default: ;// on ne fait rien
      }; // fin du switch
     };
    }; // fin du for
  };

// récupération et création de la liste de tous les grandeurs particulières
// ces grandeurs sont ajoutées à la liste passées en paramètres
void Hypo_hooke2D_C::ListeGrandeurs_particulieres(bool absolue,List_io<TypeQuelconque>& liTQ) const
{ //on commence par définir une grandeur_scalaire_double
  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
   //  $$$ 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);
     };
    };
   //  -----cas de la déformation d'épaisseur à t uniquement
   //on regarde si ce type d'info existe déjà: si oui on augmente la taille du tableau, si non on crée
   {List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
    for (itq=liTQ.begin();itq!=itqfin;itq++)
      if ((*itq).EnuTypeQuelconque() == DEF_EPAISSEUR)
        { 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(DEF_EPAISSEUR,EPS11,grand_courant);
         liTQ.push_back(typQ1);
        };
   };
   //  $$$ cas de la déformation cumulée associée à la loi, c-a-d au type d'intégration
   {List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
    for (itq=liTQ.begin();itq!=itqfin;itq++)
      if ((*itq).EnuTypeQuelconque() == DEF_ASSO_LOI)
       {Tab_Grandeur_TenseurBB& tyTQ= *((Tab_Grandeur_TenseurBB*) (*itq).Grandeur_pointee()); // pour simplifier
        int taille = tyTQ.Taille()+1;
        tyTQ.Change_taille(taille); nexistePas = false;
       };
    if (nexistePas)
      {int dim_espace = ParaGlob::Dimension();
       TenseurBB* tens = NevezTenseurBB(dim_espace); // un tenseur typique
       Tab_Grandeur_TenseurBB epsassoBB(*tens,1);
       // def d'un type quelconque représentatif
       TypeQuelconque typQ(DEF_ASSO_LOI,EPS11,epsassoBB);
       liTQ.push_back(typQ);
       delete tens; // car on n'en a plus besoin
      };
   };
  };
                          
// calcul d'un module d'young équivalent à la loi
double Hypo_hooke2D_C::Module_young_equivalent
        (Enum_dure temps,const Deformation & ,SaveResul *saveDon)
 { // au niveau instantané on a: E=(3*Kc*mu)/(2*Kc+mu);
   // et nu = (Kc-mu)/(2*Kc+mu) (vérifié plusieurs fois !!)
   
   // on récupère le conteneur
   SaveResul_Hypo_hooke2D_C & save_resul = *((SaveResul_Hypo_hooke2D_C*) saveDon);
   // au niveau instantané on a: E=(3*Kc*mu)/(2*Kc+mu);
   // et nu = (Kc-mu)/(2*Kc+mu)
   double E=0.;
   switch (temps)
    {case TEMPS_0 : // rien n'a été calculé on utilise les grandeurs initiales
          E=(3*Kc*mu)/(2*Kc+mu);
          break;
     case TEMPS_t : // on utilise les grandeurs stockées à t
          {double Kc_actuelle = save_resul.Kc_t;
           double mu_actuelle = save_resul.mu_t;
            
           E= (3*Kc_actuelle*mu_actuelle)/(2*Kc_actuelle+mu_actuelle);
           break;
          }
     case TEMPS_tdt : // on utilise les grandeurs stockées à tdt
          {double Kc_actuelle = save_resul.Kc;
           double mu_actuelle = save_resul.mu;
            
           E= (3*Kc_actuelle*mu_actuelle)/(2*Kc_actuelle+mu_actuelle);
           break;
          }
    };
     
   return  E;

  };
  
// récupération d'un module de compressibilité équivalent à la loi pour un chargement nul
double Hypo_hooke2D_C::Module_compressibilite_equivalent
         (Enum_dure temps,const Deformation & ,SaveResul * saveDon)
  {  // ici le module  correspond à Kc, cependant Kc est un module tangent et non
     // sécant ... peut-être sera changé par la suite
     // 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
     SaveResul_Hypo_hooke2D_C & save_resul = *((SaveResul_Hypo_hooke2D_C*) saveDon);
     double K=0.;
     switch (temps)
      {case TEMPS_0 : // rien n'a été calculé on utilise les grandeurs initiales
            K=Kc/3.;
            break;
       case TEMPS_t : // on utilise les grandeurs stockées à t
            {K=save_resul.Kc_t/3.;
             break;
            }
       case TEMPS_tdt : // on utilise les grandeurs stockées à tdt
            {K = save_resul.Kc/3.;
             break;
            }
      };
     
     return  K;

  };

// calcul de la vitesse de deformation epsBH33_point
double Hypo_hooke2D_C::Deps33BH(TenseurBB &  epsBB_,TenseurBB &  DepsBB_,TenseurHH & gijHH_)
 {   
   #ifdef MISE_AU_POINT	 	 
	 if (DepsBB_.Dimension() != 2)
	    { cout << "\nErreur : la dimension devrait etre 2 !\n";
		  cout << " Hypo_hooke2D_C::Deps33BH(\n";
		  Sortie(1);
		};
    #endif
    const Tenseur2BB & epsBB = *((Tenseur2BB*) &epsBB_); // passage en dim 2
    const Tenseur2BB & Deps_BB = *((Tenseur2BB*) &DepsBB_); // passage en dim 2
    const Tenseur2HH & gijHH = *((Tenseur2HH*) &gijHH_); //   "      "  "  "

    // cas de la thermo dépendance, on calcul les grandeurs
    if (mu_temperature != NULL) mu = mu_temperature->Valeur(*temperature);
    if (!compress_thermophysique) // sinon kc est mis à jour avec la méthode CalculGrandeurTravail(..)
     {if (Kc_temperature != NULL) Kc = Kc_temperature->Valeur(*temperature);};
    // cas d'une non-linéarité en fonction de la déformation
    double Kc_use=Kc;// pour ne pas changer les valeurs à chaque passage !!
    double mu_use=mu;//         "
    if ((Kc_IIeps != NULL)||(mu_IIeps != NULL)) 
     { Tenseur2BH epsBH = epsBB * gijHH;
       if (Kc_IIeps != NULL)
        { double coef1 = Kc_IIeps->Valeur(epsBH && epsBH); 
          Kc_use *= coef1;
         };
       if (mu_IIeps != NULL)
        { double coef2 = mu_IIeps->Valeur(epsBH && epsBH); 
          mu_use *= coef2;
         };
     };
    // on a delta eps_3^3 = -nu/(1.-nu) (delta eps_1^1+delta eps_2^2)
	 // -- pour simplifier on calcul les E et Nu correspondant
	 // double E=(3*Kc_use*mu_use)/(2*Kc_use+mu_use); // a priori ne sert pas
    double nu = (Kc_use-mu_use)/(2*Kc_use+mu_use);// (vérifié plusieurs fois !!)
    Tenseur2BH  DepsBH =  Deps_BB * gijHH;
    double Deps_33 =  -nu/(1.-nu) * DepsBH.Trace();
    return Deps_33;
 };
   
 // 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 Hypo_hooke2D_C::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
     SaveResul_Hypo_hooke2D_C & save_resul = *((SaveResul_Hypo_hooke2D_C*) 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 MODULE_COMPRESSIBILITE: case MODULE_CISAILLEMENT: case DEF_EPAISSEUR:
             { // 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;
             }
          case DEF_ASSO_LOI:
            { // on crée le conteneur ad hoc pour le passage d'info
              // def d'un conteneur de grandeurs quelconques,
              int dim_espace = ParaGlob::Dimension();
              TenseurBB* tens = NevezTenseurBB(dim_espace); // un tenseur typique
              Grandeur_TenseurBB grand_courant(*tens);
              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 Hypo_hooke2D_C::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 MODULE_COMPRESSIBILITE : case MODULE_CISAILLEMENT: case DEF_EPAISSEUR:
        case DEF_ASSO_LOI:
          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
  
 };
 
// vérification et préparation de l'acces aux grandeurs locales
void  Hypo_hooke2D_C::Verif_et_preparation_acces_grandeurs_locale()
  {list <EnumTypeQuelconque > listEnuQuelc; // def de la liste des grandeurs quelconque
   
   // ---récup des grandeurs quelconques nécessaires pour les fonction nD
   if (mu_nD != NULL)
    {const Tableau <EnumTypeQuelconque>& tab_enu_quelc = mu_nD->Tab_enu_quelconque();
     int tail = tab_enu_quelc.Taille();
     if (tail)
      {for (int i = 1; i<= tail; i++)
         listEnuQuelc.push_back(tab_enu_quelc(i));
      };
    };
   if (Kc_nD != NULL)
    {const Tableau <EnumTypeQuelconque>& tab_enu_quelc = mu_nD->Tab_enu_quelconque();
     int tail = tab_enu_quelc.Taille();
     if (tail)
      {for (int i = 1; i<= tail; i++)
         listEnuQuelc.push_back(tab_enu_quelc(i));
      };
    };

   listEnuQuelc.sort();
   listEnuQuelc.unique();


   // activation dans la loi de la demande des grandeurs quelconques
   this->Activation_stockage_grandeurs_quelconques(listEnuQuelc);
  };

 // ========== codage des METHODES VIRTUELLES  protegees:================
        // calcul des contraintes a t+dt
//void Calcul_SigmaHH (TenseurHH & sigHH_t,TenseurBB& DepsBB,DdlElement & tab_ddl
//    ,TenseurBB & gijBB_t,TenseurHH & gijHH_t,BaseB& giB,BaseH& gi_H, TenseurBB & epsBB_
//    ,TenseurBB & delta_epsBB_
//    ,TenseurBB & gijBB_,TenseurHH & gijHH_,Tableau <TenseurBB *>& d_gijBB_
//    ,double& jacobien_0,double& jacobien,TenseurHH & sigHH
//    ,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double&  module_cisaillement
//    ,const Met_abstraite::Expli_t_tdt& ex);
void Hypo_hooke2D_C::Calcul_SigmaHH (TenseurHH& sigHH_t,TenseurBB& DepsBB_,DdlElement &
             ,TenseurBB & gijBB_t_,TenseurHH & gijHH_t_,BaseB& ,BaseH& ,TenseurBB& epsBB_
             ,TenseurBB& delta_epsBB_
             , TenseurBB& gijBB_ ,TenseurHH & gijHH_,Tableau <TenseurBB *>&
             ,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 (DepsBB_.Dimension() != 2)
	    { cout << "\nErreur : la dimension devrait etre 2 !\n";
		     cout << " Hypo_hooke2D_C::Calcul_SigmaHH\n";
		     Sortie(1);
		   };
    #endif
    const Tenseur2BB & epsBB = *((Tenseur2BB*) &epsBB_); // passage en dim 2
    const Tenseur2BB & Deps_BB = *((Tenseur2BB*) &DepsBB_); // passage en dim 2
    const Tenseur2BB & delta_epsBB = *((Tenseur2BB*) &delta_epsBB_); // passage en dim 3
    const Tenseur2HH & gijHH = *((Tenseur2HH*) &gijHH_); //   "      "  "  "
    const Tenseur2BB & gijBB = *((Tenseur2BB*) &gijBB_); //   "      "  "  "
    const Tenseur2HH & gijHH_t = *((Tenseur2HH*) &gijHH_t_); //   "      "  "  "
    const Tenseur2BB & gijBB_t = *((Tenseur2BB*) &gijBB_t_); //   "      "  "  "
    Tenseur2HH & sigHH = *((Tenseur2HH*) &sigHH_);  //   "      "  "  "
    Tenseur2HH & sigHH_nn = *((Tenseur2HH*) &sigHH_t);  //   "      "  "  "

    SaveResul_Hypo_hooke2D_C & save_resul = *((SaveResul_Hypo_hooke2D_C*) saveResul);

    // tenseur intermédiaires utilisées selon les cas (par forcément dans tous les cas !!)
    Tenseur2BH sigBH_n;Tenseur2HH sigHH_n; Tenseur2BB sigBB_n;Tenseur2BB sig_interBB_n;
    switch (type_derive) //case 1: cas d'une dérivée de Lie deux fois contravariante : cas par défaut
     {case -1: // cas d'une dérivée de jauman: 1/2 deux fois covariant + deux fois contra
        {sig_interBB_n = gijBB_t * sigHH_nn * gijBB_t;
         sigBH_n = 0.5*( sig_interBB_n * gijHH + gijBB * sigHH_nn) ;
         sigHH_n = gijHH * sigBH_n ; 
         sigBB_n = sigBH_n * gijBB;
         // pour la déformation cumulée associée,
         Tenseur2HH eps_interHH_n =  gijHH_t * save_resul.eps_cumulBB_t * gijHH_t;
         Tenseur2BB epsBB_n = 0.5*( gijBB * eps_interHH_n * gijBB + save_resul.eps_cumulBB_t);
         save_resul.eps_cumulBB = delta_epsBB + epsBB_n;
         break;
        }
      case 0: // cas d'une dérivée de Lie deux fois covariantes
        {sigBB_n = gijBB_t * sigHH_nn * gijBB_t;
         sigBH_n = sigBB_n * gijHH ;
         sigHH_n = gijHH * sigBH_n ;
         // pour la déformation cumulée associée, on sait que cela donne directement la def d'Almansi
         // mais la def passée en paramètre pourrait ne pas être d'Almansi, donc on calcule
         // quand même la def cumulée
         save_resul.eps_cumulBB = save_resul.eps_cumulBB_t + delta_epsBB;
         break;
        }
      case 1: // cas d'une dérivée de Lie deux fois contravariantes
        {sigHH_n = sigHH_nn;
         sigBH_n = gijBB * sigHH_n;
         sigBB_n = sigBH_n * gijBB; 
         // pour la déformation cumulée associée,
         Tenseur2HH eps_interHH_n =  gijHH_t * save_resul.eps_cumulBB_t * gijHH_t;
         Tenseur2BB epsBB_n =  gijBB *  eps_interHH_n * gijBB ;
         save_resul.eps_cumulBB = delta_epsBB + epsBB_n;
         break;}
      };

    // 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;
    
    // introduction de la def d'épaisseur (de l'itération précédente)
    // dans une liste utilisable éventuellement

    // cas de la thermo dépendance, on calcul les grandeurs
    if (mu_temperature != NULL)
      { mu = mu_temperature->Valeur(*temperature);}
    else if (mu_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);
//        // on introduit la grandeur epsBH33
//        List_io<Ddl_etendu> deja_calculer_etend;
//        List_io<const TypeQuelconque *> deja_calculer_Q;
//        Grandeur_scalaire_double grand_courant(save_resul.epsBH33);
//        TypeQuelconque typQ1(DEF_EPAISSEUR,EPS11,grand_courant);
//        deja_calculer_Q.push_front(&typQ1);
 
        Tableau <double> & tab_val = Loi_comp_abstraite::Loi_comp_Valeur_FnD_Evoluee
            (mu_nD,1 // une seule valeur attendue en retour
             ,ex_impli,ex_expli_tdt,ex_expli
             ,NULL
             ,NULL //&deja_calculer_Q
             ,&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 = mu_nD->Li_enu_etendu_scalaire();
        List_io <TypeQuelconque >& li_quelc = mu_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 = mu_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 a la fonction mu "
                  << " doit calculer un scalaire or le tableau de retour est de taille "
                  << tab_val.Taille() << " ce n'est pas normal !\n";
             cout << " Hypo_hooke2D_C::Calcul_SigmaHH\n";
             Sortie(1);
           };
        #endif
*/
        // on récupère le premier élément du tableau uniquement
        mu = tab_val(1);
      };
    if (!compress_thermophysique) // sinon kc est mis à jour avec la méthode CalculGrandeurTravail(..)
     {if (Kc_temperature != NULL)
       {Kc = Kc_temperature->Valeur(*temperature);}
      else if (Kc_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
             (Kc_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 = Kc_nD->Li_enu_etendu_scalaire();
         List_io <TypeQuelconque >& li_quelc = Kc_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 = Kc_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 a la fonction Kc "
                   << " doit calculer un scalaire or le tableau de retour est de taille "
                   << tab_val.Taille() << " ce n'est pas normal !\n";
              cout << " Hypo_hooke2D_C::Calcul_SigmaHH\n";
              Sortie(1);
            };
         #endif
*/
         // on récupère le premier élément du tableau uniquement
         Kc = tab_val(1);
       };
     };

    // cas d'une non-linéarité en fonction de la déformation
    double Kc_use=Kc;// pour ne pas changer les valeurs à chaque passage !!
    double mu_use=mu;//         "
    if ((Kc_IIeps != NULL)||(mu_IIeps != NULL)) 
     { Tenseur2BH epsBH = epsBB * gijHH;
       if (Kc_IIeps != NULL)
        { double coef1 = Kc_IIeps->Valeur(epsBH && epsBH); 
          Kc_use *= coef1;
         };
       if (mu_IIeps != NULL)
        { double coef2 = mu_IIeps->Valeur(epsBH && epsBH); 
          mu_use *= coef2;
         };
     };


    // sauvegarde des paramètres matériau
    save_resul.Kc = Kc_use;
    save_resul.mu = mu_use;

    Tenseur2BH  DepsBH =  Deps_BB * gijHH;
    // recup de l'incrément de temps
	   double deltat=ParaGlob::Variables_de_temps().IncreTempsCourant();
    // le calcul de la contrainte correspond à l'intégration d'une équation différencielle
    // D_barre=1/mu dS/dt pour la partie déviatoire
    // et pour la partie sphérique 
    // I_D = 1/(Kc) dI_Sig/dt 
    // en 2D contraintes planes, epsBH33 s'exprime en fonction des deux autres def d'où la possibilité
    // de calculer la trace uniquement en fonction de epsBH11 et epsBH22
	 // -- pour simplifier on calcul les E et Nu correspondant
	 // double E=(3*Kc*mu)/(2*Kc+mu); // a priori ne sert pas
    double nu = (Kc_use-mu_use)/(2*Kc_use+mu_use);// (vérifié plusieurs fois !!)
    double coef_trace = (1.-2.*nu)/(1.-nu); // a priori une erreur  mu_use/Kc_use;   
    double IDeps = DepsBH.Trace() * coef_trace;
    static const double untier=1./3.;
    Tenseur2BH  Deps_barre_BH = DepsBH - (untier * IDeps) * IdBH2;
    // cas de la partie sphérique: sig33 = 0 en contraintes planes
    double Isig_n = sigBH_n.Trace();
    double Isigma = Isig_n + deltat * Kc_use * IDeps;
    // cas de la partie déviatorique

    switch (cas_calcul)
     { case 0: // calcul normal (tous les termes)
     	{ // cas de la partie sphérique déjà calculée
          // cas de la partie déviatorique
          Tenseur2BH SBH_n = sigBH_n - (untier * Isig_n) * IdBH2;
          Tenseur2HH SHH = gijHH * (SBH_n + deltat * mu_use * Deps_barre_BH);
          sigHH = SHH + (untier * Isigma) * gijHH ;
     	  break;	
     	}
       case 1: // calcul de la partie déviatorique seule
     	{ // cas de la partie déviatorique
          Tenseur2BH SBH_n = sigBH_n - (untier * Isig_n) * IdBH2;
          sigHH = gijHH * (SBH_n + deltat * mu_use * Deps_barre_BH);
     	  break;	
     	}
       case 2: // calcul de la partie sphérique seule
     	{ // cas de la partie sphérique
          sigHH = (untier * Isigma) * gijHH ;
     	  break;	
     	}
       default:
       	{ cout << "\n erreur l'indicateur cas_calcul= " << cas_calcul << " n'a pas une valeur correcte !! "
       	       << "\n Hypo_hooke2D_C::Calcul_SigmaHH (.... ";
       	  Sortie(1);     
       	}
     };
    // récup de la compressibilité (-p_point = compress * I_D, S_point = 2 * cisaille * D_barre)
    module_compressibilite = Kc_use/3.;
    module_cisaillement = 0.5 * mu_use;
    // -- partie epsBH33
    // calcul de la déformation d'épaisseur: on utilise la compressibilité
    // d'où le calcul de la nouvelle épaisseur en utilisant la relation:
    // log (var_vol) = traceSig / 3 / K
    if (Dabs(Kc_use) < ConstMath::pasmalpetit)
      // on ne va pas pouvoir calculer une nouvelle épaisseur
      {if (Dabs(Isigma) < ConstMath::pasmalpetit)
        // la contrainte est également très faible donc c'est normale, rien ne bouge
        save_resul.epsBH33 = save_resul.epsBH33_t;
       else // sinon c'est un peu bizarre, on signale au cas où
        {if (ParaGlob::NiveauImpression()>2)
          cout << "\n *** pb dans le calcul de la deformation d'epaisseur: "
               << " coef de compressibilite = "<<Kc_use << " et la trace de sigma = "
               << Isigma << " on continue avec une deformation d'epaisseur inchangee  ... "
               << "\n Hypo_hooke2D_C::Calcul_SigmaHH(...) "
               << endl;
        };
      }
    else // sinon le module étant suffisament grand on va pouvoir calculer
      {// on pose
       double log_var_surf = log((*(ex.jacobien_tdt))/(*(ex.jacobien_0)));
       // log (var_vol) = traceSig / 3 / K = log(var_sur) + log(var_epais)
       // d'où log(var_epais) = epsBH33 = traceSig / 3 / K - log(var_sur)
//       save_resul.eps33 = Isigma * untier / Kc_use - log_var_surf;
       // modif 2 mai 2024: dans le cas d'une loi hypo élastique on utilise la forme incrémentale
       // delta eps_3^3 = -nu/(1.-nu) (delta eps_1^1+delta eps_2^2)
         double DepsBH_33 =  -nu/(1.-nu) * DepsBH.Trace();//trace 2D
       save_resul.epsBH33 += DepsBH_33;
      };

    // traitement des énergies
    // on incrémente l'énergie élastique 
    energ.ChangeEnergieElastique(energ_t.EnergieElastique() +   0.5 * deltat * ((sigHH + sigHH_nn) && Deps_BB));
    
  
    LibereTenseur(); 
 };
        
//        void Calcul_DsigmaHH_tdt (TenseurHH & sigHH_t,TenseurBB& DepsBB,DdlElement & tab_ddl
//            ,BaseB& giB_t,TenseurBB & gijBB_t,TenseurHH & gijHH_t
//            ,BaseB& giB_tdt,Tableau <BaseB> & d_giB_tdt,BaseH& giH_tdt,Tableau <BaseH> & d_giH_tdt
//            ,TenseurBB & epsBB_tdt,Tableau <TenseurBB *>& d_epsBB
//            ,TenseurBB & delta_epsBB,TenseurBB & gijBB_tdt,TenseurHH & gijHH_tdt
//            ,Tableau <TenseurBB *>& d_gijBB_tdt
//            ,Tableau <TenseurHH *>& d_gijHH_tdt,double& jacobien_0,double& jacobien
//            ,Vecteur& d_jacobien_tdt,TenseurHH& sigHH,Tableau <TenseurHH *>& d_sigHH
//            ,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double&  module_cisaillement
//            ,const Met_abstraite::Impli& ex);
        // calcul des contraintes a t+dt et de ses variations
void Hypo_hooke2D_C::Calcul_DsigmaHH_tdt (TenseurHH& sigHH_t,TenseurBB& DepsBB_,DdlElement & tab_ddl
            ,BaseB& ,TenseurBB & gijBB_t_,TenseurHH & gijHH_t_
            ,BaseB& ,Tableau <BaseB> & ,BaseH& ,Tableau <BaseH> &
            ,TenseurBB & epsBB_tdt,Tableau <TenseurBB *>& d_epsBB
            ,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 & energ_t,double& module_compressibilite,double&  module_cisaillement
            ,const Met_abstraite::Impli& ex)
 {
   #ifdef MISE_AU_POINT	 	 
    if (DepsBB_.Dimension() != 2)
       { cout << "\nErreur : la dimension devrait etre 2 !\n";
         cout << " Hypo_hooke2D_C::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 << " Hypo_hooke2D_C::Calcul_SDsigmaHH_tdt\n";
         Sortie(1);
       };
    #endif
    const Tenseur2BB & epsBB = *((Tenseur2BB*) &epsBB_tdt); // passage en dim 2
    const Tenseur2BB & Deps_BB = *((Tenseur2BB*) &DepsBB_); // passage en dim 2
    const Tenseur2HH & gijHH = *((Tenseur2HH*) &gijHH_tdt); //   "      "  "  "
    const Tenseur2BB & gijBB = *((Tenseur2BB*) &gijBB_tdt); //   "      "  "  "
    Tenseur2HH & sigHH = *((Tenseur2HH*) &sigHH_tdt);  //   "      "  "  "
    Tenseur2HH & sigHH_nn = *((Tenseur2HH*) &sigHH_t);  //   "      "  "  "

    const Tenseur2BB & delta_epsBB = *((Tenseur2BB*) &delta_epsBB_); // passage en dim 2
    const Tenseur2HH & gijHH_t = *((Tenseur2HH*) &gijHH_t_); //   "      "  "  "
    const Tenseur2BB & gijBB_t = *((Tenseur2BB*) &gijBB_t_); //   "      "  "  "

    SaveResul_Hypo_hooke2D_C & save_resul = *((SaveResul_Hypo_hooke2D_C*) saveResul);

    // tenseur intermédiaires utilisées selon les cas (par forcément dans tous les cas !!)
    Tenseur2BH sigBH_n;Tenseur2HH sigHH_n; Tenseur2BB sigBB_n;Tenseur2BB sig_interBB_n;
    switch (type_derive) //case 1: cas d'une dérivée de Lie deux fois contravariante : cas par défaut
     {case -1: // cas d'une dérivée de jauman: 1/2 deux fois covariant + deux fois contra
        {sig_interBB_n = gijBB_t * sigHH_nn * gijBB_t;
         sigBH_n = 0.5*( sig_interBB_n * gijHH + gijBB * sigHH_nn) ;
         sigHH_n = gijHH * sigBH_n ; 
         sigBB_n = sigBH_n * gijBB;
         // pour la déformation cumulée associée,
         Tenseur2HH eps_interHH_n =  gijHH_t * save_resul.eps_cumulBB_t * gijHH_t;
         Tenseur2BB epsBB_n = 0.5*( gijBB * eps_interHH_n * gijBB + save_resul.eps_cumulBB_t);
         save_resul.eps_cumulBB = delta_epsBB + epsBB_n;
         break;
        }
      case 0: // cas d'une dérivée de Lie deux fois covariantes
        {sigBB_n = gijBB_t * sigHH_nn * gijBB_t;
         sigBH_n = sigBB_n * gijHH ;
         sigHH_n = gijHH * sigBH_n ;
         // pour la déformation cumulée associée, on sait que cela donne directement la def d'Almansi
         // mais la def passée en paramètre pourrait ne pas être d'Almansi, donc on calcule
         // quand même la def cumulée
         save_resul.eps_cumulBB = save_resul.eps_cumulBB_t + delta_epsBB;
         break;
        }
      case 1: // cas d'une dérivée de Lie deux fois contrariantes
        {sigHH_n = sigHH_nn;
         sigBH_n = gijBB * sigHH_n;
         sigBB_n = sigBH_n * gijBB; 
         // pour la déformation cumulée associée,
         Tenseur2HH eps_interHH_n =  gijHH_t * save_resul.eps_cumulBB_t * gijHH_t;
         Tenseur2BB epsBB_n =  gijBB *  eps_interHH_n * gijBB ;
         save_resul.eps_cumulBB = delta_epsBB + epsBB_n;
         break;
        }
      };

      
    // 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;

    // cas de la thermo dépendance, on calcul les grandeurs
    if (mu_temperature != NULL)
      { mu = mu_temperature->Valeur(*temperature);}
    else if (mu_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
            (mu_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 = mu_nD->Li_enu_etendu_scalaire();
        List_io <TypeQuelconque >& li_quelc = mu_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 = mu_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 a la fonction mu "
                  << " doit calculer un scalaire or le tableau de retour est de taille "
                  << tab_val.Taille() << " ce n'est pas normal !\n";
             cout << " Hypo_hooke2D_C::Calcul_SigmaHH\n";
             Sortie(1);
           };
        #endif
        */
        // on récupère le premier élément du tableau uniquement
        mu = tab_val(1);
      };
    if (!compress_thermophysique) // sinon kc est mis à jour avec la méthode CalculGrandeurTravail(..)
     {if (Kc_temperature != NULL)
       {Kc = Kc_temperature->Valeur(*temperature);}
      else if (Kc_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
             (Kc_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 = Kc_nD->Li_enu_etendu_scalaire();
         List_io <TypeQuelconque >& li_quelc = Kc_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 = Kc_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 a la fonction Kc "
                   << " doit calculer un scalaire or le tableau de retour est de taille "
                   << tab_val.Taille() << " ce n'est pas normal !\n";
              cout << " Hypo_hooke2D_C::Calcul_SigmaHH\n";
              Sortie(1);
            };
         #endif
         */
         // on récupère le premier élément du tableau uniquement
         Kc = tab_val(1);
       };
     };


    // cas d'une non-linéarité en fonction de la déformation
    Tenseur2BH epsBH; Courbe1D::ValDer valder_Kc,valder_mu;
    double Kc_base=Kc;double Kc_use=Kc;// pour ne pas changer les valeurs à chaque passage !!
    double mu_base=mu;double mu_use=mu;//     idem
    if ((Kc_IIeps != NULL)||(mu_IIeps != NULL)) 
     { epsBH = epsBB * gijHH;double II_eps=epsBH.II();
       if (Kc_IIeps != NULL)
        { valder_Kc  = Kc_IIeps->Valeur_Et_derivee(II_eps); 
          Kc_use *= valder_Kc.valeur;
        };
       if (mu_IIeps != NULL)
        { valder_mu  = mu_IIeps->Valeur_Et_derivee(II_eps); 
          mu_use *= valder_mu.valeur;
        };
     };

    // sauvegarde des paramètres matériau
    save_resul.Kc = Kc_use;
    save_resul.mu = mu_use;

    Tenseur2BH  DepsBH =  Deps_BB * gijHH;
    // recup de l'incrément de temps
	   double deltat=ParaGlob::Variables_de_temps().IncreTempsCourant();
    // le calcul de la contrainte correspond à l'intégration d'une équation différencielle
    // D_barre=1/mu dS/dt pour la partie déviatoire
    // et pour la partie sphérique 
    // I_D = 1/(Kc) dI_Sig/dt    
    // en 2D contraintes planes, eps33 s'exprime en fonction des deux autres def d'où la possibilité
    // de calculer la trace uniquement en fonction de eps11 et eps22
	 // -- pour simplifier on calcul les E et Nu correspondant
	 // double E=(3*Kc*mu)/(2*Kc+mu); // a priori ne sert pas
    double nu = (Kc_use-mu_use)/(2*Kc_use+mu_use);// (vérifié plusieurs fois !!)
    double coef_trace = (1.-2.*nu)/(1.-nu); // a priori une erreur  mu_use/Kc_use;   
    double IDeps = DepsBH.Trace() * coef_trace;
    static const double untier=1./3.;
    Tenseur2BH  Deps_barre_BH = DepsBH - (untier * IDeps) * IdBH2; 
    double Isig_n = sigBH_n.Trace();
    Tenseur2BH SBH_n = sigBH_n - (untier * Isig_n) * IdBH2;

    double unSurDeltat=0;    
	   if (Abs(deltat) >= ConstMath::trespetit)
     {unSurDeltat = 1./deltat;}
    else
    // si l'incrément de temps est tres petit on remplace 1/deltat par un nombre tres grand
     { // non un pas de temps doit être positif !! or certaine fois il peut y avoir des pb
       if (unSurDeltat < 0)
        { cout << "\n le pas de temps est négatif !! "; };
       unSurDeltat = ConstMath::tresgrand;
      }; 
    // cas de la partie sphérique
    double Isigma = Isig_n + deltat * Kc_use * IDeps;
    // cas de la partie déviatorique

    switch (cas_calcul)
     { case 0: // calcul normal (tous les termes)
     	{ // la partie sphérique est déjà calculé, cas de la partie déviatorique
          Tenseur2HH SHH = gijHH * (SBH_n + deltat * mu_use * Deps_barre_BH);
          sigHH = SHH + (untier * Isigma) * gijHH ;
     	  break;	
     	}
       case 1: // calcul de la partie déviatorique seule
     	{ sigHH = gijHH * (SBH_n + deltat * mu_use * Deps_barre_BH);
     	  break;	
     	}
       case 2: // calcul de la partie sphérique seule
     	{ sigHH = (untier * Isigma) * gijHH *IdBH3;
          break;	
     	}
       default:
       	{ cout << "\n erreur l'indicateur cas_calcul= " << cas_calcul << " n'a pas une valeur correcte !! "
       	       << "\n Hypo_hooke2D_C::Calcul_DsigmaHH_tdt (.... ";
       	  Sortie(1);     
       	}	
     };
  
////--- debug
//cout << "\n Hypo_hooke2D_C::Calcul_DsigmaHH_tdt";
//cout << "\n IDeps= "<<IDeps << " Isig_n= "<<Isig_n << " Isigma= "<<Isigma
//     << " mu_use= "<< mu_use << "\n Deps_barre_BH ";
//Deps_barre_BH.Ecriture(cout);
//cout << " sigHH "; sigHH.Ecriture(cout);
//cout << " Deps_BB "; Deps_BB.Ecriture(cout);
//cout << " gijHH "; gijHH.Ecriture(cout);
//cout << endl;
////--- fin debug

    // cas de la partie déviatoire puis du tenseur total 
    int nbddl = d_gijBB_tdt.Taille();
    Tenseur2BH d_DepsBH,d_Deps_barre_BH,depsBH; // tenseurs de travail  
    Tenseur2BH dsigBH_n,d_SBH_n; // tenseurs de travail 
    Tenseur_ns2HH d_SHH; // tenseurs de travail 
    // en fait dans le cas d'une linéarisation seul le transport de la contrainte à de l'importance
    // maintenant calcul de l'opérateur tangent
    for (int i = 1; i<= nbddl; i++)
      {// on fait uniquement une égalité d'adresse pour ne pas utiliser
       // le constructeur d'ou la profusion d'* et de ()
       Tenseur2HH & dsigHH = *((Tenseur2HH*) (d_sigHH(i)));  // passage en dim 1
       const Tenseur2BB & dgijBB =  *((Tenseur2BB*)(d_gijBB_tdt(i)));  // passage en dim 1
       const Tenseur2HH & dgijHH = *((Tenseur2HH*)(d_gijHH_tdt(i))) ; // pour simplifier l'ecriture
       const Tenseur2BB & depsBB = *((Tenseur2BB *) (d_epsBB(i))); //    "
       // variation de la vitesse de déformation
       d_DepsBH = ( unSurDeltat) * depsBB * gijHH + Deps_BB * dgijHH;
       // variation de la trace
       double d_IDeps = d_DepsBH.Trace() * coef_trace;
       // variation du déviateur
       d_Deps_barre_BH =  d_DepsBH - (d_IDeps/3.) * IdBH2; 

       // variation de sigma_n
       switch (type_derive) 
        { case -1: // // cas d'une dérivée de jauman: 1/2 deux fois covariant + deux fois contra
           {// pour info sigBH_n = 0.5*(gijBB * sigHH_n + (gijBB_t * sigHH_n * gijBB_t) * gijHH) 
            dsigBH_n = 0.5*(sig_interBB_n * dgijHH + dgijBB * sigHH_nn ); 
            break;}
          case 0: // cas d'une dérivée de Lie deux fois covariantes
           {// pour info sigBH_n = (gijBB_t * sigHH_n * gijBB_t) * gijHH
            dsigBH_n = sigBB_n * dgijHH;  
            break;}
          case 1: // cas d'une dérivée de Lie deux fois contravariantes
           {// pour info sigBH_n = gijBB * sigHH_n
            dsigBH_n = dgijBB * sigHH_n; break;}
           };    
       // variation de la trace de sigma_n du au transport
       double dIsig_n = dsigBH_n.Trace();
       // variation de la trace de sigma actuel
       double dIsigma = dIsig_n + deltat * Kc_use * d_IDeps;
       double dIIepsBH=0.;
       if ((Kc_IIeps != NULL) || (mu_IIeps != NULL))
       	{depsBH =  epsBB * dgijHH  + depsBB * gijHH ;
       	 dIIepsBH = (depsBH && epsBH) + (epsBH && depsBH);
       	 };
       if (Kc_IIeps != NULL)
          { double d_Kc = Kc_base * valder_Kc.derivee * (dIIepsBH);
            dIsigma += deltat * d_Kc * IDeps;           
          };
       // variation du déviateur due au transport
       d_SBH_n = dsigBH_n - (untier * dIsig_n) * IdBH2;
       //
       switch (cas_calcul)
        { case 0: // calcul normal (tous les termes)
     	   { // variation du déviateur des contraintes
             d_SHH = dgijHH * (SBH_n + deltat * mu_use * Deps_barre_BH)
                     + gijHH * (d_SBH_n + deltat * mu_use * d_Deps_barre_BH);
             // cas d'une non-linéarité en fonction de la déformation
             if (mu_IIeps != NULL)
              { depsBH =  epsBB * dgijHH  + depsBB * gijHH ;
                double d_mu = mu_base * valder_mu.derivee * (dIIepsBH);
                d_SHH += gijHH * ((deltat * d_mu) * Deps_barre_BH);           
               };
             dsigHH = d_SHH + (untier * dIsigma) * gijHH
                            + (untier * Isigma) * dgijHH ;
     	     break;	
     	   }
          case 1: // calcul de la partie déviatorique seule
     	   { // variation du déviateur des contraintes
             dsigHH = dgijHH * (SBH_n + deltat * mu_use * Deps_barre_BH)
                            + gijHH * (d_SBH_n + deltat * mu_use * d_Deps_barre_BH);
             // cas d'une non-linéarité en fonction de la déformation
             if (mu_IIeps != NULL)
              { depsBH =  epsBB * dgijHH  + depsBB * gijHH ;
                double d_mu = mu_base * valder_mu.derivee * (dIIepsBH);
                dsigHH += gijHH * ((deltat * d_mu) * Deps_barre_BH);           
               };
     	     break;	
     	   }
          case 2: // calcul de la partie sphérique seule
     	   { dsigHH = (untier * dIsigma) * gijHH 
                      + (untier * Isigma) * dgijHH ;
             break;	
     	   }
        };
      };
  
    // récup de la compressibilité (-p_point = compress * I_D, S_point = cisaille * D_barre)
    module_compressibilite = Kc_use/3.;
    module_cisaillement = 0.5 * mu_use;

    // -- partie eps33
    // calcul de la déformation d'épaisseur: on utilise la compressibilité
    // d'où le calcul de la nouvelle épaisseur en utilisant la relation:
    // log (var_vol) = traceSig / 3 / K
    if (Dabs(Kc_use) < ConstMath::pasmalpetit)
      // on ne va pas pouvoir calculer une nouvelle épaisseur
      {if (Dabs(Isigma) < ConstMath::pasmalpetit)
        // la contrainte est également très faible donc c'est normale, rien ne bouge
        save_resul.epsBH33 = save_resul.epsBH33_t;
       else // sinon c'est un peu bizarre, on signale au cas où
        {if (ParaGlob::NiveauImpression()>2)
          cout << "\n *** pb dans le calcul de la deformation d'epaisseur: "
               << " coef de compressibilite = "<<Kc_use << " et la trace de sigma = "
               << Isigma << " on continue avec une deformation d'epaisseur inchangee  ... "
               << "\n Hypo_hooke2D_C::Calcul_SigmaHH(...) "
               << endl;
        };
      }
    else // sinon le module étant suffisament grand on va pouvoir calculer
      {// on pose
       double log_var_surf = log((*(ex.jacobien_tdt))/(*(ex.jacobien_0)));
       // log (var_vol) = traceSig / 3 / K = log(var_sur) + log(var_epais)
       // d'où log(var_epais) = epsBH33 = traceSig / 3 / K - log(var_sur)
       //       save_resul.eps33 = Isigma * untier / Kc_use - log_var_surf;
       // modif 2 mai 2024: dans le cas d'une loi hypo élastique on utilise la forme incrémentale
       // delta eps_3^3 = -nu/(1.-nu) (delta eps_1^1+delta eps_2^2)
         double DepsBH_33 =  -nu/(1.-nu) * DepsBH.Trace();//trace 2D
       save_resul.epsBH33 += DepsBH_33;
      };


    // traitement des énergies
    // on incrémente l'énergie élastique 
    energ.ChangeEnergieElastique(energ_t.EnergieElastique() +   0.5 * deltat * ((sigHH + sigHH_nn) && Deps_BB));
  
    LibereTenseur(); 
 };