// FICHIER : LoiDeformationsPlanes.cp // CLASSE : LoiDeformationsPlanes // 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) . // // 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 . // // For more information, please consult: . //#include "Debug.h" #include "LesLoisDeComp.h" # include using namespace std; //introduces namespace std #include #include #include "Sortie.h" #include "TypeQuelconqueParticulier.h" #include "TypeConsTens.h" #include "NevezTenseurQ.h" #include "Util.h" #include "LoiDeformationsPlanes.h" //==================== cas de la class de sauvegarde SaveResul =================== // constructeur par défaut à ne pas utiliser LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes() : le_SaveResul(NULL) ,l_sigoHH(NULL),l_sigoHH_t(NULL),sigInvar(3),sigInvar_t(3),l_energ(),l_energ_t() { cout << "\n erreur, le constructeur par defaut ne doit pas etre utilise !" << "\n LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes()"; Sortie(1); }; // le constructeur courant LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes (SaveResul* l_des_SaveResul): le_SaveResul(NULL) ,l_sigoHH(NULL),l_sigoHH_t(NULL),sigInvar(3),sigInvar_t(3) ,l_energ(),l_energ_t() { if (l_des_SaveResul != NULL) le_SaveResul = l_des_SaveResul->Nevez_SaveResul(); // par défaut les contraintes sont en dim 3 l_sigoHH=NevezTenseurHH(3,0); // idem interHH, par défaut les contraintes sont en dim 3 l_sigoHH_t =NevezTenseurHH(3,0.); }; // constructeur de copie LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes (const LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes& sav ): le_SaveResul(NULL) ,l_sigoHH(NULL),l_sigoHH_t(NULL),sigInvar(sav.sigInvar),sigInvar_t(sav.sigInvar_t) ,l_energ(sav.l_energ),l_energ_t(sav.l_energ_t) { if (sav.le_SaveResul != NULL) {le_SaveResul=(sav.le_SaveResul)->Nevez_SaveResul();}; // automatiquement les tenseurs sont non nul l_sigoHH=NevezTenseurHH(*(sav.l_sigoHH)); l_sigoHH_t =NevezTenseurHH(*(sav.l_sigoHH_t)); }; // destructeur LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes::~SaveResul_LoiDeformationsPlanes() { if (le_SaveResul != NULL) delete le_SaveResul; delete l_sigoHH; delete l_sigoHH_t; }; // affectation Loi_comp_abstraite::SaveResul & LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes::operator = ( const Loi_comp_abstraite::SaveResul & a) { LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes& sav = *((LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes*) &a); // on affecte si non dimensionné, sinon on crée à l'identique if (sav.le_SaveResul != NULL) { if (le_SaveResul == NULL) {le_SaveResul = sav.le_SaveResul->Nevez_SaveResul();} else {(*le_SaveResul) = *(sav.le_SaveResul);}; }; // idem pour les tenseurs if (sav.l_sigoHH != NULL) { if (l_sigoHH == NULL) l_sigoHH = NevezTenseurHH(*(sav.l_sigoHH)); else *(l_sigoHH) = *(sav.l_sigoHH); }; if (sav.l_sigoHH_t != NULL) { if (l_sigoHH_t == NULL) l_sigoHH_t = NevezTenseurHH(*(sav.l_sigoHH_t)); else *(l_sigoHH_t) = *(sav.l_sigoHH_t); }; // puis les grandeurs qui ne posent pas de pb sigInvar = sav.sigInvar; sigInvar_t = sav.sigInvar_t; l_energ = sav.l_energ; l_energ_t = sav.l_energ_t; return *this; }; //============= 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 LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes::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 != "S_D_Plane") { cout << "\n erreur en lecture du conteneur pour la loi de contrainte plane generique " << " \n LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes::Lecture_base_info(.."; Sortie(1); } #endif if (le_SaveResul != NULL) le_SaveResul->Lecture_base_info(ent,cas); // la contrainte sauvegardée est celle stable uniquement l_sigoHH_t->Lecture(ent); // lecture du tenseur à t (*l_sigoHH) = (*l_sigoHH_t); // init à la même valeur de la contrainte à tdt // invariants de contraintes ent >> toto >> sigInvar_t(1) >> sigInvar_t(2) >> sigInvar_t(3); sigInvar = sigInvar_t; // lecture de l'énergie à t ent >> l_energ_t; l_energ = l_energ_t; // puis init au cas où de la valeur à tdt }; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) void LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes::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 S_D_Plane "; // données de la loi if (le_SaveResul != NULL) le_SaveResul->Ecriture_base_info(sort,cas);sort << " "; // la contrainte sauvegardée est celle stable uniquement l_sigoHH_t->Ecriture(sort); sort << " " ;// écriture du tenseur // invariants de contraintes sort << " invarsig: " << sigInvar_t(1) << " " << sigInvar_t(2) <<" " << sigInvar_t(3) ; sort << " " << l_energ_t; // écriture de l'énergie à t }; // mise à jour des informations transitoires en définitif s'il y a convergence // par exemple (pour la plasticité par exemple) void LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes::TdtversT() { if (le_SaveResul != NULL) // mise à jour du conteneur éventuel de la loi interne le_SaveResul->TdtversT(); (*l_sigoHH_t) = (*l_sigoHH); sigInvar_t = sigInvar; l_energ_t = l_energ; }; void LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes::TversTdt() { if (le_SaveResul != NULL) // mise à jour du conteneur éventuel de la loi interne le_SaveResul->TversTdt(); (*l_sigoHH) = (*l_sigoHH_t); sigInvar = sigInvar_t; l_energ = l_energ_t; }; // affichage à l'écran des infos void LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes::Affiche() const { cout << "\n SaveResul_LoiDeformationsPlanes: " ; cout << "\n SaveResul: "; if (le_SaveResul != NULL) { cout << "\n "; le_SaveResul->Affiche();}; cout << "\n l_sigoHH: "; l_sigoHH->Ecriture(cout); cout << "\n l_sigoHH_t: "; l_sigoHH_t->Ecriture(cout); cout << "\n invariants_contraintes_t: " << sigInvar_t(1) << " " << sigInvar_t(2) <<" " << sigInvar_t(3) ; cout << "\n l_energ: "; cout << l_energ; cout << "\n l_energ_t: "; cout << l_energ_t; cout << "\n .. fin SaveResul_LoiDeformationsPlanes:.. \n" ; }; //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 LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes::ChBase_des_grandeurs(const Mat_pleine& beta,const Mat_pleine& gamma) { // on ne s'intéresse qu'aux grandeurs tensorielles if (le_SaveResul != NULL) // s'il y a un conteneur affecté le_SaveResul->ChBase_des_grandeurs(beta,gamma); l_sigoHH->ChBase(gamma); l_sigoHH_t->ChBase(gamma); // les vecteurs sont un moyen de stockage mais pas dépendant de la base, donc pas de chgt de coordonnées }; // procedure permettant de completer éventuellement les données particulières // de la loi stockées // au niveau du point d'intégration par exemple: exemple: un repère d'anisotropie // completer est appelé apres sa creation avec les donnees du bloc transmis // peut etre appeler plusieurs fois Loi_comp_abstraite::SaveResul* LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes ::Complete_SaveResul(const BlocGen & bloc, const Tableau & tab_coor ,const Loi_comp_abstraite* loi) {// on transmet au conteneur 3D interne const LoiDeformationsPlanes * loi_DP = (const LoiDeformationsPlanes*) loi; le_SaveResul->Complete_SaveResul(bloc,tab_coor,loi_DP->lois_interne); return this; }; // ---- récupération d'information: spécifique à certaine classe dérivée double LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes::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_LoiDeformationsPlanes::Deformation_plastique()"; Sortie(1); return 0.; // pour taire le warning, mais on ne passe jamais là }; //==================== fin du cas de la class de sauvegarde SaveResul ============ LoiDeformationsPlanes::LoiDeformationsPlanes () : // Constructeur par defaut Loi_comp_abstraite(LOI_DEFORMATIONS_PLANES,RIEN_CATEGORIE_LOI_COMP,2) ,lois_interne(NULL) ,d_sigma_deps_inter(NULL) // -- conteneur des métriques ,expli_3D(NULL),impli_3D(NULL),umat_cont_3D(NULL) // -- les variables pointées dans les conteneurs, et leur pointeur associé éventuellement ,giB_0_3D(),giH_0_3D(),giB_t_3D(),giH_t_3D(),giB_tdt_3D(),giH_tdt_3D() ,gijBB_0_3D(),gijHH_0_3D(),gijBB_t_3D(),gijHH_t_3D() ,gijBB_tdt_3D(),gijHH_tdt_3D() ,gradVmoyBB_t_3D(),gradVmoyBB_tdt_3D(),gradVBB_tdt_3D() ,gradVmoyBB_t_3D_P(NULL),gradVmoyBB_tdt_3D_P(NULL),gradVBB_tdt_3D_P(NULL) ,jacobien_tdt_3D(0.),jacobien_0_3D(0.) // les vrais tableaux associés aux tableaux de pointeurs ,d_giB_tdt_3D(),d_giH_tdt_3D() ,d_gijBB_tdt_3D(),d2_gijBB_tdt_3D(),d_gijHH_tdt_3D() ,d_gijBB_tdt_3D_P(NULL),d2_gijBB_tdt_3D_P(NULL),d_gijHH_tdt_3D_P(NULL) ,d_jacobien_tdt_3D(NULL) ,d_gradVmoyBB_t_3D(),d_gradVmoyBB_tdt_3D(),d_gradVBB_t_3D(),d_gradVBB_tdt_3D() ,d_gradVmoyBB_t_3D_P(NULL),d_gradVmoyBB_tdt_3D_P(NULL),d_gradVBB_t_3D_P(NULL),d_gradVBB_tdt_3D_P(NULL) // puis les grandeurs hors métriques ,sig_HH_t_3D(),sig_HH_3D(),Deps_BB_3D(),eps_BB_3D(),delta_eps_BB_3D() ,d_eps_BB_3D_P(),d_sig_HH_3D_P() ,d_eps_BB_3D(),d_sig_HH_3D(),d_sigma_deps_3D() // un conteneur d'un point d'intégration courant ,ptintmeca(3) { // conteneurs des métriques // a priori seules les grandeurs principales sont affecté expli_3D = new Met_abstraite::Expli_t_tdt // constructeur normal (&giB_0_3D,&giH_0_3D,&giB_t_3D,&giH_t_3D,&giB_tdt_3D,&giH_tdt_3D ,&gijBB_0_3D,&gijHH_0_3D,&gijBB_t_3D,&gijHH_t_3D ,&gijBB_tdt_3D,&gijHH_tdt_3D ,gradVmoyBB_t_3D_P,gradVmoyBB_tdt_3D_P,gradVBB_tdt_3D_P // pas affecté par défaut ,&d_gijBB_tdt_3D_P,&jacobien_tdt_3D,&jacobien_t_3D,&jacobien_0_3D); impli_3D = new Met_abstraite::Impli // constructeur normal (&giB_0_3D,&giH_0_3D,&giB_t_3D,&giH_t_3D,&giB_tdt_3D,&d_giB_tdt_3D,&giH_tdt_3D,&d_giH_tdt_3D ,&gijBB_0_3D,&gijHH_0_3D,&gijBB_t_3D,&gijHH_t_3D,&gijBB_tdt_3D,&gijHH_tdt_3D ,gradVmoyBB_t_3D_P,gradVmoyBB_tdt_3D_P,gradVBB_tdt_3D_P // pas affecté par défaut ,&d_gijBB_tdt_3D_P ,d2_gijBB_tdt_3D_P // pas affecté par défaut ,&d_gijHH_tdt_3D_P ,&jacobien_tdt_3D,&jacobien_t_3D,&jacobien_0_3D,&d_jacobien_tdt_3D ,d_gradVmoyBB_t_3D_P,d_gradVmoyBB_tdt_3D_P // pas affecté par défaut ,d_gradVBB_t_3D_P,d_gradVBB_tdt_3D_P); // pas affecté par défaut umat_cont_3D = new Met_abstraite::Umat_cont // constructeur normal (&giB_0_3D,&giH_0_3D,&giB_t_3D,&giH_t_3D,&giB_tdt_3D,&giH_tdt_3D ,&gijBB_0_3D,&gijHH_0_3D,&gijBB_t_3D,&gijHH_t_3D ,&gijBB_tdt_3D,&gijHH_tdt_3D ,gradVmoyBB_t_3D_P,gradVmoyBB_tdt_3D_P,gradVBB_tdt_3D_P // pas affecté par défaut ,&jacobien_tdt_3D,&jacobien_t_3D,&jacobien_0_3D); // on ajoute les invariants au pt integ courant ptintmeca.Change_statut_Invariants_contrainte (true); }; // Constructeur de copie LoiDeformationsPlanes::LoiDeformationsPlanes (const LoiDeformationsPlanes& loi) : Loi_comp_abstraite(loi) ,lois_interne(NULL) ,d_sigma_deps_inter(NULL) // -- conteneur des métriques: ce sont des pointeurs, pour l'instant on ne les affecte pas ,expli_3D(NULL),impli_3D(NULL),umat_cont_3D(NULL) // -- les variables pointées dans les conteneurs ,giB_0_3D(loi.giB_0_3D),giH_0_3D(loi.giH_0_3D),giB_t_3D(loi.giB_t_3D),giH_t_3D(loi.giH_t_3D) ,giB_tdt_3D(loi.giB_tdt_3D),d_giB_tdt_3D(loi.d_giB_tdt_3D),giH_tdt_3D(loi.giH_tdt_3D) ,d_giH_tdt_3D(loi.d_giH_tdt_3D),gijBB_0_3D(loi.gijBB_0_3D),gijHH_0_3D(loi.gijHH_0_3D) ,gijBB_t_3D(loi.gijBB_t_3D),gijHH_t_3D(loi.gijHH_t_3D),gijBB_tdt_3D(loi.gijBB_tdt_3D) ,gijHH_tdt_3D(loi.gijHH_tdt_3D),gradVmoyBB_t_3D(loi.gradVmoyBB_t_3D) ,gradVmoyBB_tdt_3D(loi.gradVmoyBB_tdt_3D),gradVBB_tdt_3D(loi.gradVBB_tdt_3D) ,jacobien_0_3D(loi.jacobien_0_3D),d_jacobien_tdt_3D(loi.d_jacobien_tdt_3D) ,d_gradVBB_t_3D_P(loi.d_gradVBB_t_3D_P),d_gradVBB_tdt_3D_P(loi.d_gradVBB_tdt_3D_P) // avec les vrais tableaux associés aux tableaux de pointeurs: ici uniquement le dimensionnement ,d_gijBB_tdt_3D(loi.d_gijBB_tdt_3D),d2_gijBB_tdt_3D(loi.d2_gijBB_tdt_3D) ,d_gijHH_tdt_3D(loi.d_gijHH_tdt_3D) ,d_gradVmoyBB_t_3D(loi.d_gradVmoyBB_t_3D),d_gradVmoyBB_tdt_3D(loi.d_gradVmoyBB_tdt_3D) ,d_gradVBB_t_3D(loi.d_gradVBB_t_3D),d_gradVBB_tdt_3D(loi.d_gradVBB_tdt_3D) // puis les grandeurs hors métriques, pour les tableaux de pointeurs, c'est uniquement du dimensionnement ,sig_HH_t_3D(loi.sig_HH_t_3D),sig_HH_3D(loi.sig_HH_3D),Deps_BB_3D(loi.Deps_BB_3D) ,eps_BB_3D(loi.eps_BB_3D),delta_eps_BB_3D(loi.delta_eps_BB_3D) ,d_eps_BB_3D_P(loi.d_eps_BB_3D_P),d_sig_HH_3D_P(loi.d_sig_HH_3D_P) ,d_eps_BB_3D(loi.d_eps_BB_3D),d_sig_HH_3D(loi.d_sig_HH_3D),d_sigma_deps_3D(loi.d_sigma_deps_3D) // un conteneur d'un point d'intégration courant ,ptintmeca(loi.ptintmeca) { lois_interne = loi.lois_interne->Nouvelle_loi_identique(); // association des pointeurs de grandeurs si nécessaire if (loi.gradVmoyBB_t_3D_P != NULL) {gradVmoyBB_t_3D_P = &gradVmoyBB_t_3D;}; if (loi.gradVmoyBB_tdt_3D_P != NULL) {gradVmoyBB_tdt_3D_P = &gradVmoyBB_tdt_3D;}; if (loi.gradVBB_tdt_3D_P != NULL) {gradVBB_tdt_3D_P = &gradVBB_tdt_3D;}; // def des tableaux de pointeurs pour les conteneurs de métriques // -- cas des tableaux de pointeurs, ils ont déjà la bonne dimension int ta_d_gijBB_tdt_3D = loi.d_gijBB_tdt_3D.Taille(); for (int i=1;i<= ta_d_gijBB_tdt_3D;i++) d_gijBB_tdt_3D_P(i) = &(d_gijBB_tdt_3D(i)); if (loi.d2_gijBB_tdt_3D_P!= NULL) { int tai_d2_gijBB_tdt_3D = d2_gijBB_tdt_3D.Taille1(); d2_gijBB_tdt_3D_P = new Tableau2 (tai_d2_gijBB_tdt_3D); int taj_d2_gijBB_tdt_3D = d2_gijBB_tdt_3D.Taille2(); for (int i=1;i<= tai_d2_gijBB_tdt_3D;i++) for (int j=1;j<= taj_d2_gijBB_tdt_3D;j++) (*d2_gijBB_tdt_3D_P)(i,j) = &(d2_gijBB_tdt_3D(i,j)); }; int ta_d_gijHH_tdt_3D = d_gijHH_tdt_3D.Taille(); for (int i=1;i<= ta_d_gijHH_tdt_3D;i++) d_gijHH_tdt_3D_P(i) = &(d_gijHH_tdt_3D(i)); if (loi.d_gradVmoyBB_t_3D_P != NULL) { int ta_d_gradVmoyBB_t_3D = d_gradVmoyBB_t_3D.Taille(); d_gradVmoyBB_t_3D_P = new Tableau (ta_d_gradVmoyBB_t_3D); for (int i=1;i<= ta_d_gradVmoyBB_t_3D;i++) (*d_gradVmoyBB_t_3D_P)(i) = &(d_gradVmoyBB_t_3D(i)); }; if (loi.d_gradVmoyBB_tdt_3D_P != NULL) { int ta_d_gradVmoyBB_tdt_3D = d_gradVmoyBB_tdt_3D.Taille(); d_gradVmoyBB_tdt_3D_P = new Tableau (ta_d_gradVmoyBB_tdt_3D); for (int i=1;i<= ta_d_gradVmoyBB_tdt_3D;i++) (*d_gradVmoyBB_tdt_3D_P)(i) = &(d_gradVmoyBB_tdt_3D(i)); }; if (loi.d_gradVBB_t_3D_P != NULL) { int ta_d_gradVBB_t_3D = d_gradVBB_t_3D.Taille(); d_gradVBB_t_3D_P = new Tableau (ta_d_gradVBB_t_3D); for (int i=1;i<= ta_d_gradVBB_t_3D;i++) (*d_gradVBB_t_3D_P)(i) = &(d_gradVBB_t_3D(i)); }; if (loi.d_gradVBB_tdt_3D_P != NULL) { int ta_d_gradVBB_tdt_3D = d_gradVBB_tdt_3D.Taille(); d_gradVBB_tdt_3D_P = new Tableau (ta_d_gradVBB_tdt_3D); for (int i=1;i<= ta_d_gradVBB_tdt_3D;i++) (*d_gradVBB_tdt_3D_P)(i) = &(d_gradVBB_tdt_3D(i)); }; // conteneurs des métriques // a priori seules les grandeurs principales sont affecté expli_3D = new Met_abstraite::Expli_t_tdt // constructeur normal (&giB_0_3D,&giH_0_3D,&giB_t_3D,&giH_t_3D,&giB_tdt_3D,&giH_tdt_3D ,&gijBB_0_3D,&gijHH_0_3D,&gijBB_t_3D,&gijHH_t_3D ,&gijBB_tdt_3D,&gijHH_tdt_3D ,gradVmoyBB_t_3D_P,gradVmoyBB_tdt_3D_P,gradVBB_tdt_3D_P // pas affecté par défaut ,&d_gijBB_tdt_3D_P,&jacobien_tdt_3D,&jacobien_t_3D,&jacobien_0_3D); impli_3D = new Met_abstraite::Impli // constructeur normal (&giB_0_3D,&giH_0_3D,&giB_t_3D,&giH_t_3D,&giB_tdt_3D,&d_giB_tdt_3D,&giH_tdt_3D,&d_giH_tdt_3D ,&gijBB_0_3D,&gijHH_0_3D,&gijBB_t_3D,&gijHH_t_3D,&gijBB_tdt_3D,&gijHH_tdt_3D ,gradVmoyBB_t_3D_P,gradVmoyBB_tdt_3D_P,gradVBB_tdt_3D_P // pas affecté par défaut ,&d_gijBB_tdt_3D_P ,d2_gijBB_tdt_3D_P // pas affecté par défaut ,&d_gijHH_tdt_3D_P ,&jacobien_tdt_3D,&jacobien_t_3D,&jacobien_0_3D,&d_jacobien_tdt_3D ,d_gradVmoyBB_t_3D_P,d_gradVmoyBB_tdt_3D_P // pas affecté par défaut ,d_gradVBB_t_3D_P,d_gradVBB_tdt_3D_P); // pas affecté par défaut umat_cont_3D = new Met_abstraite::Umat_cont // constructeur normal (&giB_0_3D,&giH_0_3D,&giB_t_3D,&giH_t_3D,&giB_tdt_3D,&giH_tdt_3D ,&gijBB_0_3D,&gijHH_0_3D,&gijBB_t_3D,&gijHH_t_3D ,&gijBB_tdt_3D,&gijHH_tdt_3D ,gradVmoyBB_t_3D_P,gradVmoyBB_tdt_3D_P,gradVBB_tdt_3D_P // pas affecté par défaut ,&jacobien_tdt_3D,&jacobien_t_3D,&jacobien_0_3D); // puis les tableaux de pointeurs de grandeurs hors métriques int ta_d_eps_BB_3D = d_eps_BB_3D.Taille(); for (int i=1;i<= ta_d_eps_BB_3D;i++) d_eps_BB_3D_P(i) = &(d_eps_BB_3D(i)); int ta_d_sig_HH_3D = d_sig_HH_3D.Taille(); for (int i=1;i<= ta_d_sig_HH_3D;i++) d_sig_HH_3D_P(i) = &(d_sig_HH_3D(i)); }; LoiDeformationsPlanes::~LoiDeformationsPlanes () // Destructeur { if (lois_interne != NULL) delete lois_interne; if (d_sigma_deps_inter != NULL) delete d_sigma_deps_inter; // les conteneurs de pointeurs: delete expli_3D;delete impli_3D; delete umat_cont_3D; // pour les grandeurs de base, pas de new, donc pas de delete // pour les tableaux de pointeurs, idem s'ils ne sont pas addressé par un pointeur // sinon il faut détruire le tableau if (d2_gijBB_tdt_3D_P!= NULL) delete d2_gijBB_tdt_3D_P; if (d_gradVmoyBB_t_3D_P!= NULL) delete d_gradVmoyBB_t_3D_P; if (d_gradVmoyBB_tdt_3D_P!= NULL) delete d_gradVmoyBB_tdt_3D_P; if (d_gradVBB_t_3D_P!= NULL) delete d_gradVBB_t_3D_P; if (d_gradVBB_tdt_3D_P!= NULL) delete d_gradVBB_tdt_3D_P; }; // def d'une instance de données spécifiques, et initialisation // valable une fois que les différentes lois internes sont définit LoiDeformationsPlanes::SaveResul * LoiDeformationsPlanes::New_et_Initialise() { // on crée éventuellement le conteneur pour la loi SaveResul* le_SaveResul = NULL; if (lois_interne != NULL) le_SaveResul = lois_interne->New_et_Initialise(); // on ramène la bonne instance LoiDeformationsPlanes::SaveResul * retour = new SaveResul_LoiDeformationsPlanes(le_SaveResul); // retour return retour; }; // Lecture des donnees de la classe sur fichier void LoiDeformationsPlanes::LectureDonneesParticulieres (UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { // vérification que la dimension de l'espace est 3D if (ParaGlob::Dimension() != 3) { cout << "\n *** erreur : la dimension de l'espace doit etre 3, " << " pour pouvoir utiliser une loi de contrainte plane "; if (ParaGlob::NiveauImpression() > 5) cout << "\n LoiDeformationsPlanes::LectureDonneesParticulieres (... "; Sortie(1); }; // lecture du nom de la loi string st2,nom3; *(entreePrinc->entree) >> st2; // definition de la loi LoiAbstraiteGeneral * pt = LesLoisDeComp::Def_loi(st2); lois_interne = (Loi_comp_abstraite*) LesLoisDeComp::Def_loi(st2); pt = lois_interne; // --- lecture des informations particulières propres à la loi entreePrinc->NouvelleDonnee(); // prepa du flot de lecture pt->LectureDonneesParticulieres (entreePrinc,lesCourbes1D,lesFonctionsnD); // on s'occupe de la catégorie après la lecture des informations particulières (variable def dans LoiAbstraiteGeneral) LoiAbstraiteGeneral::categorie_loi_comp = pt->Id_categorie(); if (!GroupeMecanique(categorie_loi_comp)) { cout << "\n erreur1 en lecture des lois constitutives elementaire" << " d'une loi LoiDeformationsPlanes" << "\n la loi lue: " << pt->Nom_comport() << " n'est pas une loi mecanique, elle fait partie " << " de la categorie: "<< Nom_categorie_loi_comp(categorie_loi_comp); entreePrinc->MessageBuffer("**erreur LoiDeformationsPlanes::LectureDonneesParticulieres (...**"); throw (UtilLecture::ErrNouvelleDonnee(-1)); Sortie(1); }; // si la loi est thermo dépendante on indique que la loi de contrainte plane l'est aussi if (((Loi_comp_abstraite*)pt)->ThermoDependante()) this->thermo_dependant = true; // lecture de l'indication de fin de lecture if(strstr(entreePrinc->tablcar,"fin_loi_deformation_plane")!=0) entreePrinc->NouvelleDonnee(); // appel au niveau de la classe mère Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire (*entreePrinc,lesFonctionsnD,false); }; // affichage de la loi void LoiDeformationsPlanes::Affiche() const { cout << "\n ....... loi de comportement LoiDeformationsPlanes ........"; cout << "\n -- partie relative a la loi interne: "; lois_interne->Affiche(); cout << "\n ....... fin de la loi de comportement LoiDeformationsPlanes ........"; }; // affichage et definition interactive des commandes particulières à chaques lois void LoiDeformationsPlanes::Info_commande_LoisDeComp(UtilLecture& entreePrinc) { ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier sort << "\n# ....... loi de comportement LoiDeformationsPlanes ........" << "\n# a)sur la premiere ligne on indique : " << "\n# Obligatoirement: le nom de la loi de comportement 3D sur laquelle on veut imposer une condition de deformation plane " << "\n# La suite des informations est relative a la loi 3D, voir donc la syntaxe associee" << "\n# " << "\n# a la fin de fin de la loi, on indique un mot cle de fin "; sort << "\n fin_loi_deformation_plane # ----- fin de Loi de deformation plane " << endl; }; // test si la loi est complete int LoiDeformationsPlanes::TestComplet() { int ret = LoiAbstraiteGeneral::TestComplet(); ret *=lois_interne->TestComplet(); return ret; }; // calcul d'un module d'young équivalent à la loi, ceci pour un // chargement nul double LoiDeformationsPlanes::Module_young_equivalent(Enum_dure temps,const Deformation & def ,SaveResul * saveResul_ex) { SaveResul_LoiDeformationsPlanes & save_resul = *((SaveResul_LoiDeformationsPlanes*) saveResul_ex); double E =lois_interne->Module_young_equivalent(temps,def,save_resul.le_SaveResul); return E; }; // récupération d'un module de compressibilité équivalent à la loi, ceci pour un chargement nul // il s'agit ici de la relation -pression = sigma_trace/3. = module de compressibilité * I_eps double LoiDeformationsPlanes::Module_compressibilite_equivalent(Enum_dure temps,const Deformation & def ,SaveResul * saveResul_ex) { SaveResul_LoiDeformationsPlanes & save_resul = *((SaveResul_LoiDeformationsPlanes*) saveResul_ex); double module_compressibilite =lois_interne->Module_compressibilite_equivalent(temps,def,save_resul.le_SaveResul); return module_compressibilite; }; // activation des données des noeuds et/ou elements nécessaires au fonctionnement de la loi // exemple: mise en service des ddl de température aux noeuds // ici la grandeur qui sert de proportion entre la première loi et la seconde void LoiDeformationsPlanes::Activation_donnees(Tableau& tabnoeud,bool dilatation,LesPtIntegMecaInterne& lesPtMecaInt) { // appel relatif à la lois associée lois_interne->Activation_donnees(tabnoeud,dilatation,lesPtMecaInt); // appel de la méthode de la classe mère Loi_comp_abstraite::Activ_donnees(tabnoeud,dilatation,lesPtMecaInt); }; // 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 LoiDeformationsPlanes::Grandeur_particuliere (bool absolue,List_io& liTQ,Loi_comp_abstraite::SaveResul * saveDon,list& decal) const { // tout d'abord on récupère le conteneur SaveResul_LoiDeformationsPlanes & save_resul = *((SaveResul_LoiDeformationsPlanes*) saveDon); int dim = ParaGlob::Dimension(); // maintenant on s'occupe des grandeurs de la loi elle même, List_io::iterator itq,itqfin=liTQ.end(); list::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 { EnumTypeQuelconque enuTQ = tipParticu.EnuTypeQuelconque().EnumTQ(); SaveResul_LoiDeformationsPlanes & save_resul = *((SaveResul_LoiDeformationsPlanes*) saveDon); // 2) -----cas des contraintes individuelles à chaque loi à t uniquement if (enuTQ == CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T) { Tab_Grandeur_TenseurHH& tyTQ= *((Tab_Grandeur_TenseurHH*) (*itq).Grandeur_pointee()); // pour simplifier // en fait on utilise systématiquement un tenseur d'ordre le + élevé, car c'est le conteneur le plus générique // et Tab_Grandeur_TenseurHH ne supporte que des tenseurs du même ordre donc s'il y a un tenseur élevé // interne il faut que tous les tenseurs soient du même ordre TenseurHH* sigHH = (save_resul.l_sigoHH_t); // pour simplifier if (Dabs(sigHH->Dimension()) != dim) {tyTQ(1+(*idecal)).Affectation_trans_dimension(*sigHH,true); } else // cas même dimension {tyTQ(1+(*idecal)) = (*(save_resul.l_sigoHH_t)); }; (*idecal)++; }; // 3) -----cas de l'énergie élastique individuelles à chaque loi à t if (enuTQ == ENERGIE_ELASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T) { Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier tyTQ(1+(*idecal)) = save_resul.l_energ_t.EnergieElastique(); (*idecal)++; }; // 4) -----cas de l'énergie plastique individuelles à chaque loi à t if (enuTQ == ENERGIE_PLASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T) { Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier tyTQ(1+(*idecal)) = save_resul.l_energ_t.DissipationPlastique(); (*idecal)++; }; // 5) -----cas de l'énergie visqueuse individuelles à chaque loi à t if (enuTQ == ENERGIE_VISQUEUSE_INDIVIDUELLE_A_CHAQUE_LOI_A_T) { Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier tyTQ(1+(*idecal)) = save_resul.l_energ_t.DissipationVisqueuse(); (*idecal)++; }; }; }; // puis appel pour la lois associée lois_interne->Grandeur_particuliere(absolue,liTQ,save_resul.le_SaveResul,decal); }; // récupération de la liste de tous les grandeurs particulières // ces grandeurs sont ajoutées à la liste passées en paramètres // absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière void LoiDeformationsPlanes::ListeGrandeurs_particulieres(bool absolue,List_io& liTQ) const { // tout d'abord on passe en revue les grandeurs des lois associées // ** au niveau de l'exécution ce sera l'inverse de cette ordre: on s'occupera d'abord de this puis les lois internes // ** mais a priori cela n'a pas d'importance // appel de la loi 3D int nb_loi = 1; // pour être identique pour la loi additive !! lois_interne->ListeGrandeurs_particulieres(absolue,liTQ); // ... maintenant on s'occupe des grandeurs de la loi elle même, // 1) -----cas des contraintes individuelles à la loi à t uniquement {// ici il s'agit du tenseur des contraintes du pas précédent ou du pas actuel //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::iterator itq,itqfin=liTQ.end(); bool nexistePas = true; for (itq=liTQ.begin();itq!=itqfin;itq++) if ((*itq).EnuTypeQuelconque() == CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T) { Tab_Grandeur_TenseurHH& tyTQ= *((Tab_Grandeur_TenseurHH*) (*itq).Grandeur_pointee()); // pour simplifier int taille = tyTQ.Taille()+nb_loi; tyTQ.Change_taille(taille); nexistePas = false; }; if (nexistePas) {TenseurHH* tens = NevezTenseurHH(ParaGlob::Dimension()); // un tenseur typique // en fait on utilise systématiquement un tenseur d'ordre le + élevé, car c'est le conteneur le plus générique // et Tab_Grandeur_TenseurHH ne supporte que des tenseurs du même ordre donc s'il y a un tenseur élevé // interne il faut que tous les tenseurs soient du même ordre Tab_Grandeur_TenseurHH gtHH(*tens,nb_loi); // def d'un type quelconque représentatif TypeQuelconque typQ(CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T,SIG11,gtHH); liTQ.push_back(typQ); delete tens; // car on n'en a plus besoin }; }; }; // pour toutes les énergies Tableau tab_double(nb_loi); Tab_Grandeur_scalaire_double grand_courant(tab_double); // 3) -----cas de l'énergie élastique individuelles à chaque loi à 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::iterator itq,itqfin=liTQ.end(); bool nexistePas = true; for (itq=liTQ.begin();itq!=itqfin;itq++) if ((*itq).EnuTypeQuelconque() == ENERGIE_ELASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T) { Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier int taille = tyTQ.Taille()+nb_loi; tyTQ.Change_taille(taille); nexistePas = false; }; if (nexistePas) {TypeQuelconque typQ1(ENERGIE_ELASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T,SIG11,grand_courant); liTQ.push_back(typQ1); }; }; // 4) -----cas de l'énergie plastique individuelles à chaque loi à 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::iterator itq,itqfin=liTQ.end(); bool nexistePas = true; for (itq=liTQ.begin();itq!=itqfin;itq++) if ((*itq).EnuTypeQuelconque() == ENERGIE_PLASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T) { Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier int taille = tyTQ.Taille()+nb_loi; tyTQ.Change_taille(taille); nexistePas = false; }; if (nexistePas) {TypeQuelconque typQ1(ENERGIE_PLASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T,SIG11,grand_courant); liTQ.push_back(typQ1); }; }; // 5) -----cas de l'énergie visqueuse individuelles à chaque loi à 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::iterator itq,itqfin=liTQ.end(); bool nexistePas = true; for (itq=liTQ.begin();itq!=itqfin;itq++) if ((*itq).EnuTypeQuelconque() == ENERGIE_VISQUEUSE_INDIVIDUELLE_A_CHAQUE_LOI_A_T) { Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier int taille = tyTQ.Taille()+nb_loi; tyTQ.Change_taille(taille); nexistePas = false; }; if (nexistePas) {TypeQuelconque typQ1(ENERGIE_VISQUEUSE_INDIVIDUELLE_A_CHAQUE_LOI_A_T,SIG11,grand_courant); liTQ.push_back(typQ1); }; }; }; //----- 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 LoiDeformationsPlanes::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { if (cas == 1) { string st1; string nom; ent >> st1 >> nom ; if (st1 != "LOI_DEFORMATIONS_PLANES") { cout << "\n erreur en lecture de la loi : LOI_DEFORMATIONS_PLANES, on attendait le mot cle : LOI_DEFORMATIONS_PLANES " << " et on a lue: " << st1 << "\n LoiDeformationsPlanes::Lecture_base_info_loi(..."; Sortie(1); }; // on lit la loi 3D ent >> st1; lois_interne = (Loi_comp_abstraite *) LesLoisDeComp::Def_loi(st1); lois_interne->Lecture_base_info_loi(ent,cas,lesRef,lesCourbes1D,lesFonctionsnD); } else { // on utilise directement la loi déjà défini lois_interne->Lecture_base_info_loi(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 LoiDeformationsPlanes::Ecriture_base_info_loi(ofstream& sort,const int cas) { if (cas == 1) { sort << "\n LOI_DEFORMATIONS_PLANES loi_associe: "; sort << lois_interne->Nom_comport() << " "; lois_interne->Ecriture_base_info_loi(sort,cas); } else { lois_interne->Ecriture_base_info_loi(sort,cas); }; }; // ========== codage des METHODES VIRTUELLES protegees:================ // calcul des contraintes a t+dt void LoiDeformationsPlanes::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 & d_gijBB_, double& jacobien_0,double& jacobien,TenseurHH & sigHH ,EnergieMeca & energ,const EnergieMeca & ,double& module_compressibilite,double& module_cisaillement ,const Met_abstraite::Expli_t_tdt& ex) { // récup du conteneur spécifique SaveResul_LoiDeformationsPlanes & save_resul = *((SaveResul_LoiDeformationsPlanes*) saveResul); module_compressibilite=module_cisaillement=0.; // init energ.Inita(0.); // initialisation des énergies mises en jeux // initialisation du tenseurs contrainte sig_HH_3D.Inita(0.); // passage des informations spécifique à la loi le_SaveResul lois_interne->IndiqueSaveResult(save_resul.le_SaveResul); lois_interne->IndiquePtIntegMecaInterne(ptintmeca_en_cours);// idem pour ptintmeca lois_interne->IndiqueDef_en_cours(def_en_cours); // idem pour def en cours // passage des métriques de l'ordre 2 vers 3 Passage_metrique_ordre2_vers_3(ex); // passage des informations liées à la déformation de 2 vers 3, et variation de volume éventuelle Vecteur* d_jacobien_tdt = NULL; // ne sert pas ici Tableau * d_epsBB=NULL; // " " Passage_deformation_volume_ordre2_vers_3(DepsBB,epsBB_,d_epsBB,delta_epsBB ,jacobien_0,jacobien,d_jacobien_tdt); lois_interne->Calcul_SigmaHH((*save_resul.l_sigoHH_t),Deps_BB_3D,tab_ddl,gijBB_t_3D,gijHH_t_3D,giB_tdt_3D,giH_tdt_3D ,eps_BB_3D,delta_eps_BB_3D, gijBB_tdt_3D,gijHH_tdt_3D,d_gijBB_tdt_3D_P,jacobien_0_3D,jacobien_tdt_3D,sig_HH_3D ,save_resul.l_energ,save_resul.l_energ_t,module_compressibilite,module_cisaillement,*expli_3D ); // sig_HH_3D.Ecriture(cout); (*save_resul.l_sigoHH) = sig_HH_3D; // sauvegarde en locale // calcul des invariants de contrainte Tenseur3BH sigBH = gijBB_tdt_3D * sig_HH_3D; save_resul.sigInvar(1) = sigBH.Trace(); save_resul.sigInvar(2) = sigBH.II(); save_resul.sigInvar(3) = sigBH.Det(); energ = save_resul.l_energ; // récup des énergies // passage des tenseurs résultats à l'ordre 2 ((Tenseur2HH*) &sigHH)->Affectation_3D_a_2D(sig_HH_3D); // sigHH_tdt.Ecriture(cout); LibereTenseur(); }; // calcul des contraintes a t+dt et de ses variations void LoiDeformationsPlanes::Calcul_DsigmaHH_tdt (TenseurHH& sigHH_t,TenseurBB& DepsBB,DdlElement & tab_ddl ,BaseB& giB_t,TenseurBB & gijBB_t,TenseurHH & gijHH_t ,BaseB& giB_tdt,Tableau & d_giB_tdt,BaseH& giH_tdt,Tableau & d_giH_tdt ,TenseurBB & epsBB_tdt,Tableau & d_epsBB, TenseurBB & delta_epsBB,TenseurBB & gijBB_tdt,TenseurHH & gijHH_tdt, Tableau & d_gijBB_tdt, Tableau & d_gijHH_tdt,double& jacobien_0,double& jacobien, Vecteur& d_jacobien_tdt,TenseurHH& sigHH_tdt,Tableau & d_sigHH ,EnergieMeca & energ,const EnergieMeca & ,double& module_compressibilite,double& module_cisaillement ,const Met_abstraite::Impli& ex) { // récup du conteneur spécifique SaveResul_LoiDeformationsPlanes & save_resul = *((SaveResul_LoiDeformationsPlanes*) saveResul); module_compressibilite=module_cisaillement=0.; // init energ.Inita(0.); // initialisation des énergies mises en jeux // on vérifie que le tableau de travail intermédiaire statique est correctement // dimensionné sinon on le modifie int taille = d_sigHH.Taille(); // on affecte et/ou on redimensionne éventuellement les tableaux contraintes-déformation fonction du nombre de ddl // pour le passage 3D: on considère que tous les tableaux doivent avoir la même dimension: la même que dans le cas 2D int ta_d_sig_HH_3D = d_sig_HH_3D.Taille(); if (ta_d_sig_HH_3D != taille) { // cela veut dire que tous les tableaux sont mal dimensionnés int ta_d_sig_HH = d_sigHH.Taille(); d_sig_HH_3D.Change_taille(ta_d_sig_HH); d_sig_HH_3D_P.Change_taille(ta_d_sig_HH); for (int i=1;i<=ta_d_sig_HH;i++) {d_sig_HH_3D_P(i) = &(d_sig_HH_3D(i));} }; for (int i=1;i<=ta_d_sig_HH_3D;i++) {d_sig_HH_3D_P(i)->Inita(0.);}; // initialisation du tenseurs contrainte sig_HH_3D.Inita(0.); // passage des informations spécifique à la loi le_SaveResul lois_interne->IndiqueSaveResult(save_resul.le_SaveResul); lois_interne->IndiquePtIntegMecaInterne(ptintmeca_en_cours);// idem pour ptintmeca lois_interne->IndiqueDef_en_cours(def_en_cours); // idem pour def en cours // passage des métriques de l'ordre 2 vers 3 Passage_metrique_ordre2_vers_3(ex); // passage des informations liées à la déformation de 2 vers 3, et variation de volume Passage_deformation_volume_ordre2_vers_3(DepsBB,epsBB_tdt,&d_epsBB,delta_epsBB ,jacobien_0,jacobien,&d_jacobien_tdt); lois_interne->Calcul_DsigmaHH_tdt ((*save_resul.l_sigoHH_t),Deps_BB_3D,tab_ddl,giB_t_3D,gijBB_t_3D,gijHH_t_3D ,giB_tdt_3D,d_giB_tdt_3D,giH_tdt_3D,d_giH_tdt_3D ,eps_BB_3D,d_eps_BB_3D_P,delta_eps_BB_3D,gijBB_tdt_3D,gijHH_tdt_3D,d_gijBB_tdt_3D_P ,d_gijHH_tdt_3D_P,jacobien_0_3D,jacobien_tdt_3D,d_jacobien_tdt_3D ,sig_HH_3D,d_sig_HH_3D_P ,save_resul.l_energ,save_resul.l_energ_t,module_compressibilite,module_cisaillement,*impli_3D ); // sig_HH_3D.Ecriture(cout); (*save_resul.l_sigoHH) = sig_HH_3D; // sauvegarde en locale // calcul des invariants de contrainte Tenseur3BH sigBH = gijBB_tdt_3D * sig_HH_3D; save_resul.sigInvar(1) = sigBH.Trace(); save_resul.sigInvar(2) = sigBH.II(); save_resul.sigInvar(3) = sigBH.Det(); energ = save_resul.l_energ; // récup des énergies // passage des tenseurs résultats à l'ordre 2 ((Tenseur2HH*) &sigHH_tdt)->Affectation_3D_a_2D(sig_HH_3D); // sigHH_tdt.Ecriture(cout); // récup de l'opérateur tangent for (int k=1;k<=taille;k++) ((Tenseur2HH*) d_sigHH(k))->Affectation_3D_a_2D(*d_sig_HH_3D_P(k)); LibereTenseur(); //---debug //fichier.close(); //---fin debug }; // calcul des contraintes et ses variations par rapport aux déformations a t+dt // en_base_orthonormee: le tenseur de contrainte en entrée est en orthonormee // le tenseur de déformation et son incrémentsont également en orthonormees // si = false: les bases transmises sont utilisées // ex: contient les éléments de métrique relativement au paramétrage matériel = X_(0)^a void LoiDeformationsPlanes::Calcul_dsigma_deps (bool en_base_orthonormee, TenseurHH & sigHH_t,TenseurBB& DepsBB ,TenseurBB & epsBB_tdt,TenseurBB & delta_epsBB,double& jacobien_0,double& jacobien ,TenseurHH& sigHH_tdt,TenseurHHHH& d_sigma_deps ,EnergieMeca & energ,const EnergieMeca & ,double& module_compressibilite,double& module_cisaillement ,const Met_abstraite::Umat_cont& ex) { // on commence par créer un tenseur contrainte qui totalisera toutes les contraintes // le tenseurs est initialisé à 0. // int dim_tens = sigHH_tdt.Dimension(); // TenseurHH * sigtotalHH = (NevezTenseurHH(dim_tens,0.)); // TenseurHH * zeroHH = (NevezTenseurHH(dim_tens,0.)); // TenseurHH * deltaSigHH = (NevezTenseurHH(dim_tens,0.)); // pour la variation de contraintes SaveResul_LoiDeformationsPlanes & save_resul = *((SaveResul_LoiDeformationsPlanes*) saveResul); module_compressibilite=module_cisaillement=0.; // init energ.Inita(0.); // initialisation des énergies mises en jeux // redimentionnement éventuel pour le comportement tangent if (d_sigma_deps_inter != NULL) { if (d_sigma_deps_inter->Dimension() != d_sigma_deps.Dimension()) { delete d_sigma_deps_inter; d_sigma_deps_inter = NevezTenseurHHHH(d_sigma_deps);} } else {d_sigma_deps_inter = NevezTenseurHHHH(d_sigma_deps);}; // initialisation du tenseurs contrainte save_resul.l_sigoHH->Inita(0.); // initialisation du comportement tangent d_sigma_deps_inter->Inita(0.); // passage des informations spécifique à la loi le_SaveResul lois_interne->IndiqueSaveResult(save_resul.le_SaveResul); lois_interne->IndiquePtIntegMecaInterne(ptintmeca_en_cours);// idem pour ptintmeca lois_interne->IndiqueDef_en_cours(def_en_cours); // idem pour def en cours lois_interne->Calcul_dsigma_deps (en_base_orthonormee, (*save_resul.l_sigoHH_t),DepsBB,epsBB_tdt,delta_epsBB,jacobien_0,jacobien ,(*save_resul.l_sigoHH),*d_sigma_deps_inter ,save_resul.l_energ,save_resul.l_energ_t,module_compressibilite,module_cisaillement,ex ); energ = save_resul.l_energ; // récup des énergies // on sauvegarde la contrainte partielle totale sigHH_tdt=(*save_resul.l_sigoHH); // récup de l'opérateur tangent d_sigma_deps=*d_sigma_deps_inter; // delete sigtotalHH; delete zeroHH;delete deltaSigHH; LibereTenseur();LibereTenseurQ(); }; // fonction interne utilisée par les classes dérivées de Loi_comp_abstraite // pour répercuter les modifications de la température // ici utiliser pour modifier la température des lois élémentaires // l'Enum_dure: indique quel est la température courante : 0 t ou tdt void LoiDeformationsPlanes::RepercuteChangeTemperature(Enum_dure temps) { lois_interne->temperature_0 = this->temperature_0; lois_interne->temperature_t = this->temperature_t; lois_interne->temperature_tdt = this->temperature_tdt; lois_interne->dilatation=dilatation; if (dilatation) {// a- dimensionnement des tenseurs intermédiaires int dim_tens = epsBB_therm->Dimension(); // -- cas de la déformation if (lois_interne->epsBB_therm == NULL) { lois_interne->epsBB_therm = NevezTenseurBB(dim_tens);} else if (lois_interne->epsBB_therm->Dimension() != dim_tens) { delete lois_interne->epsBB_therm;lois_interne->epsBB_therm = NevezTenseurBB(dim_tens);}; // -- cas de la vitesse de déformation if (lois_interne->DepsBB_therm == NULL) { lois_interne->DepsBB_therm = NevezTenseurBB(dim_tens);} else if (lois_interne->DepsBB_therm->Dimension() != dim_tens) { delete lois_interne->DepsBB_therm;lois_interne->DepsBB_totale = NevezTenseurBB(dim_tens);}; // b- affectation des tenseurs (*lois_interne->epsBB_therm)=(*epsBB_therm); (*lois_interne->DepsBB_therm)=(*DepsBB_therm); }; lois_interne->RepercuteChangeTemperature(temps); switch (temps) { case TEMPS_0: {lois_interne->temperature = &lois_interne->temperature_0; break; } case TEMPS_t: {lois_interne->temperature = &lois_interne->temperature_t; break; } case TEMPS_tdt: {lois_interne->temperature = &lois_interne->temperature_tdt; break; } default: { cout << "\n erreur, cas de temps non prevu !! " << "\n LoiDeformationsPlanes::RepercuteChangeTemperature(..."; Sortie(1); }; }; }; void LoiDeformationsPlanes::CalculGrandeurTravail (const PtIntegMecaInterne& ptintmec ,const Deformation & def,Enum_dure temps,const ThermoDonnee& dTP ,const Met_abstraite::Impli* ex_impli ,const Met_abstraite::Expli_t_tdt* ex_expli_tdt ,const Met_abstraite::Umat_cont* ex_umat ,const List_io* exclure_dd_etend ,const List_io* exclure_Q ) { // récup des infos spécifiques SaveResul_LoiDeformationsPlanes & save_resul = *((SaveResul_LoiDeformationsPlanes*) saveResul); // par défaut on active les invariants // ptintmeca concerne des tenseurs d'ordres 2 donc il faut transformer en 3D bool plusZero=true; // on ajoute des 0 pour les grandeurs manquantes // on commence par transférer le tout ptintmeca.Affectation_2D_a_3D(ptintmec,plusZero); // ensuite on traite les points particuliers // pour tout ce qui est def: l'ajout de 0 est ok // pour la contrainte à t on récupère la valeur sauvegardée, car c'est celle spécifique aux déformations planes (*ptintmeca.SigHH_t()) = (*save_resul.l_sigoHH_t); // pour les invariants de contraintes, on ne peut pas les recalculer, donc on récupère ce qui a été sauvegardé if (ptintmeca.Statut_Invariants_contrainte()) // le conteneur des invariants a pu être effacé par Affectation_2D_a_3D ptintmeca.SigInvar() = save_resul.sigInvar_t; // passage des informations spécifique à la loi le_SaveResul lois_interne->IndiqueSaveResult(save_resul.le_SaveResul); lois_interne->IndiquePtIntegMecaInterne(ptintmeca_en_cours);// idem pour ptintmeca lois_interne->IndiqueDef_en_cours(def_en_cours); // idem pour def en cours lois_interne->CalculGrandeurTravail(ptintmeca,def,temps,dTP ,ex_impli,ex_expli_tdt,ex_umat,exclure_dd_etend,exclure_Q); // passage à la loi 3D }; // passage des grandeurs métriques de l'ordre 2 à 3: cas implicite void LoiDeformationsPlanes::Passage_metrique_ordre2_vers_3(const Met_abstraite::Impli& ex) {// on s'occupe du redimensionnement éventuel // on affecte et/ou on redimensionne éventuellement les tableaux fonction du nombre de ddl pour le passage 3D // la partie dépendant des vitesses: entre accolades pour pouvoir fermer {if (ex.gradVmoyBB_t != NULL) {impli_3D->gradVmoyBB_t= gradVmoyBB_t_3D_P = &gradVmoyBB_t_3D;}; if (ex.gradVmoyBB_tdt != NULL) {impli_3D->gradVmoyBB_tdt=gradVmoyBB_tdt_3D_P = &gradVmoyBB_tdt_3D;}; if (ex.gradVBB_tdt != NULL) {impli_3D->gradVBB_tdt=gradVBB_tdt_3D_P = &gradVBB_tdt_3D;}; // on s'occupe tout d'abord des tableaux de vitesses qui peuvent ne pas exister if (ex.d_gradVmoyBB_t != NULL) // cas où il existe { int tail=ex.d_gradVmoyBB_t->Taille(); if (d_gradVmoyBB_t_3D_P == NULL) {d_gradVmoyBB_t_3D_P = new Tableau (tail); impli_3D->d_gradVmoyBB_t = d_gradVmoyBB_t_3D_P;} else {d_gradVmoyBB_t_3D_P->Change_taille(tail);}; d_gradVmoyBB_t_3D.Change_taille(tail); for (int i=1;i<= tail;i++) (*d_gradVmoyBB_t_3D_P)(i) = &(d_gradVmoyBB_t_3D(i)); }; if (ex.d_gradVmoyBB_tdt != NULL) // cas où il existe { int tail=ex.d_gradVmoyBB_tdt->Taille(); if (d_gradVmoyBB_tdt_3D_P == NULL) {d_gradVmoyBB_tdt_3D_P = new Tableau (tail); impli_3D->d_gradVmoyBB_tdt = d_gradVmoyBB_tdt_3D_P;} else {d_gradVmoyBB_tdt_3D_P->Change_taille(tail);}; d_gradVmoyBB_tdt_3D.Change_taille(tail); for (int i=1;i<= tail;i++) (*d_gradVmoyBB_tdt_3D_P)(i) = &(d_gradVmoyBB_tdt_3D(i)); }; if (ex.d_gradVBB_t != NULL) // cas où il existe { int tail=ex.d_gradVBB_t->Taille(); if (d_gradVBB_t_3D_P == NULL) {d_gradVBB_t_3D_P = new Tableau (tail); impli_3D->d_gradVBB_t = d_gradVBB_t_3D_P;} else {d_gradVBB_t_3D_P->Change_taille(tail);}; d_gradVBB_t_3D.Change_taille(tail); for (int i=1;i<= tail;i++) (*d_gradVBB_t_3D_P)(i) = &(d_gradVBB_t_3D(i)); }; if (ex.d_gradVBB_tdt != NULL) // cas où il existe { int tail=ex.d_gradVBB_tdt->Taille(); if (d_gradVBB_tdt_3D_P == NULL) {d_gradVBB_tdt_3D_P = new Tableau (tail); impli_3D->d_gradVBB_tdt = d_gradVBB_tdt_3D_P;} else {d_gradVBB_tdt_3D_P->Change_taille(tail);}; d_gradVBB_tdt_3D.Change_taille(tail); for (int i=1;i<= tail;i++) (*d_gradVBB_tdt_3D_P)(i) = &(d_gradVBB_tdt_3D(i)); }; }; // fin de la partie dédiée à la vitesse // maintenant on s'occupe uniquement du redimensionnement des tableaux restants // -- on s'occupe des tableaux nécessaire à la métrique int ta_ex_d_giB_tdt = ex.d_giB_tdt->Taille(); // la dimension if (d_giB_tdt_3D.Taille() != ta_ex_d_giB_tdt) { d_giB_tdt_3D.Change_taille(ta_ex_d_giB_tdt);}; int ta_ex_d_giH_tdt = ex.d_giH_tdt->Taille(); // la dimension if (d_giH_tdt_3D.Taille() != ta_ex_d_giH_tdt) { d_giH_tdt_3D.Change_taille(ta_ex_d_giH_tdt);}; int ta_ex_d_gijBB_tdt = ex.d_gijBB_tdt->Taille(); // la dimension if (d_gijBB_tdt_3D.Taille() != ta_ex_d_gijBB_tdt) { d_gijBB_tdt_3D.Change_taille(ta_ex_d_gijBB_tdt); d_gijBB_tdt_3D_P.Change_taille(ta_ex_d_gijBB_tdt); for (int i=1;i<=ta_ex_d_gijBB_tdt;i++) {d_gijBB_tdt_3D_P(i) = &(d_gijBB_tdt_3D(i));}; }; int ta_ex_d_gijHH_tdt = ex.d_gijHH_tdt->Taille(); if (d_gijHH_tdt_3D.Taille() != ta_ex_d_gijHH_tdt) { d_gijHH_tdt_3D.Change_taille(ta_ex_d_gijHH_tdt); d_gijHH_tdt_3D_P.Change_taille(ta_ex_d_gijHH_tdt); for (int i=1;i<=ta_ex_d_gijHH_tdt;i++) {d_gijHH_tdt_3D_P(i) = &(d_gijHH_tdt_3D(i));}; }; if( d_jacobien_tdt_3D.Taille() != ex.d_jacobien_tdt->Taille()) {d_jacobien_tdt_3D.Change_taille(ex.d_jacobien_tdt->Taille());} // le tableau à double dimension if (ex.d2_gijBB_tdt != NULL) { int taille1=ex.d2_gijBB_tdt->Taille1(); int taille2=ex.d2_gijBB_tdt->Taille2(); if (d2_gijBB_tdt_3D_P == NULL) { d2_gijBB_tdt_3D_P = impli_3D->d2_gijBB_tdt = new Tableau2 (taille1,taille2); d2_gijBB_tdt_3D.Change_taille(taille1,taille2); for (int i=1;i<=taille1;i++) for (int j=1;j<= taille2;j++) { (*d2_gijBB_tdt_3D_P)(i,j) = &d2_gijBB_tdt_3D(i,j);}; } else if ((taille1 != d2_gijBB_tdt_3D.Taille1()) || (taille2 != d2_gijBB_tdt_3D.Taille2())) { d2_gijBB_tdt_3D_P->Change_taille(taille1,taille2); d2_gijBB_tdt_3D.Change_taille(taille1,taille2); for (int i=1;i<=taille1;i++) for (int j=1;j<= taille2;j++) { (*d2_gijBB_tdt_3D_P)(i,j) = &d2_gijBB_tdt_3D(i,j);}; }; }; // on commence par recopier les grandeurs de l'ordre 2 à 3 bool plusZero = true; // on complète avec des 0 dans un premier temps int type_recopie = 0; // on recopie les grandeurs de 0,t et tdt impli_3D->Passage_de_Ordre2_vers_Ordre3(ex,plusZero,type_recopie); // --pour le debug // cout <<"\n LoiDeformationsPlanes::Passage_metrique_ordre2_vers_3(c " // << "\n 2D gijBB_tdt: "; ex.gijBB_tdt->Ecriture(cout); // cout << "\n 3D gijBB_tdt: "; impli_3D->gijBB_tdt->Ecriture(cout); // --fin pour le debug // maintenant on s'occupe de mettre à jour les grandeurs manquantes // - les bases naturelles: le vecteur normal est normé et est identique pour les bases naturelles et duales giB_0_3D.CoordoB(3) = (Util::ProdVec_coorB(giB_0_3D(1),giB_0_3D(2))).Normer(); giH_0_3D.CoordoH(3) = giB_0_3D(3).Bas_haut(); giB_t_3D.CoordoB(3) = (Util::ProdVec_coorB(giB_t_3D(1),giB_t_3D(2))).Normer(); giH_t_3D.CoordoH(3) = giB_t_3D(3).Bas_haut(); // cas particulier du vecteur tdt giB_tdt_3D.CoordoB(3) = (Util::ProdVec_coorB(giB_tdt_3D(1),giB_tdt_3D(2))); // calcul du vecteur normal non normé double norme_N_tdt = giB_tdt_3D(3).Norme(); // calcul de la norme qui nous servira pour les variations giB_tdt_3D.CoordoB(3) /= norme_N_tdt; giH_tdt_3D.CoordoH(3) = giB_tdt_3D(3).Bas_haut(); // - les tenseurs métriques: a priori 1 pour la direction 3 gijBB_0_3D.Coor(3,3)=gijHH_0_3D.Coor(3,3)=gijBB_t_3D.Coor(3,3)=gijHH_t_3D.Coor(3,3) =gijBB_tdt_3D.Coor(3,3)=gijHH_tdt_3D.Coor(3,3)=1.; // - les variations du vecteur normal CoordonneeB d_NN; // un vecteur de travail #ifdef MISE_AU_POINT if (ex.d_giB_tdt->Taille() != ex.d_giH_tdt->Taille()) { cout << "\n **** sans doute une erreur: (ex.d_giB_tdt->Taille() "<< ex.d_giB_tdt->Taille() << " != ex.d_giH_tdt->Taille()) " << ex.d_giH_tdt->Taille() << "\n LoiDeformationsPlanes::Passage_metrique_ordre2_vers_3(const Met_abstraite::Impli& ex)"; Sortie(1); }; #endif for (int iddl=1;iddl<= ta_ex_d_giB_tdt;iddl++) { // tout d'abord on calcul la variation de la normale non normée d_NN = (Util::ProdVec_coorB(d_giB_tdt_3D(iddl)(1),giB_tdt_3D(2))) + (Util::ProdVec_coorB(giB_tdt_3D(1),d_giB_tdt_3D(iddl)(2))); // maintenant on calcul la variation du vecteur normal unitaire d_giB_tdt_3D(iddl).CoordoB(3) = Util::VarUnVect_coorB(giB_tdt_3D(3),d_NN,norme_N_tdt); // qui est identique pour la base duale d_giH_tdt_3D(iddl).CoordoH(3) = d_giB_tdt_3D(iddl)(3).Bas_haut(); }; // -- pour les tenseurs métriques, la valeur est fixe donc pas de variation }; // passage des grandeurs métriques de l'ordre 2 à 3: cas explicite void LoiDeformationsPlanes::Passage_metrique_ordre2_vers_3(const Met_abstraite::Expli_t_tdt& ex) { // on s'occupe du redimensionnement éventuel // on affecte et/ou on redimensionne éventuellement les tableaux fonction du nombre de ddl pour le passage 3D // la dimension des tableaux : on considère que tous les tableaux doivent avoir la même dimension int ta_ex_d_gijBB_tdt = ex.d_gijBB_tdt->Taille(); // la dimension // la partie dépendant des vitesses: entre accolades pour pouvoir fermer {if (ex.gradVmoyBB_t != NULL) {expli_3D->gradVmoyBB_t= gradVmoyBB_t_3D_P = &gradVmoyBB_t_3D;}; if (ex.gradVmoyBB_tdt != NULL) {expli_3D->gradVmoyBB_tdt=gradVmoyBB_tdt_3D_P = &gradVmoyBB_tdt_3D;}; if (ex.gradVBB_tdt != NULL) {expli_3D->gradVBB_tdt=gradVBB_tdt_3D_P = &gradVBB_tdt_3D;}; }; // fin de la partie dédiée à la vitesse // maintenant on s'occupe uniquement du redimensionnement des tableaux restants int ta_d_gijBB_tdt_3D = d_gijBB_tdt_3D.Taille(); if (ta_d_gijBB_tdt_3D != ta_ex_d_gijBB_tdt) { // cela veut dire que tous les tableaux sont mal dimensionnés // -- on s'occupe des tableaux nécessaire à la métrique d_gijBB_tdt_3D.Change_taille(ta_ex_d_gijBB_tdt); d_gijBB_tdt_3D_P.Change_taille(ta_ex_d_gijBB_tdt); for (int i=1;i<=ta_ex_d_gijBB_tdt;i++) {d_gijBB_tdt_3D_P(i) = &(d_gijBB_tdt_3D(i));}; }; // on commence par recopier les grandeurs de l'ordre 2 à 3 bool plusZero = true; // on complète avec des 0 dans un premier temps int type_recopie = 0; // on recopie les grandeurs de 0,t et tdt expli_3D->Passage_de_Ordre2_vers_Ordre3(ex,plusZero,type_recopie); // --pour le debug // cout <<"\n LoiDeformationsPlanes::Passage_metrique_ordre2_vers_3(c " // << "\n 2D gijBB_tdt: "; ex.gijBB_tdt->Ecriture(cout); // cout << "\n 3D gijBB_tdt: "; expli_3D->gijBB_tdt->Ecriture(cout); // --fin pour le debug // maintenant on s'occupe de mettre à jour les grandeurs manquantes // - les bases naturelles: le vecteur normal est normé et est identique pour les bases naturelles et duales giB_0_3D.CoordoB(3) = (Util::ProdVec_coorB(giB_0_3D(1),giB_0_3D(2))).Normer(); giH_0_3D.CoordoH(3) = giB_0_3D(3).Bas_haut(); giB_t_3D.CoordoB(3) = (Util::ProdVec_coorB(giB_t_3D(1),giB_t_3D(2))).Normer(); giH_t_3D.CoordoH(3) = giB_t_3D(3).Bas_haut(); // cas particulier du vecteur tdt giB_tdt_3D.CoordoB(3) = (Util::ProdVec_coorB(giB_tdt_3D(1),giB_tdt_3D(2))); // calcul du vecteur normal non normé double norme_N_tdt = giB_tdt_3D(3).Norme(); // calcul de la norme qui nous servira pour les variations giB_tdt_3D.CoordoB(3) /= norme_N_tdt; giH_tdt_3D.CoordoH(3) = giB_tdt_3D(3).Bas_haut(); // - les tenseurs métriques: a priori 1 pour la direction 3 gijBB_0_3D.Coor(3,3)=gijHH_0_3D.Coor(3,3)=gijBB_t_3D.Coor(3,3) =gijHH_t_3D.Coor(3,3)=gijBB_tdt_3D.Coor(3,3)=gijHH_tdt_3D.Coor(3,3)=1.; // -- pour les tenseurs métriques, la valeur est fixe donc pas de variation }; // passage des informations liées à la déformation de 2 vers 3, et variation de volume éventuelle void LoiDeformationsPlanes::Passage_deformation_volume_ordre2_vers_3 (TenseurBB& DepsBB,TenseurBB & epsBB_tdt,Tableau * d_epsBB ,TenseurBB & delta_epsBB,double& jacobien_0,double& jacobien ,Vecteur* d_jacobien_tdt) { // a priori on complète avec des 0, mais dans un second temps il faudra modifier les eps33 bool plusZero = true; Deps_BB_3D.Affectation_2D_a_3D(*((Tenseur2BB*) &DepsBB),plusZero); eps_BB_3D.Affectation_2D_a_3D(*((Tenseur2BB*) &epsBB_tdt),plusZero); delta_eps_BB_3D.Affectation_2D_a_3D(*((Tenseur2BB*) &delta_epsBB),plusZero); if(d_epsBB != NULL) { int taille = d_epsBB->Taille(); // redimensionnement éventuel int ta_d_eps_BB_3D = d_eps_BB_3D.Taille(); if (ta_d_eps_BB_3D != taille) {// cela veut dire que tous les tableaux sont mal dimensionnés d_eps_BB_3D.Change_taille(taille); d_eps_BB_3D_P.Change_taille(taille); for (int i=1;i<=taille;i++) {d_eps_BB_3D_P(i) = &(d_eps_BB_3D(i));} }; // passage 2D 3D for (int i=1;i<=taille;i++) d_eps_BB_3D(i).Affectation_2D_a_3D(*((Tenseur2BB*) (*d_epsBB)(i)),plusZero); }; // calcul du jacobien 3D // pour l'instant on se contente de recopier, ce qui suppose une épaisseur = 1. jacobien_0_3D = jacobien_0; jacobien_tdt_3D = jacobien; if(d_jacobien_tdt != NULL) d_jacobien_tdt_3D = (*d_jacobien_tdt); };