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

1227 lines
60 KiB
C++
Raw Normal View History

ajout des lois de comportement
2021-09-23 11:21:15 +02:00
// FICHIER : Loi_Umat.cp
// CLASSE : Loi_Umat
// 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 "ConstMath.h"
#include "MathUtil.h"
#include "CharUtil.h"
#include "Util.h"
#include "Loi_Umat.h"
// ------------------fonctions interne template ------------
// multiplication de tenseur par des bases
template <class T1,class T2,class Base2,class Base1>
T1 & produit_1_pourLoiUmat(T1 & A,T2& Nous, const Base2 & gi2, const Base1 & gi1)
{ int dim = abs(A.Dimension());
int dimint = abs(Nous.Dimension());
for (int i=1;i<= dim; i++)
for (int j=1; j<= dim; j++)
{ A.Coor(i,j) = 0.;
for (int al=1; al<= dimint; al++)
for (int be=1; be<= dimint; be++)
A.Coor(i,j) += Nous(al,be)* (gi1.Coordo(al)(i)*gi2.Coordo(be)(j)+gi2.Coordo(al)(i)*gi1.Coordo(be)(j));
}
return A;
};
//==================== cas de la class de sauvegarde SaveResul ===================
// constructeur par défaut
Loi_Umat::SaveResul_Loi_Umat::SaveResul_Loi_Umat() :
save_pour_loi_ext(NULL),hsurh0(ConstMath::tresgrand),h_tsurh0(ConstMath::tresgrand)
{};
// constructeur de copie
Loi_Umat::SaveResul_Loi_Umat::SaveResul_Loi_Umat(const Loi_Umat::SaveResul_Loi_Umat& sav ):
save_pour_loi_ext(sav.save_pour_loi_ext),hsurh0(sav.hsurh0),h_tsurh0(sav.h_tsurh0)
{};
// affectation
Loi_comp_abstraite::SaveResul &
Loi_Umat::SaveResul_Loi_Umat::operator = ( const Loi_comp_abstraite::SaveResul & a)
{ Loi_Umat::SaveResul_Loi_Umat& sav = *((Loi_Umat::SaveResul_Loi_Umat*) &a);
// on affecte si non dimensionné, sinon on crée à l'identique
if (sav.save_pour_loi_ext != NULL)
{ if (save_pour_loi_ext == NULL)
{save_pour_loi_ext = sav.save_pour_loi_ext->Nevez_SaveResul();}
else
{(*save_pour_loi_ext) = *(sav.save_pour_loi_ext);};
};
hsurh0 = sav.hsurh0; h_tsurh0 = sav.h_tsurh0;
return *this;
};
//============= lecture écriture dans base info ==========
// 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_Umat::SaveResul_Loi_Umat::Lecture_base_info (ifstream& ent,const int cas)
{ // ici toutes les données sont toujours a priori variables
// ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas
string toto; ent >> toto;
int titi=0.;
ent >> titi;
if (titi == 1 )
ent >> toto >> hsurh0; h_tsurh0 = hsurh0;
#ifdef MISE_AU_POINT
if (toto != "S_R_LoiUmat")
{ cout << "\n erreur en lecture du conteneur pour la loi Umat"
<< " \n Loi_Umat::SaveResul_Loi_Umat::Lecture_base_info(..";
Sortie(1);
}
#endif
if (save_pour_loi_ext!=NULL)
{save_pour_loi_ext->Lecture_base_info(ent,cas);};
};
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Loi_Umat::SaveResul_Loi_Umat::Ecriture_base_info (ofstream& sort,const int cas)
{ // ici toutes les données sont toujours a priori variables
// ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas
sort << "\n S_R_LoiUmat ";
if (hsurh0 != ConstMath::tresgrand )
sort << "\n 1 " << "CP:hsurh0= " << h_tsurh0;
else sort << "\n 0 ";
if (save_pour_loi_ext!=NULL)
{save_pour_loi_ext->Ecriture_base_info(sort,cas);};
};
// mise à jour des informations transitoires en définitif s'il y a convergence
// par exemple (pour la plasticité par exemple)
void Loi_Umat::SaveResul_Loi_Umat::TdtversT()
{ if (save_pour_loi_ext!=NULL)
save_pour_loi_ext->TdtversT();
// CP par défaut: car c'est aussi rapide que le test (sans doute ?)
h_tsurh0 = hsurh0;
};
void Loi_Umat::SaveResul_Loi_Umat::TversTdt()
{ if (save_pour_loi_ext!=NULL)
save_pour_loi_ext->TversTdt();
// CP par défaut: car c'est aussi rapide que le test (sans doute ?)
hsurh0 = h_tsurh0;
};
//==================== fin du cas de la class de sauvegarde SaveResul ============
Loi_Umat::Loi_Umat (Enum_comp enu) : // Constructeur par defaut
Loi_comp_abstraite(enu,CAT_MECANIQUE,0)
,nom_de_la_loi("_")
,umatAbaqus(ParaGlob::Dimension(),Loi_Umat::Choix_dim(enu))
,loi_ext(NULL)
,utilisation_umat_interne(NULL)
,umat_met3D(),umat_met2D(),umat_met1D()
,d_sigma_deps_2D(),d_sigma_deps_1D()
,gabBB_tdt(NULL),gabHH_tdt(NULL),gabBB_t(NULL),gabHH_t(NULL)
,gixB_0(),gixB_t(),gixB_tdt(),gixH_0(),gixH_t(),gixH_tdt()
// des pointeurs nulles pour les grandeurs qui actuellement ne servent pas
,ggaB_0null(NULL),ggaB_tnull(NULL),ggaH_0null(NULL)
,ggradVmoyBB_tnull(NULL),ggradVmoyBB_tdtnull(NULL),ggradVBB_tdtnull(NULL)
// --//\\-- grandeurs particulières pour le cas contraintes planes
// -- conteneur des métriques
,umat_cont_3D(NULL)
,umat_cont_2D(NULL)
,Ip2_B(ParaGlob::Dimension(),2) // pour définir la base 2D locale dans l'espace de travail
// -- les variables pointées dans les conteneurs, et leur pointeur associé éventuellement
,giB_0_3D(),giH_0_3D(),giB_t_3D(),giH_t_3D(),giB_tdt_3D(),giH_tdt_3D()
,gijBB_0_3D(),gijHH_0_3D(),gijBB_t_3D(),gijHH_t_3D()
,gijBB_tdt_3D(),gijHH_tdt_3D()
,gradVmoyBB_t_3D(),gradVmoyBB_tdt_3D(),gradVBB_tdt_3D()
,gradVmoyBB_t_3D_P(NULL),gradVmoyBB_tdt_3D_P(NULL),gradVBB_tdt_3D_P(NULL)
,jacobien_tdt_3D(0.),jacobien_0_3D(0.)
// idem en 2D
,Ip3B_0_3D(),Ip3H_0_3D() // ne fait pas partie de umat_cont_2D
,giB_0_2D(ParaGlob::Dimension(),2),giH_0_2D(ParaGlob::Dimension(),2)
,giB_t_2D(ParaGlob::Dimension(),2),giH_t_2D(ParaGlob::Dimension(),2)
,giB_tdt_2D(ParaGlob::Dimension(),2),giH_tdt_2D(ParaGlob::Dimension(),2)
,gijBB_0_2D(),gijHH_0_2D(),gijBB_t_2D(),gijHH_t_2D()
,gijBB_tdt_2D(),gijHH_tdt_2D()
,gradVmoyBB_t_2D(),gradVmoyBB_tdt_2D(),gradVBB_tdt_2D()
,gradVmoyBB_t_2D_P(NULL),gradVmoyBB_tdt_2D_P(NULL),gradVBB_tdt_2D_P(NULL)
,jacobien_tdt_2D(0.),jacobien_0_2D(0.)
// --//\\-- fin grandeurs particulières pour le cas contraintes planes
{ // définition de la métrique umat
int dim_base=3;
int nbvec_base_3D=3;
DdlElement tabddl; // init par défaut -> pas de ddl élément
int nb_noeud_interpol=0; // par de noeud, on n'a pas a s'en servir normalement
umat_met3D.Dim_NbVec(dim_base,nbvec_base_3D,tabddl,nb_noeud_interpol);
int nbvec_base_2D=2;//dim_base=2;
umat_met2D.Dim_NbVec(dim_base,nbvec_base_2D,tabddl,nb_noeud_interpol);
int nbvec_base_1D=1;//dim_base=1;
umat_met1D.Dim_NbVec(dim_base,nbvec_base_1D,tabddl,nb_noeud_interpol);
// on definit les variables a priori toujours utiles
Tableau<Enum_variable_metrique> tab(13);
tab(1)=igiB_0;tab(2)=igiB_t;tab(3)=igiB_tdt;
tab(4)=igiH_0;tab(5)=igiH_t;tab(6)=igiH_tdt ;
tab(7)=igijBB_0;tab(8)=igijBB_t;tab(9)=igijBB_tdt;
tab(10)=igijHH_0;tab(11)=igijHH_t;tab(12)=igijHH_tdt ;
tab(13)=igradVmoyBB_t;
umat_met3D.PlusInitVariables(tab) ;
umat_met2D.PlusInitVariables(tab) ;
umat_met1D.PlusInitVariables(tab) ;
// --//\\-- grandeurs particulières pour le cas contraintes planes
umat_cont_3D = new Met_abstraite::Umat_cont // constructeur normal
(&giB_0_3D,&giH_0_3D,&giB_t_3D,&giH_t_3D,&giB_tdt_3D,&giH_tdt_3D
,&gijBB_0_3D,&gijHH_0_3D,&gijBB_t_3D,&gijHH_t_3D
,&gijBB_tdt_3D,&gijHH_tdt_3D
,gradVmoyBB_t_3D_P,gradVmoyBB_tdt_3D_P,gradVBB_tdt_3D_P // pas affecté par défaut
,&jacobien_tdt_3D,&jacobien_t_3D,&jacobien_0_3D);
// idem 2D
umat_cont_2D = new Met_abstraite::Umat_cont // constructeur normal
(&giB_0_2D,&giH_0_2D,&giB_t_2D,&giH_t_2D,&giB_tdt_2D,&giH_tdt_2D
,&gijBB_0_2D,&gijHH_0_2D,&gijBB_t_2D,&gijHH_t_2D
,&gijBB_tdt_2D,&gijHH_tdt_2D
,gradVmoyBB_t_2D_P,gradVmoyBB_tdt_2D_P,gradVBB_tdt_2D_P // pas affecté par défaut
,&jacobien_tdt_2D,&jacobien_t_2D,&jacobien_0_2D);
// --//\\-- fin grandeurs particulières pour le cas contraintes planes
};
// Constructeur de copie
Loi_Umat::Loi_Umat (const Loi_Umat& loi) :
Loi_comp_abstraite(loi)
,nom_de_la_loi(loi.nom_de_la_loi),umatAbaqus(loi.umatAbaqus)
,loi_ext(loi.loi_ext),utilisation_umat_interne(loi.utilisation_umat_interne)
,umat_met3D(loi.umat_met3D),umat_met2D(loi.umat_met2D),umat_met1D(loi.umat_met1D)
,d_sigma_deps_2D(loi.d_sigma_deps_2D),d_sigma_deps_1D(loi.d_sigma_deps_1D)
,gabBB_tdt(NULL),gabHH_tdt(NULL),gabBB_t(NULL),gabHH_t(NULL)
,gixB_0(),gixB_t(),gixB_tdt(),gixH_0(),gixH_t(),gixH_tdt()
// -- conteneur des métriques: ce sont des pointeurs, pour l'instant on ne les affecte pas
,umat_cont_3D(NULL)
,umat_cont_2D(loi.umat_cont_2D) // umat_cont_2D avec uniquement des pointeurs
,Ip2_B(loi.Ip2_B) // pour définir la base 2D locale dans l'espace travail
// -- les variables pointées dans les conteneurs
,giB_0_3D(loi.giB_0_3D),giH_0_3D(loi.giH_0_3D),giB_t_3D(loi.giB_t_3D),giH_t_3D(loi.giH_t_3D)
,giB_tdt_3D(loi.giB_tdt_3D)
,gijBB_0_3D(loi.gijBB_0_3D),gijHH_0_3D(loi.gijHH_0_3D)
,gijBB_t_3D(loi.gijBB_t_3D),gijHH_t_3D(loi.gijHH_t_3D),gijBB_tdt_3D(loi.gijBB_tdt_3D)
,gijHH_tdt_3D(loi.gijHH_tdt_3D),gradVmoyBB_t_3D(loi.gradVmoyBB_t_3D)
,gradVmoyBB_tdt_3D(loi.gradVmoyBB_tdt_3D),gradVBB_tdt_3D(loi.gradVBB_tdt_3D)
,jacobien_0_3D(loi.jacobien_0_3D)
// idem en 2D
,Ip3B_0_3D(loi.Ip3B_0_3D),Ip3H_0_3D(loi.Ip3H_0_3D) // ne fait pas partie de umat_cont_2D
,giB_0_2D(loi.giB_0_2D),giH_0_2D(loi.giH_0_2D),giB_t_2D(loi.giB_t_2D),giH_t_2D(loi.giH_t_2D)
,giB_tdt_2D(loi.giB_tdt_2D)
,gijBB_0_2D(loi.gijBB_0_2D),gijHH_0_2D(loi.gijHH_0_2D)
,gijBB_t_2D(loi.gijBB_t_2D),gijHH_t_2D(loi.gijHH_t_2D),gijBB_tdt_2D(loi.gijBB_tdt_2D)
,gijHH_tdt_2D(loi.gijHH_tdt_2D),gradVmoyBB_t_2D(loi.gradVmoyBB_t_2D)
,gradVmoyBB_tdt_2D(loi.gradVmoyBB_tdt_2D),gradVBB_tdt_2D(loi.gradVBB_tdt_2D)
,jacobien_0_2D(loi.jacobien_0_2D)
{ gabBB_tdt=NevezTenseurBB(*loi.gabBB_tdt);gabHH_tdt=NevezTenseurHH(*loi.gabHH_tdt);
gabBB_t=NevezTenseurBB(*loi.gabBB_t);gabHH_t=NevezTenseurHH(*loi.gabHH_t);
// association des pointeurs de grandeurs si nécessaire
if (loi.gradVmoyBB_t_3D_P != NULL) {gradVmoyBB_t_3D_P = &gradVmoyBB_t_3D;};
if (loi.gradVmoyBB_tdt_3D_P != NULL) {gradVmoyBB_tdt_3D_P = &gradVmoyBB_tdt_3D;};
if (loi.gradVBB_tdt_3D_P != NULL) {gradVBB_tdt_3D_P = &gradVBB_tdt_3D;};
umat_cont_3D = new Met_abstraite::Umat_cont // constructeur normal
(&giB_0_3D,&giH_0_3D,&giB_t_3D,&giH_t_3D,&giB_tdt_3D,&giH_tdt_3D
,&gijBB_0_3D,&gijHH_0_3D,&gijBB_t_3D,&gijHH_t_3D
,&gijBB_tdt_3D,&gijHH_tdt_3D
,gradVmoyBB_t_3D_P,gradVmoyBB_tdt_3D_P,gradVBB_tdt_3D_P // pas affecté par défaut
,&jacobien_tdt_3D,&jacobien_t_3D,&jacobien_0_3D);
// idem 2D
umat_cont_2D = new Met_abstraite::Umat_cont // constructeur normal
(&giB_0_2D,&giH_0_2D,&giB_t_2D,&giH_t_2D,&giB_tdt_2D,&giH_tdt_2D
,&gijBB_0_2D,&gijHH_0_2D,&gijBB_t_2D,&gijHH_t_2D
,&gijBB_tdt_2D,&gijHH_tdt_2D
,gradVmoyBB_t_2D_P,gradVmoyBB_tdt_2D_P,gradVBB_tdt_2D_P // pas affecté par défaut
,&jacobien_tdt_2D,&jacobien_t_2D,&jacobien_0_2D);
};
Loi_Umat::~Loi_Umat ()
// Destructeur
{ if (gabBB_tdt != NULL) delete gabBB_tdt;
if (gabHH_tdt != NULL) delete gabHH_tdt;
if (gabBB_t != NULL) delete gabBB_t;
if (gabHH_t != NULL) delete gabHH_t;
// les conteneurs de pointeurs:
delete umat_cont_3D;
delete umat_cont_2D;
// pour les grandeurs de base, pas de new, donc pas de delete
};
// def d'une instance de données spécifiques, et initialisation
Loi_comp_abstraite::SaveResul * Loi_Umat::New_et_Initialise()
{ Loi_comp_abstraite::SaveResul* sav = new SaveResul_Loi_Umat();
// dans le cas ou la loi est interne on stocke ses infos égalements
if (utilisation_umat_interne)
{ SaveResul_Loi_Umat* sv = (SaveResul_Loi_Umat*) sav;
sv->save_pour_loi_ext = ((Loi_comp_abstraite*)loi_ext)->New_et_Initialise();
};
return sav;
};
// fonction de travail
int Loi_Umat::Choix_dim(Enum_comp enu)
{if(enu == LOI_VIA_UMAT_CP)
return 2;
else
return 3;
};
// Lecture des donnees de la classe sur fichier
void Loi_Umat::LectureDonneesParticulieres (UtilLecture * entreePrinc,LesCourbes1D&
,LesFonctions_nD& lesFonctionsnD)
{ // lecture du nom de la loi
string toto;
*(entreePrinc->entree) >> toto >> nom_de_la_loi;
if (toto != "nom_de_la_loi=")
{ cout << "\n erreur en lecture du nom de la loi, on aurait du lire le mot cle nom_de_la_loi="
<< " suivi du nom de la loi ";
entreePrinc->MessageBuffer("**erreur1: Loi_Umat::LectureDonneesParticulieres(... **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// lecture de la catégorie
string categorie;
*(entreePrinc->entree) >> toto >> categorie;
if (toto != "categorie=")
{ cout << "\n erreur en lecture du nom de la loi, on aurait du lire le mot cle categorie="
<< " suivi du nom de la categorie ";
entreePrinc->MessageBuffer("**erreur2: Loi_Umat::LectureDonneesParticulieres(... **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// on met à jour la catégorie de la loi
Enum_categorie_loi_comp cat = Id_nom_categorie_loi_comp(categorie.c_str());
ChangeCategorie(cat);
if (cat==CAT_THERMO_MECANIQUE) {thermo_dependant=true;}
else {thermo_dependant=false;};
// lecture de la dimension
string dimension;
*(entreePrinc->entree) >> toto >> dimension;
if (toto != "dim_loi=")
{ cout << "\n erreur en lecture du nom de la loi, on aurait du lire le mot cle dim_loi="
<< " suivi de la dimension: 1D ou 2D ou 3D ";
entreePrinc->MessageBuffer("**erreur3: Loi_Umat::LectureDonneesParticulieres(... **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// on met à jour la dimension de la loi
if ((dimension== "1D") || (dimension=="1")) {Change_dimension(1); }
else if ((dimension == "2D") || (dimension=="2")) {Change_dimension(2); }
else if ((dimension == "3D") || (dimension=="3")) {Change_dimension(3); }
else
{ cout << "\n erreur en lecture de la dimension de la loi geree par umat"
<< " on devrait lire 1 ou 2 ou 3 ou 1D ou 2D ou 3D";
entreePrinc->MessageBuffer("**erreur4: Loi_Umat::LectureDonneesParticulieres(... **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
string nom_class_methode("Loi_Umat::LectureDonneesParticulieres");
// lecture de la ligne qui suit
entreePrinc->NouvelleDonnee();
*(entreePrinc->entree) >> toto;
if (toto != "fin_loi_Umat")
{ if (toto == "nom_pipe_envoi=")
{// lecture du nom du pipe d'envoi
string nom_pipe_envoi; *(entreePrinc->entree) >> nom_pipe_envoi;
umatAbaqus.Change_nom_pipe_envoi(nom_pipe_envoi);
*(entreePrinc->entree) >> toto;
// on regarde si éventuellement il y a le pipe de reception
if(toto == "nom_pipe_reception=")
{ string nom_pipe_reception; *(entreePrinc->entree) >> nom_pipe_reception;
umatAbaqus.Change_nom_pipe_reception(nom_pipe_reception);
}
else
{ cout << "\n erreur en lecture du nom du pipe de reception, on aurait du lire le mot "
<< " cle nom_pipe_reception=, suivi du nom du pipe ";
entreePrinc->MessageBuffer("**erreur5: Loi_Umat::LectureDonneesParticulieres(... **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
entreePrinc->NouvelleDonnee();// préparation du flot
if(strstr(entreePrinc->tablcar,"permet_affichage_")!=0)
{// on lit le niveau de commentaire
string nom; *(entreePrinc->entree) >> nom;
Lecture_permet_affichage(entreePrinc,lesFonctionsnD);
// string mot_cle("permet_affichage_");
// entreePrinc->Lecture_un_parametre_int(0,nom_class_methode
// ,0, 10,mot_cle,permet_affichage);
entreePrinc->NouvelleDonnee();// préparation du flot
};
}
else if (toto == "utilisation_umat_interne")
{// cas d'une umat interne
utilisation_umat_interne=true;
entreePrinc->NouvelleDonnee();// préparation du flot
if(strstr(entreePrinc->tablcar,"permet_affichage_")!=0)
{// on lit le niveau de commentaire
string nom; *(entreePrinc->entree) >> nom;
Lecture_permet_affichage(entreePrinc,lesFonctionsnD);
// string mot_cle("permet_affichage_");
// entreePrinc->Lecture_un_parametre_int(0,nom_class_methode
// ,0, 10,mot_cle,permet_affichage);
entreePrinc->NouvelleDonnee();// préparation du flot
};
if(strstr(entreePrinc->tablcar,"fin_loi_Umat")==0)
{ cout << "\n erreur en lecture de la fin de la loi on devrait avoir le mot cle fin_loi_Umat "
<< " soit le mot cle : permet_affichage_ ";
entreePrinc->MessageBuffer("**erreur6: Loi_Umat::LectureDonneesParticulieres(... **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
}
else
{ cout << "\n erreur en lecture de la fin de la loi on devrait soit avoir le mot cle fin_loi_Umat "
<< " ou alors les noms des pipes d'envoi et de reception (cf doc) ";
entreePrinc->MessageBuffer("**erreur7: Loi_Umat::LectureDonneesParticulieres(... **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
};
// 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_Umat::Affiche() const
{ cout << "\n loi de comportement Umat "<<dim<<"D : "<< nom_de_la_loi << " ";
if(thermo_dependant) {cout << " thermodependante ";};
cout << " categorie " << Nom_categorie_loi_comp(categorie_loi_comp) << " ";
Loi_comp_abstraite::Affiche_don_classe_abstraite();
};
// affichage et definition interactive des commandes particulières à chaques lois
void Loi_Umat::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# | exemple de loi de comportement defini en Umat |"
<< "\n# | via un processus qui dialogue avec herezh++ |"
<< "\n# ----------------------------------------------------------"
<< "\n nom_de_la_loi= acier categorie= CAT_MECANIQUE dim_loi= 3 "
<< "\n nom_pipe_envoi= pipe_envoi nom_pipe_reception= pipe_reception "
<< "\n fin_loi_Umat " << endl ;
if ((rep != "o") && (rep != "O" ) && (rep != "0") )
{ sort << "\n ....................................................................................."
<< "\n# NB: en contrainte plane, la loi se nomme LOI_VIA_UMAT_CP et il faut utiliser : dim_loi= 2 "
<< "\n# - le nom de la loi, peut permettre le choix entre plusieurs Umat "
<< "\n# - les differentes categorie sont: "
<< "\n# CAT_MECANIQUE pour une loi utilisable pour un calcul mecanique "
<< "\n# CAT_THERMO_MECANIQUE pour une loi utilisable pour un calcul thermo-mecanique "
<< "\n# CAT_THERMO_PHYSIQUE pour une loi thermo-physique "
<< "\n# - dim_loi peut etre: "
// << "\n# 1D : permet la traction - compression "
<< "\n# 2D : 2D contraintes planes ou deformations planes"
<< "\n# 3D : 3D classique (sans particularite) "
<< "\n# - la ligne suivante est facultative (par contre si elle existe elle doit etre complete)"
<< "\n# nom_pipe_envoi= suivi du nom du pipe d'envoi (par defaut = Umat_reception_Hz "
<< "\n# nom_pipe_reception= suivi du nom du pipe de recepetion (par defaut= Umat_envoi_Hz "
<< "\n# - a la place des nom de pipe il est possible de mettre le mot cle: utilisation_umat_interne "
<< "\n# dans ce cas il n'est pas fait appel au pipe, on travail directement avec une loi interne "
<< "\n# defini dans le fichier .info d'entree d'herezh "
<< "\n# permet_affichage_ <un entier> :"
<< "\n# - mot cle fin_loi_Umat "
<< "\n# - ensuite il est possible de definir le type de deformation a utiliser "
<< "\n# comme pour tous les autres lois "
<< "\n#:....................................................................................."
<< endl;
};
// appel de la classe mère
Loi_comp_abstraite::Info_commande_don_LoisDeComp(entreePrinc);
};
// test si la loi est complete
int Loi_Umat::TestComplet()
{ // appel de la fonction mère
return LoiAbstraiteGeneral::TestComplet();
};
//----- 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_Umat::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;
};
// cas de la structure UmatAbaqus
umatAbaqus.Lecture_base_info(ent,cas);
// 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_Umat::Ecriture_base_info_loi(ofstream& sort,const int cas)
{ if (cas == 1)
{ sort << " " << Nom_comp(this->Id_comport()) << " " << thermo_dependant;
};
// cas de la structure UmatAbaqus
umatAbaqus.Ecriture_base_info(sort,cas);
// 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_Umat::Module_young_equivalent(Enum_dure temps,const Deformation & def,SaveResul * )
{ if (thermo_dependant)
{temperature_tdt = def.DonneeInterpoleeScalaire(TEMP,temps);
temperature_t = def.DonneeInterpoleeScalaire(TEMP,TEMPS_t);
};
// comme on ne connait la loi, on fait un appel standart avec une déformation donnée
// on en déduit le module d'young
// .. définition de jeux de données adoc
umatAbaqus.Init_un();
// *** on impose une déformation de traction et de cisaillement arbitraire ******
double dep=0.001;// une valeur arbitraire
(*(umatAbaqus.eps_meca)).Coor(1,1)=(*(umatAbaqus.delta_eps_meca)).Coor(1,1)=dep;
(*(umatAbaqus.eps_meca)).Coor(1,2)=(*(umatAbaqus.delta_eps_meca)).Coor(1,2)=dep;
(*(umatAbaqus.eps_meca)).Coor(2,1)=(*(umatAbaqus.delta_eps_meca)).Coor(2,1)=dep;
umatAbaqus.temper_t= temperature_t;
umatAbaqus.delta_temper=temperature_tdt-temperature_t;
BaseH giH(3);
double jacobien_0,jacobien =1.;
EnergieMeca energ,energ_t; // variables intermédiaires, ne sert pas vraiment ici
double module_compressibilite=0.; double module_cisaillement=0. ;
// construction de la métrique umat associée:
// ici on considére que la base de référence actuelle est orthonormée
// ainsi: gijBB_tdt -> gabBB = identitée, idem en HH
// pour gijBB_0 et gijHH_0, on utilise la déformation arbitraire proposée
// a faire *******************
// (*gabBB_0) = (*gabBB_t) = IdBB3 - 2. * (*(umatAbaqus.eps_meca));
// (*gabHH_0) = (*gabHH_t) = gabBB_0->Monte2Indices();
// mise à jour du conteneur de la métrique umat
// umat_met3D.Mise_a_jour_grandeur(&gixB_0,&gixH_0,&gixB_t,&gixH_t,&gixB_tdt,&gixH_tdt
// ,IdBB,IdHH,gabBB_t,gabHH_t,gabBB_tdt,gabHH_tdt
// ,ggradVmoyBB_tnull,ggradVmoyBB_tdtnull,ggradVBB_tdtnull
// ,&jacobien,&jacobien_0);
// appel d'un calcul Umat
bool en_base_orthonormee = true; // les tenseurs sont en orthonormee a priori
Calcul_dsigma_deps (en_base_orthonormee, *(umatAbaqus.t_sigma),*(umatAbaqus.delta_eps_meca)
,(*(umatAbaqus.eps_meca)),(*(umatAbaqus.delta_eps_meca)),jacobien_0,jacobien
,*(umatAbaqus.t_sigma),*(umatAbaqus.d_sigma_deps),energ,energ_t
,module_compressibilite,module_cisaillement,umat_met3D.Conteneur_Umat()) ;
// calcul approché du E
// a) calcul du coefficient de compressibilité
Tenseur3HH& sig= *((Tenseur3HH*) umatAbaqus.t_sigma);
Tenseur3BB& eps= *((Tenseur3BB*) umatAbaqus.eps_meca);
double Isig= sig(1,1)+sig(2,2)+sig(3,3);
double Ieps= dep; //eps(1,1)+eps(2,2)+eps(3,3);
double Kc=(Isig)/(Ieps);
// b) calcul du coefficient de cisaillement moyen
double mu= sig(1,2)/dep;
// c) calcul de E approchée
double E=(3*Kc*mu)/(2*Kc+mu);
LibereTenseur();
LibereTenseurQ();
return E;
};
// ========== codage des METHODES VIRTUELLES protegees:================
// calcul des contraintes a t+dt
void Loi_Umat::Calcul_SigmaHH (TenseurHH& ,TenseurBB& ,DdlElement & tab_ddl,
TenseurBB & ,TenseurHH & ,BaseB& ,BaseH& ,TenseurBB& epsBB_,
TenseurBB& ,TenseurBB& ,
TenseurHH & ,Tableau <TenseurBB *>& d_gijBB_,double& ,double& ,
TenseurHH &
,EnergieMeca & ,const EnergieMeca &
,double& ,double&
,const Met_abstraite::Expli_t_tdt& )
{
#ifdef MISE_AU_POINT
if (epsBB_.Dimension() != 3)
{ cout << "\nErreur : la dimension devrait etre 3 !\n";
cout << " Loi_Umat::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 << " Loi_Umat::Calcul_SigmaHH\n";
Sortie(1);
};
#endif
cout << "\n pour l'instant le calcul en explicit n' implantees en Umat interne"
<< "\n Loi_Umat::Calcul_SigmaHH (.... ";
Sortie(1);
};
// calcul des contraintes a t+dt et de ses variations
void Loi_Umat::Calcul_DsigmaHH_tdt (TenseurHH& sigHH_t_,TenseurBB& DepsBB_,DdlElement & tab_ddl
,BaseB& giB_t,TenseurBB & gijBB_t,TenseurHH & gijHH_t
,BaseB& giB_tdt,Tableau <BaseB> & d_giB_tdt,BaseH& giH_tdt,Tableau <BaseH> & d_giH_tdt
,TenseurBB & epsBB_tdt,Tableau <TenseurBB *>& d_epsBB
,TenseurBB & delta_epsBB_,TenseurBB & gijBB_tdt,TenseurHH & gijHH_tdt
,Tableau <TenseurBB *>& d_gijBB_tdt
,Tableau <TenseurHH *>& d_gijHH_tdt,double& jacobien_0,double& jacobien
,Vecteur& d_jacobien_tdt,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 (tab_ddl.NbDdl() != d_gijBB_tdt.Taille())
{ cout << "\nErreur : le nb de ddl est != de la taille de d_gijBB_tdt !\n";
cout << " Loi_Umat::Calcul_DsigmaHH_tdt\n";
Sortie(1);
};
#endif
// en fonction de la dimension on modifie les tenseurs de passage dans l'umat
switch (abs(epsBB_tdt.Dimension()))
{ case 2: // cas de tenseur en 2 dimension
{ const Tenseur2BB & epsBB = *((Tenseur2BB*) &epsBB_tdt); // passage explicite en dim 2
const Tenseur2BB & delta_epsBB = *((Tenseur2BB*) &delta_epsBB_); // passage en dim 2
const Tenseur2BB & DepsBB = *((Tenseur2BB*) &DepsBB_); // passage en dim 2
const Tenseur2HH & gijHH = *((Tenseur2HH*) &gijHH_tdt); // " " " "
Tenseur2HH & sigHH = *((Tenseur2HH*) &sigHH_tdt); // " " " "
Tenseur2HH & sigHH_t = *((Tenseur2HH*) &sigHH_t_); // " " " "
// on définit des tenseurs intermédiaires pour la contrainte et la déformation
Tenseur2BB eps_orthoBB(epsBB),delta_eps_orthoBB(delta_epsBB);
Tenseur2HH sig_orthoHH(sigHH_t);
Tenseur2BB D_orthoBB(DepsBB);
//la loi en dimension 2 doit s'exprimer dans un repère orthonormé de dimension 2
// on va utiliser une méthode particulière de la déformation associé
#ifdef MISE_AU_POINT
// vérif que le pointeur est ok
if (def_en_cours == NULL)
{ cout << "\nErreur : la deformation en cours n'est pas utilisable "
<< " on ne peut pas continuere ! !\n" ;
cout << " Loi_Umat::Calcul_DsigmaHH_tdt\n";
Sortie(1);
};
#endif
// détermination d'une bases particulière orthonormée pour représenter les tenseurs
// on est en contrainte plane ou déformation plane, la géométrie interpolée est de type 2D
// et on considère que la normale suivant laquelle la contrainte ou la déformation 33 est nulle
// est normale à la géométrie 2D, d'où l'utilisation d'une méthode ad hoc de la déformation en cours
// en sortie on a une matrice de passage, qui permet de passer de la base curviligne
// à cette base particulière que l'on va appeler IPa
// Le choix qui est fait est de calculer le passage gH(alpha) -> IP^beta ,
// c-a-d Aa(alpha,beta) = les coordonnées de gH(alpha) dans la base IP^beta,
// ou encore: la ligne alpha de Aa = les coordonnées locales de gH(alpha)
// NB: si on a besoin du passage de gB(alpha) on utilise la matrice
// inverse transposée de Aa
Mat_pleine Aa(2,2); // matrice de passage
bool absolue = false; // on utilise un repère locale ad hoc
def_en_cours->BasePassage(absolue,(*ex.giB_0),(*ex.giH_0),Aa);
// pour le changement de repère: la nouvelle base doit-être tel que
// gp^i = gamma^i_{.j} * g^j et gp_i = beta_i^{.j} g_j
// ici gp^i = Ip^i d'où [gamma] = [Aa]^{-1T} et [beta] = [Aa]^T
Mat_pleine gamma(Aa.Inverse().Transpose());
Mat_pleine beta(Aa.Transpose());
// on passe ensuite les tenseurs dans la base locale orthonormée
eps_orthoBB.ChBase(beta);
delta_eps_orthoBB.ChBase(beta);
D_orthoBB.ChBase(beta);
sig_orthoHH.ChBase(gamma);
sigHH.ChBase(gamma); // normalement ne sert à rien car est un résultat
// maintenant on va calculer l'équivalent local des bases à 0
ex.giB_0->ChangeBase_curviligne(Aa,giB_0_2D,giH_0_2D,Ip3B_0_3D);
// giB_0_2D et giH_0_2D contiennent les coordonnées des gi initiaux dans la nouvelle
// base ortho: mais il s'agit toujours des gi relatifs aux theta i de départ
// Ip3B_0_3D contient les coordonnées de la base ortho 2D + 1D (normal aux 2 premiers)
// , exprimées dans le repère 3D
// on doit avoir Ip3H_0_3D = Ip3B_0_3D mais comme la variance n'est pas la même il faut les
// affecter en passant outre la variance
Ip3H_0_3D.Affectation_trans_variance(Ip3B_0_3D);
// on change de base: pour exprimer les bases précédentes mais maintenant dans le nouveau
// repère Ip3B_0_3D
ex.giB_t->Change_repere(Ip3H_0_3D,giB_t_2D);
ex.giB_tdt->Change_repere(Ip3H_0_3D,giB_tdt_2D);
ex.giH_t->Change_repere(Ip3B_0_3D,giH_t_2D);
ex.giH_tdt->Change_repere(Ip3B_0_3D,giH_tdt_2D);
// donc maintenant umat_cont_2D contient via ses pointeurs les nouvelles bases
#ifdef MISE_AU_POINT
if (Permet_affichage() > 5)
mise à jour 7.010
2023-05-03 17:23:49 +02:00
{cout << "\n\n Loi_Umat::Calcul_DsigmaHH_tdt (.. ";
ajout des lois de comportement
2021-09-23 11:21:15 +02:00
cout << "\n gamma= "; Aa.Affiche();
cout << " base ex.giB_0:" << (*ex.giB_0);
cout << "\n base Ip : "<<Ip3B_0_3D;
cout << "\n base ex.giB_t:" << (*ex.giB_t);
cout << "\n dans Ip:" << giB_t_2D;
cout << "\n base ex.giB_tdt:" << (*ex.giB_tdt);
cout << "\n dans ip:" << giB_tdt_2D;
cout << "\n def epsBB: "<<epsBB;
cout << "\n def eps_orthoBB: "<< eps_orthoBB;
}
#endif
// maintenant on peut construire le reste de la métrique
const Met_abstraite::Umat_cont& umat_cont = umat_met2D.Construction_Umat(*umat_cont_2D);
#ifdef MISE_AU_POINT
if (Permet_affichage() > 5)
{cout << "\n base gip_B_t:" << (*umat_cont.giB_t);
cout << "\n base gip_B_tdt:" << (*umat_cont.giB_tdt);
};
#endif
bool en_base_orthonormee=true; // ici les tenseurs sont en orthonormee a priori
// c'est-à-dire dans un repère orthonormée, la direction 3 correspond à la direction
// pour laquelle sig^33 = 0
// appel de la procedure umat
Calcul_dsigma_deps (en_base_orthonormee, sig_orthoHH,D_orthoBB
,eps_orthoBB,delta_eps_orthoBB,jacobien_0,jacobien
,sigHH,d_sigma_deps_2D,energ,energ_t
,module_compressibilite,module_cisaillement,umat_cont);
#ifdef MISE_AU_POINT
if (Permet_affichage() > 5)
{cout << "\n contrainte sigHH dans Ip_a : "<<sigHH;
cout << "\n d_sigma_deps_2D dans Ip_a :" << d_sigma_deps_2D;
};
#endif
// la contrainte résultat : est tel qu'elle représente les composantes
// du tenseur contrainte dans le repère non orthonormée \hat I'_a
// les composantes de \hat I'_a dans I'_a sont giB_tdt_2D
// on a par définition: \hat I'_al = gamma(be,al) * \hat g_be
// la matrice gamma est utilisée sous forme de sa transposée
// maintenant on veut le tenseur des contraintes dans la base \hat g_be
// donc la relation \hat I'_al = gamma(be,al) * \hat g_be la relation de changement
// de base de l'ancienne base \hat I'_al à la nouvelle voulue \hat g_be
// avec comme matrice de changement: transposée (gamma)
sigHH.ChBase(gamma.Transpose(),true);
#ifdef MISE_AU_POINT
if (Permet_affichage() > 5)
{cout << "\n sigHH dans g_i :" <<sigHH;
};
#endif
// calcul de l'opérateur tangent / ddl
int nbddl = d_gijBB_tdt.Taille();
// ---- première solution --- on travail dans le repère local
int cas_resoudre = 1;
if (cas_resoudre==1)
{// on ramène l'opérateur tangent dans le repère local
Tenseur2HHHH d_sigma_depsHHHH; // init
// en sortie de Calcul_dsigma_deps, d_sigma_deps_2D est relatif à l'opérateur tangent
// dans le repère
// giH_tdt_2D
// ---- rappel du changement de repère pour le 4ième ordre ----
// changement des composantes du tenseur, retour donc dans la même variance
// en argument : A -> une reference sur le tenseur résultat qui a la même dimension
// retour d'une reference sur A
// A = A^{ijkl) g_i rond g_j rond g_k rond g_l = A'^{efgh) gp_i rond gpp_j rond g_k rond gp_l
// g_i = beta_i^j gp_j --> A'^{efgh) = A^{ijkl) beta_i^e beta_j^f beta_k^g beta_l^h
// TenseurHHHH & ChangeBase(TenseurHHHH & A,const BaseB & gi) const;
// pour simplifier on définit un nouveau repère qui va nous servir pour le
// changement de base, ceci à partir de la relation
// \hat I'_al = gamma(be,al) * \hat g_be
// gammaB est construit à partir de la matrice gamma transposée
BaseB gammaB(2,2);
gammaB.CoordoB(1)(1) = gamma(1,1);gammaB.CoordoB(1)(2) = gamma(2,1);
gammaB.CoordoB(2)(1) = gamma(1,2);gammaB.CoordoB(2)(2) = gamma(2,2);
// on change de repère
d_sigma_deps_2D.ChangeBase(d_sigma_depsHHHH,gammaB);
#ifdef MISE_AU_POINT
if (Permet_affichage() > 5)
{cout << "\n d_sigma_deps_2D: dans g_i" << d_sigma_deps_2D;
};
#endif
for (int i = 1; i<= nbddl; i++)
{ Tenseur2HH & dsigHH = *((Tenseur2HH*) (d_sigHH(i))); // passage en dim 2
const Tenseur2BB & depsBB = *((Tenseur2BB *) (d_epsBB(i))); // "
dsigHH = d_sigma_depsHHHH && depsBB;
};
};
// l'autre cas, voir 3D n'est pas d'actualité pour l'instant
break;
}
case 3: // cas en 3 dimension
{ const Tenseur3BB & epsBB = *((Tenseur3BB*) &epsBB_tdt); // passage en dim 3
const Tenseur3BB & delta_epsBB = *((Tenseur3BB*) &delta_epsBB_); // passage en dim 3
const Tenseur3BB & DepsBB = *((Tenseur3BB*) &DepsBB_); // passage en dim 3
const Tenseur3HH & gijHH = *((Tenseur3HH*) &gijHH_tdt); // " " " "
Tenseur3HH & sigHH = *((Tenseur3HH*) &sigHH_tdt); // " " " "
Tenseur3HH & sigHH_t = *((Tenseur3HH*) &sigHH_t_); // " " " "
// on définit des tenseurs intermédiaires pour la contrainte et la déformation
Tenseur3BB epsAA,delta_epsAA; Tenseur3HH sigAA;
// cout << "\n epsBB " << epsBB;
// calcul de la déformation et de l'accroissement dans le repère orthonormee
epsBB.BaseAbsolue(epsAA,giH_tdt);
// cout << "\n epsAA "; (umatAbaqus.eps_meca)->Ecriture(cout);
// int toto; cout << "\n une lettre ? "; cin >> toto;
delta_epsBB.BaseAbsolue(delta_epsAA,giH_tdt);
// calcul de la vitesse de déformation dans le repère orthonormee
Tenseur3BB D_abs_epsBB;
DepsBB.BaseAbsolue(D_abs_epsBB,giH_tdt);
// calcul de la contrainte initiale dans le repère orthonormee
sigHH_t.BaseAbsolue(sigAA,giB_tdt);
mise à jour 7.010
2023-05-03 17:23:49 +02:00
#ifdef MISE_AU_POINT
if (Permet_affichage() > 5)
{cout << "\n\n Loi_Umat::Calcul_DsigmaHH_tdt (.. ";
cout << "\n eps en absolu :";epsAA.Ecriture(cout);
cout << "\n Deps en absolu :";D_abs_epsBB.Ecriture(cout);
cout << "\n delta_eps en absolu :";delta_epsAA.Ecriture(cout);
cout << "\n sig_t en absolu :";sigAA.Ecriture(cout);
}
#endif
ajout des lois de comportement
2021-09-23 11:21:15 +02:00
// construction de la métrique umat associée à la métrique actuelle,
// c'est-à-dire construction de la métrique correspondant aux coordonnées initiales
// considérées comme paramétrage matériel
const Met_abstraite::Umat_cont& umat_cont = umat_met3D.Construction_Umat(ex);
bool en_base_orthonormee=true; // ici les tenseurs sont en orthonormee a priori
// appel de la procedure umat
Calcul_dsigma_deps (en_base_orthonormee, sigAA,D_abs_epsBB
,epsAA,delta_epsAA,jacobien_0,jacobien
,*(umatAbaqus.t_sigma),*(umatAbaqus.d_sigma_deps),energ,energ_t
,module_compressibilite,module_cisaillement,umat_cont);
// passage de la contrainte dans la base locale HH
Tenseur3HH & sigabHH_tdt = *((Tenseur3HH*) (umatAbaqus.t_sigma)); // // passage en dim 3 explicite
sigabHH_tdt.Baselocale(sigHH,*(ex.giH_tdt));
// calcul de l'opérateur tangent / ddl
int nbddl = d_gijBB_tdt.Taille();
Tenseur3HHHH & d_sigma_deps = *((Tenseur3HHHH *) umatAbaqus.d_sigma_deps);
// ---- première solution --- on travail dans le repère local
int cas_resoudre = 1;
if (cas_resoudre==1)
{// on ramène l'opérateur tangent dans le repère local
Tenseur3HHHH d_sigma_depsHHHH;
d_sigma_deps.Baselocale(d_sigma_depsHHHH,*(ex.giH_tdt));
for (int i = 1; i<= nbddl; i++)
{ Tenseur3HH & dsigHH = *((Tenseur3HH*) (d_sigHH(i))); // passage en dim 3
const Tenseur3BB & depsBB = *((Tenseur3BB *) (d_epsBB(i))); // "
dsigHH = d_sigma_depsHHHH && depsBB;
};
}
else // ---- cas on travail dans le repère global ---- (ne fonctionne pas !!)
{
Tenseur3BB depsAA; Tenseur3BB dep1AA,dep2AA;
Tenseur3HH dsigAA; Tenseur3HH dsig1AA;
// on rajoute l'effet de la déformation
// terme sigma.D + D.sigma
d_sigma_deps += 2*Tenseur3HHHH::Prod_tensoriel_barre(sigabHH_tdt,IdHH3);
for (int i = 1; i<= nbddl; i++)
{ Tenseur3HH & dsigHH = *((Tenseur3HH*) (d_sigHH(i))); // passage en dim 3
const Tenseur3BB & d_gijBB = *((Tenseur3BB*)(d_gijBB_tdt(i))); // passage en dim 3
const Tenseur3HH & dgijHH = *((Tenseur3HH*)(d_gijHH_tdt(i))) ; // pour simplifier l'ecriture
const Tenseur3BB & depsBB = *((Tenseur3BB *) (d_epsBB(i))); // "
// tout d'abord variation de la déformation en orthonormee
depsBB.BaseAbsolue(depsAA,*(ex.giH_tdt)); // 1) prise en compte de la variation de depsBB
// 2) puis on tiens compte de la variation des gamma_a^i qui servent au changement de base
// de la base locale à la base orthonormee
depsAA += produit_1_pourLoiUmat(dep1AA,epsBB,(*(ex.d_giH_tdt))(i),*(ex.giH_tdt));
// dérivée de sigma^ab / d_ddl
dsigAA = d_sigma_deps && depsAA;
// dérivée de sigma^ij / d_ddl
dsigAA.Baselocale(dsigHH,*(ex.giH_tdt)); // 1) prise en compte de la variation de dsigAA
// 2) puis prise en compte de la variation des gamma_a^i qui servent au changement de base
// du global au locale (c'est-à-dire l'opération inverse que pour la déformation) mais dans
// les deux cas c'est les gamma_a^i qui servent !
// a priori ces les termes -W.sigma + sigma.W ?????
dsigHH += produit_1_pourLoiUmat(dsig1AA,sigabHH_tdt,(*(ex.d_giH_tdt))(i),*(ex.giH_tdt));
};
};
break;
}
default:
{cout << "\n pour l'instant seules les lois 3D sont implantees en Umat interne"
<< "\n Loi_Umat::Calcul_DsigmaHH_tdt (.... ";
Sortie(1);
}
};
// on libère les tenseurs intermédiaires
LibereTenseur();
LibereTenseurQ();
};
// calcul des contraintes et ses variations par rapport aux déformations a t+dt
// en_base_orthonormee: le tenseur de contrainte en entrée est en orthonormee
// le tenseur de déformation et son incrémentsont également en orthonormees
// si = false: les bases transmises sont utilisées
// ex: contient les éléments de métrique relativement au paramétrage matériel = X_(0)^a
void Loi_Umat::Calcul_dsigma_deps (bool en_base_orthonormee, TenseurHH & sigHH_t_,TenseurBB& DepsBB
,TenseurBB & epsBB_tdt,TenseurBB & delta_epsBB_,double& jacobien_0,double& jacobien
,TenseurHH& sigHH_tdt,TenseurHHHH& d_sigma_deps
,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double& module_cisaillement
,const Met_abstraite::Umat_cont& ex)
{
// si l'on est dans une utilisation interne de l'umat on appel
// directement la loi interne
if (utilisation_umat_interne)
{ // il faut passer les informations à la loi interne
((Loi_comp_abstraite*)loi_ext)->saveResul = ((SaveResul_Loi_Umat*) saveResul)->save_pour_loi_ext;
RepercuteChangeTemperature(TEMPS_tdt);
((Loi_comp_abstraite*)loi_ext)->Calcul_dsigma_deps (en_base_orthonormee, sigHH_t_,DepsBB,epsBB_tdt
,delta_epsBB_,jacobien_0,jacobien,sigHH_tdt
,d_sigma_deps,energ,energ_t,module_compressibilite,module_cisaillement,ex
);
// on met à jour la variation d'épaisseur constatée
Loi_Umat::SaveResul_Loi_Umat& sav = *((Loi_Umat::SaveResul_Loi_Umat*) &saveResul);
sav.h_tsurh0 = ((Loi_comp_abstraite*)loi_ext)->HsurH0(((Loi_comp_abstraite*)loi_ext)->saveResul);
return;
};
// sinon on dialogue via les pipes d'où le remplissage du conteneur UmatAbaqus
// const Tenseur3BB & epsBB = *((Tenseur3BB*) &epsBB_tdt); // passage en dim 3
// const Tenseur3BB & delta_epsBB = *((Tenseur3BB*) &delta_epsBB_); // passage en dim 3
// Tenseur3HH & sigHH = *((Tenseur3HH*) &sigHH_tdt); // " " " "
// Tenseur3HH & sigHH_t = *((Tenseur3HH*) &sigHH_t_); // " " " "
SaveResul_Loi_Umat & save_resul = *((SaveResul_Loi_Umat*) saveResul);
// .. définition de jeux de données adoc
// si on a des tenseurs à 2 dimensions, on considère que l'on est en CP par défaut
int dim_reel_tens = 3 ; // init par défaut: nb sigii
int nb_reel_tau_ij = 3 ; // idem
if (ex.giB_t->NbVecteur() == 2 )
{dim_reel_tens = 2; nb_reel_tau_ij=1; };
umatAbaqus.Init_un(dim_reel_tens,nb_reel_tau_ij);
// on renseigne la position du pti
// on devrait pouvoir le récupérer de l'appel venant de loi_comp_abstraite
// mais c'est pas simple donc je recalcule
umatAbaqus.coor_pt = def_en_cours->Position_tdt();
// umatAbaqus.Init_un();
// init de la déformation et de l'accroissement
// la dimension des tenseurs passés en paramètre, peut-être 2 ou 3
// non // par contre dans l'umatAbaqus on est toujours en 3D
// on fait donc une affectation trans dimension
bool plusZero = true; // on ajoute des zéros par défaut
// (umatAbaqus.eps_meca)->Affectation_trans_dimension(epsBB_tdt,plusZero);
*(umatAbaqus.eps_meca) = epsBB_tdt;
// (umatAbaqus.delta_eps_meca)->Affectation_trans_dimension(delta_epsBB_,plusZero);
*(umatAbaqus.delta_eps_meca) = delta_epsBB_;
// init de la contrainte initiale
// (umatAbaqus.t_sigma)->Affectation_trans_dimension(sigHH_t_,plusZero);
*(umatAbaqus.t_sigma)=sigHH_t_;
// récup des températures
umatAbaqus.temper_t=temperature_t; // température initiale
umatAbaqus.delta_temper=temperature_tdt-temperature_t; // variation de température
// récup des temps
const VariablesTemps& v_temps = ParaGlob::Variables_de_temps();
umatAbaqus.temps_tdt = v_temps.TempsCourant();
umatAbaqus.delta_t = v_temps.IncreTempsCourant();
umatAbaqus.temps_t = umatAbaqus.temps_tdt-umatAbaqus.delta_t;
// init des énergies
umatAbaqus.energie_elastique=energ_t.EnergieElastique();
umatAbaqus.dissipation_plastique=energ_t.DissipationPlastique();
umatAbaqus.dissipation_visqueuse=energ_t.DissipationVisqueuse();
// init des gradients
// les bases dans l'umatAbaqus ont toujours 3 vecteurs, mais
// ex peut en avoir que 2 : cas CP par exemple
int nb_vecteur = (ex.giB_t)->NbVecteur();
bool pas_Zero_base=false; // on ne veut pas changer le 3ième vecteur
// qui a été initialisé normalement correctement avec umatAbaqus.Init_un();
// umatAbaqus.giB_t.Affectation_partielle(nb_vecteur, *(ex.giB_t),pas_Zero_base);
umatAbaqus.giB_t = *(ex.giB_t);
// umatAbaqus.giB_tdt.Affectation_partielle(nb_vecteur, *(ex.giB_tdt),pas_Zero_base);
umatAbaqus.giB_tdt = *(ex.giB_tdt);
// si on est en tenseur 2D et en dimension 3 il faut définir les normales
if ((ex.giB_t->NbVecteur() == 2 )&& (ParaGlob::Dimension()==3))
{ umatAbaqus.N_t = Util::ProdVec_coorB( (*ex.giB_t)(1), (*ex.giB_t)(2));
umatAbaqus.N_tdt = Util::ProdVec_coorB( (*ex.giB_tdt)(1), (*ex.giB_tdt)(2));
};
// coordonnées du point, longueur caractéristique, les indices
if (umatAbaqus.nb_increment==1)
umatAbaqus.nom_materiau = nom_de_la_loi;
// le nombre d'itération est sytématiquement laissé à 1
// idem pour le nb de plis le np de pt d'integ dans le plis
// la longueur caractéristique est mise à 1. par défaut
// appel des routines Umat
umatAbaqus.EcritureDonneesPourUmat(utilisation_umat_interne,Permet_affichage());
umatAbaqus.LectureResultatUmat(utilisation_umat_interne,Permet_affichage());
// on met à jour la variation d'épaisseur constatée
Loi_Umat::SaveResul_Loi_Umat& sav = *((Loi_Umat::SaveResul_Loi_Umat*) &saveResul);
sav.hsurh0 = umatAbaqus.N_tdt.Norme();
// ------ retour des résultats
// les énergies
energ.ChangeEnergieElastique(umatAbaqus.energie_elastique);
energ.ChangeDissipationPlastique(umatAbaqus.dissipation_plastique);
energ.ChangeDissipationVisqueuse(umatAbaqus.dissipation_visqueuse);
// les contraintes
// les contraintes de l'umatAbaqus sont toujours en 3D,
// par contre l'utilisation interne peut-être en 2D: par exemple en CP
// sigHH_tdt.Affectation_trans_dimension(*(umatAbaqus.t_sigma),plusZero);
sigHH_tdt = *(umatAbaqus.t_sigma);
// l'opérateur tangent
// d_sigma_deps.Affectation_trans_dimension(*(umatAbaqus.d_sigma_deps),plusZero);
d_sigma_deps=*(umatAbaqus.d_sigma_deps);
// il faut maintenant calculer les modules de compressibilité et de cisaillement
Calcul_compressibilite_cisaillement(ex,module_compressibilite,module_cisaillement);
// on libère les tenseurs intermédiaires
LibereTenseur();
LibereTenseurQ();
};
// fonction interne utilisée par les classes dérivées de Loi_comp_abstraite
// pour répercuter les modifications de la température
// ici utiliser pour modifier la température des lois élémentaires
// l'Enum_dure: indique quel est la température courante : 0 t ou tdt
void Loi_Umat::RepercuteChangeTemperature(Enum_dure temps)
{ // la répercution n'est licite que s'il y a une loi interne
if (loi_ext != NULL)
{// pour l'instant on se place dans le cas d'une Loi_comp_abstraite
Loi_comp_abstraite * lois_interne = (Loi_comp_abstraite*) loi_ext;
lois_interne->temperature_0 = this->temperature_0;
lois_interne->temperature_t = this->temperature_t;
lois_interne->temperature_tdt = this->temperature_tdt;
lois_interne->dilatation=dilatation;
lois_interne->RepercuteChangeTemperature(temps);
// on répercute également les déformations thermiques, qui ne sont utilisées
// telles quelles que pour certaines lois: ex: loi hyper-élastique
if (dilatation)
{// a- dimensionnement des tenseurs intermédiaires
int dim_tens = epsBB_therm->Dimension();
// -- cas de la déformation
if (lois_interne->epsBB_therm == NULL) { lois_interne->epsBB_therm = NevezTenseurBB(dim_tens);}
else if (lois_interne->epsBB_therm->Dimension() != dim_tens)
{ delete lois_interne->epsBB_therm;lois_interne->epsBB_therm = NevezTenseurBB(dim_tens);};
// -- cas de la vitesse de déformation
if (lois_interne->DepsBB_therm == NULL) { lois_interne->DepsBB_therm = NevezTenseurBB(dim_tens);}
else if (lois_interne->DepsBB_therm->Dimension() != dim_tens)
{ delete lois_interne->DepsBB_therm;lois_interne->DepsBB_totale = NevezTenseurBB(dim_tens);};
// b- affectation des tenseurs
(*lois_interne->epsBB_therm)=(*epsBB_therm);
(*lois_interne->DepsBB_therm)=(*DepsBB_therm);
};
switch (temps)
{ case TEMPS_0:
{lois_interne->temperature = &lois_interne->temperature_0;
break;
}
case TEMPS_t:
{lois_interne->temperature = &lois_interne->temperature_t;
break;
}
case TEMPS_tdt:
{lois_interne->temperature = &lois_interne->temperature_tdt;
break;
}
default:
{ cout << "\n erreur, cas de temps non prevu !! "
<< "\n LoiContraintesPlanes::RepercuteChangeTemperature(...";
Sortie(1);
};
};
};
};
// passage des grandeurs métriques de l'ordre 2 à 3
void Loi_Umat::Passage_metrique_ordre2_vers_3(const Met_abstraite::Umat_cont& ex)
{// on s'occupe du redimensionnement éventuel
// la partie dépendant des vitesses: entre accolades pour pouvoir fermer
{if (ex.gradVmoyBB_t != NULL) {umat_cont_3D->gradVmoyBB_t= gradVmoyBB_t_3D_P = &gradVmoyBB_t_3D;};
if (ex.gradVmoyBB_tdt != NULL) {umat_cont_3D->gradVmoyBB_tdt=gradVmoyBB_tdt_3D_P = &gradVmoyBB_tdt_3D;};
if (ex.gradVBB_tdt != NULL) {umat_cont_3D->gradVBB_tdt=gradVBB_tdt_3D_P = &gradVBB_tdt_3D;};
}; // fin de la partie dédiée à la vitesse
// on commence par recopier les grandeurs de l'ordre 2 à 3
bool plusZero = true; // on complète avec des 0 dans un premier temps
int type_recopie=0; // = 0 -> on transfert les grandeurs à 0, t et tdt
umat_cont_3D->Passage_de_Ordre2_vers_Ordre3(ex,plusZero,type_recopie);
// maintenant on s'occupe de mettre à jour les grandeurs manquantes
// - les bases naturelles: le vecteur normal est normé et est identique pour les bases naturelles et duales
giB_0_3D.CoordoB(3) = (Util::ProdVec_coorB(giB_0_3D(1),giB_0_3D(2))).Normer();
giH_0_3D.CoordoH(3) = giB_0_3D(3).Bas_haut();
giB_t_3D.CoordoB(3) = (Util::ProdVec_coorB(giB_t_3D(1),giB_t_3D(2))).Normer();
giH_t_3D.CoordoH(3) = giB_t_3D(3).Bas_haut();
// cas particulier du vecteur tdt
giB_tdt_3D.CoordoB(3) = (Util::ProdVec_coorB(giB_tdt_3D(1),giB_tdt_3D(2))); // calcul du vecteur normal non normé
double norme_N_tdt = giB_tdt_3D(3).Norme(); // calcul de la norme qui nous servira pour les variations
giB_tdt_3D.CoordoB(3) /= norme_N_tdt;
giH_tdt_3D.CoordoH(3) = giB_tdt_3D(3).Bas_haut();
// - les tenseurs métriques: au début 1 pour la direction 3
gijBB_0_3D.Coor(3,3)=gijHH_0_3D.Coor(3,3)=gijBB_t_3D.Coor(3,3)=gijHH_t_3D.Coor(3,3)=gijBB_tdt_3D.Coor(3,3)=gijHH_tdt_3D.Coor(3,3)=1.;
};
// calcul des modules de compressibilité et de cisaillement
// en fonction des résultats de l'umat
void Loi_Umat::Calcul_compressibilite_cisaillement(const Met_abstraite::Umat_cont& ex
,double & module_compressibilite,double & module_cisaillement)
{
switch (umatAbaqus.t_sigma->Dimension())
{case 3:
{Tenseur3HB sigHB = (*umatAbaqus.t_sigma) * (*ex.gijBB_tdt);
// cas du module de compressibilité
double trace_sig_sur_trois = 1./3. * sigHB.Trace();
double log_V = log((*ex.jacobien_tdt));
module_compressibilite = trace_sig_sur_trois / log_V;
// cas du module de cisaillement
double Qsig = sigHB.II();
Tenseur3HB epsHB = (*ex.gijHH_tdt) * (*umatAbaqus.eps_meca) ;
double deux_Qeps = 2.*epsHB.II();
module_cisaillement = Qsig / deux_Qeps;
break;
}
case 2: // en CP
{if ((umatAbaqus.dim_tens == 2) && (umatAbaqus.nb_tau_ij == 1))
{Tenseur2HB sigHB = (*umatAbaqus.t_sigma) * (*ex.gijBB_tdt);
// cas du module de compressibilité
// la contrainte 33 = 0
double trace_sig_sur_trois = 1./3. * sigHB.Trace();
// on démarre d'une base ortho donc le jacobien initial par principe = 1
double V = Dabs((*ex.jacobien_tdt)); // cas de la surface
// il faut maintenant introduire la surface
// la normale en 3 = 1 initialement
double var_3 = umatAbaqus.N_tdt.Norme();
V *= var_3;
double log_V = log(V);
// pour éviter une division de 0/0 on régularise
module_compressibilite = Dabs(trace_sig_sur_trois / (log_V+DSigne(log_V)*ConstMath::petit));
// cas du module de cisaillement
double Qsig = sigHB.II();
// il faut que l'on reconstruise un tenseur 3D avec la déformation d'épaisseur
Tenseur3HB epsHB; double eps_33=0;double delta_eps_33 = 0.;
double var_3_t = umatAbaqus.N_t.Norme();
epsHB.Affectation_trans_dimension((*ex.gijHH_tdt) * (*umatAbaqus.eps_meca),true);
// N_tdt = la nouvelle normale, compte tenu de la variation d'épaisseur
// et on part de N_0 qui est normé, d'où on considère que ||N_tdt|| = h/h0
switch (type_de_deformation)
{case DEFORMATION_STANDART : case DEFORMATION_POUTRE_PLAQUE_STANDART :
// cas d'une déformation d'Almansi
{ // epsBB33 = 1/2 * (1. - (h0/h)^2), en orthonormee
// dans le repère local: epsBB33 = 1/2 * (h^2 - 1.), or h0=1. donc : epsBB33 = 1/2 * ((h/h0)^2 - 1.)
eps_33 = 0.5 * (var_3 * var_3 - 1.);
delta_eps_33 = 0.5 * (var_3 * var_3 - var_3_t * var_3_t);
};
break;
case DEFORMATION_LOGARITHMIQUE : case DEF_CUMUL_CORROTATIONNEL : case DEFORMATION_CUMU_LOGARITHMIQUE :
// cas d'une def logarithmique ou une approximation
{ eps_33 = log(var_3);
delta_eps_33 = log(var_3) - log(var_3_t);
};
break;
default :
cout << "\nErreur : type de deformation qui n'est pas actuellement pris en compte, type= "
<< Nom_type_deformation(type_de_deformation);
cout << "\n Loi_Umat::Calcul_compressibilite_cisaillement(.. \n";
Sortie(1);
};
// le vecteur normal est normal à g_i à tous les temps (on considère que l'on reste dans le plan principal
// du coup g^{33} = h0^2/h^2 ce qui permet de calculer eps^3_3
epsHB.Coor(3,3)=eps_33 /(var_3*var_3);
double deux_Qeps = 2.*epsHB.II();
// pour éviter une division de 0/0 on régularise
module_cisaillement = Qsig / (deux_Qeps+ConstMath::petit);;
}
else
{ cout << "\n ** erreur, ce cas n'est pas encore pris en compte: "
<< " tenseur d'ordre 2 et situation non en contrainte plane !";
cout << "\n Loi_Umat::Calcul_compressibilite_cisaillement(.. \n";
Sortie(1);
};
break;
}
default:
cout << "\n ** erreur, ce cas n'est pas encore pris en compte: ";
cout << "\n Loi_Umat::Calcul_compressibilite_cisaillement(.. \n";
Sortie(1);
break;
};
#ifdef MISE_AU_POINT
if (Permet_affichage() > 4)
{cout << "\n module_compressibilite= " << module_compressibilite;
cout << "\n module_cisaillement= " << module_cisaillement;
};
#endif
};
Reference in a new issue Copy permalink