Herezh_dev/comportement/iso_elas_nonlinear/Iso_elas_SE1D.cc

370 lines
15 KiB
C++
Raw Normal View History

2021-09-23 11:21:15 +02:00
// FICHIER : Iso_elas_SE1D.cp
// CLASSE : Iso_elas_SE1D
// 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.
//
2023-05-03 17:23:49 +02:00
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
2021-09-23 11:21:15 +02:00
// 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_SE1D.h"
#include "MathUtil.h"
Iso_elas_SE1D::Iso_elas_SE1D () : // Constructeur par defaut
Loi_comp_abstraite(ISO_ELAS_SE1D,CAT_MECANIQUE,1),f_coefficient(NULL),symetrique(true)
,nu(0.)
{ };
// Constructeur de copie
Iso_elas_SE1D::Iso_elas_SE1D (const Iso_elas_SE1D& loi) :
Loi_comp_abstraite(loi)
,f_coefficient(loi.f_coefficient),symetrique(loi.symetrique)
,nu(loi.nu)
{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_SE1D::~Iso_elas_SE1D ()
// Destructeur
{ if (f_coefficient != NULL)
if (f_coefficient->NomCourbe() == "_") delete f_coefficient;
};
// Lecture des donnees de la classe sur fichier
void Iso_elas_SE1D::LectureDonneesParticulieres
(UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D,LesFonctions_nD& lesFonctionsnD)
{ // on regarde tout d'abord si le comportement est symétrique
string toto,nom;
if(strstr(entreePrinc->tablcar,"non_symetrique")!= NULL)
{ *(entreePrinc->entree) >> toto; symetrique = false;} else { symetrique = true; };
// lecture de la courbe de coefficient multiplicatif
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_SE1D::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);
}
// lecture d'un coefficient de Poisson éventuel
if(strstr(entreePrinc->tablcar,"nu=")!= NULL)
{ *(entreePrinc->entree) >> toto >> nu; };
// 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_SE1D::Affiche() const
{ cout << " \n loi de comportement isoelastique non lineaire 1D de type contrainte = f(epsilon)"
<< " \n fonction f() " ;
f_coefficient->Affiche();
cout << "\n nu= " << nu;
// 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_SE1D::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 1D de type sigma = f(epsilon).......|"
<< "\n# | .. definition de la courbe f() .. |"
<< "\n# --------------------------------------------------------------------------------------------"
<< "\n f_coefficient courbe1 # exemple d'une courbe deja existante symetrique par rapport a 0";
if ((rep != "o") && (rep != "O" ) && (rep != "0") )
{ sort
<< "\n\n# non_symetrique f_coefficient courbe1 # exemple d'une courbe deja existante "
<< " non symetrique par rapport a 0 (la courbe doit etre defini en negative et positive) "
<< "\n\n# exemple d'une courbe defini a la suite "
<< "\n non_symetrique f_coefficient COURBEPOLYLINEAIRE_1_D"
<< "\n Debut_des_coordonnees_des_points"
<< "\n Coordonnee dim= 2 -0.03 -350. "
<< "\n Coordonnee dim= 2 -0.02 -300. "
<< "\n Coordonnee dim= 2 -0.01 -200. "
<< "\n Coordonnee dim= 2 0. 0. "
<< "\n Coordonnee dim= 2 0.05 200. "
<< "\n Coordonnee dim= 2 0.1 300. "
<< "\n Coordonnee dim= 2 0.15 350. "
<< "\n Fin_des_coordonnees_des_points "
<< "\n# .. fin de la definition de la courbe sigma = f(epsilon).. \n"
<< "\n "
<< "\n par defaut la loi ne prend pas en compte les deformations transversales cependant "
<< "\n il est possible d'indiquer un coeff de Poisson non nul, pour cela on indique apres la fonction "
<< "\n nu= une valeur "
<< "\n "
<< "\n "
;
};
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_SE1D::TestComplet()
{ int ret = LoiAbstraiteGeneral::TestComplet();
if ( f_coefficient == NULL)
{ cout << " \n la fonction f(epsilon) n'est pas défini 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_SE1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
,LesFonctions_nD& lesFonctionsnD)
{ string toto;
if (cas == 1)
{ // la symétrie
ent >> toto >> symetrique;
// la courbe f(epsilon)
ent >> toto;
if (toto != "fonction_epsilon")
{ cout << "\n erreur en lecture de la fonction epsilon, on attendait fonction_epsilon et on a lue " << toto
<< "\n Iso_elas_SE1D::Lecture_base_info_loi(...";
Sortie(1);
};
f_coefficient = lesCourbes1D.Lecture_pour_base_info(ent,cas,f_coefficient);
ent >> nu;
}
// 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_SE1D::Ecriture_base_info_loi(ofstream& sort,const int cas)
{ if (cas == 1)
{ // la courbe f(epsilon)
sort << " \n symetrie " << symetrique << " fonction_epsilon ";
LesCourbes1D::Ecriture_pour_base_info(sort,cas,f_coefficient);
sort << "\n nu= "<<nu << " ";
}
// appel de la classe mère
Loi_comp_abstraite::Ecriture_don_base_info(sort,cas);
};
// ========== codage des METHODES VIRTUELLES protegees:================
// calcul des contraintes a t+dt
void Iso_elas_SE1D::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() != 1)
{ cout << "\nErreur : la dimension devrait etre 1 !\n";
cout << " Iso_elas_SE1D::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_SE1D::Calcul_SigmaHH\n";
Sortie(1);
};
#endif
const Tenseur1BB & epsBB = *((Tenseur1BB*) &epsBB_); // passage en dim 1
const Tenseur1BB & delta_epsBB = *((Tenseur1BB*) &delta_epsBB_); // passage en dim 1
const Tenseur1HH & gijHH = *((Tenseur1HH*) &gijHH_); // " " " "
Tenseur1HH & sigHH = *((Tenseur1HH*) &sigHH_); // " " " "
Tenseur1BH epsBH = epsBB * gijHH;
Tenseur1BH sigBH;
if (symetrique)
{ sigBH.Coor(1,1) = f_coefficient->Valeur(Dabs(epsBH(1,1))); }
else
{ sigBH.Coor(1,1) = f_coefficient->Valeur(epsBH(1,1)); }
// la contrainte en deux fois contravariante
sigHH = gijHH * sigBH;
// -- calcul des modules
// on passe par la définition d'un pseudo module d'Young régularisé éventuellement
double E;
if (symetrique)
{ if (Dabs(epsBH(1,1)) > ConstMath::petit)
{E= sigBH(1,1)/Dabs(epsBH(1,1));}
else // sinon on calcule pour une petite def arbitraire
{E= f_coefficient->Valeur(ConstMath::pasmalpetit)/(ConstMath::pasmalpetit);
};
}
else
{ if (Dabs(epsBH(1,1)) > ConstMath::petit)
{E= sigBH(1,1)/(epsBH(1,1));}
else // sinon on calcule pour une petite def arbitraire
{ double x = DSigne(epsBH(1,1))*ConstMath::pasmalpetit;
E= f_coefficient->Valeur(x)/(x);
};
};
// puis les formules classiques
module_compressibilite = E/(3.*(1.-2.*nu));
module_cisaillement = 0.5 * E/(2.*(1+nu));
// 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;
LibereTenseur();
};
// calcul des contraintes a t+dt et de ses variations
void Iso_elas_SE1D::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& )
{
#ifdef MISE_AU_POINT
if (epsBB_tdt.Dimension() != 1)
{ cout << "\nErreur : la dimension devrait etre 1 !\n";
cout << " Iso_elas_SE1D::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_SE1D::Calcul_SDsigmaHH_tdt\n";
Sortie(1);
};
#endif
const Tenseur1BB & epsBB = *((Tenseur1BB*) &epsBB_tdt); // passage en dim 1
const Tenseur1BB & delta_epsBB = *((Tenseur1BB*) &delta_epsBB_); // passage en dim 1
const Tenseur1HH & gijHH = *((Tenseur1HH*) &gijHH_tdt); // " " " "
Tenseur1HH & sigHH = *((Tenseur1HH*) &sigHH_tdt); // " " " "
Tenseur1BH epsBH = epsBB * gijHH;
// Tenseur1BH sigBH = f(epsBH);
Courbe1D::ValDer valder_ver; // valeur et dérivée
if (symetrique)
{ valder_ver = f_coefficient->Valeur_Et_derivee(Dabs(epsBH(1,1)));}
else
{ valder_ver = f_coefficient->Valeur_Et_derivee(epsBH(1,1));}
Tenseur1BH sigBH; sigBH.Coor(1,1) = valder_ver.valeur;
sigHH = gijHH * sigBH;
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 ()
Tenseur1HH & dsigHH = *((Tenseur1HH*) (d_sigHH(i))); // passage en dim 1
const Tenseur1BB & dgijBB = *((Tenseur1BB*)(d_gijBB_tdt(i))); // passage en dim 1
const Tenseur1HH & dgijHH = *((Tenseur1HH*)(d_gijHH_tdt(i))) ; // pour simplifier l'ecriture
const Tenseur1BB & depsBB = *((Tenseur1BB *) (d_epsBB(i))); // "
Tenseur1BH depsBH = depsBB * gijHH_tdt + epsBB_tdt * dgijHH;
dsigHH = dgijHH * sigBH
+ (gijHH * depsBH) * valder_ver.derivee;
};
// -- calcul des modules
// on passe par la définition d'un pseudo module d'Young régularisé éventuellement
double E;
if (symetrique)
{ if (Dabs(epsBH(1,1)) > ConstMath::petit)
{E= sigBH(1,1)/Dabs(epsBH(1,1));}
else // sinon on calcule pour une petite def arbitraire
{valder_ver = f_coefficient->Valeur_Et_derivee(ConstMath::pasmalpetit);
E= valder_ver.valeur/(ConstMath::pasmalpetit);
};
}
else
{ if (Dabs(epsBH(1,1)) > ConstMath::petit)
{E= sigBH(1,1)/(epsBH(1,1));}
else // sinon on calcule pour une petite def arbitraire
{double x = DSigne(epsBH(1,1))*ConstMath::pasmalpetit;
valder_ver = f_coefficient->Valeur_Et_derivee(x);
E= valder_ver.valeur/(x);
};
};
// puis les formules classiques
module_compressibilite = E/(3.*(1.-2.*nu));
module_cisaillement = 0.5 * E/(2.*(1+nu));
// 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;
LibereTenseur();
};