V 7.030 : modif calcul de epsBH33 dans Hypo_hooke2D_C

Parametres/EnteteParaGlob.h

@@ -41,7 +41,7 @@
 	   EnumLangue ParaGlob::langueHZ = FRANCAIS; // langue utilisée pour les entrées sorties
     int ParaGlob::nbComposantesTenseur = 1; // nombre de composantes par defaut a 1
     int ParaGlob::nivImpression = 2; // niveau d'impression
-    string ParaGlob::nbVersion = "7.029" ;   // numéro de version du logiciel
+    string ParaGlob::nbVersion = "7.030" ;   // numéro de version du logiciel
     string ParaGlob::NbVersionsurfichier = ""; // numéro de version lue en entrée fichier
     int ParaGlob::nb_diggit_double_calcul= 17; // nombre de chiffre significatifs utilisé pour 
                                         // l'affichage des double précision pour l'archivage

comportement/Hypo_elastique/Hypo_hooke2D_C.cc

@@ -49,7 +49,7 @@ using namespace std;  //introduces namespace std
 
 // 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.),eps33(0.),eps33_t(0.),eps_cumulBB(),eps_cumulBB_t()
+ 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);
@@ -58,14 +58,14 @@ Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C() :
 // 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.),eps33(0.),eps33_t(0.),eps_cumulBB(),eps_cumulBB_t()
+ 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)
- ,eps33(sav.eps33),eps33_t(sav.eps33_t)
+ ,epsBH33(sav.epsBH33),epsBH33_t(sav.epsBH33_t)
  ,eps_cumulBB(sav.eps_cumulBB),eps_cumulBB_t(sav.eps_cumulBB_t)
   { };
          // destructeur
@@ -94,8 +94,8 @@ void Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::Lecture_base_info
    
      // lecture des données de la loi
      ent  >> toto >> Kc >> toto >> mu;
-     ent >> toto >> eps33>> toto >> eps_cumulBB;
+     ent >> toto >> epsBH33>> toto >> eps_cumulBB;
-     eps33_t = eps33;eps_cumulBB_t = eps_cumulBB;
+     epsBH33_t = epsBH33;eps_cumulBB_t = eps_cumulBB;
   };
 
 // def d'une instance de données spécifiques, et initialisation
@@ -104,6 +104,8 @@ Hypo_hooke2D_C::SaveResul *  Hypo_hooke2D_C::New_et_Initialise()
      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;   
    };
@@ -118,7 +120,7 @@ void Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::Ecriture_base_info
       sort << "\n HYPO_E_ISO_2D_C  ";
       // données de la loi
       sort << "\n  Kc= "<< Kc << " mu= " << mu;
-      sort << " eps33= "<<eps33
+      sort << " epsBH33= "<<epsBH33
            << " eps_cumulBB= "<<eps_cumulBB
            << " ";
   };
@@ -127,7 +129,7 @@ void Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::Ecriture_base_info
 void Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::Affiche() const
    { cout << "\n SaveResul_Hypo_hooke2D_C: " ;
      cout <<"\n  Kc= "<< Kc << " mu= " << mu ;
-     cout << "\n  eps33= " << eps33 << " eps_cumulBB= " << eps_cumulBB << " ";
+     cout << "\n  epsBH33= " << epsBH33 << " eps_cumulBB= " << eps_cumulBB << " ";
      cout << "\n .. fin SaveResul_Hypo_hooke2D_C:.. \n" ;
    };
 
@@ -151,6 +153,47 @@ void Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::ChBase_des_grandeurs(const Mat_pl
   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
+        };
+      }
+ };
+
 
 //================================================================================================
 
@@ -883,7 +926,7 @@ void Hypo_hooke2D_C::Ecriture_base_info_loi(ofstream& sort,const int cas)
 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.eps33;
+  return save_resul.epsBH33;
 };
 
 // récupération de la variation relative d'épaisseur calculée: h/h0
@@ -896,8 +939,8 @@ 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 eps33 à la même valeur en mixte et en absolu
+  // d'autre part normalement epsBH33 à la même valeur en mixte et en absolu
-  return exp(save_resul.eps33);
+  return exp(save_resul.epsBH33);
 };
 
 // récupération des grandeurs particulière (hors ddl )
@@ -916,7 +959,7 @@ void Hypo_hooke2D_C::Grandeur_particuliere
       { // 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);}
+          if (Kc_temperature != NULL) {tyTQ(1+(*idecal))=Kc_temperature->Valeur(*temperature)/3.;}
           else {tyTQ(1+(*idecal))=save_resul.Kc/3.;(*idecal)++;};
           break;
          }
@@ -929,12 +972,12 @@ void Hypo_hooke2D_C::Grandeur_particuliere
        //  -----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.eps33;(*idecal)++;
+          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 en le 2D au 3D
+          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
@@ -1083,7 +1126,7 @@ double Hypo_hooke2D_C::Module_compressibilite_equivalent
 
   };
 
-// calcul de la vitesse de deformation eps33_point
+// calcul de la vitesse de deformation epsBH33_point
 double Hypo_hooke2D_C::Deps33BH(TenseurBB &  epsBB_,TenseurBB &  DepsBB_,TenseurHH & gijHH_)
  {   
    #ifdef MISE_AU_POINT	 	 
@@ -1115,7 +1158,7 @@ double Hypo_hooke2D_C::Deps33BH(TenseurBB &  epsBB_,TenseurBB &  DepsBB_,Tenseur
           mu_use *= coef2;
          };
      };
-    // on a eps_33 = -nu/(1.-nu) (eps_11+eps_22)
+    // 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 !!)
@@ -1124,6 +1167,79 @@ double Hypo_hooke2D_C::Deps33BH(TenseurBB &  epsBB_,TenseurBB &  DepsBB_,Tenseur
     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
+  
+ };
+
+
  // ========== codage des METHODES VIRTUELLES  protegees:================
         // calcul des contraintes a t+dt
 //void Calcul_SigmaHH (TenseurHH & sigHH_t,TenseurBB& DepsBB,DdlElement & tab_ddl
@@ -1200,6 +1316,9 @@ void Hypo_hooke2D_C::Calcul_SigmaHH (TenseurHH& sigHH_t,TenseurBB& DepsBB_,DdlEl
     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);}
@@ -1208,11 +1327,18 @@ void Hypo_hooke2D_C::Calcul_SigmaHH (TenseurHH& sigHH_t,TenseurBB& DepsBB_,DdlEl
       { // 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
+             ,NULL //&deja_calculer_Q
              ,&list_save
             );
 
@@ -1318,8 +1444,8 @@ void Hypo_hooke2D_C::Calcul_SigmaHH (TenseurHH& sigHH_t,TenseurBB& DepsBB_,DdlEl
     // 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é
+    // 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 eps11 et eps22
+    // 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 !!)
@@ -1361,7 +1487,7 @@ void Hypo_hooke2D_C::Calcul_SigmaHH (TenseurHH& sigHH_t,TenseurBB& DepsBB_,DdlEl
     // 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 eps33
+    // -- 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
@@ -1369,7 +1495,7 @@ void Hypo_hooke2D_C::Calcul_SigmaHH (TenseurHH& sigHH_t,TenseurBB& DepsBB_,DdlEl
       // 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.eps33 = save_resul.eps33_t;
+        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: "
@@ -1384,7 +1510,11 @@ void Hypo_hooke2D_C::Calcul_SigmaHH (TenseurHH& sigHH_t,TenseurBB& DepsBB_,DdlEl
        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;
+//       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
@@ -1759,7 +1889,7 @@ void Hypo_hooke2D_C::Calcul_DsigmaHH_tdt (TenseurHH& sigHH_t,TenseurBB& DepsBB_,
       // 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.eps33 = save_resul.eps33_t;
+        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: "
@@ -1774,7 +1904,11 @@ void Hypo_hooke2D_C::Calcul_DsigmaHH_tdt (TenseurHH& sigHH_t,TenseurBB& DepsBB_,
        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;
+       //       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;
       };
 
 

comportement/Hypo_elastique/Hypo_hooke2D_C.h

@@ -111,7 +111,7 @@ class Hypo_hooke2D_C : public Loi_comp_abstraite
          virtual SaveResul & operator = ( const SaveResul & a)
            {SaveResul_Hypo_hooke2D_C& sav = *((SaveResul_Hypo_hooke2D_C*) &a);
              Kc=sav.Kc;Kc_t=sav.Kc_t;mu=sav.mu;mu_t=sav.mu_t;
-             eps33=sav.eps33;eps33_t=sav.eps33_t;
+             epsBH33=sav.epsBH33;epsBH33_t=sav.epsBH33_t;
              eps_cumulBB = sav.eps_cumulBB;eps_cumulBB_t=sav.eps_cumulBB_t;
              return *this;
            };
@@ -128,9 +128,15 @@ class Hypo_hooke2D_C : public Loi_comp_abstraite
          // mise à jour des informations transitoires en définitif s'il y a convergence
          // par exemple (pour la plasticité par exemple)
          void TdtversT()
-           {Kc_t = Kc; mu_t=mu;eps33_t=eps33;eps_cumulBB_t=eps_cumulBB;} ;
+           {Kc_t = Kc; mu_t=mu;epsBH33_t=epsBH33;eps_cumulBB_t=eps_cumulBB;
+            // mise à jour de la liste des grandeurs quelconques internes
+            Mise_a_jour_map_type_quelconque();
+           } ;
          void TversTdt()
-           {Kc = Kc_t; mu = mu_t; eps33=eps33_t;eps_cumulBB=eps_cumulBB_t;} ;
+           {Kc = Kc_t; mu = mu_t; epsBH33=epsBH33_t;eps_cumulBB=eps_cumulBB_t;
+            // mise à jour de la liste des grandeurs quelconques internes
+            Mise_a_jour_map_type_quelconque();
+           } ;
     
          // affichage à l'écran des infos
          void Affiche() const;
@@ -156,8 +162,22 @@ class Hypo_hooke2D_C : public Loi_comp_abstraite
          // données protégées
          double Kc,Kc_t; // les paramètres matériaux réellement utilisés
          double mu,mu_t;
-         double eps33,eps33_t; // déformation d'épaisseur
+         double epsBH33,epsBH33_t; // déformation d'épaisseur en mixte
          Tenseur2BB eps_cumulBB,eps_cumulBB_t; // déformation cumulée associée à la loi
+ 
+         // --- gestion d'une map de grandeurs quelconques éventuelles ---
+
+         // une map de grandeurs quelconques particulière qui peut servir aux classes appelantes
+         // il s'agit ici d'une map interne qui a priori ne doit servir qu'aux class loi de comportement
+         // un exemple d'utilisation est une loi combinée qui a besoin de grandeurs spéciales définies
+         // -> n'est pas sauvegardé, car a priori il s'agit de grandeurs redondantes
+         map <  EnumTypeQuelconque , TypeQuelconque, std::less < EnumTypeQuelconque> > map_type_quelconque;
+
+         // récupération des type quelconque sous forme d'un arbre pour faciliter la recherche
+         const map <  EnumTypeQuelconque , TypeQuelconque, std::less < EnumTypeQuelconque> >* Map_type_quelconque()
+               const {return &map_type_quelconque;};
+        private:
+          void Mise_a_jour_map_type_quelconque();
    };
 
         // def d'une instance de données spécifiques, et initialisation
@@ -191,6 +211,15 @@ class Hypo_hooke2D_C : public Loi_comp_abstraite
   // ces grandeurs sont ajoutées à la liste passées en paramètres
   void ListeGrandeurs_particulieres(bool absolue,List_io<TypeQuelconque>& ) const;
   
+  // 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
+  virtual void Insertion_conteneur_dans_save_result(SaveResul * saveResul);
+  
+  // 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
+  virtual void Activation_stockage_grandeurs_quelconques(list <EnumTypeQuelconque >& listEnuQuelc);
+
   // calcul d'un module d'young équivalent à la loi, ceci pour un
   // chargement nul
   double Module_young_equivalent(Enum_dure temps,const Deformation & ,SaveResul * saveResul );
@@ -236,7 +265,7 @@ class Hypo_hooke2D_C : public Loi_comp_abstraite
   // indique si la loi est en contraintes planes en s'appuyant sur un comportement 3D
   virtual bool Contraintes_planes_de_3D() const {return true;};
  
-  // calcul de la vitesse de deformation eps33_point
+  // calcul de la vitesse de deformation epsBH33_point
   double Deps33BH(TenseurBB &  epsBB_,TenseurBB &  DepsBB_,TenseurHH & gijHH_);
 	
 	protected :