369 lines
15 KiB
C++
369 lines
15 KiB
C++
// 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.
|
|
//
|
|
// 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 <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();
|
|
};
|
|
|
|
|
|
|