From 3811288322ce2173d4d16f96271d98af9f9ab456 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?G=C3=A9rard=20Rio?= Date: Fri, 3 May 2024 11:15:46 +0200 Subject: [PATCH] V 7.030 : modif calcul de epsBH33 dans Hypo_hooke2D_C --- Parametres/EnteteParaGlob.h | 2 +- comportement/Hypo_elastique/Hypo_hooke2D_C.cc | 186 +++++++++++++++--- comportement/Hypo_elastique/Hypo_hooke2D_C.h | 41 +++- 3 files changed, 196 insertions(+), 33 deletions(-) diff --git a/Parametres/EnteteParaGlob.h b/Parametres/EnteteParaGlob.h index 3e7b965..7192f68 100644 --- a/Parametres/EnteteParaGlob.h +++ b/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 diff --git a/comportement/Hypo_elastique/Hypo_hooke2D_C.cc b/comportement/Hypo_elastique/Hypo_hooke2D_C.cc index 4e59d47..7610e68 100644 --- a/comportement/Hypo_elastique/Hypo_hooke2D_C.cc +++ b/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; - eps33_t = eps33;eps_cumulBB_t = eps_cumulBB; + 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 @@ -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= "< >::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 - return exp(save_resul.eps33); + // 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 ) @@ -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 !!) @@ -1123,6 +1166,79 @@ double Hypo_hooke2D_C::Deps33BH(TenseurBB & epsBB_,TenseurBB & DepsBB_,Tenseur 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 & 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 ::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 & listEnuQuelc) + { // récup de la liste de stockage + list & listlocale = ListQuelc_mis_en_acces_localement(); + // on parcours la liste des grandeurs à activer + // et on remplit la liste locale + list ::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 @@ -1144,9 +1260,9 @@ void Hypo_hooke2D_C::Calcul_SigmaHH (TenseurHH& sigHH_t,TenseurBB& DepsBB_,DdlEl #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); - }; + 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 @@ -1199,6 +1315,9 @@ void Hypo_hooke2D_C::Calcul_SigmaHH (TenseurHH& sigHH_t,TenseurBB& DepsBB_,DdlEl 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) @@ -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 list_save; // inter pour l'appel de la fonction list_save.push_back(saveResul); +// // on introduit la grandeur epsBH33 +// List_io deja_calculer_etend; +// List_io 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 & 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é - // de calculer la trace uniquement en fonction de eps11 et eps22 + // 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 !!) @@ -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; }; diff --git a/comportement/Hypo_elastique/Hypo_hooke2D_C.h b/comportement/Hypo_elastique/Hypo_hooke2D_C.h index d472ee1..f3e44b0 100644 --- a/comportement/Hypo_elastique/Hypo_hooke2D_C.h +++ b/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 @@ -190,7 +210,16 @@ class Hypo_hooke2D_C : public Loi_comp_abstraite // récupération de la liste de tous les grandeurs particulières // ces grandeurs sont ajoutées à la liste passées en paramètres void ListeGrandeurs_particulieres(bool absolue,List_io& ) 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 & 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 :