1369 lines
63 KiB
C++
Executable file
1369 lines
63 KiB
C++
Executable file
// FICHIER : Maheo_hyper.cc
|
|
// CLASSE : Maheo_hyper
|
|
|
|
|
|
// This file is part of the Herezh++ application.
|
|
//
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
// of mechanics for large transformations of solid structures.
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
//
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
//
|
|
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
|
// AUTHOR : Gérard Rio
|
|
// E-MAIL : gerardrio56@free.fr
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License,
|
|
// or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
//
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
|
|
|
|
|
//#include "Debug.h"
|
|
|
|
# include <iostream>
|
|
using namespace std; //introduces namespace std
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
#include "Sortie.h"
|
|
#include "TypeConsTens.h"
|
|
#include "CharUtil.h"
|
|
|
|
#include "Maheo_hyper.h"
|
|
#include "MathUtil.h"
|
|
#include "Enum_TypeQuelconque.h"
|
|
#include "TypeQuelconqueParticulier.h"
|
|
|
|
|
|
|
|
Maheo_hyper::Maheo_hyper () : // Constructeur par defaut
|
|
Hyper_W_gene_3D(MAHEO_HYPER,CAT_MECANIQUE,3)
|
|
,Qsig_rev(-ConstMath::trespetit)
|
|
, mu1_rev(-ConstMath::trespetit)
|
|
,mu2_rev(-ConstMath::trespetit)
|
|
,Qsig_use(0.), mu1_use(0.),mu2_use(0.) // recalculés avant chaque utilisation
|
|
,Qsig_nD(NULL),mu1_nD(NULL),mu2_nD(NULL)
|
|
,fact_regularisation(ConstMath::pasmalpetit)
|
|
,Qsig_rev_temperature(NULL),mu1_rev_temperature(NULL),mu2_rev_temperature(NULL)
|
|
,W_d(0.),W_v(0.)
|
|
,W_d_J1(0.),W_d_J2(0.),W_v_J3(0.),W_v_J3J3(0.)
|
|
,W_d_J1_2(0.),W_d_J1_J2(0.),W_d_J2_2(0.)
|
|
{nb_para_loi = 3; };
|
|
|
|
// Constructeur de copie
|
|
Maheo_hyper::Maheo_hyper (const Maheo_hyper& loi) :
|
|
Hyper_W_gene_3D(loi)
|
|
,Qsig_rev(loi.Qsig_rev)
|
|
, mu1_rev(loi.mu1_rev)
|
|
,mu2_rev(loi.mu2_rev)
|
|
,Qsig_use(0.), mu1_use(0.),mu2_use(0.) // recalculés avant chaque utilisation
|
|
,Qsig_rev_temperature(loi.Qsig_rev_temperature)
|
|
,mu1_rev_temperature(loi.mu1_rev_temperature)
|
|
,mu2_rev_temperature(loi.mu2_rev_temperature)
|
|
,Qsig_nD(loi.Qsig_nD),mu1_nD(loi.mu1_nD),mu2_nD(loi.mu2_nD)
|
|
,fact_regularisation(loi.fact_regularisation)
|
|
,W_d(loi.W_d),W_v(loi.W_v)
|
|
,W_d_J1(loi.W_d_J1),W_d_J2(loi.W_d_J2),W_v_J3(loi.W_v_J3),W_v_J3J3(loi.W_v_J3J3)
|
|
,W_d_J1_2(loi.W_d_J1_2),W_d_J1_J2(loi.W_d_J1_J2),W_d_J2_2(loi.W_d_J2_2)
|
|
{ nb_para_loi = 3; // nb paramètres de la loi
|
|
// on regarde s'il s'agit de courbes locales ou de courbes globales
|
|
if (Qsig_rev_temperature != NULL)
|
|
if (Qsig_rev_temperature->NomCourbe() == "_")
|
|
Qsig_rev_temperature = Courbe1D::New_Courbe1D(*(loi.Qsig_rev_temperature));
|
|
if (mu1_rev_temperature != NULL)
|
|
if (mu1_rev_temperature->NomCourbe() == "_")
|
|
mu1_rev_temperature = Courbe1D::New_Courbe1D(*(loi.mu1_rev_temperature));
|
|
if (mu2_rev_temperature != NULL)
|
|
if (mu2_rev_temperature->NomCourbe() == "_")
|
|
mu2_rev_temperature = Courbe1D::New_Courbe1D(*(loi.mu2_rev_temperature));
|
|
|
|
// idem pour les fonctions nD
|
|
if (Qsig_nD != NULL)
|
|
if (Qsig_nD->NomFonction() == "_")
|
|
{// comme il s'agit d'une fonction locale on la redéfinie (sinon pb lors du destructeur de loi)
|
|
string non_courbe("_");
|
|
Qsig_nD = Fonction_nD::New_Fonction_nD(*loi.Qsig_nD);
|
|
};
|
|
if (mu1_nD != NULL)
|
|
if (mu1_nD->NomFonction() == "_")
|
|
{// comme il s'agit d'une fonction locale on la redéfinie (sinon pb lors du destructeur de loi)
|
|
string non_courbe("_");
|
|
mu1_nD = Fonction_nD::New_Fonction_nD(*loi.mu1_nD);
|
|
};
|
|
if (mu2_nD != NULL)
|
|
if (mu2_nD->NomFonction() == "_")
|
|
{// comme il s'agit d'une fonction locale on la redéfinie (sinon pb lors du destructeur de loi)
|
|
string non_courbe("_");
|
|
mu2_nD = Fonction_nD::New_Fonction_nD(*loi.mu2_nD);
|
|
};
|
|
};
|
|
|
|
Maheo_hyper::~Maheo_hyper ()
|
|
// Destructeur
|
|
{ if (Qsig_rev_temperature != NULL)
|
|
if (Qsig_rev_temperature->NomCourbe() == "_") delete Qsig_rev_temperature;
|
|
if (mu1_rev_temperature != NULL)
|
|
if (mu1_rev_temperature->NomCourbe() == "_") delete mu1_rev_temperature;
|
|
if (mu2_rev_temperature != NULL)
|
|
if (mu2_rev_temperature->NomCourbe() == "_") delete mu2_rev_temperature;
|
|
// idem pour les fonctions nD
|
|
if (Qsig_nD != NULL) if (Qsig_nD->NomFonction() == "_") delete Qsig_nD;
|
|
if (mu1_nD != NULL) if (mu1_nD->NomFonction() == "_") delete mu1_nD;
|
|
if (mu2_nD != NULL) if (mu2_nD->NomFonction() == "_") delete mu2_nD;
|
|
};
|
|
|
|
// Lecture des donnees de la classe sur fichier
|
|
void Maheo_hyper::LectureDonneesParticulieres
|
|
(UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D
|
|
,LesFonctions_nD& lesFonctionsnD)
|
|
{ string toto,nom;
|
|
// lecture de Qsig_rev
|
|
string mot_cle = "Qsig_rev=";
|
|
string nom_class_methode = "Maheo_hyper::LectureDonneesParticulieres";
|
|
entreePrinc->Lecture_et_verif_mot_cle(nom_class_methode,mot_cle);
|
|
// maintenant choix thermodépendant ou pas
|
|
if(strstr(entreePrinc->tablcar,"Qsig_rev_thermo_dependant_")!=0)
|
|
{ mot_cle = "Qsig_rev_thermo_dependant_";
|
|
entreePrinc->Lecture_et_verif_mot_cle(nom_class_methode,mot_cle);
|
|
// lecture de la loi d'évolution
|
|
Qsig_rev_temperature = Lecture_courbe(entreePrinc,lesCourbes1D);
|
|
thermo_dependant=true; // on indique que la loi est thermo-dépendant
|
|
}
|
|
else
|
|
*(entreePrinc->entree) >> Qsig_rev ;
|
|
// lecture de mu1_rev
|
|
mot_cle = "mu1_rev=";
|
|
entreePrinc->Lecture_et_verif_mot_cle(nom_class_methode,mot_cle);
|
|
// maintenant choix thermodépendant ou pas
|
|
if(strstr(entreePrinc->tablcar,"mu1_rev_temperature_")!=0)
|
|
{ mot_cle = "mu1_rev_temperature_";
|
|
entreePrinc->Lecture_et_verif_mot_cle(nom_class_methode,mot_cle);
|
|
// lecture de la loi d'évolution
|
|
mu1_rev_temperature = Lecture_courbe(entreePrinc,lesCourbes1D);
|
|
thermo_dependant=true; // on indique que la loi est thermo-dépendant
|
|
}
|
|
else
|
|
*(entreePrinc->entree) >> mu1_rev;
|
|
// lecture de mu2_rev
|
|
mot_cle = "mu2_rev=";
|
|
entreePrinc->Lecture_et_verif_mot_cle(nom_class_methode,mot_cle);
|
|
// maintenant choix thermodépendant ou pas
|
|
if(strstr(entreePrinc->tablcar,"mu2_rev_temperature_")!=0)
|
|
{ mot_cle = "mu2_rev_temperature_";
|
|
entreePrinc->Lecture_et_verif_mot_cle(nom_class_methode,mot_cle);
|
|
// lecture de la loi d'évolution
|
|
mu2_rev_temperature = Lecture_courbe(entreePrinc,lesCourbes1D);
|
|
thermo_dependant=true; // on indique que la loi est thermo-dépendant
|
|
}
|
|
else
|
|
{*(entreePrinc->entree) >> mu2_rev;
|
|
// s'il n'y a plus rien n'a lire, il faut passer un enregistrement
|
|
if((strstr(entreePrinc->tablcar,"avec_regularisation_")==0)
|
|
&& (strstr(entreePrinc->tablcar,"avec_nD_")==0)
|
|
)
|
|
entreePrinc->NouvelleDonnee();
|
|
};
|
|
|
|
// -------- on regarde s'il y a une dépendance à une fonction nD
|
|
if (strstr(entreePrinc->tablcar,"avec_nD_")!=NULL)
|
|
{ string nom1,nom2;
|
|
// lecture des fonctions nD
|
|
entreePrinc->NouvelleDonnee(); // passage d'une ligne
|
|
|
|
// on lit tant que l'on ne rencontre pas la ligne contenant "fin_parametres_avec_nD_"
|
|
// ou un nouveau mot clé global auquel cas il y a pb !!
|
|
MotCle motCle; // ref aux mots cle
|
|
while (strstr(entreePrinc->tablcar,"fin_parametres_avec_nD_")==0)
|
|
{
|
|
// si on a un mot clé global dans la ligne courante c-a-d dans tablcar --> erreur
|
|
if ( motCle.SimotCle(entreePrinc->tablcar))
|
|
{ cout << "\n erreur de lecture des parametre de dependance a une fonction nD: on n'a pas trouve le mot cle "
|
|
<< " fin_parametres_avec_nD_ et par contre la ligne courante contient un mot cle global ";
|
|
entreePrinc->MessageBuffer
|
|
("** erreur51 des parametres de reglage de la loi de comportement Maheo_hyper**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
|
|
// lecture d'un mot clé
|
|
*(entreePrinc->entree) >> nom1;
|
|
|
|
if ((entreePrinc->entree)->rdstate() == 0)
|
|
{} // lecture normale
|
|
#ifdef ENLINUX
|
|
else if ((entreePrinc->entree)->fail())
|
|
// on a atteind la fin de la ligne et on appelle un nouvel enregistrement
|
|
{ entreePrinc->NouvelleDonnee(); // lecture d'un nouvelle enregistrement
|
|
*(entreePrinc->entree) >>nom1;
|
|
}
|
|
#else
|
|
else if ((entreePrinc->entree)->eof())
|
|
// la lecture est bonne mais on a atteind la fin de la ligne
|
|
{ if(nom1 != "fin_parametres_avec_nD_")
|
|
{entreePrinc->NouvelleDonnee(); *(entreePrinc->entree) >> nom1;};
|
|
}
|
|
#endif
|
|
else // cas d'une erreur de lecture
|
|
{ cout << "\n erreur de lecture inconnue ";
|
|
entreePrinc->MessageBuffer
|
|
("** erreur61 des parametres de reglage de la loi de comportement Maheo_hyper**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
|
|
if(nom1 == "Qsig_nD=")
|
|
{string nom_fonct;
|
|
// lecture du nom de la fonction
|
|
*(entreePrinc->entree) >> nom_fonct;
|
|
|
|
// maintenant on définit la fonction
|
|
if (lesFonctionsnD.Existe(nom_fonct))
|
|
{Qsig_nD = lesFonctionsnD.Trouve(nom_fonct);
|
|
}
|
|
else
|
|
{// sinon il faut la lire maintenant
|
|
string non("_");
|
|
Qsig_nD = Fonction_nD::New_Fonction_nD(non, Id_Nom_Fonction_nD(nom_fonct));
|
|
// lecture de la fonction
|
|
Qsig_nD->LectDonnParticulieres_Fonction_nD (non,entreePrinc);
|
|
// maintenant on vérifie que la fonction est utilisable
|
|
if (Qsig_nD->NbComposante() != 1 )
|
|
{ cout << "\n erreur en lecture, la fonction " << nom_fonct
|
|
<< " est une fonction vectorielle a " << Qsig_nD->NbComposante()
|
|
<< " composante alors qu'elle devrait etre scalaire ! "
|
|
<< " elle n'est donc pas utilisable !! ";
|
|
string message("\n**erreur031** \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 = Qsig_nD->Tab_enu_etendu();
|
|
if (tab_enu.Contient(TEMP))
|
|
thermo_dependant=true;
|
|
// prepa du flot de lecture
|
|
entreePrinc->NouvelleDonnee();
|
|
}
|
|
else if(nom1 == "mu1_nD=")
|
|
{string nom_fonct;
|
|
// lecture du nom de la fonction
|
|
*(entreePrinc->entree) >> nom_fonct;
|
|
|
|
// maintenant on définit la fonction
|
|
if (lesFonctionsnD.Existe(nom_fonct))
|
|
{mu1_nD = lesFonctionsnD.Trouve(nom_fonct);
|
|
}
|
|
else
|
|
{// sinon il faut la lire maintenant
|
|
string non("_");
|
|
mu1_nD = Fonction_nD::New_Fonction_nD(non, Id_Nom_Fonction_nD(nom_fonct));
|
|
// lecture de la fonction
|
|
mu1_nD->LectDonnParticulieres_Fonction_nD (non,entreePrinc);
|
|
// maintenant on vérifie que la fonction est utilisable
|
|
if (mu1_nD->NbComposante() != 1 )
|
|
{ cout << "\n erreur en lecture, la fonction " << nom_fonct
|
|
<< " est une fonction vectorielle a " << mu1_nD->NbComposante()
|
|
<< " composante alors qu'elle devrait etre scalaire ! "
|
|
<< " elle n'est donc pas utilisable !! ";
|
|
string message("\n**erreur031** \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 = mu1_nD->Tab_enu_etendu();
|
|
if (tab_enu.Contient(TEMP))
|
|
thermo_dependant=true;
|
|
// prepa du flot de lecture
|
|
entreePrinc->NouvelleDonnee();
|
|
}
|
|
else if(nom1 == "mu2_nD=")
|
|
{string nom_fonct;
|
|
// lecture du nom de la fonction
|
|
*(entreePrinc->entree) >> nom_fonct;
|
|
|
|
// maintenant on définit la fonction
|
|
if (lesFonctionsnD.Existe(nom_fonct))
|
|
{mu2_nD = lesFonctionsnD.Trouve(nom_fonct);
|
|
}
|
|
else
|
|
{// sinon il faut la lire maintenant
|
|
string non("_");
|
|
mu2_nD = Fonction_nD::New_Fonction_nD(non, Id_Nom_Fonction_nD(nom_fonct));
|
|
// lecture de la fonction
|
|
mu2_nD->LectDonnParticulieres_Fonction_nD (non,entreePrinc);
|
|
// maintenant on vérifie que la fonction est utilisable
|
|
if (mu2_nD->NbComposante() != 1 )
|
|
{ cout << "\n erreur en lecture, la fonction " << nom_fonct
|
|
<< " est une fonction vectorielle a " << mu2_nD->NbComposante()
|
|
<< " composante alors qu'elle devrait etre scalaire ! "
|
|
<< " elle n'est donc pas utilisable !! ";
|
|
string message("\n**erreur031** \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 = mu2_nD->Tab_enu_etendu();
|
|
if (tab_enu.Contient(TEMP))
|
|
thermo_dependant=true;
|
|
// prepa du flot de lecture
|
|
entreePrinc->NouvelleDonnee();
|
|
}
|
|
else // cas d'une erreur
|
|
{ cout << "\n erreur en lecture de la dependance a une fonction nD des coefficients, on aurait du lire "
|
|
<< " le mot cle Qsig_nD= ou mu1_nD= ou mu2_nD= et on a lu: "
|
|
<< nom1;
|
|
entreePrinc->MessageBuffer("**erreur7 Maheo_hyper::LectureDonneesParticulieres (...**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
}; //-- fin du while
|
|
entreePrinc->NouvelleDonnee(); // passage du mot clé "fin_parametres_avec_nD_"
|
|
|
|
};
|
|
|
|
// cas avec une régularisation éventuelle
|
|
if (strstr(entreePrinc->tablcar,"avec_regularisation_")!=NULL)
|
|
{ mot_cle = "avec_regularisation_";
|
|
entreePrinc->Lecture_et_verif_mot_cle(nom_class_methode,mot_cle);
|
|
*(entreePrinc->entree) >> fact_regularisation;
|
|
};
|
|
|
|
// lecture de l'indication éventuelle du post traitement
|
|
string le_mot_cle = "sortie_post_";
|
|
if (entreePrinc->Lecture_un_parametre_int(0,nom_class_methode,0,1,le_mot_cle,sortie_post))
|
|
entreePrinc->NouvelleDonnee(); // passage éventuel du mot clé sortie_post_;
|
|
|
|
// --- appel au niveau de la classe mère
|
|
// ici il n'y a pas de type de déformation associé
|
|
// mais on prend la def standart d'almansi, pour les fonctions associées éventuelles
|
|
Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire
|
|
(*entreePrinc,lesFonctionsnD,true);
|
|
};
|
|
|
|
// affichage de la loi
|
|
void Maheo_hyper::Affiche() const
|
|
{ cout << " \n loi de comportement hyper elastique 3D Maheo_hyper \n";
|
|
|
|
if ( Qsig_rev_temperature != NULL) { cout << " Qsig_rev thermo dependant "
|
|
<< " courbe Qsig_rev=f(T): " << Qsig_rev_temperature->NomCourbe() <<" ";}
|
|
else { cout << " Qsig_rev= " << Qsig_rev << " ";};
|
|
if ( mu1_rev_temperature != NULL) { cout << " mu1_rev thermo dependant "
|
|
<< " courbe mu1_rev=f(T): " << mu1_rev_temperature->NomCourbe() <<" ";}
|
|
else { cout << " mu1_rev= " << mu1_rev << " ";};
|
|
if ( mu2_rev_temperature != NULL) { cout << " mu2_rev thermo dependant "
|
|
<< " courbe mu2_rev=f(T): " << mu2_rev_temperature->NomCourbe() <<" ";}
|
|
else { cout << " mu2_rev= " << mu2_rev << " ";};
|
|
|
|
// les dépendances à une fonction nD
|
|
if (Qsig_nD)
|
|
{cout << " fonction nD Qsig_nD: ";
|
|
if (Qsig_nD->NomFonction() != "_")
|
|
cout << Qsig_nD->NomFonction();
|
|
else
|
|
Qsig_nD->Affiche();
|
|
};
|
|
if (mu1_nD)
|
|
{cout << " fonction nD mu1_nD: ";
|
|
if (mu1_nD->NomFonction() != "_")
|
|
cout << mu1_nD->NomFonction();
|
|
else
|
|
mu1_nD->Affiche();
|
|
};
|
|
if (mu2_nD)
|
|
{cout << " fonction nD mu2_nD: ";
|
|
if (mu2_nD->NomFonction() != "_")
|
|
cout << mu2_nD->NomFonction();
|
|
else
|
|
mu2_nD->Affiche();
|
|
};
|
|
// appel de la classe mère
|
|
Loi_comp_abstraite::Affiche_don_classe_abstraite();
|
|
};
|
|
|
|
// affichage et definition interactive des commandes particulières à chaques lois
|
|
void Maheo_hyper::Info_commande_LoisDeComp(UtilLecture& entreePrinc)
|
|
{ ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
|
|
cout << "\n definition standart (rep o) ou exemples exhaustifs (rep n'importe quoi) ? ";
|
|
string rep = "_";
|
|
// procédure de lecture avec prise en charge d'un retour chariot
|
|
rep = lect_return_defaut(true,"o");
|
|
|
|
sort << "\n# ----------------------------------------------------------------------------------"
|
|
<< "\n# |... loi de comportement hyper elastique 3D Maheo_hyper .. |"
|
|
<< "\n# ----------------------------------------------------------------------------------"
|
|
<< "\n\n# exemple de definition de loi"
|
|
<< "\n Qsig_rev= 2 mu1_rev= 0.0167 mu2_rev= 0.45 "
|
|
<< "\n# .. fin de la definition de la loi Maheo_hyper \n" << endl;
|
|
if ((rep != "o") && (rep != "O" ) && (rep != "0") )
|
|
{ sort << "\n# "
|
|
<< "\n#------------------------------------------------------------------------------------"
|
|
<< "\n# il est possible de definir des parametres thermo-dependants (1 ou 2 ou 3 parametres)"
|
|
<< "\n# par exemple pour les trois parametres on ecrit: "
|
|
<< "\n#------------------------------------------------------------------------------------"
|
|
<< "\n# Qsig_rev= Qsig_rev_thermo_dependant_ courbe1 "
|
|
<< "\n# mu1_rev= mu1_rev_temperature_ courbe2 "
|
|
<< "\n# mu2_rev= mu2_rev_temperature_ courbe3 "
|
|
<< "\n# ou encore "
|
|
<< "\n# Qsig_rev= Qsig_rev_temperature_ courbe2 "
|
|
<< "\n# mu1_rev= 0.0167 mu2_rev= mu2_rev_temperature_ courbe4 "
|
|
<< "\n#------------------------------------------------------------------------------------"
|
|
<< "\n# noter qu'apres la definition de chaque courbe, on change de ligne, a l'inverse "
|
|
<< "\n# si la valeur du parametre est fixe, on poursuit sur la meme ligne. "
|
|
<< "\n#"
|
|
<< "\n#--------------------- dependance explicite a une fonction nD -----------------------------------"
|
|
<< "\n# il est egalement possible de definir une dependance des parametres a une fonction nD "
|
|
<< "\n# dans ce cas, a la suite de la dependance explicite a la temperature via une courbr 1D "
|
|
<< "\n# ou a la suite du dernier parametre fixe, on met le mot cle: avec_nD_ "
|
|
<< "\n# puis sur les lignes qui suivent on met des fonctions nD multiplicatives des parametres "
|
|
<< "\n# initiaux, puis un mot cle signalant la fin des fonctions: fin_parametres_avec_nD_ "
|
|
<< "\n# suit un exemple de declaration (il est possible d'ommettre certaine fonction ! "
|
|
<< "\n# la presence de fct nD est facultative), de meme il est possible soit d'utiliser une fonction "
|
|
<< "\n# deja defini soit de donner directement la fonction nD (comme pour les autres lois) "
|
|
<< "\n# Enfin, apres chaque definition de fonction il faut passer a une nouvelle ligne "
|
|
<< "\n# "
|
|
<< "\n# exemple de definition de loi"
|
|
<< "\n# Qsig_rev= 1 mu1_rev= 1 mu2_rev= 1 avec_nD_ "
|
|
<< "\n# Qsig_nD= fct_nD_1 "
|
|
<< "\n# mu1_nD= fct_nD_2 "
|
|
<< "\n# mu2_nD= fct_nD_3 "
|
|
<< "\n# fin_parametres_avec_nD_ "
|
|
<< "\n# "
|
|
<< "\n# Remarques: "
|
|
<< "\n# - les fonction nD sont des fonctions multiplicatives "
|
|
<< "\n# des parametres initiaux (ou de ceux obtenus apres dependance explicite a la temperature "
|
|
<< "\n# ( bien noter que la loi obtenue peut-etre quelconque, en particulier plus du tout "
|
|
<< "\n# hyperelastique, tout depend des choix des fcts nD !) "
|
|
<< "\n# "
|
|
<< "\n#----------------------------------- avec_regularisation_ -------------------------------"
|
|
<< "\n# il est possible d'indiquer un facteur de regularisation qui permet d'eviter "
|
|
<< "\n# des problemes de NaN, de type division par 0 par exemple "
|
|
<< "\n# 1/a est remplace par 1/(a+fact_regularisation), par defaut fact_regularisation = 1.e-12 "
|
|
<< "\n# pour indiquer un facteur de regulation non nul on indique en dernier parametre "
|
|
<< "\n# le mot cle avec_regularisation_ suivi du facteur voulu "
|
|
<< "\n# ex: "
|
|
<< "\n# avec_regularisation_ 1.e-12 "
|
|
<< "\n# ce mot cle doit se situer avant eventuelement le mot cle sortie_post_ "
|
|
<< "\n#"
|
|
<< "\n#----------------------------------- sortie_post_ -------------------------------------"
|
|
<< "\n# il est possible de recuperer differentes grandeurs de travail par exemple "
|
|
<< "\n# l'intensite du potentiel, comme ces grandeurs sont calculees au moment de la resolution "
|
|
<< "\n# et ne sont pas stockees. On peut egalement recuperer la valeur des coefficients de la loi "
|
|
<< "\n# (utile s'ils varient) sous forme d'un tableau de triplet : Qsig_rev C01 C10 mu1_rev mu2_use "
|
|
<< "\n# Il faut indiquer le mot cle sortie_post_ suivi de 1 (par defaut = 0) "
|
|
<< "\n# ensuite au moment de la constitution du .CVisu on aura acces aux grandeurs de travail "
|
|
<< "\n# ex: "
|
|
<< "\n# sortie_post_ 1 "
|
|
<< "\n# ce mot cle est le dernier des parametres specifiques de la loi il doit se situe "
|
|
<< "\n# a la fin de la derniere ligne de donnees "
|
|
<< "\n#"
|
|
<< "\n#------------------------------------------------------------------------------------"
|
|
<< endl;
|
|
};
|
|
// appel de la classe Hyper_W_gene_3D
|
|
Hyper_W_gene_3D::Info_commande_LoisDeComp_hyper3D(entreePrinc);
|
|
// appel de la classe mère
|
|
Loi_comp_abstraite::Info_commande_don_LoisDeComp(entreePrinc);
|
|
};
|
|
|
|
// test si la loi est complete
|
|
int Maheo_hyper::TestComplet()
|
|
{ int ret = LoiAbstraiteGeneral::TestComplet();
|
|
|
|
if ((Qsig_rev_temperature == NULL) && (Qsig_rev == (-ConstMath::trespetit)))
|
|
{ cout << " \n le coefficient Qsig_rev de la loi Maheo_hyper n'est pas defini pour la loi "
|
|
<< Nom_comp(id_comp)
|
|
<< '\n' << endl;
|
|
ret = 0;
|
|
};
|
|
if ((mu1_rev_temperature == NULL) && (mu1_rev == (-ConstMath::trespetit)))
|
|
{ cout << " \n le coefficient mu1_rev de la loi Maheo_hyper n'est pas defini pour la loi "
|
|
<< Nom_comp(id_comp)
|
|
<< '\n' << endl;
|
|
ret = 0;
|
|
};
|
|
if ((mu2_rev_temperature == NULL) && (mu2_rev == (-ConstMath::trespetit)))
|
|
{ cout << " \n le coefficient mu2_rev de la loi Maheo_hyper n'est pas defini pour la loi "
|
|
<< Nom_comp(id_comp)
|
|
<< '\n' << endl;
|
|
ret = 0;
|
|
};
|
|
//
|
|
if (ret == 0)
|
|
{this-> Affiche();
|
|
ret = 0;
|
|
};
|
|
return ret;
|
|
};
|
|
|
|
//----- lecture écriture de restart -----
|
|
|
|
// cas donne le niveau de la récupération
|
|
// = 1 : on récupère tout
|
|
// = 2 : on récupère uniquement les données variables (supposées comme telles)
|
|
void Maheo_hyper::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
|
|
,LesFonctions_nD& lesFonctionsnD)
|
|
{ string nom; bool test;
|
|
if (cas == 1)
|
|
{ // === Qsig_rev
|
|
ent >> nom >> test;
|
|
// vérification
|
|
#ifdef MISE_AU_POINT
|
|
if (nom != "Qsig_rev")
|
|
{ cout << "\n erreur en lecture du parametres Qsig_rev de la loi de mooney rivlin 3D"
|
|
<< " on devait lire Qsig_rev= avant le second parametre "
|
|
<< " et on a lue: " << nom << " "
|
|
<< "\n Maheo_hyper::Lecture_base_info_loi(..."
|
|
<< endl;
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
if (!test)
|
|
{ ent >> Qsig_rev;
|
|
if (Qsig_rev_temperature != NULL) {if (Qsig_rev_temperature->NomCourbe() == "_")
|
|
delete Qsig_rev_temperature; Qsig_rev_temperature = NULL;};
|
|
}
|
|
else
|
|
{ ent >> nom; Qsig_rev_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,Qsig_rev_temperature); };
|
|
// on regarde si il y a une fonction nD multiplicative
|
|
ent >> nom;
|
|
if (nom == "Qsig_nD:")
|
|
Qsig_nD = lesFonctionsnD.Lecture_pour_base_info(ent,cas,Qsig_nD);
|
|
|
|
// === mu1_rev
|
|
ent >> nom >> test;
|
|
// vérification
|
|
#ifdef MISE_AU_POINT
|
|
if (nom != "mu1_rev")
|
|
{ cout << "\n erreur en lecture du parametres mu1_rev de la loi de mooney rivlin 3D"
|
|
<< " on devait lire mu1_rev= avant le second parametre "
|
|
<< " et on a lue: " << nom << " "
|
|
<< "\n Maheo_hyper::Lecture_base_info_loi(..."
|
|
<< endl;
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
if (!test)
|
|
{ ent >> mu1_rev;
|
|
if (mu1_rev_temperature != NULL) {if (mu1_rev_temperature->NomCourbe() == "_")
|
|
delete mu1_rev_temperature; mu1_rev_temperature = NULL;};
|
|
}
|
|
else
|
|
{ ent >> nom; mu1_rev_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,mu1_rev_temperature); };
|
|
// on regarde si il y a une fonction nD multiplicative
|
|
ent >> nom;
|
|
if (nom == "mu1_nD:")
|
|
mu1_nD = lesFonctionsnD.Lecture_pour_base_info(ent,cas,mu1_nD);
|
|
|
|
// === mu2_rev
|
|
ent >> nom >> test;
|
|
// vérification
|
|
#ifdef MISE_AU_POINT
|
|
if (nom != "mu2_rev")
|
|
{ cout << "\n erreur en lecture du parametres mu2_rev de la loi de mooney rivlin 3D"
|
|
<< " on devait lire mu2_rev= avant le second parametre "
|
|
<< " et on a lue: " << nom << " "
|
|
<< "\n Maheo_hyper::Lecture_base_info_loi(..."
|
|
<< endl;
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
if (!test)
|
|
{ ent >> mu2_rev;
|
|
if (mu2_rev_temperature != NULL) {if (mu2_rev_temperature->NomCourbe() == "_")
|
|
delete mu2_rev_temperature; mu2_rev_temperature = NULL;};
|
|
}
|
|
else
|
|
{ ent >> nom; mu2_rev_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,mu2_rev_temperature); };
|
|
// on regarde si il y a une fonction nD multiplicative
|
|
ent >> nom;
|
|
if (nom == "mu2_nD:")
|
|
mu2_nD = lesFonctionsnD.Lecture_pour_base_info(ent,cas,mu2_nD);
|
|
};
|
|
// 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 Maheo_hyper::Ecriture_base_info_loi(ofstream& sort,const int cas)
|
|
{ if (cas == 1)
|
|
{ // Qsig_rev
|
|
sort << " Qsig_rev= ";
|
|
if (Qsig_rev_temperature == NULL)
|
|
{ sort << false << " " << Qsig_rev << " ";}
|
|
else
|
|
{ sort << true << " fonction_Qsig_rev_temperature ";
|
|
LesCourbes1D::Ecriture_pour_base_info(sort,cas,Qsig_rev_temperature);
|
|
};
|
|
if (Qsig_nD != NULL)
|
|
{sort << " Qsig_nD: " << " ";
|
|
LesFonctions_nD::Ecriture_pour_base_info(sort, cas,Qsig_nD);
|
|
}
|
|
else {sort << " non_Qsig_nD "; };
|
|
|
|
// mu1_rev
|
|
sort << " mu1_rev= ";
|
|
if (mu1_rev_temperature == NULL)
|
|
{ sort << false << " " << mu1_rev << " ";}
|
|
else
|
|
{ sort << true << " fonction_mu1_rev_temperature ";
|
|
LesCourbes1D::Ecriture_pour_base_info(sort,cas,mu1_rev_temperature);
|
|
};
|
|
if (mu1_nD != NULL)
|
|
{sort << " 2 mu1_nD: " << " ";
|
|
LesFonctions_nD::Ecriture_pour_base_info(sort, cas,mu1_nD);
|
|
}
|
|
else {sort << " non_mu1_nD "; };
|
|
|
|
// mu2_rev
|
|
sort << " mu2_rev= ";
|
|
if (mu2_rev_temperature == NULL)
|
|
{ sort << false << " " << mu2_rev << " ";}
|
|
else
|
|
{ sort << true << " fonction_mu2_rev_temperature ";
|
|
LesCourbes1D::Ecriture_pour_base_info(sort,cas,mu2_rev_temperature);
|
|
};
|
|
if (mu2_nD != NULL)
|
|
{sort << " 2 mu1_nD: " << " ";
|
|
LesFonctions_nD::Ecriture_pour_base_info(sort, cas,mu1_nD);
|
|
}
|
|
else {sort << " non_mu2_nD "; };
|
|
};
|
|
// 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 l'instant à faire !!
|
|
double Maheo_hyper::Module_young_equivalent(Enum_dure temps,const Deformation & ,SaveResul * )
|
|
{// comme la loi n'a pas de partie volumique, le module d'Young équivalent est nul
|
|
return 0.;
|
|
};
|
|
|
|
// calcul d'un module compressibilité équivalent à la loi:
|
|
double Maheo_hyper::Module_compressibilite_equivalent(Enum_dure temps,const Deformation & ,SaveResul * )
|
|
{// comme la loi n'a pas de partie volumique, le module de compressibilité est nul
|
|
return 0.;
|
|
};
|
|
|
|
// ========== codage des METHODES VIRTUELLES protegees:================
|
|
// calcul des contraintes a t+dt
|
|
void Maheo_hyper::Calcul_SigmaHH (TenseurHH& ,TenseurBB& ,DdlElement & tab_ddl,
|
|
TenseurBB & ,TenseurHH & ,BaseB& ,BaseH& ,TenseurBB & epsBB_,
|
|
TenseurBB & ,
|
|
TenseurBB & gijBB_,TenseurHH & gijHH_,Tableau <TenseurBB *>& d_gijBB_,
|
|
double& jacobien_0,double& jacobien,TenseurHH & sigHH_
|
|
,EnergieMeca & energ,const EnergieMeca & ,double& module_compressibilite,double& module_cisaillement
|
|
,const Met_abstraite::Expli_t_tdt& ex)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if (epsBB_.Dimension() != 3)
|
|
{ cout << "\nErreur : la dimension devrait etre 3 !\n";
|
|
cout << " Maheo_hyper::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 << " Maheo_hyper::Calcul_SigmaHH\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
Tenseur3HH & sigHH = *((Tenseur3HH*) &sigHH_); // passage explicite en tenseur dim 3
|
|
|
|
// init coef matériaux
|
|
Qsig_use = Qsig_rev;
|
|
mu1_use = mu1_rev;
|
|
mu2_use = mu2_rev;
|
|
|
|
// cas de la thermo dépendance, on calcul les grandeurs
|
|
if (Qsig_rev_temperature != NULL) Qsig_use = Qsig_rev_temperature->Valeur(*temperature);
|
|
if (mu1_rev_temperature != NULL) mu1_use = mu1_rev_temperature->Valeur(*temperature);
|
|
if (mu2_rev_temperature != NULL) mu2_use = mu2_rev_temperature->Valeur(*temperature);
|
|
|
|
// récup du conteneur spécifique du point, pour sauvegarde éventuelle
|
|
SaveResulHyper_W_gene_3D & save_resulHyper_W = *((SaveResulHyper_W_gene_3D*) saveResul);
|
|
// dans le cas de l'utilisation de fct nD
|
|
if ( (Qsig_nD != NULL) || (mu1_nD != NULL)
|
|
|| (mu2_nD != NULL)
|
|
)
|
|
{ // 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;
|
|
if (Qsig_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
|
|
(Qsig_nD,1 // une seule valeur attendue en retour
|
|
,ex_impli,ex_expli_tdt,ex_expli
|
|
,NULL
|
|
,NULL
|
|
,&list_save
|
|
);
|
|
// on récupère le premier élément du tableau uniquement
|
|
Qsig_use *= tab_val(1);
|
|
};
|
|
if (mu1_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
|
|
(mu1_nD,1 // une seule valeur attendue en retour
|
|
,ex_impli,ex_expli_tdt,ex_expli
|
|
,NULL
|
|
,NULL
|
|
,&list_save
|
|
);
|
|
// on récupère le premier élément du tableau uniquement
|
|
mu1_use *= tab_val(1);
|
|
};
|
|
if (mu2_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
|
|
(mu2_nD,1 // une seule valeur attendue en retour
|
|
,ex_impli,ex_expli_tdt,ex_expli
|
|
,NULL
|
|
,NULL
|
|
,&list_save
|
|
);
|
|
// on récupère le premier élément du tableau uniquement
|
|
mu2_use *= tab_val(1);
|
|
};
|
|
};
|
|
if (sortie_post)
|
|
{// sauvegarde des paramètres matériau
|
|
(*save_resulHyper_W.para_loi)(1) = Qsig_use;
|
|
(*save_resulHyper_W.para_loi)(2) = mu1_use;
|
|
(*save_resulHyper_W.para_loi)(3) = mu2_use;
|
|
};
|
|
|
|
// calcul des invariants et de leurs variations premières (méthode de Hyper_W_gene_3D)
|
|
Invariants_et_var1(*(ex.gijBB_0),*(ex.gijHH_0),gijBB_,gijHH_,jacobien_0,jacobien);
|
|
// calcul du potentiel et de ses dérivées premières / aux invariants J_r
|
|
Potentiel_et_var();
|
|
// stockage éventuel pour du post-traitement
|
|
if (sortie_post)
|
|
{ save_resulHyper_W.invP->potentiel= W_d + W_v;
|
|
};
|
|
|
|
// calcul du tenseur des contraintes: on tiend compte du fait que le potentiel ne dépend que de J1
|
|
sigHH = (W_d_J1/V) * d_J_r_epsBB_HH(1);
|
|
// sigHH = (W_d_J1/V) * d_J_r_epsBB_HH(1) + (W_d_J2/V) * d_J_r_epsBB_HH(2)
|
|
// + (W_v_J3/V) * d_J_r_epsBB_HH(3);
|
|
|
|
// calcul du module de compressibilité
|
|
module_compressibilite = 2. * W_v_J3; // ici 0
|
|
// pour le module de cisaillement, pour l'instant je ne fais rien !! à voir ***
|
|
module_cisaillement = 0.;
|
|
|
|
// traitement des énergies
|
|
energ.Inita(0.);
|
|
energ.ChangeEnergieElastique((W_d)/V);
|
|
// energ.ChangeEnergieElastique((W_d+W_v)/V);
|
|
|
|
LibereTenseur();
|
|
};
|
|
|
|
// calcul des contraintes a t+dt et de ses variations
|
|
void Maheo_hyper::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 & gijBB_tdt,TenseurHH & gijHH_tdt_
|
|
,Tableau <TenseurBB *>& d_gijBB_tdt
|
|
,Tableau <TenseurHH *>& ,double& jacobien_0,double& jacobien
|
|
,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 (epsBB_tdt.Dimension() != 3)
|
|
{ cout << "\nErreur : la dimension devrait etre 3 !\n";
|
|
cout << " Maheo_hyper::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 << " Maheo_hyper::Calcul_SDsigmaHH_tdt\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
Tenseur3HH & sigHH = *((Tenseur3HH*) &sigHH_tdt); // passage en dim 3 explicite
|
|
Tenseur3HH & gijHH_tdt = *((Tenseur3HH*) &gijHH_tdt_); // passage en dim 3 explicite
|
|
|
|
// init coef matériaux
|
|
Qsig_use = Qsig_rev;
|
|
mu1_use = mu1_rev;
|
|
mu2_use = mu2_rev;
|
|
|
|
|
|
// cas de la thermo dépendance, on calcul les grandeurs
|
|
if (Qsig_rev_temperature != NULL) Qsig_use = Qsig_rev_temperature->Valeur(*temperature);
|
|
if (mu1_rev_temperature != NULL) mu1_use = mu1_rev_temperature->Valeur(*temperature);
|
|
if (mu2_rev_temperature != NULL) mu2_use = mu2_rev_temperature->Valeur(*temperature);
|
|
|
|
// récup du conteneur spécifique du point, pour sauvegarde éventuelle
|
|
SaveResulHyper_W_gene_3D & save_resulHyper_W = *((SaveResulHyper_W_gene_3D*) saveResul);
|
|
// dans le cas de l'utilisation de fct nD
|
|
if ( (Qsig_nD != NULL) || (mu1_nD != NULL)
|
|
|| (mu2_nD != NULL)
|
|
)
|
|
{ // 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;
|
|
if (Qsig_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
|
|
(Qsig_nD,1 // une seule valeur attendue en retour
|
|
,ex_impli,ex_expli_tdt,ex_expli
|
|
,NULL
|
|
,NULL
|
|
,&list_save
|
|
);
|
|
// on récupère le premier élément du tableau uniquement
|
|
Qsig_use *= tab_val(1);
|
|
};
|
|
if (mu1_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
|
|
(mu1_nD,1 // une seule valeur attendue en retour
|
|
,ex_impli,ex_expli_tdt,ex_expli
|
|
,NULL
|
|
,NULL
|
|
,&list_save
|
|
);
|
|
// on récupère le premier élément du tableau uniquement
|
|
mu1_use *= tab_val(1);
|
|
};
|
|
if (mu2_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
|
|
(mu2_nD,1 // une seule valeur attendue en retour
|
|
,ex_impli,ex_expli_tdt,ex_expli
|
|
,NULL
|
|
,NULL
|
|
,&list_save
|
|
);
|
|
// on récupère le premier élément du tableau uniquement
|
|
mu2_use *= tab_val(1);
|
|
};
|
|
};
|
|
if (sortie_post)
|
|
{// sauvegarde des paramètres matériau
|
|
(*save_resulHyper_W.para_loi)(1) = Qsig_use;
|
|
(*save_resulHyper_W.para_loi)(2) = mu1_use;
|
|
(*save_resulHyper_W.para_loi)(3) = mu2_use;
|
|
};
|
|
|
|
// calcul des invariants et de leurs variations premières et secondes
|
|
Invariants_et_var2(*(ex.gijBB_0),*(ex.gijHH_0),gijBB_tdt,gijHH_tdt,jacobien_0,jacobien);
|
|
// calcul du potentiel et de ses dérivées premières et secondes / aux invariants J_r
|
|
Potentiel_et_var2();
|
|
// stockage éventuel pour du post-traitement
|
|
if (sortie_post)
|
|
{ // récup du conteneur spécifique du point, pour sauvegarde éventuelle
|
|
SaveResulHyper_W_gene_3D & save_resulHyper_W = *((SaveResulHyper_W_gene_3D*) saveResul);
|
|
save_resulHyper_W.invP->potentiel= W_d + W_v;
|
|
};
|
|
// calcul du tenseur des contraintes: on tiend compte du fait que le potentiel ne dépend que de J1
|
|
double unSurV=1./V;
|
|
sigHH = (W_d_J1*unSurV) * d_J_r_epsBB_HH(1);
|
|
// sigHH = (W_d_J1*unSurV) * d_J_r_epsBB_HH(1) + (W_d_J2*unSurV) * d_J_r_epsBB_HH(2)
|
|
// + (W_v_J3*unSurV) * d_J_r_epsBB_HH(3);
|
|
// cout << "\n sigHH " << sigHH
|
|
// << "\n d_J_r_epsBB_HH1 " << d_J_r_epsBB_HH(1)
|
|
// << "\n d_J_r_epsBB_HH2 " << d_J_r_epsBB_HH(2)
|
|
// << "\n d_J_r_epsBB_HH3 " << d_J_r_epsBB_HH(3)
|
|
// << "\n (W_d_J1*unSurV) " << (W_d_J1*unSurV)
|
|
// << " (W_d_J2*unSurV) " << (W_d_J2*unSurV)
|
|
// << " (W_d_J3*unSurV) " << (W_v_J3*unSurV);
|
|
|
|
|
|
// calcul de la variation seconde du potentiel par rapport à epsij epskl
|
|
// on tiend compte du fait que le potentiel ne dépend que de J1
|
|
Tenseur3HHHH d2W_d2epsHHHH
|
|
= // tout d'abord les dérivées secondes du potentiel déviatoire
|
|
W_d_J1_2 * Tenseur3HHHH::Prod_tensoriel(d_J_r_epsBB_HH(1),d_J_r_epsBB_HH(1))
|
|
// puis les dérivées premières du potentiel déviatoire
|
|
+ W_d_J1 * d_J_1_eps2BB_HHHH;
|
|
// = // tout d'abord les dérivées secondes du potentiel déviatoire
|
|
// W_d_J1_2 * Tenseur3HHHH::Prod_tensoriel(d_J_r_epsBB_HH(1),d_J_r_epsBB_HH(1))
|
|
// + W_d_J1_J2 * Tenseur3HHHH::Prod_tensoriel(d_J_r_epsBB_HH(1),d_J_r_epsBB_HH(2))
|
|
// + W_d_J2_2 * Tenseur3HHHH::Prod_tensoriel(d_J_r_epsBB_HH(2),d_J_r_epsBB_HH(2))
|
|
// // puis les dérivées premières du potentiel déviatoire
|
|
// + W_d_J1 * d_J_1_eps2BB_HHHH + W_d_J2 * d_J_2_eps2BB_HHHH
|
|
// // enfin les dérivées seconde et première du potentiel sphérique
|
|
// + W_v_J3 * d_J_3_eps2BB_HHHH
|
|
// + W_v_J3J3 * Tenseur3HHHH::Prod_tensoriel(d_J_r_epsBB_HH(3),d_J_r_epsBB_HH(3));
|
|
|
|
// calcul de la variation du tenseur des contraintes par rapports aux déformations
|
|
// on tient compte du fait que V*sigHH = d W/ d epsij
|
|
Tenseur3HH interHH = -sigHH ; //* (-0.5*unSurV*unSurV);
|
|
|
|
// Tenseur3HHHH dSigdepsHHHH(1,interHH,d_J_r_epsBB_HH(3));
|
|
Tenseur3HHHH dSigdepsHHHH(1,interHH,gijHH_tdt);
|
|
// dSigdepsHHHH += (unSurV) * d2W_d2epsHHHH;
|
|
|
|
Tenseur3HHHH interHHHH((unSurV) * d2W_d2epsHHHH); // cas des tenseurs généraux
|
|
dSigdepsHHHH += interHHHH; // cas des tenseurs généraux
|
|
|
|
//---------------------------------------------------------------------------------
|
|
// vérif numérique de l'opérateur tangent
|
|
// Cal_dsigma_deps_num (*(ex.gijBB_0),*(ex.gijHH_0),gijBB_tdt,gijHH_tdt,jacobien_0,jacobien,dSigdepsHHHH);
|
|
//---------------------------------------------------------------------------------
|
|
|
|
// calcul des variations / aux ddl
|
|
int nbddl = d_gijBB_tdt.Taille();
|
|
for (int i = 1; i<= nbddl; i++)
|
|
{ // on fait uniquement une égalité d'adresse et de ne pas utiliser
|
|
// le constructeur d'ou la profusion d'* et de ()
|
|
Tenseur3HH & dsigHH = *((Tenseur3HH*) (d_sigHH(i))); // passage en dim 3
|
|
const Tenseur3BB & depsBB = *((Tenseur3BB *) (d_epsBB(i))); // "
|
|
dsigHH = dSigdepsHHHH && depsBB;
|
|
};
|
|
|
|
// calcul du module de compressibilité
|
|
module_compressibilite = 2. * W_v_J3;// ici 0
|
|
// pour le module de cisaillement, pour l'instant je ne fais rien !! à voir ***
|
|
module_cisaillement = 0.;
|
|
|
|
// traitement des énergies
|
|
energ.Inita(0.);
|
|
energ.ChangeEnergieElastique((W_d+W_v)/V);
|
|
|
|
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 Maheo_hyper::Calcul_dsigma_deps (bool en_base_orthonormee, TenseurHH & ,TenseurBB&
|
|
,TenseurBB & epsBB_tdt,TenseurBB &, double& jacobien_0,double& jacobien
|
|
,TenseurHH& sigHH_tdt,TenseurHHHH& d_sigma_deps_
|
|
,EnergieMeca & energ,const EnergieMeca & ,double& module_compressibilite,double& module_cisaillement
|
|
,const Met_abstraite::Umat_cont& ex )
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if (epsBB_tdt.Dimension() != 3)
|
|
{ cout << "\nErreur : la dimension devrait etre 3 !\n";
|
|
cout << " Maheo_hyper::Calcul_dsigma_deps\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
Tenseur3HH & sigHH = *((Tenseur3HH*) &sigHH_tdt); // // passage en dim 3 explicite
|
|
Tenseur3HH & gijHH_tdt = *((Tenseur3HH*) ex.gijHH_tdt); // passage en dim 3 explicite
|
|
|
|
// init coef matériaux
|
|
Qsig_use = Qsig_rev;
|
|
mu1_use = mu1_rev;
|
|
mu2_use = mu2_rev;
|
|
|
|
// cas de la thermo dépendance, on calcul les grandeurs
|
|
if (Qsig_rev_temperature != NULL) Qsig_use = Qsig_rev_temperature->Valeur(*temperature);
|
|
if (mu1_rev_temperature != NULL) mu1_use = mu1_rev_temperature->Valeur(*temperature);
|
|
if (mu2_rev_temperature != NULL) mu2_use = mu2_rev_temperature->Valeur(*temperature);
|
|
|
|
// récup du conteneur spécifique du point, pour sauvegarde éventuelle
|
|
SaveResulHyper_W_gene_3D & save_resulHyper_W = *((SaveResulHyper_W_gene_3D*) saveResul);
|
|
// dans le cas de l'utilisation de fct nD
|
|
if ( (Qsig_nD != NULL) || (mu1_nD != NULL)
|
|
|| (mu2_nD != NULL)
|
|
)
|
|
{ // opération de transmission de la métrique
|
|
const Met_abstraite::Impli* ex_impli = NULL;
|
|
const Met_abstraite::Expli_t_tdt* ex_expli_tdt = NULL;
|
|
const Met_abstraite::Umat_cont* ex_expli = &ex;
|
|
if (Qsig_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
|
|
(Qsig_nD,1 // une seule valeur attendue en retour
|
|
,ex_impli,ex_expli_tdt,ex_expli
|
|
,NULL
|
|
,NULL
|
|
,&list_save
|
|
);
|
|
// on récupère le premier élément du tableau uniquement
|
|
Qsig_use *= tab_val(1);
|
|
};
|
|
if (mu1_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
|
|
(mu1_nD,1 // une seule valeur attendue en retour
|
|
,ex_impli,ex_expli_tdt,ex_expli
|
|
,NULL
|
|
,NULL
|
|
,&list_save
|
|
);
|
|
// on récupère le premier élément du tableau uniquement
|
|
mu1_use *= tab_val(1);
|
|
};
|
|
if (mu2_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
|
|
(mu2_nD,1 // une seule valeur attendue en retour
|
|
,ex_impli,ex_expli_tdt,ex_expli
|
|
,NULL
|
|
,NULL
|
|
,&list_save
|
|
);
|
|
// on récupère le premier élément du tableau uniquement
|
|
mu2_use *= tab_val(1);
|
|
};
|
|
};
|
|
if (sortie_post)
|
|
{// sauvegarde des paramètres matériau
|
|
(*save_resulHyper_W.para_loi)(1) = Qsig_use;
|
|
(*save_resulHyper_W.para_loi)(2) = mu1_use;
|
|
(*save_resulHyper_W.para_loi)(3) = mu2_use;
|
|
};
|
|
|
|
// calcul des invariants et de leurs variations premières et secondes
|
|
Invariants_et_var2(*(ex.gijBB_0),*(ex.gijHH_0),*(ex.gijBB_tdt),gijHH_tdt,jacobien_0,jacobien);
|
|
// calcul du potentiel et de ses dérivées premières et secondes / aux invariants J_r
|
|
Potentiel_et_var2();
|
|
// stockage éventuel pour du post-traitement
|
|
if (sortie_post)
|
|
{ // récup du conteneur spécifique du point, pour sauvegarde éventuelle
|
|
SaveResulHyper_W_gene_3D & save_resulHyper_W = *((SaveResulHyper_W_gene_3D*) saveResul);
|
|
save_resulHyper_W.invP->potentiel= W_d + W_v;
|
|
};
|
|
// calcul du tenseur des contraintes, on travaille ici dans le repère matériel finale correspondant
|
|
// aux coordonnées initiales X_(0)^a, on obtient donc un tenseur dans la base naturelle finale
|
|
double unSurV=1./V;
|
|
// on tiend compte du fait que le potentiel ne dépend que de J1
|
|
Tenseur3HH sig_localeHH = (W_d_J1*unSurV) * d_J_r_epsBB_HH(1);
|
|
// Tenseur3HH sig_localeHH = (W_d_J1*unSurV) * d_J_r_epsBB_HH(1) + (W_d_J2*unSurV) * d_J_r_epsBB_HH(2)
|
|
// + (W_v_J3*unSurV) * d_J_r_epsBB_HH(3);
|
|
// passage éventuelle dans la base I_a
|
|
if (en_base_orthonormee)
|
|
{sig_localeHH.BaseAbsolue(sigHH,*(ex.giB_tdt));}
|
|
else {sigHH = sig_localeHH;}; // sinon la base locale est la bonne
|
|
|
|
// calcul de la variation seconde du potentiel par rapport à epsij epskl
|
|
// on tiend compte du fait que le potentiel ne dépend que de J1
|
|
Tenseur3HHHH d2W_d2epsHHHH
|
|
= // tout d'abord les dérivées secondes du potentiel déviatoire
|
|
W_d_J1_2 * Tenseur3HHHH::Prod_tensoriel(d_J_r_epsBB_HH(1),d_J_r_epsBB_HH(1))
|
|
// puis les dérivées premières du potentiel déviatoire
|
|
+ W_d_J1 * d_J_1_eps2BB_HHHH;
|
|
// = // tout d'abord les dérivées secondes du potentiel déviatoire
|
|
// W_d_J1_2 * Tenseur3HHHH::Prod_tensoriel(d_J_r_epsBB_HH(1),d_J_r_epsBB_HH(1))
|
|
// + W_d_J1_J2 * Tenseur3HHHH::Prod_tensoriel(d_J_r_epsBB_HH(1),d_J_r_epsBB_HH(2))
|
|
// + W_d_J2_2 * Tenseur3HHHH::Prod_tensoriel(d_J_r_epsBB_HH(2),d_J_r_epsBB_HH(2))
|
|
// // puis les dérivées premières du potentiel déviatoire
|
|
// + W_d_J1 * d_J_1_eps2BB_HHHH + W_d_J2 * d_J_2_eps2BB_HHHH
|
|
// // enfin les dérivées seconde et première du potentiel sphérique
|
|
// + W_v_J3 * d_J_3_eps2BB_HHHH
|
|
// + W_v_J3J3 * Tenseur3HHHH::Prod_tensoriel(d_J_r_epsBB_HH(3),d_J_r_epsBB_HH(3));
|
|
|
|
// calcul de la variation du tenseur des contraintes par rapports aux déformations
|
|
// on tient compte du fait que V*sigHH = d W/ d epsij
|
|
Tenseur3HH interHH = -sig_localeHH ; //* (-0.5*unSurV*unSurV);
|
|
|
|
// calcul de la variation du tenseur des contraintes par rapports aux déformations
|
|
// on tient compte du fait que V*sigHH = d W/ d epsij
|
|
Tenseur3HHHH dSigdepsHHHH(1,interHH,gijHH_tdt);
|
|
// dSigdepsHHHH += (unSurV) * d2W_d2epsHHHH;
|
|
|
|
Tenseur3HHHH interHHHH((unSurV) * d2W_d2epsHHHH); // cas des tenseurs généraux
|
|
dSigdepsHHHH += interHHHH; // cas des tenseurs généraux
|
|
|
|
// transfert des informations: on pas d'un tenseur de 81 composantes à 36
|
|
// avec des symétries par rapport aux deux premiers indices et par rapport aux deux derniers
|
|
/// Tenseur3HHHH d_sigma_depsHHHH; d_sigma_depsHHHH.TransfertDunTenseurGeneral(dSigdepsHHHH.Symetrise1et2_3et4());
|
|
// calcul de la première partie de l'opérateur tangent (correspond au changement de repère
|
|
// gi_tdt -> Ia de l'opérateur calculer précédemment
|
|
Tenseur3HHHH & d_sigma_depsFinHHHH = *((Tenseur3HHHH*) &d_sigma_deps_); // pour accés directe
|
|
// passage éventuelle dans la base I_a
|
|
if (en_base_orthonormee)
|
|
{dSigdepsHHHH.ChangeBase(d_sigma_depsFinHHHH,*(ex.giB_tdt));}
|
|
else
|
|
{d_sigma_depsFinHHHH = dSigdepsHHHH;};
|
|
|
|
// traitement des énergies
|
|
energ.Inita(0.);
|
|
energ.ChangeEnergieElastique((W_d)/V);
|
|
// energ.ChangeEnergieElastique((W_d+W_v)/V);
|
|
|
|
LibereTenseur();
|
|
LibereTenseurQ();
|
|
|
|
};
|
|
|
|
//---------------------- méthodes privées -------------------------------
|
|
// calcul du potentiel et de ses dérivées premières / aux invariants J_r
|
|
void Maheo_hyper::Potentiel_et_var()
|
|
{ // calcul de grandeurs intermédiaires
|
|
#ifdef MISE_AU_POINT
|
|
if ((J_r(1)-3.) < 0.)
|
|
{ cout << "\nErreur : (J_r(1)-3.)= "<<(J_r(1)-3.) <<" est < 0. !"
|
|
<< " ce n'est pas possible avec les formules actuelles ";
|
|
cout << "\n Maheo_hyper::Calcul_dsigma_deps\n";
|
|
Sortie(1);
|
|
};
|
|
if ((mu1_use/Qsig_use) < 0.)
|
|
{ cout << "\nErreur : mu1_rev/Qsig_rev= "<<mu1_use/Qsig_use <<" est < 0. !"
|
|
<< " ce n'est pas possible avec les formules actuelles ";
|
|
cout << "\n Maheo_hyper::Calcul_dsigma_deps\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
double J_r1moins3 = DabsMaX(J_r(1)-3.,0.); // aux arondis près on peut avoir un pb de 0.
|
|
double racineIBmoins3 = sqrt(J_r1moins3);
|
|
double mu1SurQsigfoisracineIBmoins3 = mu1_use/Qsig_use*racineIBmoins3;
|
|
double tanh_mu1Sur_etc = tanh(mu1SurQsigfoisracineIBmoins3);
|
|
|
|
// le potentiel
|
|
W_d= Qsig_use*Qsig_use*log(cosh(mu1SurQsigfoisracineIBmoins3))+mu2_use*J_r1moins3;
|
|
// variation / J1
|
|
W_d_J1 = Qsig_use/(2.*(fact_regularisation+racineIBmoins3))
|
|
* tanh_mu1Sur_etc + mu2_use ;
|
|
// variation / J2
|
|
W_d_J2 = 0.;
|
|
// et / à V et J3
|
|
W_v = 0.; // potentiel volumique
|
|
W_v_J3 = 0.; // variation / J3
|
|
};
|
|
|
|
// calcul du potentiel et de ses dérivées premières et secondes / aux invariants J_r
|
|
void Maheo_hyper::Potentiel_et_var2()
|
|
{ // calcul de grandeurs intermédiaires
|
|
#ifdef MISE_AU_POINT
|
|
if ((J_r(1)-3.) < -ConstMath::petit)
|
|
{ cout << "\nErreur : (J_r(1)-3.)= "<<(J_r(1)-3.) <<" est < 0. !"
|
|
<< " ce n'est pas possible avec les formules actuelles ";
|
|
cout << "\n Maheo_hyper::Calcul_dsigma_deps\n";
|
|
Sortie(1);
|
|
};
|
|
if ((mu1_use/Qsig_use) < -ConstMath::petit)
|
|
{ cout << "\nErreur : mu1_rev/Qsig_rev= "<<mu1_use/Qsig_use <<" est < 0. !"
|
|
<< " ce n'est pas possible avec les formules actuelles ";
|
|
cout << "\n Maheo_hyper::Calcul_dsigma_deps\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
double J_r1moins3 = DabsMaX(J_r(1)-3.,0.); // aux arondis près on peut avoir un pb de 0.
|
|
double racineIBmoins3 = sqrt(J_r1moins3);
|
|
double mu1SurQsigfoisracineIBmoins3 = mu1_use * racineIBmoins3 /Qsig_use;
|
|
double tanh_mu1Sur_etc = tanh(mu1SurQsigfoisracineIBmoins3);
|
|
|
|
// le potentiel
|
|
W_d= Qsig_use*Qsig_use*log(cosh(mu1SurQsigfoisracineIBmoins3))+mu2_use*J_r1moins3;
|
|
// variation / J1
|
|
W_d_J1 = Qsig_use/(2.*(fact_regularisation+racineIBmoins3))
|
|
* tanh_mu1Sur_etc + mu2_use ;
|
|
// variation seconde / J1
|
|
W_d_J1_2 = -Qsig_use*0.25*exp(-1.5*log(J_r1moins3+fact_regularisation))*tanh_mu1Sur_etc
|
|
+ mu1_use * 0.25 / (fact_regularisation+J_r1moins3) * (1.-tanh_mu1Sur_etc * tanh_mu1Sur_etc);
|
|
|
|
W_d_J2 = 0.; // variation / J2
|
|
W_d_J1_J2 = W_d_J2_2 = 0.; // dérivées secondes
|
|
|
|
// et / à V et J3
|
|
W_v = 0.; // potentiel volumique
|
|
W_v_J3 = 0.; // variation / J3
|
|
W_v_J3J3 = 0.; // et der seconde
|
|
|
|
// cout << "\n Jr= " << J_r(1) << " " << J_r(2) << " " << J_r(3) << " pot " << W_d << " " << W_v ;
|
|
};
|
|
|
|
|
|
// calcul de la dérivée numérique de la contrainte
|
|
void Maheo_hyper::Cal_dsigma_deps_num (const TenseurBB & gijBB_0_,const TenseurHH & gijHH_0_
|
|
,const TenseurBB & gijBB_tdt_,const TenseurHH & gijHH_tdt_
|
|
,const double& jacobien_0,const double& jacobien
|
|
,Tenseur3HHHH& dSigdepsHHHH)
|
|
|
|
|
|
{ const Tenseur3BB & gijBB_0 = *((Tenseur3BB*) &gijBB_0_); // passage en dim 3 explicit
|
|
const Tenseur3BB & gijBB_tdt = *((Tenseur3BB*) &gijBB_tdt_); // "
|
|
const Tenseur3HH & gijHH_0 = *((Tenseur3HH*) &gijHH_0_); // "
|
|
const Tenseur3HH & gijHH_tdt = *((Tenseur3HH*) &gijHH_tdt_); // "
|
|
|
|
Tenseur3BB gijBBtdt_N; // tenseur modifié
|
|
Tenseur3HH gijHHtdt_N; // idem_0
|
|
double delta = ConstMath::unpeupetit*10.;
|
|
double unSurDelta = 1./delta;
|
|
|
|
// init coef matériaux
|
|
Qsig_use = Qsig_rev;
|
|
mu1_use = mu1_rev;
|
|
mu2_use = mu2_rev;
|
|
|
|
// cas de la thermo dépendance, on calcul les grandeurs
|
|
if (Qsig_rev_temperature != NULL) Qsig_use = Qsig_rev_temperature->Valeur(*temperature);
|
|
if (mu1_rev_temperature != NULL) mu1_use = mu1_rev_temperature->Valeur(*temperature);
|
|
if (mu2_rev_temperature != NULL) mu2_use = mu2_rev_temperature->Valeur(*temperature);
|
|
|
|
// cas des contraintes et de ses variations analytiques
|
|
// Tenseur3HHHH dSigdepsHHHH; // le tenseur contenant les dérivées analytiques
|
|
Tenseur3HH SigmaHH_deb;
|
|
Cal_sigmaEtDer_pour_num(gijBB_0_,gijHH_0_,gijBB_tdt_,gijHH_tdt_
|
|
,jacobien_0,jacobien,SigmaHH_deb,dSigdepsHHHH);
|
|
// dimensionnement pour la matrice numérique
|
|
Tenseur3HHHH dSigdepsHHHH_num;
|
|
|
|
// on va boucler sur les composantes de gijBB
|
|
for (int i=1;i<=3;i++)
|
|
for (int j=1;j<=3;j++)
|
|
{ gijBBtdt_N = gijBB_tdt;
|
|
gijBBtdt_N.Coor(i,j) += delta;
|
|
// en fait dans l'opération précédente on a modifier les termes (i,j) et (j,i)
|
|
// car le tenseur est symétrique
|
|
// on a donc en variation numérique la somme des deux dérivées
|
|
// on définit un coeff multiplicatif qui vaut 1 ou 0.5
|
|
double coef=1.; if (i != j) coef = 0.5;
|
|
gijHHtdt_N = gijBBtdt_N.Inverse();
|
|
double jacobien_N=sqrt(gijBBtdt_N.Det());
|
|
|
|
// cas des contraintes
|
|
Tenseur3HH SigmaHH_N;
|
|
Cal_sigma_pour_num(gijBB_0_,gijHH_0_,(const TenseurBB &) gijBBtdt_N,(const TenseurHH &) gijHHtdt_N
|
|
,jacobien_0,jacobien_N,SigmaHH_N);
|
|
|
|
// calcul des dérivées numériques et comparaisons
|
|
for (int k=1;k<=3;k++)
|
|
for (int l=1;l<=3;l++)
|
|
{ //
|
|
double derSigNum = coef * 2.*(SigmaHH_N(k,l) - SigmaHH_deb(k,l) )*unSurDelta;
|
|
dSigdepsHHHH_num.Change(k,l,i,j,derSigNum);
|
|
double derSigAna = dSigdepsHHHH(k,l,i,j);//0.5*(dSigdepsHHHH(k,l,i,j) + dSigdepsHHHH(k,l,j,i));
|
|
bool erreur = false;
|
|
if (diffpourcent(derSigNum,derSigAna,MaX(Dabs(derSigNum),Dabs(derSigAna)),0.1))
|
|
if (MaX(Dabs(derSigNum),Dabs(derSigAna)) > 200.)
|
|
{if (MiN(Dabs(derSigNum),Dabs(derSigAna)) == 0.)
|
|
{if ( MaX(Dabs(derSigNum),Dabs(derSigAna)) > 50.*delta) erreur = true;}
|
|
else erreur = true;
|
|
};
|
|
// erreur = false; // a virer
|
|
if (erreur)
|
|
{
|
|
// calcul des dérivées d'éléments intermédiaires pour voir
|
|
|
|
//
|
|
cout << "\n erreur dans le calcul analytique de l'operateur tangent "
|
|
<< "\n derSigNum= " << derSigNum << " derSigAna= " << derSigAna
|
|
<< " klij= " << k << " " << l << " " << i << " " << j
|
|
<< " SigmaHH_N(k,l)= " << SigmaHH_N(k,l);
|
|
cout << "\n Maheo_hyper::Calcul_derivee_numerique(..";
|
|
cout << "\n un caractere ";
|
|
// --- pour le débug ----
|
|
// calcul des invariants et de leurs variations premières en numérique
|
|
Invariants_et_var1_deb(gijBB_0_,gijHH_0_,(const TenseurBB &) gijBBtdt_N,(const TenseurHH &) gijHHtdt_N
|
|
,jacobien_0,jacobien_N);
|
|
// calcul des invariants et de leurs variations premières et secondes
|
|
Invariants_et_var2_deb(gijBB_0_,gijHH_0_,(const TenseurBB &) gijBBtdt_N,(const TenseurHH &) gijHHtdt_N
|
|
,jacobien_0,jacobien_N);
|
|
string toto;
|
|
toto= lect_chaine();
|
|
};
|
|
};
|
|
};
|
|
// passage des dérivées numériques aux dérivées finales
|
|
dSigdepsHHHH= dSigdepsHHHH_num;
|
|
};
|
|
|
|
// calcul de la contrainte avec le minimum de variable de passage, utilisé pour le numérique
|
|
void Maheo_hyper::Cal_sigma_pour_num(const TenseurBB & gijBB_0,const TenseurHH & gijHH_0
|
|
,const TenseurBB & gijBB_tdt,const TenseurHH & gijHH_tdt
|
|
,const double& jacobien_0,const double& jacobien,TenseurHH & sigHH_)
|
|
{
|
|
Tenseur3HH & sigHH = *((Tenseur3HH*) &sigHH_); // passage en dim 3 explicite
|
|
|
|
|
|
// calcul des invariants et de leurs variations premières (méthode de Hyper_W_gene_3D)
|
|
// Invariants_et_var1(gijBB_0,gijHH_0,gijBB_tdt,gijHH_tdt,jacobien_0,jacobien);
|
|
// pour vérif on appelle var2, mais c'est à virer
|
|
Invariants_et_var1(gijBB_0,gijHH_0,gijBB_tdt,gijHH_tdt,jacobien_0,jacobien);
|
|
// calcul du potentiel et de ses dérivées premières / aux invariants J_r
|
|
Potentiel_et_var();
|
|
|
|
// calcul du tenseur des contraintes
|
|
sigHH = (W_d_J1/V) * d_J_r_epsBB_HH(1);
|
|
// sigHH = (W_d_J1/V) * d_J_r_epsBB_HH(1) + (W_d_J2/V) * d_J_r_epsBB_HH(2)
|
|
// + (W_v_J3/V) * d_J_r_epsBB_HH(3);
|
|
|
|
};
|
|
|
|
// idem avec la variation
|
|
void Maheo_hyper::Cal_sigmaEtDer_pour_num(const TenseurBB & gijBB_0,const TenseurHH & gijHH_0
|
|
,const TenseurBB & gijBB_tdt,const TenseurHH & gijHH_tdt
|
|
,const double& jacobien_0,const double& jacobien
|
|
,TenseurHH & sigHH_,Tenseur3HHHH& dSigdepsHHHH)
|
|
{
|
|
Tenseur3HH & sigHH = *((Tenseur3HH*) &sigHH_); // passage en dim 3 explicite
|
|
// calcul des invariants et de leurs variations premières et seconde (méthode de Hyper_W_gene_3D)
|
|
Invariants_et_var2(gijBB_0,gijHH_0,gijBB_tdt,gijHH_tdt,jacobien_0,jacobien);
|
|
// calcul du potentiel et de ses dérivées premières / aux invariants J_r
|
|
Potentiel_et_var2();
|
|
|
|
// calcul du tenseur des contraintes
|
|
double unSurV=1./V;
|
|
sigHH = (W_d_J1*unSurV) * d_J_r_epsBB_HH(1);
|
|
// sigHH = (W_d_J1*unSurV) * d_J_r_epsBB_HH(1) + (W_d_J2*unSurV) * d_J_r_epsBB_HH(2)
|
|
// + (W_v_J3*unSurV) * d_J_r_epsBB_HH(3);
|
|
|
|
// calcul de la variation seconde du potentiel par rapport à epsij epskl
|
|
Tenseur3HHHH d2W_d2epsHHHH
|
|
= W_d_J1 * d_J_1_eps2BB_HHHH;
|
|
|
|
// = W_d_J1 * d_J_1_eps2BB_HHHH + W_d_J2 * d_J_2_eps2BB_HHHH
|
|
// + W_v_J3 * d_J_3_eps2BB_HHHH
|
|
// + W_v_J3J3 * Tenseur3HHHH::Prod_tensoriel(d_J_r_epsBB_HH(3),d_J_r_epsBB_HH(3));
|
|
// cout << "\n d2W_d2epsHHHH(1,1,1,1)= " << d2W_d2epsHHHH(1,1,1,1);
|
|
|
|
// calcul de la variation du tenseur des contraintes par rapports aux déformations
|
|
// on tient compte du fait que V*sigHH = d W/ d epsij
|
|
Tenseur3HH interHH = -sigHH ; //* (-0.5*unSurV*unSurV);
|
|
|
|
Tenseur3HHHH d_igdepsHHHH(1,interHH,gijHH_tdt);
|
|
d_igdepsHHHH += (unSurV) * d2W_d2epsHHHH;
|
|
dSigdepsHHHH = d_igdepsHHHH;
|
|
};
|