1363 lines
59 KiB
C++
1363 lines
59 KiB
C++
// FICHIER : Loi_iso_elas.cp
|
|
// CLASSE : Loi_iso_elas
|
|
|
|
|
|
// 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 <iostream>
|
|
using namespace std; //introduces namespace std
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
#include "Sortie.h"
|
|
#include "TypeConsTens.h"
|
|
#include "ConstMath.h"
|
|
#include "CharUtil.h"
|
|
|
|
#include "Loi_iso_elas2D_D.h"
|
|
|
|
#include "Enum_TypeQuelconque.h"
|
|
#include "TypeQuelconqueParticulier.h"
|
|
|
|
|
|
// mise à jour de la liste des grandeurs quelconques internes
|
|
void Loi_iso_elas2D_D::SaveResulLoi_iso_elas2D_D::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 =========
|
|
|
|
Loi_iso_elas2D_D::Loi_iso_elas2D_D () : // Constructeur par defaut
|
|
Loi_comp_abstraite(ISOELAS2D_D,CAT_MECANIQUE,2),E(-ConstMath::trespetit),nu(-2.*ConstMath::trespetit)
|
|
,E_temperature(NULL),cas_calcul(0),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
|
|
};
|
|
|
|
// Contructeur fonction du E et du nu
|
|
Loi_iso_elas2D_D::Loi_iso_elas2D_D(const double& EE,const double& nunu):
|
|
Loi_comp_abstraite(ISOELAS2D_D,CAT_THERMO_MECANIQUE,2),E(EE),nu(nunu)
|
|
,E_temperature(NULL),cas_calcul(0),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
|
|
Loi_iso_elas2D_D::Loi_iso_elas2D_D (const Loi_iso_elas2D_D& loi) :
|
|
Loi_comp_abstraite(loi),E(loi.E),nu(loi.nu)
|
|
,E_temperature(loi.E_temperature)
|
|
,E_nD(loi.E_nD),nu_nD(loi.nu_nD)
|
|
,cas_calcul(loi.cas_calcul)
|
|
{// on regarde s'il s'agit d'une courbe locale ou d'une courbe globale
|
|
if (E_temperature != NULL)
|
|
if (E_temperature->NomCourbe() == "_")
|
|
{// comme il s'agit d'une courbe locale on la redéfinie (sinon pb lors du destructeur de loi)
|
|
string non_courbe("_");
|
|
E_temperature = Courbe1D::New_Courbe1D(*loi.E_temperature);
|
|
};
|
|
// 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
|
|
};
|
|
|
|
Loi_iso_elas2D_D::~Loi_iso_elas2D_D ()
|
|
// Destructeur
|
|
{ if (E_temperature != NULL)
|
|
if (E_temperature->NomCourbe() == "_") delete E_temperature;
|
|
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 Loi_iso_elas2D_D::LectureDonneesParticulieres (UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D
|
|
,LesFonctions_nD& lesFonctionsnD)
|
|
{ // on regarde si le module d'young est thermo dépendant
|
|
string nom_class_methode("Loi_iso_elas2D_D::LectureDonneesParticulieres");
|
|
if(strstr(entreePrinc->tablcar,"thermo_dependant_")!=0)
|
|
{ string nom; thermo_dependant=true;
|
|
*(entreePrinc->entree) >> nom;
|
|
if (nom != "thermo_dependant_")
|
|
{ cout << "\n erreur en lecture de la thermodependance, on aurait du lire le mot cle thermo_dependant_"
|
|
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
|
|
entreePrinc->MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
// lecture de la loi d'évolution du module d'young 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))
|
|
{ E_temperature = lesCourbes1D.Trouve(nom);
|
|
}
|
|
else
|
|
{ // sinon il faut la lire maintenant
|
|
string non_courbe("_");
|
|
E_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
|
|
// lecture de la courbe
|
|
E_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
|
|
}
|
|
}
|
|
// sinon on regarde si le module d'young dépend d'une fonction nD
|
|
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
|
|
*(entreePrinc->entree) >> E ;
|
|
};
|
|
|
|
// lecture du coefficient de poisson
|
|
// 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;
|
|
}
|
|
else // sinon on lit la valeur scalaire
|
|
{*(entreePrinc->entree) >> nu;};
|
|
|
|
// on regarde si le calcul est éventuellement uniquement déviatorique
|
|
cas_calcul = 0; // par défaut
|
|
if (strstr(entreePrinc->tablcar,"seule_deviatorique")!=NULL)
|
|
{cas_calcul=1;};
|
|
// idem pour la partie sphérique
|
|
if (strstr(entreePrinc->tablcar,"seule_spherique")!=NULL)
|
|
{if (cas_calcul == 1) {cas_calcul=0;} else {cas_calcul = 2;};};
|
|
|
|
// appel au niveau de la classe mère
|
|
Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire
|
|
(*entreePrinc,lesFonctionsnD);
|
|
|
|
};
|
|
// affichage de la loi
|
|
void Loi_iso_elas2D_D::Affiche() const
|
|
{ if(thermo_dependant)
|
|
{ cout << "\n loi de comportement isoelastique 2D deformations planes thermodependante"
|
|
<< " courbe E=f(T): " << E_temperature->NomCourbe() <<" ";
|
|
if ( E_temperature->NomCourbe() == "_") E_temperature->Affiche();
|
|
}
|
|
else if (E_nD != NULL)
|
|
{cout << "\n loi de comportement 2D deformations planes isoelastique avec E fonction nD: ";
|
|
cout << "E_fonction_nD:" << " ";
|
|
if (E_nD->NomFonction() != "_")
|
|
cout << E_nD->NomFonction();
|
|
else
|
|
E_nD->Affiche();
|
|
}
|
|
else
|
|
{ cout << " \n loi de comportement isoelastique 2D deformations planes"
|
|
<< " 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 ;
|
|
};
|
|
|
|
// indicateur de cas de calcul
|
|
if (cas_calcul != 0)
|
|
{ if (cas_calcul == 1)
|
|
{cout << " calcul uniquement deviatorique ";}
|
|
else if (cas_calcul == 2)
|
|
{cout << " calcul uniquement spherique ";}
|
|
else
|
|
{cout << " cas de calcul mal defini !! ";};
|
|
}
|
|
cout << endl;
|
|
// appel de la classe mère
|
|
Loi_comp_abstraite::Affiche_don_classe_abstraite();
|
|
};
|
|
|
|
// affichage et definition interactive des commandes particulières à chaques lois
|
|
void Loi_iso_elas2D_D::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");
|
|
|
|
if (E == -ConstMath::trespetit)
|
|
{ // on initialise à une valeur arbitraire
|
|
E = 210000;}
|
|
if (nu == -2.*ConstMath::trespetit)
|
|
{ // on initialise à une valeur arbitraire
|
|
nu = 0.3;}
|
|
sort << "\n# ....... loi de comportement isoelastique 2D, deformation planes ........"
|
|
<< "\n# module d'young : coefficient de poisson "
|
|
<< "\n " << setprecision(6) << E << " " << setprecision(6) << nu << endl;
|
|
if ((rep != "o") && (rep != "O" ) && (rep != "0") )
|
|
{ // cas d'une loi thermo dépendante
|
|
sort << "\n# 1) ............ loi de comportement 2D, deformation planes themodependante........................."
|
|
<< "\n#: definition de la courbe donnant l'evolution du module d'young en fonction de la temperature :"
|
|
<< "\n#: suivi de la definition du coefficient de poisson (independant de la temperature) :"
|
|
<< "\n#:...............................................................................................:"
|
|
<< "\n# thermo_dependant_ courbe1 " << " " << setprecision(6) << nu <<"\n"
|
|
<< "\n# NB: courbe1 est le nom d'une courbe deja defini, on peut egalement definir directement une"
|
|
<< "\n# nouvelle courbe apres le mot cle thermo_dependant_ puis la courbe sans nom de reference "
|
|
<< "\n# 2) .................. dependance a une fonction nD ......................"
|
|
<< "\n# Le module d'Young et le coefficient de Poisson peuvent au choix dependre d'une fonction nD. "
|
|
<< "\n# Dans ce cas E ne doit pas avoir ete declare thermodependant, mais on peut inclure une"
|
|
<< "\n# thermo-dependance dans la fonction nD, idem pour nu "
|
|
<< "\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# "
|
|
<< "\n# 3) .................. partitionnement du tenseur des contraintes ......................"
|
|
<< "\n# Il est possible d'indiquer que l'on souhaite calculer seulement la partie spherique de la loi"
|
|
<< "\n# pour cela on met le mot cle: seule_spherique a la fin des donnees sur la meme ligne "
|
|
<< "\n# D'une maniere identique il est possible d'indiquer que l'on souhaite calculer seulement la partie"
|
|
<< "\n# la partie deviatorique de la loi, pour cela on met le mot cle: seule_deviatorique "
|
|
<< endl;
|
|
};
|
|
|
|
// appel de la classe mère
|
|
Loi_comp_abstraite::Info_commande_don_LoisDeComp(entreePrinc);
|
|
};
|
|
|
|
// test si la loi est complete
|
|
int Loi_iso_elas2D_D::TestComplet()
|
|
{ int ret = LoiAbstraiteGeneral::TestComplet();
|
|
if (!thermo_dependant)
|
|
{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;
|
|
};
|
|
}
|
|
else
|
|
{if ((E_temperature == NULL) && (E_nD == NULL) && (nu_nD == NULL))
|
|
{ cout << "\n cas d'une loi thermo dependante, la courbe E=f(T) n'est pas defini !! "; 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;
|
|
};
|
|
// test du cas de calcul
|
|
if ((cas_calcul < 0) || (cas_calcul > 2))
|
|
{ cout << "\n l'indicateur de calcul cas_calcul= " << cas_calcul << " n'est pas correcte "
|
|
<< "\n ceci pour la Loi_iso_elas2D_D";
|
|
Affiche();
|
|
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 Loi_iso_elas2D_D::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
|
|
SaveResulLoi_iso_elas2D_D & save_resul = *((SaveResulLoi_iso_elas2D_D*) saveDon);
|
|
// ici on est en 3D 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 Loi_iso_elas2D_D::ListeGrandeurs_particulieres(bool absolue,List_io<TypeQuelconque>& liTQ) const
|
|
{ // ici on est en 3D 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 Loi_iso_elas2D_D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
|
|
,LesFonctions_nD& lesFonctionsnD)
|
|
{ string toto,nom;
|
|
if (cas == 1)
|
|
{ ent >> toto >> thermo_dependant >> toto;
|
|
// tout d'abord la lecture de E
|
|
int type =0;
|
|
ent >> type;
|
|
switch (type)
|
|
{ case 1 :
|
|
{ent >> nom;
|
|
if (nom != " fonction_temperature ")
|
|
{ cout << "\n erreur en lecture de la fonction temperature, on attendait "
|
|
<< " fonction_temperature et on a lue " << nom
|
|
<< "\n Loi_iso_elas2D_D::Lecture_base_info_loi(...";
|
|
Sortie(1);
|
|
};
|
|
E_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,E_temperature);
|
|
break;
|
|
};
|
|
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 Loi_iso_elas2D_D::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: 1 c-a-d E fonction temperature, 2 E fonction nD, "
|
|
<< " 3 E une valeur fixe "
|
|
<< "\n Loi_iso_elas2D_D::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 Loi_iso_elas2D_D::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 Loi_iso_elas2D_D::Lecture_base_info_loi(...";
|
|
Sortie(1);
|
|
break;
|
|
};
|
|
|
|
// indicateur pour les calculs partielles
|
|
string type_de_calcul;
|
|
ent >> nom >> type_de_calcul ;
|
|
if (type_de_calcul == "seul_deviatorique")
|
|
{cas_calcul=1;}
|
|
else if (type_de_calcul == "seul_spherique")
|
|
{cas_calcul=2;}
|
|
else
|
|
{cas_calcul=0;}
|
|
// l'indicateur pour les calculs partielles
|
|
// ent >> nom >> cas_calcul ;
|
|
}; // --- fin de if (cas == 1), on ne fait rien dans les autres cas: rien n'a sauvegarder
|
|
// 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 Loi_iso_elas2D_D::Ecriture_base_info_loi(ofstream& sort,const int cas)
|
|
{ if (cas == 1)
|
|
{ sort << " ISOELAS2D_D " << thermo_dependant << " module Young: " ;
|
|
// tout d'abord le module d'Young
|
|
if (E_temperature != NULL)
|
|
{sort << " 1 fonction_temperature ";
|
|
LesCourbes1D::Ecriture_pour_base_info(sort,cas,E_temperature);
|
|
}
|
|
else 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 ; };
|
|
// indicateur de cas de calcul
|
|
if (cas_calcul != 0)
|
|
{ if (cas_calcul == 1)
|
|
{sort << "\n seul_deviatorique ";}
|
|
else if (cas_calcul == 2)
|
|
{sort << " seul_spherique ";}
|
|
else
|
|
{sort << " cas_de_calcul_mal_defini ";};
|
|
};
|
|
};
|
|
// 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 Loi_iso_elas2D_D::Module_young_equivalent(Enum_dure temps,const Deformation & def,SaveResul * saveDon)
|
|
{ // on récupère le conteneur
|
|
SaveResulLoi_iso_elas2D_D & save_resul = *((SaveResulLoi_iso_elas2D_D*) saveDon);
|
|
double E_sortie=E; // init
|
|
bool recup = false;
|
|
switch (temps)
|
|
{
|
|
case TEMPS_t : // on utilise les grandeurs stockées à t
|
|
if (save_resul.E_t != (-ConstMath::trespetit))
|
|
{E_sortie= save_resul.E_t;recup = true;}
|
|
break;
|
|
case TEMPS_tdt : // on utilise les grandeurs stockées à tdt
|
|
if (save_resul.E != (-ConstMath::trespetit))
|
|
{E_sortie= save_resul.E;recup = true;}
|
|
break;
|
|
|
|
case TEMPS_0 : // rien n'a été calculé
|
|
recup = false;
|
|
};
|
|
// dans tous les autres cas on utilise soit les fonctions
|
|
// si elles existent sinon on concerve les valeurs par défaut
|
|
if (!recup)
|
|
{//on essaie un calcul
|
|
// cas des courbes d'évolution
|
|
if (E_temperature != NULL)
|
|
{ double tempera = def.DonneeInterpoleeScalaire(TEMP,temps);
|
|
E_sortie = E_temperature->Valeur(tempera);
|
|
}
|
|
else 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 << " Loi_iso_elas2D_D::Module_compressibilite_equivalent(..\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// on récupère le premier élément du tableau uniquement
|
|
E_sortie = tab_val(1);
|
|
};
|
|
};
|
|
|
|
return E_sortie;
|
|
};
|
|
|
|
// 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 Loi_iso_elas2D_D::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
|
|
SaveResulLoi_iso_elas2D_D & save_resul = *((SaveResulLoi_iso_elas2D_D*) saveDon);
|
|
|
|
double E_sortie=E;double nu_sortie=nu; // init
|
|
bool recup = false;
|
|
switch (temps)
|
|
{
|
|
case TEMPS_t : // on utilise les grandeurs stockées à t
|
|
if (save_resul.E_t != (-ConstMath::trespetit))
|
|
{E_sortie= save_resul.E_t;recup = true;}
|
|
break;
|
|
case TEMPS_tdt : // on utilise les grandeurs stockées à tdt
|
|
if (save_resul.E != (-ConstMath::trespetit))
|
|
{E_sortie= save_resul.E;recup = true;}
|
|
break;
|
|
|
|
case TEMPS_0 : // rien n'a été calculé
|
|
recup = false;
|
|
};
|
|
// dans tous les autres cas on utilise soit les fonctions
|
|
// si elles existent sinon on concerve les valeurs par défaut
|
|
if (!recup)
|
|
{//on essaie un calcul
|
|
// cas des courbes d'évolution
|
|
if (E_temperature != NULL)
|
|
{ double tempera = def.DonneeInterpoleeScalaire(TEMP,temps);
|
|
E_sortie = E_temperature->Valeur(tempera);
|
|
}
|
|
else 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 << " Loi_iso_elas2D_D::Module_compressibilite_equivalent(..\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// on récupère le premier élément du tableau uniquement
|
|
E_sortie = tab_val(1);
|
|
};
|
|
};
|
|
|
|
// idem pour nu
|
|
recup = false;
|
|
switch (temps)
|
|
{
|
|
case TEMPS_t : // on utilise les grandeurs stockées à t
|
|
if (save_resul.nu_t != (-2.*ConstMath::trespetit))
|
|
{nu_sortie= save_resul.nu_t;recup = true;}
|
|
break;
|
|
case TEMPS_tdt : // on utilise les grandeurs stockées à tdt
|
|
if (save_resul.nu != (-2.*ConstMath::trespetit))
|
|
{nu_sortie= save_resul.nu;recup = true;}
|
|
break;
|
|
|
|
case TEMPS_0 : // rien n'a été calculé
|
|
recup = false;
|
|
};
|
|
// dans tous les autres cas on utilise soit les fonctions
|
|
// si elles existent sinon on concerve les valeurs par défaut
|
|
if (!recup)
|
|
{//on essaie un calcul
|
|
if (nu_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 = 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 << " Loi_iso_elas2D_D::Module_compressibilite_equivalent(..\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// on récupère le premier élément du tableau uniquement
|
|
nu_sortie = tab_val(1);
|
|
};
|
|
};
|
|
|
|
// retour du module
|
|
double K= E_sortie/(3.*(1.-2.*nu_sortie));
|
|
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 Loi_iso_elas2D_D::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
|
|
SaveResulLoi_iso_elas2D_D & save_resul = *((SaveResulLoi_iso_elas2D_D*) 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 Loi_iso_elas2D_D::Activation_stockage_grandeurs_quelconques(list <EnumTypeQuelconque >& listEnuQuelc)
|
|
{ // récup de la liste de stockage
|
|
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
|
|
|
|
};
|
|
|
|
|
|
// ---------------------------- methode propre a la loi -----------------------
|
|
// calcul de la contrainte sigma33
|
|
double Loi_iso_elas2D_D::Sig33BH(TenseurBB & epsBB_,TenseurHH & gijHH_)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if (Permet_affichage() > 3)
|
|
{cout << "\n --- loi de comportement iso elas 2D D Calcul Sig33BH --- ";
|
|
Signature_pti_encours(cout);
|
|
};
|
|
if (epsBB_.Dimension() != 2)
|
|
{ cout << "\nErreur : la dimension devrait etre 2 !\n";
|
|
cout << " Loi_iso_elas2D_D::Sig33BH(\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
|
|
const Tenseur2BB & epsBB = *((Tenseur2BB*) &epsBB_); // passage en dim 2
|
|
const Tenseur2HH & gijHH = *((Tenseur2HH*) &gijHH_); // " " " "
|
|
|
|
Tenseur2BH epsBH = epsBB * gijHH; // deformation en mixte
|
|
|
|
// l'idée ici est d'utiliser les grandeurs de la loi déjà calculées et stockées
|
|
// compte tenu du fait que l'on ne connait pas la métrique etc...
|
|
|
|
// on récupère le conteneur
|
|
SaveResulLoi_iso_elas2D_D & save_res_en_cours = *((SaveResulLoi_iso_elas2D_D*) saveResul);
|
|
|
|
double E_actu=save_res_en_cours.E;
|
|
double nu_actu = save_res_en_cours.nu;
|
|
|
|
if ((E_actu==0.) && (nu_actu ==0.))
|
|
{cout << "\n *** attention, dans le calcul de Sig33BH, E et nu n'ont pas ete encore "
|
|
<< " stockees on retient les valeurs initiales par defaut de la loi ";
|
|
nu_actu = nu;
|
|
E_actu = E;
|
|
}
|
|
|
|
// calcul du coefficient
|
|
double coef1 = E_actu/((1.-2.*nu_actu)*3.);
|
|
// calcul du deviateur des deformations
|
|
double Ieps = epsBH.Trace();
|
|
double sig33BH = (Ieps * coef1) ; // le resultat
|
|
return sig33BH;
|
|
};
|
|
|
|
|
|
// ========== codage des METHODES VIRTUELLES protegees:================
|
|
// calcul des contraintes à t+dt
|
|
void Loi_iso_elas2D_D::Calcul_SigmaHH (TenseurHH& ,TenseurBB& ,DdlElement & ,
|
|
TenseurBB & ,TenseurHH & ,BaseB& ,BaseH& ,TenseurBB& epsBB_,
|
|
TenseurBB& ,TenseurBB& ,
|
|
TenseurHH & gijHH_,Tableau <TenseurBB *>& ,double& ,double& ,
|
|
TenseurHH & sigHH_
|
|
,EnergieMeca & energ,const EnergieMeca &
|
|
,double& module_compressibilite,double& module_cisaillement
|
|
,const Met_abstraite::Expli_t_tdt& ex)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if (Permet_affichage() > 3)
|
|
{cout << "\n ---- Loi_iso_elas2D_D::Calcul_SigmaHH ---- ";
|
|
Signature_pti_encours(cout);
|
|
};
|
|
if (epsBB_.Dimension() != 2)
|
|
{ cout << "\nErreur : la dimension devrait etre 2 !\n";
|
|
cout << " Loi_iso_elas2D_D::Calcul_SigmaHH\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
const Tenseur2BB & epsBB = *((Tenseur2BB*) &epsBB_); // passage en dim 2
|
|
const Tenseur2HH & gijHH = *((Tenseur2HH*) &gijHH_); // " " " "
|
|
Tenseur2HH & sigHH = *((Tenseur2HH*) &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;
|
|
|
|
Tenseur2BH epsBH = epsBB * gijHH; // deformation en mixte
|
|
// calcul éventuel des paramètres de la loi
|
|
if (E_temperature != NULL) {E = E_temperature->Valeur(*temperature);}
|
|
else 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 << " Loi_iso_elas2D_D::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 << " Loi_iso_elas2D_D::Calcul_SigmaHH\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
*/
|
|
// on récupère le premier élément du tableau uniquement
|
|
nu = tab_val(1);
|
|
};
|
|
|
|
// sauvegarde des paramètres matériau
|
|
SaveResulLoi_iso_elas2D_D & save_resul = *((SaveResulLoi_iso_elas2D_D*) saveResul);
|
|
save_resul.E = E;
|
|
save_resul.nu = nu;
|
|
|
|
// calcul des coefficients
|
|
double coef1 = (E*nu)/((1.-2.*nu)*(1+nu));
|
|
double coef2 = E/(1.+ nu);
|
|
module_compressibilite = E/(3.*(1.-2.*nu));
|
|
module_cisaillement = coef2/2.;
|
|
// calcul du deviateur des deformations
|
|
double Ieps = epsBH.Trace();
|
|
Tenseur2BH sigBH;
|
|
switch (cas_calcul)
|
|
{ case 0: // calcul normal (tous les termes)
|
|
{ sigBH = (Ieps * coef1) * IdBH2 + coef2 * epsBH ; // contrainte en mixte
|
|
sigHH = gijHH * sigBH; // en deux fois contravariants
|
|
break;
|
|
}
|
|
case 1: // calcul de la partie déviatorique seule
|
|
{ sigBH = coef2 * (epsBH - (Ieps/3.)*IdBH2); // contrainte en mixte
|
|
sigHH = gijHH * sigBH; // en deux fois contravariants
|
|
break;
|
|
}
|
|
case 2: // calcul de la partie sphérique seule
|
|
{ sigBH = (Ieps * (coef1 + coef2/3.))*IdBH2; // contrainte en mixte
|
|
sigHH = gijHH * sigBH; // en deux fois contravariants
|
|
break;
|
|
}
|
|
default:
|
|
{ cout << "\n erreur l'indicateur cas_calcul= " << cas_calcul << " n'a pas une valeur correcte !! "
|
|
<< "\n Loi_iso_elas2D_D::Calcul_SigmaHH (.... ";
|
|
Sortie(1);
|
|
}
|
|
};
|
|
|
|
// traitement des énergies
|
|
energ.Inita(0.);
|
|
energ.ChangeEnergieElastique(0.5 * (sigHH && epsBB));
|
|
|
|
#ifdef MISE_AU_POINT
|
|
if (Permet_affichage() > 3)
|
|
{Signature_pti_encours(cout);
|
|
cout << "\n";
|
|
if (E_temperature != NULL)
|
|
{cout << " E temperature= " << E ;}
|
|
else if (E_nD != NULL)
|
|
{cout << " E fctnD= " << E;};
|
|
if (nu_nD != NULL)
|
|
{cout << " nu fctnD= " << nu;}
|
|
cout << " module_compressibilite= " << module_compressibilite
|
|
<< " module cisaillement= " << module_cisaillement
|
|
<< " ener_elas= " << energ.EnergieElastique()
|
|
<< flush;
|
|
};
|
|
if (Permet_affichage() > 4)
|
|
cout << "\n Ieps = " << Ieps << " Isig= " << sigBH.Trace();
|
|
#endif
|
|
|
|
LibereTenseur();
|
|
};
|
|
|
|
// calcul des contraintes a t+dt et de ses variations
|
|
void Loi_iso_elas2D_D::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,
|
|
,TenseurBB & delta_epsBB,TenseurBB & gijBB_tdt,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 &
|
|
,double& module_compressibilite,double& module_cisaillement
|
|
,const Met_abstraite::Impli& ex)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if (Permet_affichage() > 3)
|
|
{cout << "\n ---- Loi_iso_elas2D_D::Calcul_DsigmaHH_tdt ---- ";
|
|
Signature_pti_encours(cout);
|
|
};
|
|
if (epsBB_tdt.Dimension() != 2)
|
|
{ cout << "\nErreur : la dimension devrait etre 2 !\n";
|
|
cout << " Loi_iso_elas2D_D::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 << " Loi_iso_elas1D::Calcul_SDsigmaHH_tdt\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
|
|
const Tenseur2BB & epsBB = *((Tenseur2BB*) &epsBB_tdt); // passage en dim 2
|
|
const Tenseur2HH & gijHH = *((Tenseur2HH*) &gijHH_tdt); // " " " "
|
|
Tenseur2HH & sigHH = *((Tenseur2HH*) &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;
|
|
|
|
// calcul éventuel des paramètres de la loi
|
|
if (E_temperature != NULL) {E = E_temperature->Valeur(*temperature);}
|
|
else if (E_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
|
|
(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 << " Loi_iso_elas2D_D::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 << " Loi_iso_elas2D_D::Calcul_SigmaHH\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
*/
|
|
// on récupère le premier élément du tableau uniquement
|
|
nu = tab_val(1);
|
|
};
|
|
|
|
// sauvegarde des paramètres matériau
|
|
SaveResulLoi_iso_elas2D_D & save_resul = *((SaveResulLoi_iso_elas2D_D*) saveResul);
|
|
save_resul.E = E;
|
|
save_resul.nu = nu;
|
|
|
|
// cas du tenseur des contraintes
|
|
Tenseur2BH epsBH = epsBB * gijHH; // deformation en mixte
|
|
// calcul des coefficients
|
|
double coef1 = (E*nu)/((1.-2.*nu)*(1+nu));
|
|
double coef2 = E/(1.+ nu);
|
|
module_compressibilite = E/(3.*(1.-2.*nu));
|
|
module_cisaillement = 0.5 * coef2;
|
|
// calcul du deviateur des deformations
|
|
double Ieps = epsBH.Trace();
|
|
Tenseur2BH sigBH;
|
|
double untiers=1./3.;
|
|
switch (cas_calcul)
|
|
{ case 0: // calcul normal (tous les termes)
|
|
{ sigBH = (Ieps * coef1) * IdBH2 + coef2 * epsBH ; // contrainte en mixte
|
|
break;
|
|
}
|
|
case 1: // calcul de la partie déviatorique seule
|
|
{ sigBH = coef2 * (epsBH - (Ieps*untiers)*IdBH2); // contrainte en mixte
|
|
break;
|
|
}
|
|
case 2: // calcul de la partie sphérique seule
|
|
{ sigBH = (Ieps * (coef1 + coef2*untiers))*IdBH2; // contrainte en mixte
|
|
break;
|
|
}
|
|
default:
|
|
{ cout << "\n erreur l'indicateur cas_calcul= " << cas_calcul << " n'a pas une valeur correcte !! "
|
|
<< "\n Loi_iso_elas2D_D::Calcul_DsigmaHH_tdt (.... ";
|
|
Sortie(1);
|
|
}
|
|
};
|
|
sigHH = gijHH * sigBH; // en deux fois contravariant
|
|
//----------------- debug
|
|
// const Tenseur2BB & gijBB = *((Tenseur2BB*) &gijBB_tdt); // passage en dim 3
|
|
//cout << "\n epsBB="<<epsBB << " gijBB_tdt= " << gijBB << " gijHH_tdt= " << gijHH<<" ";
|
|
//cout << "\n sighh="<<sigHH<<" ";
|
|
//----------- fin debug
|
|
//----------------- debug
|
|
//cout << "\n epsBB="<<epsBB<<" ";
|
|
//cout << "\n sighh="<<sigHH<<" ";
|
|
//----------- fin debug
|
|
|
|
// traitement des énergies
|
|
energ.Inita(0.);
|
|
energ.ChangeEnergieElastique(0.5 * (sigHH && epsBB));
|
|
|
|
|
|
#ifdef MISE_AU_POINT
|
|
if (Permet_affichage() > 3)
|
|
{Signature_pti_encours(cout);
|
|
cout << "\n";
|
|
if (E_temperature != NULL)
|
|
{cout << " E temperature= " << E ;}
|
|
else if (E_nD != NULL)
|
|
{cout << " E fctnD= " << E;};
|
|
if (nu_nD != NULL)
|
|
{cout << " nu fctnD= " << nu;}
|
|
cout << " module_compressibilite= " << module_compressibilite
|
|
<< " module cisaillement= " << module_cisaillement
|
|
<< " ener_elas= " << energ.EnergieElastique()
|
|
<< flush;
|
|
};
|
|
if (Permet_affichage() > 4)
|
|
cout << "\n Ieps = " << Ieps << " Isig= " << sigBH.Trace();
|
|
#endif
|
|
|
|
// 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 ()
|
|
Tenseur2HH & dsigHH = *((Tenseur2HH*) (d_sigHH(i))); // passage en dim 2
|
|
const Tenseur2HH & dgijHH = *((Tenseur2HH*)(d_gijHH_tdt(i))) ; // pour simplifier l'ecriture
|
|
const Tenseur2BB & depsBB = *((Tenseur2BB *) (d_epsBB(i))); // "
|
|
// pour chacun des ddl on calcul les tenseurs derivees
|
|
Tenseur2BH depsBH = epsBB * dgijHH + depsBB * gijHH ;
|
|
double dIeps = depsBH.Trace();
|
|
switch (cas_calcul)
|
|
{ case 0: // calcul normal (tous les termes)
|
|
{ dsigHH = dgijHH * sigBH + gijHH *
|
|
((dIeps * coef1) * IdBH2 + coef2 * depsBH);
|
|
break;
|
|
}
|
|
case 1: // calcul de la partie déviatorique seule
|
|
{ dsigHH = dgijHH * sigBH + gijHH *
|
|
coef2 * (depsBH - (dIeps*untiers)*IdBH2);
|
|
break;
|
|
}
|
|
case 2: // calcul de la partie sphérique seule
|
|
{ dsigHH = dgijHH * sigBH + gijHH *
|
|
((dIeps * (coef1 + coef2*untiers))*IdBH2);
|
|
break;
|
|
}
|
|
};
|
|
////----------------- debug
|
|
// if ((i==2) || (i==5))
|
|
// {cout << "\n dsighh("<<i<<")="<<dsigHH<<" "
|
|
// << " dgijHH= " << dgijHH << " depsBB= " << depsBB ;
|
|
// };
|
|
//----------- fin debug
|
|
};
|
|
LibereTenseur();
|
|
};
|
|
|