Herezh_dev/comportement/iso_elas_nonlinear/iso_elas_expo3D.cc

477 lines
21 KiB
C++
Raw Normal View History

2021-09-23 11:21:15 +02:00
// 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) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
//#include "Debug.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <math.h>
#include <stdlib.h>
#include "Sortie.h"
#include "TypeConsTens.h"
#include "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);
/*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 <TenseurBB *>& 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 <BaseB> & ,BaseH& ,Tableau <BaseH> & ,
TenseurBB & epsBB_tdt,Tableau <TenseurBB *>& d_epsBB,TenseurBB & delta_epsBB_,
TenseurBB & ,TenseurHH & gijHH_tdt,
Tableau <TenseurBB *>& d_gijBB_tdt,
Tableau <TenseurHH *>& d_gijHH_tdt,double& , double& ,
Vecteur& ,TenseurHH& sigHH_tdt,Tableau <TenseurHH *>& d_sigHH
,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double& module_cisaillement
,const Met_abstraite::Impli& ex )
{
#ifdef MISE_AU_POINT
if (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();
};