// FICHIER : Iso_elas_expo3D.cp // CLASSE : Iso_elas_expo3D // 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 using namespace std; //introduces namespace std #include #include #include "Sortie.h" #include "TypeConsTens.h" #include "CharUtil.h" #include "Iso_elas_expo3D.h" #include "MathUtil.h" Iso_elas_expo3D::Iso_elas_expo3D () : // Constructeur par defaut Loi_comp_abstraite(ISO_ELAS_ESPO3D,CAT_MECANIQUE,3),E(0.),nu(-2.) ,f_coefficient(NULL) ,I_x_I_HHHH(),I_xbarre_I_HHHH(),I_x_eps_HHHH(),Ixbarre_eps_HHHH() { }; // Constructeur de copie Iso_elas_expo3D::Iso_elas_expo3D (const Iso_elas_expo3D& loi) : Loi_comp_abstraite(loi),E(loi.E),nu(loi.nu) ,f_coefficient(loi.f_coefficient) ,I_x_I_HHHH(),I_xbarre_I_HHHH(),I_x_eps_HHHH(),Ixbarre_eps_HHHH() {if (f_coefficient != NULL) if (f_coefficient->NomCourbe() == "_") {// comme il s'agit d'une courbe locale on la redéfinie (sinon pb lors du destructeur de loi) string non_courbe("_"); f_coefficient = Courbe1D::New_Courbe1D(*loi.f_coefficient); }; }; Iso_elas_expo3D::~Iso_elas_expo3D () // Destructeur { if (f_coefficient != NULL) if (f_coefficient->NomCourbe() == "_") delete f_coefficient; }; // Lecture des donnees de la classe sur fichier void Iso_elas_expo3D::LectureDonneesParticulieres (UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D,LesFonctions_nD& lesFonctionsnD) { // lecture du module d'young et du coefficient de poisson if(strstr(entreePrinc->tablcar,"E=")== NULL) { cout << "\n erreur en lecture du module d'young " << " on attendait la chaine : E= "; cout << "\n Iso_elas_expo3D::LectureDonneesParticulieres " << "(UtilLecture * entreePrinc) " << endl ; entreePrinc->MessageBuffer(" "); throw (UtilLecture::ErrNouvelleDonnee(-1)); Sortie(1); } if(strstr(entreePrinc->tablcar,"nu=")== NULL) { cout << "\n erreur en lecture du coefficient de poisson " << " on attendait la chaine : nu= "; cout << "\n Iso_elas_expo3D::LectureDonneesParticulieres " << "(UtilLecture * entreePrinc) " << endl ; entreePrinc->MessageBuffer(" "); throw (UtilLecture::ErrNouvelleDonnee(-1)); Sortie(1); } string nom,toto; *(entreePrinc->entree) >> nom >> E >> nom >> nu; // lecture de la courbe de coefficient multiplicatif entreePrinc->NouvelleDonnee(); // lecture d'une nouvelle ligne if(strstr(entreePrinc->tablcar,"f_coefficient")== NULL) { cout << "\n erreur en lecture de la courbe de coefficient multiplicatif " << " on attendait la chaine : f_coefficient"; cout << "\n Iso_elas_expo3D::LectureDonneesParticulieres " << "(UtilLecture * entreePrinc) " << endl ; entreePrinc->MessageBuffer(" "); throw (UtilLecture::ErrNouvelleDonnee(-1)); Sortie(1); } *(entreePrinc->entree) >> toto >> nom; // on regarde si la courbe existe, si oui on récupère la référence if (lesCourbes1D.Existe(nom)) { f_coefficient = lesCourbes1D.Trouve(nom); } else { // sinon il faut la lire maintenant string non_courbe("_"); f_coefficient = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str())); // lecture de la courbe f_coefficient->LectDonnParticulieres_courbes (non_courbe,entreePrinc); } // appel au niveau de la classe mère Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire (*entreePrinc,lesFonctionsnD); }; // affichage de la loi void Iso_elas_expo3D::Affiche() const { cout << " \n loi de comportement isoelastique non lineaire 1D " << " E= " << E << " nu= " << nu << endl; cout << " \n fonction multiplicative " ; f_coefficient->Affiche(); // appel de la classe mère Loi_comp_abstraite::Affiche_don_classe_abstraite(); }; // affichage et definition interactive des commandes particulières à chaques lois void Iso_elas_expo3D::Info_commande_LoisDeComp(UtilLecture& entreePrinc) { ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier cout << "\n definition standart (rep o) ou exemples exhaustifs (rep n'importe quoi) ? "; string rep = "_"; // procédure de lecture avec prise en charge d'un retour chariot rep = lect_return_defaut(true,"o"); sort << "\n# --------------------------------------------------------------------" << "\n# |....... loi de comportement isoelastique non lineaire 3D ........|" << "\n# | module d'young : coefficient de poisson |" << "\n# --------------------------------------------------------------------" << "\n E= " << setprecision(6) << E << " nu= " << setprecision(6) << nu ; if ((rep != "o") && (rep != "O" ) && (rep != "0") ) { sort << "\n# .. definition de la courbe multiplicative .. " << "\n# f_coefficient courbe1 # exemple d'une courbe qui existe déjà" << "\n# exemple d'une courbe defini a la suite " << "\n# f_coefficient COURBEPOLYLINEAIRE_1_D" << "\n# Debut_des_coordonnees_des_points" << "\n# Coordonnee dim= 2 0. 1. " << "\n# Coordonnee dim= 2 1. 2. " << "\n# Fin_des_coordonnees_des_points " << "\n# .. fin de la definition de la courbe multiplicative.. "; }; sort << endl; // appel de la classe mère Loi_comp_abstraite::Info_commande_don_LoisDeComp(entreePrinc); }; // test si la loi est complete int Iso_elas_expo3D::TestComplet() { int ret = LoiAbstraiteGeneral::TestComplet(); if (E == 0.) { cout << " \n le ou les parametres de la loi ne sont pas definis, pour la loi " << Nom_comp(id_comp) << '\n'; ret = 0; } if ( f_coefficient == NULL) { cout << " \n la fonction de coefficient multiplicatif n'est pas defini pour la loi " << Nom_comp(id_comp) << '\n'; ret = 0; } return ret; }; //----- lecture écriture de restart ----- // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Iso_elas_expo3D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string toto; if (cas == 1) { ent >> toto >> E >> toto >> nu; // la courbe de coefficient multiplicatif ent >> toto; if (toto != "fonction_multiplicative") { cout << "\n erreur en lecture de la fonction epsilon, on attendait fonction_multiplicative et on a lue " << toto << "\n Iso_elas_expo3D::Lecture_base_info_loi(..."; Sortie(1); }; f_coefficient = lesCourbes1D.Lecture_pour_base_info(ent,cas,f_coefficient); } // appel de la classe mère Loi_comp_abstraite::Lecture_don_base_info(ent,cas,lesRef,lesCourbes1D,lesFonctionsnD); }; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) void Iso_elas_expo3D::Ecriture_base_info_loi(ofstream& sort,const int cas) { if (cas == 1) { sort << " module_d'young " << E << " nu " << nu ; // la courbe de coefficient multiplicatif sort << " \n fonction_multiplicative "; LesCourbes1D::Ecriture_pour_base_info(sort,cas,f_coefficient); } // appel de la classe mère Loi_comp_abstraite::Ecriture_don_base_info(sort,cas); }; // calcul d'un module d'young équivalent à la loi // pour un chargement nul double Iso_elas_expo3D::Module_young_equivalent(Enum_dure ,const Deformation & def ,SaveResul * ) { return E * f_coefficient->Valeur(Dabs(0.)); }; // récupération d'un module de compressibilité équivalent à la loi pour un chargement nul // il s'agit ici de la relation -pression = sigma_trace/3. = module de compressibilité * I_eps double Iso_elas_expo3D::Module_compressibilite_equivalent(Enum_dure ,const Deformation & def) { cout << "\n pas implante !! " << "\n Iso_elas_expo3D::Module_compressibilite_equivalent(Deformation & def)"; Sortie(1); return 0.; // pour taire le compilo /*if (!thermo_dependant) {return E/(3.*(1.-2.*nu));} else { temperature_tdt = def.DonneeInterpoleeScalaire(TEMP,TEMPS_tdt); return E_temperature->Valeur(temperature_tdt)/(3.*(1.-2.*nu)); }; */ }; // ========== codage des METHODES VIRTUELLES protegees:================ // calcul des contraintes a t+dt void Iso_elas_expo3D::Calcul_SigmaHH (TenseurHH& ,TenseurBB& ,DdlElement & tab_ddl, TenseurBB & ,TenseurHH & ,BaseB& ,BaseH& ,TenseurBB& epsBB_, TenseurBB& delta_epsBB_, TenseurBB& , TenseurHH & gijHH_,Tableau & d_gijBB_,double& ,double& , TenseurHH & sigHH_ ,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double& module_cisaillement ,const Met_abstraite::Expli_t_tdt& ex) { #ifdef MISE_AU_POINT if (epsBB_.Dimension() != 3) { cout << "\nErreur : la dimension devrait etre 1 !\n"; cout << " Iso_elas_expo3D::Calcul_SigmaHH\n"; Sortie(1); }; if (tab_ddl.NbDdl() != d_gijBB_.Taille()) { cout << "\nErreur : le nb de ddl est != de la taille de d_gijBB_ !\n"; cout << " Iso_elas_expo3D::Calcul_SigmaHH\n"; Sortie(1); }; #endif const Tenseur3BB & epsBB = *((Tenseur3BB*) &epsBB_); // passage en dim 3 const Tenseur3HH & gijHH = *((Tenseur3HH*) &gijHH_); // " " " " const Tenseur3BB & delta_epsBB = *((Tenseur3BB*) &delta_epsBB_); // passage en dim 3 Tenseur3HH & sigHH = *((Tenseur3HH*) &sigHH_); // " " " " Tenseur3BH epsBH = epsBB * gijHH; // l'invariant relatif au cisaillement double invariant_eps= sqrt(2./3. * epsBH.II() ); double Etotal = E * f_coefficient->Valeur(invariant_eps); // calcul des coefficients double coef1 = (Etotal*nu)/((1.-2.*nu)*(1+nu)); double coef2 = Etotal/(1.+ nu); // calcul du deviateur des deformations double Ieps = epsBH.Trace(); Tenseur3BH sigBH = (Ieps * coef1) * IdBH3 + coef2 * epsBH ; // contrainte en mixte sigHH = gijHH * sigBH; // en deux fois contravariant // traitement des énergies EnergieMeca deltat_ener; // init à 0. des énergies deltat_ener.ChangeEnergieElastique(0.5 * (sigHH && delta_epsBB)); // mise à jour des énergies energ = deltat_ener+energ_t; // -- calcul des modules double untiers=1./3.; // on n'utilise plus la forme linéaire, mais à la place la variation relative de volume // constaté, au sens d'une mesure logarithmique, sauf dans le cas où cette variation est trop petite //module_compressibilite = E/(3.*(1.-2.*nu)); // calcul de la valeur de la variation relative de volume en log double log_var_vol = log((*(ex.jacobien_tdt))/(*(ex.jacobien_0))); if (log_var_vol > ConstMath::petit) {module_compressibilite = sigBH.Trace() * untiers / log_var_vol;} else // si la variation de volume est trop faible on passe par la formule traditionnelle {module_compressibilite = Etotal/(3.*(1.-2.*nu));}; // pour la partie cisaillement on garde la forme associée à la loi module_cisaillement = 0.5 * coef2; LibereTenseur(); }; // calcul des contraintes a t+dt et de ses variations void Iso_elas_expo3D::Calcul_DsigmaHH_tdt (TenseurHH& ,TenseurBB& ,DdlElement & tab_ddl ,BaseB& ,TenseurBB & ,TenseurHH & , BaseB& ,Tableau & ,BaseH& ,Tableau & , TenseurBB & epsBB_tdt,Tableau & d_epsBB,TenseurBB & delta_epsBB_, TenseurBB & ,TenseurHH & gijHH_tdt, Tableau & d_gijBB_tdt, Tableau & d_gijHH_tdt,double& , double& , Vecteur& ,TenseurHH& sigHH_tdt,Tableau & d_sigHH ,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double& module_cisaillement ,const Met_abstraite::Impli& ex ) { #ifdef MISE_AU_POINT if (epsBB_tdt.Dimension() != 3) { cout << "\nErreur : la dimension devrait etre 1 !\n"; cout << " Iso_elas_expo3D::Calcul_DsigmaHH_tdt\n"; Sortie(1); }; if (tab_ddl.NbDdl() != d_gijBB_tdt.Taille()) { cout << "\nErreur : le nb de ddl est != de la taille de d_gijBB_tdt !\n"; cout << " Iso_elas_expo3D::Calcul_SDsigmaHH_tdt\n"; Sortie(1); }; #endif const Tenseur3BB & epsBB = *((Tenseur3BB*) &epsBB_tdt); // passage en dim 1 const Tenseur3HH & gijHH = *((Tenseur3HH*) &gijHH_tdt); // " " " " const Tenseur3BB & delta_epsBB = *((Tenseur3BB*) &delta_epsBB_); // passage en dim 3 Tenseur3HH & sigHH = *((Tenseur3HH*) &sigHH_tdt); // " " " " // --- cas du tenseur des contraintes Tenseur3BH epsBH = epsBB * gijHH; double invariant_eps= sqrt(2./3. * epsBH.II() ); double Etotal = E * f_coefficient->Valeur(invariant_eps); // calcul des coefficients double coef1 = (Etotal*nu)/((1.-2.*nu)*(1+nu)); double coef2 = Etotal/(1.+ nu); // calcul du deviateur des deformations double Ieps = epsBH.Trace(); Tenseur3BH sigBH = (Ieps * coef1) * IdBH3 + coef2 * epsBH ; // contrainte en mixte sigHH = gijHH * sigBH; // en deux fois contravariant // --- cas le la variation du tenseur des contraintes int nbddl = d_gijBB_tdt.Taille(); for (int i = 1; i<= nbddl; i++) { // on fait de faire uniquement une égalité d'adresse et de ne pas utiliser // le constructeur d'ou la profusion d'* et de () Tenseur3HH & dsigHH = *((Tenseur3HH*) (d_sigHH(i))); // passage en dim 3 // const Tenseur3BB & d_gijBB = *((Tenseur3BB*)(d_gijBB_tdt(i))); // passage en dim 3 const Tenseur3HH & dgijHH = *((Tenseur3HH*)(d_gijHH_tdt(i))) ; // pour simplifier l'ecriture const Tenseur3BB & depsBB = *((Tenseur3BB *) (d_epsBB(i))); // " // pour chacun des ddl on calcul les tenseurs derivees Tenseur3BH depsBH = epsBB * dgijHH + depsBB * gijHH ; double dIeps = depsBH.Trace(); dsigHH = dgijHH * sigBH + gijHH * ((dIeps * coef1) * IdBH3 + coef2 * depsBH); } // traitement des énergies EnergieMeca deltat_ener; // init à 0. des énergies deltat_ener.ChangeEnergieElastique(0.5 * (sigHH && delta_epsBB)); // mise à jour des énergies energ = deltat_ener+energ_t; // -- calcul des modules double untiers=1./3.; // on n'utilise plus la forme linéaire, mais à la place la variation relative de volume // constaté, au sens d'une mesure logarithmique, sauf dans le cas où cette variation est trop petite //module_compressibilite = E/(3.*(1.-2.*nu)); // calcul de la valeur de la variation relative de volume en log double log_var_vol = log((*(ex.jacobien_tdt))/(*(ex.jacobien_0))); if (log_var_vol > ConstMath::petit) {module_compressibilite = sigBH.Trace() * untiers / log_var_vol;} else // si la variation de volume est trop faible on passe par la formule traditionnelle {module_compressibilite = Etotal/(3.*(1.-2.*nu));}; // pour la partie cisaillement on garde la forme associée à la loi module_cisaillement = 0.5 * coef2; LibereTenseur(); }; // 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, sinon il s'agit de la base orthonormeee fixe // ex: contient les éléments de métrique relativement au paramétrage matériel = X_(0)^a void Iso_elas_expo3D::Calcul_dsigma_deps (bool en_base_orthonormee, TenseurHH & ,TenseurBB& ,TenseurBB & epsBB_tdt,TenseurBB & ,double& ,double& ,TenseurHH& sigHH_tdt,TenseurHHHH& d_sigma_deps_ ,EnergieMeca & energ,const EnergieMeca & ,double& module_compressibilite,double& module_cisaillement ,const Met_abstraite::Umat_cont& ex) { #ifdef MISE_AU_POINT if (epsBB_tdt.Dimension() != 3) { cout << "\nErreur : la dimension devrait etre 3 !\n"; cout << " Loi_iso_elas3D::Calcul_dsigma_deps\n"; Sortie(1); }; #endif const Tenseur3BB & epsBB = *((Tenseur3BB*) &epsBB_tdt); // passage en dim 3 const Tenseur3HH & gijHH = *((Tenseur3HH*) ex.gijHH_tdt); // " " " " Tenseur3HH & sigHH = *((Tenseur3HH*) &sigHH_tdt); // " " " " // cas du tenseur des contraintes Tenseur3BH epsBH; // init if (en_base_orthonormee) {epsBH = epsBB.MonteDernierIndice();} // deformation en mixte else { epsBH = epsBB * gijHH; }; // deformation en mixte double invariant_eps= sqrt(2./3. * epsBH.II() ); double Etotal = E * f_coefficient->Valeur(invariant_eps); // calcul des coefficients double coef1 = (Etotal*nu)/((1.-2.*nu)*(1+nu)); double coef2 = Etotal/(1.+ nu); // calcul du deviateur des deformations double Ieps = epsBH.Trace(); Tenseur3BH sigBH; double untiers=1./3.; // ici il n'y a pas de test sur le type de base car en mixte la base orthonormeee ou la base locale // ont les mêmes composantes sigBH = (Ieps * coef1) * IdBH3 + coef2 * epsBH ; // contrainte en mixte // sigma en deux fois contravariants if (en_base_orthonormee) {sigHH = IdHH3 * sigBH;} else { sigHH = gijHH * sigBH; }; // cas le la variation du tenseur des contraintes par rapport aux déformations Tenseur3HHHH & d_sigma_depsHHHH = *((Tenseur3HHHH*) &d_sigma_deps_); // pour simplifier if (en_base_orthonormee) { d_sigma_depsHHHH = ((Tenseur3BBBB*) &(coef1 * IdBBBB3 + coef2 * PIdBBBB3))->Monte4Indices() ; } else // sinon cas où les bases sont curvilignes { // calcul de variables intermédiaires I_x_I_HHHH=Tenseur3HHHH::Prod_tensoriel(gijHH,gijHH); I_xbarre_I_HHHH=Tenseur3HHHH::Prod_tensoriel_barre(gijHH,gijHH); Tenseur3HH epsHH(gijHH * epsBH); I_x_eps_HHHH=Tenseur3HHHH::Prod_tensoriel(gijHH,epsHH); Ixbarre_eps_HHHH=Tenseur3HHHH::Prod_tensoriel_barre(gijHH,epsHH); d_sigma_depsHHHH = coef1 * I_x_I_HHHH + (-2.*coef1) * I_x_eps_HHHH + (coef2-2.*coef1 * Ieps) * I_xbarre_I_HHHH + (-4.*coef2) * Ixbarre_eps_HHHH; }; // traitement des énergies energ.Inita(0.); energ.ChangeEnergieElastique(0.5 * (sigHH && epsBB)); // -- calcul des modules // on n'utilise plus la forme linéaire, mais à la place la variation relative de volume // constatée, au sens d'une mesure logarithmique, sauf dans le cas où cette variation est trop petite //module_compressibilite = E/(3.*(1.-2.*nu)); // calcul de la valeur de la variation relative de volume en log double log_var_vol = log((*(ex.jacobien_tdt))/(*(ex.jacobien_0))); if (log_var_vol > ConstMath::petit) {module_compressibilite = sigBH.Trace() * untiers / log_var_vol;} else // si la variation de volume est trop faible on passe par la formule traditionnelle {module_compressibilite = Etotal/(3.*(1.-2.*nu));}; // pour la partie cisaillement on garde la forme associée à la loi module_cisaillement = 0.5 * coef2; LibereTenseur(); LibereTenseurQ(); };