rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/comportement/iso_elas_nonlinear/Iso_elas_expo1D.cc

1195 lines
52 KiB
C++
Raw Normal View History

ajout des lois de comportement
2021-09-23 11:21:15 +02:00
// FICHIER : Iso_elas_expo1D.cp
// CLASSE : Iso_elas_expo1D
// 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.
//
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
ajout des lois de comportement
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 "ExceptionsLoiComp.h"
#include "Iso_elas_expo1D.h"
#include "MathUtil.h"
#include "Enum_TypeQuelconque.h"
#include "TypeQuelconqueParticulier.h"
// mise à jour de la liste des grandeurs quelconques internes
void Iso_elas_expo1D::SaveResulIso_elas_expo1D::Mise_a_jour_map_type_quelconque()
{ map < EnumTypeQuelconque , TypeQuelconque, std::less < EnumTypeQuelconque> >::iterator il
,ilfin=map_type_quelconque.end();
for (il=map_type_quelconque.begin();il != ilfin;il++)
{EnumTypeQuelconque enu = (*il).first;
switch (enu)
{case E_YOUNG:
{ Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
map_type_quelconque[E_YOUNG].Grandeur_pointee());
*(tyTQ.ConteneurDouble()) = E;
break;
};
case NU_YOUNG:
{ Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
map_type_quelconque[NU_YOUNG].Grandeur_pointee());
*(tyTQ.ConteneurDouble()) = nu;
break;
};
default: break; // sinon rien
};
}
};
// ========== fin des fonctions pour la classe de sauvegarde des résultats =========
Iso_elas_expo1D::Iso_elas_expo1D () : // Constructeur par defaut
Loi_comp_abstraite(ISO_ELAS_ESPO1D,CAT_MECANIQUE,1),E(-ConstMath::trespetit)
,nu(-2.*ConstMath::trespetit)
,f_coefficient(NULL)
,E_nD(NULL),nu_nD(NULL)
{// --- on remplit avec les grandeurs succeptible d'être utilisées
// acces à listdeTouslesQuelc_dispo_localement
list <EnumTypeQuelconque >& list_tousQuelc = ListdeTouslesQuelc_dispo_localement();
list_tousQuelc.push_back(E_YOUNG);
list_tousQuelc.push_back(NU_YOUNG);
// on supprime les doublons localement
list_tousQuelc.sort(); // on ordonne la liste
list_tousQuelc.unique(); // suppression des doublons
};
// Constructeur de copie
Iso_elas_expo1D::Iso_elas_expo1D (const Iso_elas_expo1D& loi) :
Loi_comp_abstraite(loi),E(loi.E),nu(loi.nu)
,f_coefficient(Courbe1D::New_Courbe1D(*(loi.f_coefficient)))
,E_nD(loi.E_nD),nu_nD(loi.nu_nD)
{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);
};
// idem pour les fonctions nD
if (E_nD != NULL)
if (E_nD->NomFonction() == "_")
{// comme il s'agit d'une fonction locale on la redéfinie (sinon pb lors du destructeur de loi)
string non_courbe("_");
E_nD = Fonction_nD::New_Fonction_nD(*loi.E_nD);
};
if (nu_nD != NULL)
if (nu_nD->NomFonction() == "_")
{// comme il s'agit d'une fonction locale on la redéfinie (sinon pb lors du destructeur de loi)
string non_courbe("_");
nu_nD = Fonction_nD::New_Fonction_nD(*loi.nu_nD);
};
// --- on remplit avec les grandeurs succeptible d'être utilisées
// acces à listdeTouslesQuelc_dispo_localement
list <EnumTypeQuelconque >& list_tousQuelc = ListdeTouslesQuelc_dispo_localement();
list_tousQuelc.push_back(E_YOUNG);
list_tousQuelc.push_back(NU_YOUNG);
// on supprime les doublons localement
list_tousQuelc.sort(); // on ordonne la liste
list_tousQuelc.unique(); // suppression des doublons
};
Iso_elas_expo1D::~Iso_elas_expo1D ()
// Destructeur
{ if (f_coefficient != NULL)
if (f_coefficient->NomCourbe() == "_") delete f_coefficient;
if (E_nD != NULL)
if (E_nD->NomFonction() == "_") delete E_nD;
if (nu_nD != NULL)
if (nu_nD->NomFonction() == "_") delete nu_nD;
};
// Lecture des donnees de la classe sur fichier
void Iso_elas_expo1D::LectureDonneesParticulieres
(UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D,LesFonctions_nD& lesFonctionsnD)
{ string nom_class_methode("Iso_elas_expo1D::LectureDonneesParticulieres");
// 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_expo1D::LectureDonneesParticulieres "
<< "(UtilLecture * entreePrinc) " << endl ;
entreePrinc->MessageBuffer(" ");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
else if(strstr(entreePrinc->tablcar,"E_fonction_nD:")!=0)
{ string nom;
string mot_cle1="E=";
string mot_cle2="E_fonction_nD:";
// on passe le mot clé générique
bool lec = entreePrinc->Lecture_et_verif_mot_cle(nom_class_methode,mot_cle1);
// on lit le nom de la fonction
string nom_fonct;
lec = lec && entreePrinc->Lecture_mot_cle_et_string(nom_class_methode,mot_cle2,nom_fonct);
if (!lec )
{ entreePrinc->MessageBuffer("**erreur02 en lecture** "+mot_cle2);
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// maintenant on définit la fonction
if (lesFonctionsnD.Existe(nom_fonct))
{E_nD = lesFonctionsnD.Trouve(nom_fonct);
}
else
{// sinon il faut la lire maintenant
string non("_");
E_nD = Fonction_nD::New_Fonction_nD(non, Id_Nom_Fonction_nD(nom_fonct));
// lecture de la courbe
E_nD->LectDonnParticulieres_Fonction_nD (non,entreePrinc);
// maintenant on vérifie que la fonction est utilisable
if (E_nD->NbComposante() != 1 )
{ cout << "\n erreur en lecture, la fonction " << nom_fonct
<< " est une fonction vectorielle a " << E_nD->NbComposante()
<< " composante alors qu'elle devrait etre scalaire ! "
<< " elle n'est donc pas utilisable !! ";
string message("\n**erreur03** \n"+nom_class_methode+"(...");
entreePrinc->MessageBuffer(message);
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
};
// on regarde si la fonction nD intègre la température
const Tableau <Ddl_enum_etendu>& tab_enu = E_nD->Tab_enu_etendu();
if (tab_enu.Contient(TEMP))
thermo_dependant=true;
}
// sinon si le module d'Young n'a pas été lue, on le récupère en version scalaire
else
{ // lecture du module d'young
string nom;
*(entreePrinc->entree) >> nom >> E ;
if (nom != "E=")
{ cout << "\n erreur en lecture, on attendait le mot cle E= "
<< " et on a lue " << nom;
string message("\n**erreur04** \n"+nom_class_methode+"(...");
entreePrinc->MessageBuffer(message);
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
};
// on regarde si le coefficient de poisson dépend d'une fonction nD
if(strstr(entreePrinc->tablcar,"nu_fonction_nD:")!=0)
{ string nom;
string mot_cle1="nu=";
string mot_cle2="nu_fonction_nD:";
// on passe le mot clé générique
bool lec = entreePrinc->Lecture_et_verif_mot_cle(nom_class_methode,mot_cle1);
// on lit le nom de la fonction
string nom_fonct;
lec = lec && entreePrinc->Lecture_mot_cle_et_string(nom_class_methode,mot_cle2,nom_fonct);
if (!lec )
{ entreePrinc->MessageBuffer("**erreur04 en lecture** "+mot_cle2);
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// maintenant on définit la fonction
if (lesFonctionsnD.Existe(nom_fonct))
{nu_nD = lesFonctionsnD.Trouve(nom_fonct);
}
else
{// sinon il faut la lire maintenant
string non("_");
nu_nD = Fonction_nD::New_Fonction_nD(non, Id_Nom_Fonction_nD(nom_fonct));
// lecture de la courbe
nu_nD->LectDonnParticulieres_Fonction_nD (non,entreePrinc);
// maintenant on vérifie que la fonction est utilisable
if (nu_nD->NbComposante() != 1 )
{ cout << "\n erreur en lecture, la fonction " << nom_fonct
<< " est une fonction vectorielle a " << nu_nD->NbComposante()
<< " composante alors qu'elle devrait etre scalaire ! "
<< " elle n'est donc pas utilisable !! ";
string message("\n**erreur05** \n"+nom_class_methode+"(...");
entreePrinc->MessageBuffer(message);
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
};
// on regarde si la fonction nD intègre la température
const Tableau <Ddl_enum_etendu>& tab_enu = nu_nD->Tab_enu_etendu();
if (tab_enu.Contient(TEMP))
thermo_dependant=true;
}
// sinon si le coefficient de Poisson n'a pas été lue, on le récupère en version scalaire
else
{ string nom;
*(entreePrinc->entree) >> nom >> nu ;
if (nom != "nu=")
{ cout << "\n erreur en lecture, on attendait le mot cle nu= "
<< " et on a lue " << nom;
string message("\n**erreur04** \n"+nom_class_methode+"(...");
entreePrinc->MessageBuffer(message);
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 devait avoir la presence de la chaine : f_coefficient"
;
cout << "\n Iso_elas_expo1D::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_expo1D::Affiche() const
{ cout << " \n loi de comportement isoelastique non lineaire 1D " ;
if (E_nD != NULL)
{cout << "E_fonction_nD:" << " ";
if (E_nD->NomFonction() != "_")
cout << E_nD->NomFonction();
else
E_nD->Affiche();
}
else
{ cout << " E= " << E ;
};
// puis le coefficient de Poisson
if (nu_nD != NULL)
{cout << ", nu_fonction_nD:" << " ";
if (nu_nD->NomFonction() != "_")
cout << nu_nD->NomFonction();
else
nu_nD->Affiche();
}
else
{ cout << " nu= " << nu ;
};
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_expo1D::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 ........|"
<< "\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# .................. dependance a une fonction nD ......................"
<< "\n# Le module d'Young et le coefficient de Poisson peuvent au choix dependre d'une fonction nD. "
<< "\n# Exemple pour E : "
<< "\n# E= E_fonction_nD: fonction_1 "
<< "\n# "
<< "\n# Exemple pour nu : "
<< "\n# nu= nu_fonction_nD: fonction_2 "
<< "\n# "
<< "\n# La declaration des fonctions suit la meme logique que pour les courbes 1D "
<< "\n# ";
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_expo1D::TestComplet()
{ int ret = LoiAbstraiteGeneral::TestComplet();
if ((E == -ConstMath::trespetit) && (E_nD == NULL))
{ cout << " \n le module d'young n'est pas defini pour la loi " << Nom_comp(id_comp)
<< '\n';
ret = 0;
};
if ((nu == -2.*ConstMath::trespetit) && (nu_nD == NULL))
{ cout << " \n le coefficient de poisson n'est pas défini pour la loi " << Nom_comp(id_comp)
<< '\n';
ret *= 0;
};
if ( f_coefficient == NULL)
{ cout << " \n la fonction de coefficient multiplicatif n'est pas défini pour la loi "
<< Nom_comp(id_comp)
<< '\n';
ret *= 0;
}
return ret;
};
// récupération des grandeurs particulière (hors ddl )
// correspondant à liTQ
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
void Iso_elas_expo1D::Grandeur_particuliere
(bool absolue, List_io<TypeQuelconque>& liTQ,Loi_comp_abstraite::SaveResul * saveDon,list<int>& decal) const
{ // tout d'abord on récupère le conteneur
SaveResulIso_elas_expo1D & save_resul = *((SaveResulIso_elas_expo1D*) saveDon);
// ici on est en 1D et les grandeurs sont par principe en absolue, donc la variable absolue ne sert pas
// on passe en revue la liste
List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end();
list<int>::iterator idecal=decal.begin();
for (itq=liTQ.begin();itq!=itqfin;itq++,idecal++)
{TypeQuelconque& tipParticu = (*itq); // pour simplifier
if (tipParticu.EnuTypeQuelconque().Nom_vide()) // veut dire que c'est un enum pur
switch (tipParticu.EnuTypeQuelconque().EnumTQ())
{ case E_YOUNG:
// a) ----- cas du module d'Young actuelle
{ Tab_Grandeur_scalaire_double& tyTQ
= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
tyTQ(1+(*idecal))=save_resul.E;
(*idecal)++; break;
}
case NU_YOUNG:
// b) ----- cas du coef de Poisson actuel
{ Tab_Grandeur_scalaire_double& tyTQ
= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
tyTQ(1+(*idecal))=save_resul.nu;
(*idecal)++; break;
}
// 1) -----cas du module de compressibilité dépendant de la température
case MODULE_COMPRESSIBILITE:
{ Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
tyTQ(1+(*idecal))=save_resul.E/(3.*(1.-2.*save_resul.nu));(*idecal)++;
break;
}
case MODULE_CISAILLEMENT:
{ Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
tyTQ(1+(*idecal))=save_resul.E/(2.*(1.+save_resul.nu));(*idecal)++;
break;
}
default: ;// on ne fait rien
};
};
};
// récupération de la liste de tous les grandeurs particulières
// ces grandeurs sont ajoutées à la liste passées en paramètres
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
void Iso_elas_expo1D::ListeGrandeurs_particulieres(bool absolue,List_io<TypeQuelconque>& liTQ) const
{ // ici on est en 1D et les grandeurs sont par principe en absolue, donc la variable absolue ne sert pas
Tableau <double> tab_1(1);
Tab_Grandeur_scalaire_double grand_courant(tab_1);
// def d'un type quelconque représentatif à chaque grandeur
// a priori ces grandeurs sont défini aux points d'intégration identique à la contrainte par exemple
// enu_ddl_type_pt est définit dans la loi Abtraite générale
//on regarde si ce type d'info existe déjà: si oui on augmente la taille du tableau, si non on crée
// a) $$$ cas du module d'Young actuelle
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == E_YOUNG)
{ Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TypeQuelconque typQ1(E_YOUNG,enu_ddl_type_pt,grand_courant);
liTQ.push_back(typQ1);
};
};
// b) $$$ cas du coefficient de Poisson actuel
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == NU_YOUNG)
{ Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TypeQuelconque typQ1(NU_YOUNG,enu_ddl_type_pt,grand_courant);
liTQ.push_back(typQ1);
};
};
// $$$ cas de MODULE_COMPRESSIBILITE: intéressant quand il dépend de la température
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == MODULE_COMPRESSIBILITE)
{ Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TypeQuelconque typQ1(MODULE_COMPRESSIBILITE,enu_ddl_type_pt,grand_courant);
liTQ.push_back(typQ1);
};
};
// $$$ cas de MODULE_CISAILLEMENT: intéressant quand il dépend de la température
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == MODULE_CISAILLEMENT)
{ Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TypeQuelconque typQ2(MODULE_CISAILLEMENT,enu_ddl_type_pt,grand_courant);
liTQ.push_back(typQ2);
};
};
};
//----- 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_expo1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
,LesFonctions_nD& lesFonctionsnD)
{ string toto,nom;
if (cas == 1)
{ ent >> toto >> toto ;
// tout d'abord la lecture de E
int type =0;
ent >> type;
switch (type)
{ case 2 :
{ent >> nom;
if (nom != " E_fonction_nD: ")
{ cout << "\n erreur en lecture de la fonction nD, on attendait "
<< " E_fonction_nD: et on a lue " << nom
<< "\n Iso_elas_expo1D::Lecture_base_info_loi(...";
Sortie(1);
};
E_nD = lesFonctionsnD.Lecture_pour_base_info(ent,cas,E_nD);
break;
};
case 3 :
{ent >> E;
break;
};
default: cout << "\n erreur type " << type << " non prevu, pour l'instant, les types "
<< " reconnus sont uniquement: 2 E fonction nD, "
<< " 3 E une valeur fixe "
<< "\n Iso_elas_expo1D::Lecture_base_info_loi(...";
Sortie(1);
break;
};
// le coeff de poisson
ent >> toto >> type;
switch (type)
{ case 2 :
{ent >> nom;
if (nom != " nu_fonction_nD: ")
{ cout << "\n erreur en lecture de la fonction nD, on attendait "
<< " nu_fonction_nD: et on a lue " << nom
<< "\n Iso_elas_expo1D::Lecture_base_info_loi(...";
Sortie(1);
};
nu_nD = lesFonctionsnD.Lecture_pour_base_info(ent,cas,nu_nD);
break;
};
case 3 :
{ent >> nu;
break;
};
default: cout << "\n erreur type " << type << " non prevu, pour l'instant, les types "
<< " reconnus sont uniquement: 2 nu fonction nD, "
<< " 3 nu une valeur fixe "
<< "\n Iso_elas_expo1D::Lecture_base_info_loi(...";
Sortie(1);
break;
};
// 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_expo1D::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_expo1D::Ecriture_base_info_loi(ofstream& sort,const int cas)
{ if (cas == 1)
{ sort << "\nISO_ELAS_ESPO1D: module Young:";
if (E_nD != NULL)
{sort << " 2 E_fonction_nD: " << " ";
LesFonctions_nD::Ecriture_pour_base_info(sort, cas,E_nD);
}
else
{ sort << " 3 " << E ; };
// puis nu
sort << " nu_type_et_val= ";
if (nu_nD != NULL)
{sort << " 2 nu_nD: " << " ";
LesFonctions_nD::Ecriture_pour_base_info(sort, cas,nu_nD);
}
else
{ sort << " 3 " << 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_expo1D::Module_young_equivalent(Enum_dure temps,const Deformation & def,SaveResul * saveDon)
{ // on récupère le conteneur
SaveResulIso_elas_expo1D & save_resul = *((SaveResulIso_elas_expo1D*) saveDon);
double Efinale=0.;
switch (temps)
{case TEMPS_0 : // rien n'a été calculé on essaie un calcul
{// cas des courbes d'évolution
if (E_nD != NULL)
// là il faut calcul la fonction nD
{ // ici on utilise les variables connues aux pti, ou calculées à partir de
// on commence par récupérer les conteneurs des grandeurs à fournir
List_io <Ddl_enum_etendu>& li_enu_scal = E_nD->Li_enu_etendu_scalaire();
List_io <TypeQuelconque >& li_quelc = E_nD->Li_equi_Quel_evolue();
// on initialise les grandeurs du tableau pour les valeurs numériques
Tableau <double> val_ddl_enum(li_enu_scal.size(),0.);
// init par défaut des types quelconques
List_io <TypeQuelconque >::iterator il,ilfin=li_quelc.end();
for (il = li_quelc.begin();il != ilfin; il++)
(*il).Grandeur_pointee()->InitParDefaut();
// calcul de la valeur et retour dans tab_ret
Tableau <double> & tab_val
= E_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
#ifdef MISE_AU_POINT
if (tab_val.Taille() != 1)
{ cout << "\nErreur : la fonction nD relative au module d'Young "
<< " doit calculer un scalaire or le tableau de retour est de taille "
<< tab_val.Taille() << " ce n'est pas normal !\n";
cout << " Iso_elas_expo1D::Module_compressibilite_equivalent(..\n";
Sortie(1);
};
#endif
// on récupère le premier élément du tableau uniquement
Efinale = tab_val(1);
};
double val_fonc = f_coefficient->Valeur(0.);
if ((isinf(val_fonc))||( isnan(val_fonc)))
{cout << "\n -- Iso_elas_expo1D::Module_young_equivalent(.. ";
Signature_pti_encours(cout);
cout << "\n *** erreur: la fonction renvoie un nan ou infinie ! ";
throw ErrNonConvergence_loiDeComportement();
};
Efinale *= val_fonc;
break;
}
case TEMPS_t : // on utilise les grandeurs stockées à t
{Efinale= save_resul.E_t;
break;
}
case TEMPS_tdt : // on utilise les grandeurs stockées à tdt
{Efinale= save_resul.E;
break;
}
};
return Efinale;
};
// 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_expo1D::Module_compressibilite_equivalent( Enum_dure temps,const Deformation & def,SaveResul * saveDon)
{ // compte tenu du fait que l'on ne connait pas la métrique etc... on ramène le module en cours
// on récupère le conteneur
SaveResulIso_elas_expo1D & save_resul = *((SaveResulIso_elas_expo1D*) saveDon);
double Efinale=0.;double nufinale=0.;
switch (temps)
{case TEMPS_0 : // rien n'a été calculé on essaie un calcul
{// cas des courbes d'évolution
if (E_nD != NULL)
// là il faut calculer la fonction nD
{ // ici on utilise les variables connues aux pti, ou calculées à partir de
// on commence par récupérer les conteneurs des grandeurs à fournir
List_io <Ddl_enum_etendu>& li_enu_scal = E_nD->Li_enu_etendu_scalaire();
List_io <TypeQuelconque >& li_quelc = E_nD->Li_equi_Quel_evolue();
// on initialise les grandeurs du tableau pour les valeurs numériques
Tableau <double> val_ddl_enum(li_enu_scal.size(),0.);
// init par défaut des types quelconques
List_io <TypeQuelconque >::iterator il,ilfin=li_quelc.end();
for (il = li_quelc.begin();il != ilfin; il++)
(*il).Grandeur_pointee()->InitParDefaut();
// calcul de la valeur et retour dans tab_ret
Tableau <double> & tab_val
= E_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
#ifdef MISE_AU_POINT
if (tab_val.Taille() != 1)
{ cout << "\nErreur : la fonction nD relative au module d'Young "
<< " doit calculer un scalaire or le tableau de retour est de taille "
<< tab_val.Taille() << " ce n'est pas normal !\n";
cout << " Iso_elas_expo1D::Module_compressibilite_equivalent(..\n";
Sortie(1);
};
#endif
// on récupère le premier élément du tableau uniquement
Efinale = tab_val(1);
};
// cas de nu
if (nu_nD != NULL)
// là il faut calculer la fonction nD
{ // ici on utilise les variables connues aux pti, ou calculées à partir de
// on commence par récupérer les conteneurs des grandeurs à fournir
List_io <Ddl_enum_etendu>& li_enu_scal = nu_nD->Li_enu_etendu_scalaire();
List_io <TypeQuelconque >& li_quelc = nu_nD->Li_equi_Quel_evolue();
// on initialise les grandeurs du tableau pour les valeurs numériques
Tableau <double> val_ddl_enum(li_enu_scal.size(),0.);
// init par défaut des types quelconques
List_io <TypeQuelconque >::iterator il,ilfin=li_quelc.end();
for (il = li_quelc.begin();il != ilfin; il++)
(*il).Grandeur_pointee()->InitParDefaut();
// calcul de la valeur et retour dans tab_ret
Tableau <double> & tab_val = nu_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
#ifdef MISE_AU_POINT
if (tab_val.Taille() != 1)
{ cout << "\nErreur : la fonction nD relative au coefficient de Poisson "
<< " doit calculer un scalaire or le tableau de retour est de taille "
<< tab_val.Taille() << " ce n'est pas normal !\n";
cout << " Iso_elas_expo1D::Module_compressibilite_equivalent(..\n";
Sortie(1);
};
#endif
// on récupère le premier élément du tableau uniquement
nufinale = tab_val(1);
};
double val_fonc = f_coefficient->Valeur(0.);
if ((isinf(val_fonc))||( isnan(val_fonc)))
{cout << "\n -- Iso_elas_expo1D::Module_compressibilite_equivalent(.. ";
Signature_pti_encours(cout);
cout << "\n *** erreur: la fonction renvoie un nan ou infinie ! ";
throw ErrNonConvergence_loiDeComportement();
};
Efinale *= val_fonc;
break;
}
case TEMPS_t : // on utilise les grandeurs stockées à t
{Efinale= save_resul.E_t;
nufinale= save_resul.nu_t;
break;
}
case TEMPS_tdt : // on utilise les grandeurs stockées à tdt
{Efinale= save_resul.E;
nufinale= save_resul.nu;
break;
}
};
// retour du module
double K= Efinale/(3.*(1.-2.*nufinale));
return K;
};
// insertion des conteneurs ad hoc concernant le stockage de grandeurs quelconques
// passée en paramètre, dans le save result: ces conteneurs doivent être valides
// c-a-d faire partie de listdeTouslesQuelc_dispo_localement
void Iso_elas_expo1D::Insertion_conteneur_dans_save_result(SaveResul * sr)
{
// récup de la liste de stockage
list <EnumTypeQuelconque >& listlocale = ListQuelc_mis_en_acces_localement();
// on spécialise saveresult
SaveResulIso_elas_expo1D & save_resul = *((SaveResulIso_elas_expo1D*) sr);
// -- autre stockage éventuel en fonction des grandeurs quelconques demandées par d'autres lois
List_io <EnumTypeQuelconque>::iterator jk,jkfin = listlocale.end();
for (jk=listlocale.begin();jk != jkfin;jk++)
{EnumTypeQuelconque enu = *jk;
switch (enu)
{case E_YOUNG: case NU_YOUNG:
{ // on crée le conteneur ad hoc pour le passage d'info
// def d'un conteneur de grandeurs quelconques, initialisée à 0
Grandeur_scalaire_double grand_courant(0.);
TypeQuelconque typQ1(enu,EPS11,grand_courant);
save_resul.map_type_quelconque[enu]=(typQ1);
break;
}
default:
cout << "\n *** erreur on demande l'acces a : "
<< NomTypeQuelconque(enu)
<< " or celui-ci n'est pas dispo pour la loi ";
this->Affiche();
cout << " revoir la mise en donnees ! " << endl;
Sortie(1);
};
};
};
// activation du stockage de grandeurs quelconques qui pourront ensuite être récupéré
// via le conteneur SaveResul, si la grandeur n'existe pas ici, aucune action
void Iso_elas_expo1D::Activation_stockage_grandeurs_quelconques(list <EnumTypeQuelconque >& listEnuQuelc)
mise à jour 7.010
2023-05-03 17:23:49 +02:00
{ // récup de la liste de stockage
ajout des lois de comportement
2021-09-23 11:21:15 +02:00
list <EnumTypeQuelconque >& listlocale = ListQuelc_mis_en_acces_localement();
// on parcours la liste des grandeurs à activer
// et on remplit la liste locale
list <EnumTypeQuelconque >::iterator il, ilfin = listEnuQuelc.end();
for (il = listEnuQuelc.begin();il != ilfin; il++)
// for (EnumTypeQuelconque enu : listEnuQuelc)
// on ne remplit que s'il s'agit d'une grandeur qui peut-être accessible
{switch (*il)
{case E_YOUNG : case NU_YOUNG:
listlocale.push_back(*(il));
break;
default: ; // pour les autres cas on ne fait rien
};
};
// on supprime les doublons localement
listlocale.sort(); // on ordonne la liste
listlocale.unique(); // suppression des doublons
};
// ========== codage des METHODES VIRTUELLES protegees:================
// calcul des contraintes a t+dt
void Iso_elas_expo1D::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_expo1D::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_expo1D::Calcul_SigmaHH\n";
Sortie(1);
};
#endif
const Tenseur1BB & epsBB = *((Tenseur1BB*) &epsBB_); // passage en dim 1
const Tenseur1HH & gijHH = *((Tenseur1HH*) &gijHH_); // " " " "
const Tenseur1BB & delta_epsBB = *((Tenseur1BB*) &delta_epsBB_); // passage en dim 1
Tenseur1HH & sigHH = *((Tenseur1HH*) &sigHH_); // " " " "
// opération de transmission de la métrique
const Met_abstraite::Impli* ex_impli = NULL;
const Met_abstraite::Expli_t_tdt* ex_expli_tdt = &ex;
const Met_abstraite::Umat_cont* ex_expli = NULL;
Tenseur1BH epsBH = epsBB * gijHH;
double val_fonc = f_coefficient->Valeur(Dabs(epsBH(1,1)));
if ((isinf(val_fonc))||( isnan(val_fonc)))
{cout << "\n -- Iso_elas_expo1D::Calcul_DsigmaHH_tdt(.. ";
Signature_pti_encours(cout);
cout << "\n *** erreur: la fonction renvoie un nan ou infinie ! ";
throw ErrNonConvergence_loiDeComportement();
};
if (E_nD != NULL)
// là il faut calculer la fonction nD
{ // on utilise la méthode générique de loi abstraite
list <SaveResul*> list_save; // inter pour l'appel de la fonction
list_save.push_back(saveResul);
Tableau <double> & tab_val = Loi_comp_abstraite::Loi_comp_Valeur_FnD_Evoluee
(E_nD,1 // une seule valeur attendue en retour
,ex_impli,ex_expli_tdt,ex_expli
,NULL
,NULL
,&list_save
);
/* // ici on utilise les variables connues aux pti, ou calculées à partir de
// on commence par récupérer les conteneurs des grandeurs à fournir
List_io <Ddl_enum_etendu>& li_enu_scal = E_nD->Li_enu_etendu_scalaire();
List_io <TypeQuelconque >& li_quelc = E_nD->Li_equi_Quel_evolue();
bool absolue = true; // on se place systématiquement en absolu
// on va utiliser la méhode Valeur_multi_interpoler_ou_calculer
// pour les grandeurs strictement scalaire
Tableau <double> val_ddl_enum(Valeur_multi_interpoler_ou_calculer
(absolue,TEMPS_tdt,li_enu_scal,ex_impli,ex_expli_tdt,ex_expli,NULL)
);
// on utilise la méthode Valeurs_Tensorielles_interpoler_ou_calculer
// pour les Coordonnees et Tenseur
Valeurs_Tensorielles_interpoler_ou_calculer
(absolue,TEMPS_tdt,li_quelc,ex_impli,ex_expli_tdt,ex_expli,NULL);
// calcul de la valeur et retour dans tab_ret
Tableau <double> & tab_val = E_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
#ifdef MISE_AU_POINT
if (tab_val.Taille() != 1)
{ cout << "\nErreur : la fonction nD relative au module d'Young "
<< " doit calculer un scalaire or le tableau de retour est de taille "
<< tab_val.Taille() << " ce n'est pas normal !\n";
cout << " Iso_elas_expo1D::Calcul_SigmaHH\n";
Sortie(1);
};
#endif
*/
// on récupère le premier élément du tableau uniquement
E = tab_val(1);
};
// cas de nu
if (nu_nD != NULL)
// là il faut calcul la fonction nD
{ // on utilise la méthode générique de loi abstraite
list <SaveResul*> list_save; // inter pour l'appel de la fonction
list_save.push_back(saveResul);
Tableau <double> & tab_val = Loi_comp_abstraite::Loi_comp_Valeur_FnD_Evoluee
(nu_nD,1 // une seule valeur attendue en retour
,ex_impli,ex_expli_tdt,ex_expli
,NULL
,NULL
,&list_save
);
/* // ici on utilise les variables connues aux pti, ou calculées à partir de
// on commence par récupérer les conteneurs des grandeurs à fournir
List_io <Ddl_enum_etendu>& li_enu_scal = nu_nD->Li_enu_etendu_scalaire();
List_io <TypeQuelconque >& li_quelc = nu_nD->Li_equi_Quel_evolue();
bool absolue = true; // on se place systématiquement en absolu
// on va utiliser la méhode Valeur_multi_interpoler_ou_calculer
// pour les grandeurs strictement scalaire
Tableau <double> val_ddl_enum(Valeur_multi_interpoler_ou_calculer
(absolue,TEMPS_tdt,li_enu_scal,ex_impli,ex_expli_tdt,ex_expli,NULL)
);
// on utilise la méthode Valeurs_Tensorielles_interpoler_ou_calculer
// pour les Coordonnees et Tenseur
Valeurs_Tensorielles_interpoler_ou_calculer
(absolue,TEMPS_tdt,li_quelc,ex_impli,ex_expli_tdt,ex_expli,NULL);
// calcul de la valeur et retour dans tab_ret
Tableau <double> & tab_val = nu_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
#ifdef MISE_AU_POINT
if (tab_val.Taille() != 1)
{ cout << "\nErreur : la fonction nD relative au coefficient de Poisson "
<< " doit calculer un scalaire or le tableau de retour est de taille "
<< tab_val.Taille() << " ce n'est pas normal !\n";
cout << " Iso_elas_expo1D::Calcul_SigmaHH\n";
Sortie(1);
};
#endif
*/
// on récupère le premier élément du tableau uniquement
nu = tab_val(1);
};
double E_finale = (E * val_fonc);
// sauvegarde des paramètres matériau
SaveResulIso_elas_expo1D & save_resul = *((SaveResulIso_elas_expo1D*) saveResul);
save_resul.E = E_finale;
save_resul.nu = nu;
Tenseur1BH sigBH = E_finale * epsBH;
sigHH = gijHH * sigBH;
module_compressibilite = E_finale /(3.*(1.-2.*nu));
module_cisaillement = 0.5 * E_finale /(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;
if (Permet_affichage() > 4)
{ cout << "\n -- Iso_elas_expo1D::Calcul_DsigmaHH_tdt(.. ";
Signature_pti_encours(cout);
cout << " epsBB(1,1)= "<< epsBB(1,1)
<< " epsBH(1,1)= "<< epsBH(1,1)
<< " gijHH(1,1)= "<< gijHH(1,1)
<< " x= epsb= "<< Dabs(epsBH(1,1));
if (E_nD != NULL)
{cout << " E fctnD= " << E;};
if (nu_nD != NULL)
{cout << " nu fctnD= " << nu;}
cout << " E_finale = " << E_finale
<< " sigBH(1,1)= " << sigBH(1,1)
<< " sigHH(1,1)= " << sigHH(1,1)
<< " module_compressibilite= " << module_compressibilite
<< " module cisaillement= " << module_cisaillement
<< " ener_elas= " << energ.EnergieElastique()
<< flush;
};
LibereTenseur();
};
// calcul des contraintes a t+dt et de ses variations
void Iso_elas_expo1D::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() != 1)
{ cout << "\nErreur : la dimension devrait etre 1 !\n";
cout << " Iso_elas_expo1D::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_expo1D::Calcul_SDsigmaHH_tdt\n";
Sortie(1);
};
#endif
const Tenseur1BB & epsBB = *((Tenseur1BB*) &epsBB_tdt); // passage en dim 1
const Tenseur1HH & gijHH = *((Tenseur1HH*) &gijHH_tdt); // " " " "
const Tenseur1BB & delta_epsBB = *((Tenseur1BB*) &delta_epsBB_); // passage en dim 1
Tenseur1HH & sigHH = *((Tenseur1HH*) &sigHH_tdt); // " " " "
// opération de transmission de la métrique
const Met_abstraite::Impli* ex_impli = &ex;
const Met_abstraite::Expli_t_tdt* ex_expli_tdt = NULL;
const Met_abstraite::Umat_cont* ex_expli = NULL;
Tenseur1BH epsBH = epsBB * gijHH;
// Tenseur1BH sigBH = (E * (1.-alpha* pow(epsBH(1,1),ixn))) * epsBH;
double epsb = Dabs(epsBH(1,1)); // l'invariant
Courbe1D::ValDer valder_ver = f_coefficient->Valeur_Et_derivee(epsb); // valeur et dérivée
if ((isinf(valder_ver.valeur))||( isnan(valder_ver.valeur)))
{cout << "\n -- Iso_elas_expo1D::Calcul_DsigmaHH_tdt(.. ";
Signature_pti_encours(cout);
cout << "\n *** erreur: la fonction renvoie un nan ou infinie ! ";
throw ErrNonConvergence_loiDeComportement();
};
if ((isinf(valder_ver.derivee))||( isnan(valder_ver.derivee)))
{cout << "\n -- Iso_elas_expo1D::Calcul_DsigmaHH_tdt(.. ";
Signature_pti_encours(cout);
cout << "\n *** erreur: la fonction renvoie une derivee nan ou infinie ! ";
throw ErrNonConvergence_loiDeComportement();
};
if (E_nD != NULL)
// là il faut calculer la fonction nD
{ // on utilise la méthode générique de loi abstraite
list <SaveResul*> list_save; // inter pour l'appel de la fonction
list_save.push_back(saveResul);
Tableau <double> & tab_val = Loi_comp_abstraite::Loi_comp_Valeur_FnD_Evoluee
(E_nD,1 // une seule valeur attendue en retour
,ex_impli,ex_expli_tdt,ex_expli
,NULL
,NULL
,&list_save
);
/* // ici on utilise les variables connues aux pti, ou calculées à partir de
// on commence par récupérer les conteneurs des grandeurs à fournir
List_io <Ddl_enum_etendu>& li_enu_scal = E_nD->Li_enu_etendu_scalaire();
List_io <TypeQuelconque >& li_quelc = E_nD->Li_equi_Quel_evolue();
bool absolue = true; // on se place systématiquement en absolu
// on va utiliser la méhode Valeur_multi_interpoler_ou_calculer
// pour les grandeurs strictement scalaire
Tableau <double> val_ddl_enum(Valeur_multi_interpoler_ou_calculer
(absolue,TEMPS_tdt,li_enu_scal,ex_impli,ex_expli_tdt,ex_expli,NULL)
);
// on utilise la méthode Valeurs_Tensorielles_interpoler_ou_calculer
// pour les Coordonnees et Tenseur
Valeurs_Tensorielles_interpoler_ou_calculer
(absolue,TEMPS_tdt,li_quelc,ex_impli,ex_expli_tdt,ex_expli,NULL);
// calcul de la valeur et retour dans tab_ret
Tableau <double> & tab_val = E_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
#ifdef MISE_AU_POINT
if (tab_val.Taille() != 1)
{ cout << "\nErreur : la fonction nD relative au module d'Young "
<< " doit calculer un scalaire or le tableau de retour est de taille "
<< tab_val.Taille() << " ce n'est pas normal !\n";
cout << " Iso_elas_expo1D::Calcul_SigmaHH\n";
Sortie(1);
};
#endif
*/
// on récupère le premier élément du tableau uniquement
E = tab_val(1);
};
// cas de nu
if (nu_nD != NULL)
// là il faut calcul la fonction nD
{ // on utilise la méthode générique de loi abstraite
list <SaveResul*> list_save; // inter pour l'appel de la fonction
list_save.push_back(saveResul);
Tableau <double> & tab_val = Loi_comp_abstraite::Loi_comp_Valeur_FnD_Evoluee
(nu_nD,1 // une seule valeur attendue en retour
,ex_impli,ex_expli_tdt,ex_expli
,NULL
,NULL
,&list_save
);
/* // ici on utilise les variables connues aux pti, ou calculées à partir de
// on commence par récupérer les conteneurs des grandeurs à fournir
List_io <Ddl_enum_etendu>& li_enu_scal = nu_nD->Li_enu_etendu_scalaire();
List_io <TypeQuelconque >& li_quelc = nu_nD->Li_equi_Quel_evolue();
bool absolue = true; // on se place systématiquement en absolu
// on va utiliser la méhode Valeur_multi_interpoler_ou_calculer
// pour les grandeurs strictement scalaire
Tableau <double> val_ddl_enum(Valeur_multi_interpoler_ou_calculer
(absolue,TEMPS_tdt,li_enu_scal,ex_impli,ex_expli_tdt,ex_expli,NULL)
);
// on utilise la méthode Valeurs_Tensorielles_interpoler_ou_calculer
// pour les Coordonnees et Tenseur
Valeurs_Tensorielles_interpoler_ou_calculer
(absolue,TEMPS_tdt,li_quelc,ex_impli,ex_expli_tdt,ex_expli,NULL);
// calcul de la valeur et retour dans tab_ret
Tableau <double> & tab_val = nu_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
#ifdef MISE_AU_POINT
if (tab_val.Taille() != 1)
{ cout << "\nErreur : la fonction nD relative au coefficient de Poisson "
<< " doit calculer un scalaire or le tableau de retour est de taille "
<< tab_val.Taille() << " ce n'est pas normal !\n";
cout << " Iso_elas_expo1D::Calcul_SigmaHH\n";
Sortie(1);
};
#endif
*/
// on récupère le premier élément du tableau uniquement
nu = tab_val(1);
};
Tenseur1BH sigBH = (E * valder_ver.valeur) * epsBH;
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) *( E * (1. - alpha * (ixn+1) * pow(epsBH(1,1),ixn)));
+ (gijHH * depsBH) * E * (valder_ver.valeur + epsb*valder_ver.derivee);
};
module_compressibilite = (E * valder_ver.valeur)/(3.*(1.-2.*nu));
module_cisaillement = 0.5 * (E * valder_ver.valeur)/(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;
if (Permet_affichage() > 4)
{ cout << "\n -- Iso_elas_expo1D::Calcul_DsigmaHH_tdt(.. ";
Signature_pti_encours(cout);
cout << " epsBB(1,1)= "<< epsBB(1,1)
<< " epsBH(1,1)= "<< epsBH(1,1)
<< " gijHH(1,1)= "<< gijHH(1,1)
<< " x= epsb= "<< epsb
<< " fct(x) = " << valder_ver.valeur;
if (E_nD != NULL)
{cout << " E fctnD= " << E;};
if (nu_nD != NULL)
{cout << " nu fctnD= " << nu;}
cout << " E_finale = " << (E * valder_ver.valeur)
<< " sigBH(1,1)= " << sigBH(1,1)
<< " sigHH(1,1)= " << sigHH(1,1)
<< " module_compressibilite= " << module_compressibilite
<< " module cisaillement= " << module_cisaillement
<< " ener_elas= " << energ.EnergieElastique()
<< flush;
};
LibereTenseur();
};
Reference in a new issue Copy permalink