rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/comportement/Hyper_elastique/MooneyRivlin1D.cc
Gérard Rio 0460624e94 mise à jour 7.010
2023-05-03 17:23:49 +02:00

416 lines
18 KiB
C++
Raw Permalink Blame History

// FICHIER : MooneyRivlin1D.cc
// CLASSE : MooneyRivlin1D
// 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 "MooneyRivlin1D.h"
#include "MathUtil.h"
MooneyRivlin1D::MooneyRivlin1D () : // Constructeur par defaut
Loi_comp_abstraite(MOONEY_RIVLIN_1D,CAT_MECANIQUE,1),C10(0.),C01(0.)
,C10_temperature(NULL),C01_temperature(NULL)
{ };
// Constructeur de copie
MooneyRivlin1D::MooneyRivlin1D (const MooneyRivlin1D& loi) :
Loi_comp_abstraite(loi)
,C10(loi.C10),C01(loi.C01)
,C10_temperature(loi.C10_temperature),C01_temperature(loi.C01_temperature)
{// on regarde s'il s'agit d'une courbe locale ou d'une courbe globale
if (C10_temperature->NomCourbe() == "_") C10_temperature = Courbe1D::New_Courbe1D(*(loi.C10_temperature));
if (C01_temperature->NomCourbe() == "_") C01_temperature = Courbe1D::New_Courbe1D(*(loi.C01_temperature));;
};
MooneyRivlin1D::~MooneyRivlin1D ()
// Destructeur
{ if (C10_temperature != NULL)
if (C10_temperature->NomCourbe() == "_") delete C10_temperature;
if (C01_temperature != NULL)
if (C01_temperature->NomCourbe() == "_") delete C01_temperature;
};
// Lecture des donnees de la classe sur fichier
void MooneyRivlin1D::LectureDonneesParticulieres
(UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D
,LesFonctions_nD& lesFonctionsnD)
{ string toto,nom;
// ---- lecture du coefficient C01 -----
*(entreePrinc->entree) >> nom;
if(nom != "C01=")
{ cout << "\n erreur en lecture du parametre C01, on attendait la chaine C01= et on a lu: " << nom;
cout << "\n MooneyRivlin1D::LectureDonneesParticulieres "
<< "(UtilLecture * entreePrinc) " << endl ;
entreePrinc->MessageBuffer("**erreur1 MooneyRivlin::LectureDonneesParticulieres (...**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// on regarde si le coefficient est thermo dépendante
if(strstr(entreePrinc->tablcar,"C01_thermo_dependant_")!=0)
{ thermo_dependant=true;
*(entreePrinc->entree) >> nom;
if (nom != "C01_thermo_dependant_")
{ cout << "\n erreur en lecture de la thermodependance de C01, on aurait du lire le mot cle C01_thermo_dependant_"
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
entreePrinc->MessageBuffer("**erreur2 MooneyRivlin::LectureDonneesParticulieres (...**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
// lecture de la loi d'évolution en fonction de la température
*(entreePrinc->entree) >> nom;
// on regarde si la courbe existe, si oui on récupère la référence
if (lesCourbes1D.Existe(nom))
{ C01_temperature = lesCourbes1D.Trouve(nom);
}
else
{ // sinon il faut la lire maintenant
string non_courbe("_");
C01_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
// lecture de la courbe
C01_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
}
// prepa du flot de lecture
entreePrinc->NouvelleDonnee();
}
else
{ // lecture de C01
*(entreePrinc->entree) >> C01 ;
};
// ---- puis lecture du coefficient C10 ----
*(entreePrinc->entree) >> nom;
if(nom != "C10=")
{ cout << "\n erreur en lecture du parametre C10, on attendait la chaine C10= et on a lu: " << nom;
cout << "\n MooneyRivlin1D::LectureDonneesParticulieres "
<< "(UtilLecture * entreePrinc) " << endl ;
entreePrinc->MessageBuffer("**erreur3 MooneyRivlin::LectureDonneesParticulieres (...**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// on regarde si le coefficient est thermo dépendante
if(strstr(entreePrinc->tablcar,"C10_thermo_dependant_")!=0)
{ thermo_dependant=true;
*(entreePrinc->entree) >> nom;
if (nom != "C10_thermo_dependant_")
{ cout << "\n erreur en lecture de la thermodependance de C10, on aurait du lire le mot cle C10_thermo_dependant_"
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
entreePrinc->MessageBuffer("**erreur4 MooneyRivlin::LectureDonneesParticulieres (...**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
// lecture de la loi d'évolution en fonction de la température
*(entreePrinc->entree) >> nom;
// on regarde si la courbe existe, si oui on récupère la référence
if (lesCourbes1D.Existe(nom))
{ C10_temperature = lesCourbes1D.Trouve(nom);
}
else
{ // sinon il faut la lire maintenant
string non_courbe("_");
C10_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
// lecture de la courbe
C10_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
}
// prepa du flot de lecture
entreePrinc->NouvelleDonnee();
}
else
{ // lecture de C10
*(entreePrinc->entree) >> C10 ;
};
// ---- appel au niveau de la classe mère ----
Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire
(*entreePrinc,lesFonctionsnD);
};
// affichage de la loi
void MooneyRivlin1D::Affiche() const
{ cout << " \n loi de comportement hyper elastique 1D de type mooney rivlin \n";
if ( C01_temperature != NULL) { cout << " C01 thermo dependant "
<< " courbe C01=f(T): " << C01_temperature->NomCourbe() <<" ";}
else { cout << " C01= " << C01 ;}
if ( C10_temperature != NULL) { cout << " C10 thermo dependant "
<< " courbe C10=f(T): " << C10_temperature->NomCourbe() <<" ";}
else { cout << " C10= " << C10 << " ";}
// appel de la classe mère
Loi_comp_abstraite::Affiche_don_classe_abstraite();
};
// affichage et definition interactive des commandes particulières à chaques lois
void MooneyRivlin1D::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 hyper elastique 1D de type mooney rivlin ....... |"
<< "\n# | .. deux coefficients C01 et C10 .. |"
<< "\n# ----------------------------------------------------------------------------------"
<< "\n\n# exemple de definition de loi"
<< "\n C01= 0.0167 C10= 0.145 "
<< "\n# .. fin de la definition de la loi money rivlin \n" << endl;
if ((rep != "o") && (rep != "O" ) && (rep != "0") )
{ sort << "\n#-----------------------------------"
<< "\n# il est possible de definir des parametres thermo-dependants (1 ou 2 parametres)"
<< "\n# par exemple pour les deux parametres on ecrit: "
<< "\n#-----------------------------------"
<< "\n# C01= C01_thermo_dependant_ courbe1 "
<< "\n# C10= C10_thermo_dependant_ courbe4 "
<< "\n#-----------------------------------"
<< "\n# noter qu'apres la definition de chaque courbe, on change de ligne, d'une maniere inverse "
<< "\n# si la valeur du parametre est fixe, on poursuit sur la meme ligne. "
<< "\n# par exemple supposons C01 fixe, C10, on ecrit: "
<< "\n#-----------------------------------"
<< "\n# C01= 2. C10= C10_thermo_dependant_ courbe4 "
<< "\n#-----------------------------------"
<< endl;
};
// appel de la classe mère
Loi_comp_abstraite::Info_commande_don_LoisDeComp(entreePrinc);
};
// test si la loi est complete
int MooneyRivlin1D::TestComplet()
{ int ret = LoiAbstraiteGeneral::TestComplet();
if ((C01_temperature == NULL) && (C01 == 0.))
{ cout << " \n le coefficient C01 n'est pas defini pour la loi "
<< Nom_comp(id_comp)
<< '\n' << endl;
ret = 0;
};
if ((C10_temperature == NULL) && (C10 == 0.))
{ cout << " \n le coefficient C10 n'est pas defini pour la loi "
<< Nom_comp(id_comp)
<< '\n' << endl;
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 MooneyRivlin1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
,LesFonctions_nD& lesFonctionsnD)
{ string nom;bool test;
if (cas == 1)
{ // les coefficients
// C01
ent >> nom >> test;
// vérification
#ifdef MISE_AU_POINT
if (nom != "CO1")
{ cout << "\n erreur en lecture du parametres C01 de la loi de mooney rivlin 1D"
<< " on devait lire C01= avant le premier parametre "
<< " et on a lue: " << nom << " "
<< "\n MooneyRivlin1D::Lecture_base_info_loi(..."
<< endl;
Sortie(1);
}
#endif
if (!test)
{ ent >> C01;
if (C01_temperature != NULL) {if (C01_temperature->NomCourbe() == "_")
delete C01_temperature; C01_temperature = NULL;};
}
else
{ ent >> nom; C01_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,C01_temperature); };
// C10
ent >> nom >> test;
// vérification
#ifdef MISE_AU_POINT
if (nom != "C10")
{ cout << "\n erreur en lecture du parametres C10 de la loi de mooney rivlin 1D"
<< " on devait lire C10= avant le second parametre "
<< " et on a lue: " << nom << " "
<< "\n MooneyRivlin1D::Lecture_base_info_loi(..."
<< endl;
Sortie(1);
}
#endif
if (!test)
{ ent >> C10;
if (C10_temperature != NULL) {if (C10_temperature->NomCourbe() == "_")
delete C10_temperature; C10_temperature = NULL;};
}
else
{ ent >> nom; C10_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,C10_temperature); };
}
// 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 MooneyRivlin1D::Ecriture_base_info_loi(ofstream& sort,const int cas)
{ if (cas == 1)
{ // les coefficients
sort << "\n C01= ";
if (C01_temperature == NULL)
{ sort << false << " " << C01 << " ";}
else
{ sort << true << " fonction_C01_temperature ";
LesCourbes1D::Ecriture_pour_base_info(sort,cas,C01_temperature);
};
sort << " C10= ";
if (C10_temperature == NULL)
{ sort << false << " " << C10 << " ";}
else
{ sort << true << " fonction_C10_temperature ";
LesCourbes1D::Ecriture_pour_base_info(sort,cas,C10_temperature);
};
}
// 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 MooneyRivlin1D::Calcul_SigmaHH (TenseurHH& ,TenseurBB& ,DdlElement & tab_ddl,
TenseurBB & ,TenseurHH & ,BaseB& ,BaseH& ,TenseurBB& epsBB_,
TenseurBB& , 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& )
{
#ifdef MISE_AU_POINT
if (epsBB_.Dimension() != 1)
{ cout << "\nErreur : la dimension devrait etre 1 !\n";
cout << " MooneyRivlin1D::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 << " MooneyRivlin1D::Calcul_SigmaHH\n";
Sortie(1);
};
#endif
const Tenseur1BB & epsBB = *((Tenseur1BB*) &epsBB_); // passage en dim 1
const Tenseur1HH & gijHH = *((Tenseur1HH*) &gijHH_); // " " " "
Tenseur1HH & sigHH = *((Tenseur1HH*) &sigHH_); // " " " "
Tenseur1BH epsBH = epsBB * gijHH;
Tenseur1BH sigBH;
// cas de la thermo dépendance, on calcul les grandeurs
if (C01_temperature != NULL) C01 = C01_temperature->Valeur(*temperature);
if (C10_temperature != NULL) C10 = C10_temperature->Valeur(*temperature);
double unMoins2eps = 1. - 2.*epsBH(1,1);
double racine_unMoins2eps = sqrt(unMoins2eps);
sigBH.Coor(1,1) = 2. * C10 * (1./unMoins2eps - racine_unMoins2eps)
+ 2. * C01 * (1./racine_unMoins2eps-unMoins2eps);
// la contrainte en deux fois contravariante
sigHH = gijHH * sigBH;
};
// calcul des contraintes a t+dt et de ses variations
void MooneyRivlin1D::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 & ,
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 << " MooneyRivlin1D::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 << " MooneyRivlin1D::Calcul_SDsigmaHH_tdt\n";
Sortie(1);
};
#endif
const Tenseur1BB & epsBB = *((Tenseur1BB*) &epsBB_tdt); // passage en dim 1
const Tenseur1HH & gijHH = *((Tenseur1HH*) &gijHH_tdt); // " " " "
Tenseur1HH & sigHH = *((Tenseur1HH*) &sigHH_tdt); // " " " "
// cas de la thermo dépendance, on calcul les grandeurs
if (C01_temperature != NULL) C01 = C01_temperature->Valeur(*temperature);
if (C10_temperature != NULL) C10 = C10_temperature->Valeur(*temperature);
Tenseur1BH epsBH = epsBB * gijHH;
Tenseur1BH sigBH;
double unMoins2eps = 1. - 2.*epsBH(1,1);
double unSurUnMoins2eps = 1./unMoins2eps;
double racine_unMoins2eps = sqrt(unMoins2eps);
double unSurRacine_unMoins2eps = 1./racine_unMoins2eps;
sigBH.Coor(1,1) = 2. * C10 * (unSurUnMoins2eps - racine_unMoins2eps)
+ 2. * C01 * (unSurRacine_unMoins2eps-unMoins2eps);
// la contrainte en deux fois contravariante
sigHH = gijHH * sigBH;
int nbddl = d_gijBB_tdt.Taille();
double coef = 2. * C10 * (2.* unSurUnMoins2eps * unSurUnMoins2eps + unSurRacine_unMoins2eps)
+ 2. * C01 * (unSurUnMoins2eps * unSurRacine_unMoins2eps + 2.);
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) * coef;
};
};
Reference in a new issue View git blame Copy permalink