708 lines
32 KiB
C++
708 lines
32 KiB
C++
|
|
|
|
// 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 "IsoHyperBulk3.h"
|
|
//#include "ComLoi_comp_abstraite.h"
|
|
|
|
# include <iostream>
|
|
using namespace std; //introduces namespace std
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
#include "Sortie.h"
|
|
#include "ConstMath.h"
|
|
#include "CharUtil.h"
|
|
|
|
|
|
//================== initialisation des variables static ======================
|
|
// indicateur utilisé par Verif_Potentiel_et_var
|
|
int IsoHyperBulk3::indic_Verif_PoGrenoble_et_var = 0;
|
|
//================== fin d'initialisation des variables static ================
|
|
|
|
IsoHyperBulk3::IsoHyperBulk3 () : // Constructeur par defaut
|
|
Hyper3D(ISOHYPERBULK3,CAT_MECANIQUE,false),K(ConstMath::trespetit)
|
|
,F_K_V(NULL),F_K_T(NULL)
|
|
{};
|
|
// Constructeur de copie
|
|
IsoHyperBulk3::IsoHyperBulk3 (const IsoHyperBulk3& loi) :
|
|
Hyper3D (loi),K(loi.K)
|
|
,F_K_V(loi.F_K_V),F_K_T(loi.F_K_T)
|
|
{
|
|
//--- dependance via des fonctions éventuelles
|
|
if (F_K_V != NULL)
|
|
if (F_K_V->NomCourbe() == "_")
|
|
F_K_V = Courbe1D::New_Courbe1D(*(loi.F_K_V));
|
|
if (F_K_T != NULL)
|
|
if (F_K_T->NomCourbe() == "_")
|
|
F_K_T = Courbe1D::New_Courbe1D(*(loi.F_K_T));
|
|
};
|
|
|
|
IsoHyperBulk3::~IsoHyperBulk3 ()
|
|
// Destructeur
|
|
{
|
|
//--- dependance via des fonctions éventuelles
|
|
if (F_K_V != NULL)
|
|
if (F_K_V->NomCourbe() == "_") delete F_K_V;
|
|
if (F_K_T != NULL)
|
|
if (F_K_T->NomCourbe() == "_") delete F_K_T;
|
|
};
|
|
|
|
|
|
// Lecture des donnees de la classe sur fichier
|
|
void IsoHyperBulk3::LectureDonneesParticulieres
|
|
(UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D,LesFonctions_nD& lesFonctionsnD)
|
|
{ // lecture du module
|
|
*(entreePrinc->entree) >> K ;
|
|
// puis on s'occupe des dépendances à des fonctions éventuelles
|
|
string nom;
|
|
// on regarde si le module est thermo dépendant
|
|
if(strstr(entreePrinc->tablcar,"K_thermo_dependant_")!=0)
|
|
{ *(entreePrinc->entree) >> nom;
|
|
if (nom != "K_thermo_dependant_")
|
|
{ cout << "\n erreur en lecture de la thermodependance de K, on aurait du lire le mot cle K_thermo_dependant_"
|
|
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme et on a lue: " << nom;
|
|
entreePrinc->MessageBuffer("**erreur1 IsoHyperBulk3::LectureDonneesParticulieres (...**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
// lecture de la loi d'évolution du module en fonction de la température
|
|
*(entreePrinc->entree) >> nom;
|
|
// on regarde si la courbe existe, si oui on récupère la référence
|
|
if (lesCourbes1D.Existe(nom))
|
|
{ F_K_T = lesCourbes1D.Trouve(nom);
|
|
}
|
|
else
|
|
{ // sinon il faut la lire maintenant
|
|
string non_courbe("_");
|
|
F_K_T = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
|
|
// lecture de la courbe
|
|
F_K_T->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
|
|
};
|
|
entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
|
|
};
|
|
|
|
// on regarde si le module dépend d'une fonction de V
|
|
if(strstr(entreePrinc->tablcar,"K_V_dependant_")!=0)
|
|
{ *(entreePrinc->entree) >> nom;
|
|
if (nom != "K_V_dependant_")
|
|
{ cout << "\n erreur en lecture de la dependance de K a V, on aurait du lire le mot cle K_V_dependant_"
|
|
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme et on a lue: " << nom;
|
|
entreePrinc->MessageBuffer("**erreur2 IsoHyperBulk3::LectureDonneesParticulieres (...**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
// lecture de la loi d'évolution du module en fonction de V
|
|
*(entreePrinc->entree) >> nom;
|
|
// on regarde si la courbe existe, si oui on récupère la référence
|
|
if (lesCourbes1D.Existe(nom))
|
|
{ F_K_V = lesCourbes1D.Trouve(nom);
|
|
}
|
|
else
|
|
{ // sinon il faut la lire maintenant
|
|
string non_courbe("_");
|
|
F_K_V = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
|
|
// lecture de la courbe
|
|
F_K_V->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
|
|
};
|
|
// entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
|
|
};
|
|
|
|
// Lecture des paramètre specifique sur fichier (exe: regularisation sortie_post...
|
|
Hyper3D::LectParaSpecifiques(entreePrinc,lesCourbes1D,lesFonctionsnD);
|
|
|
|
|
|
// appel au niveau de la classe mère
|
|
Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire
|
|
(*entreePrinc,lesFonctionsnD);
|
|
|
|
};
|
|
// affichage de la loi
|
|
void IsoHyperBulk3::Affiche() const
|
|
{ cout << " \n loi de comportement 3D hyperelastique isotrope uniquement volumique : " << Nom_comp(id_comp)
|
|
<< " parametres : \n";
|
|
cout << " K= " << K << " " ;
|
|
|
|
// dépendance à la température
|
|
if ( F_K_T != NULL) { cout << " multiplicateur fonction de la temperature "
|
|
<< " courbe F_K_T=f(T): " << F_K_T->NomCourbe() <<" ";
|
|
};
|
|
// dépendance à V
|
|
if ( F_K_V != NULL) { cout << " multiplicateur fonction de V "
|
|
<< " courbe F_K_V=g(V): " << F_K_V->NomCourbe() <<" ";
|
|
};
|
|
|
|
cout << endl;
|
|
// appel de la classe mère
|
|
Loi_comp_abstraite::Affiche_don_classe_abstraite();
|
|
};
|
|
|
|
// affichage et definition interactive des commandes particulières à chaques lois
|
|
void IsoHyperBulk3::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# ....... loi de comportement 3D hyperelastique isotrope ISOHYPERBULK3 ........"
|
|
<< "\n#----------------"
|
|
<< "\n# K |"
|
|
<< "\n#----------------"
|
|
<< "\n 160000 "
|
|
<< endl;
|
|
if ((rep != "o") && (rep != "O" ) && (rep != "0") )
|
|
{ sort << "\n# il est possible d'avoir un coefficient multiplicatif dependant de la temperature "
|
|
<< "\n# dans ce cas le coefficient K(T) = K * f(T) "
|
|
<< "\n# un exemple de declaration: avec courbe1 le nom d'une courbe 1D : "
|
|
<< "\n#----------------"
|
|
<< "\n# K |"
|
|
<< "\n#----------------"
|
|
<< "\n# 160000 K_thermo_dependant_ courbe1 "
|
|
<< "\n# "
|
|
<< "\n# il est possible d'avoir un coefficient multiplicatif dependant de V via une fonction "
|
|
<< "\n# g(V) quelconque, dans ce cas le coefficient K(V) = K * g(V) "
|
|
<< "\n# un exemple de declaration: avec courbe2 le nom d'une courbe 1D : "
|
|
<< "\n#----------------"
|
|
<< "\n# K |"
|
|
<< "\n#----------------"
|
|
<< "\n# 160000 K_V_dependant_ courbe2 "
|
|
<< "\n# "
|
|
<< "\n# on peut combiner les deux dependances: K(T,V) = K * f(T) * g(V) "
|
|
<< "\n# un exemple de declaration:"
|
|
<< "\n#----------------"
|
|
<< "\n# K |"
|
|
<< "\n#----------------"
|
|
<< "\n# 160000 K_thermo_dependant_ courbe1 K_V_dependant_ courbe2 "
|
|
<< "\n# "
|
|
<< "\n# comme pour toutes les lois, la declaration de chaque courbe peut etre effectuee via un nom de courbe"
|
|
<< "\n# deja existante ou en declarant directement la courbe, dans ce dernier cas, ne pas oublier de finir "
|
|
<< "\n# chaque declaration de courbe avec un retour chariot (return) "
|
|
<< "\n# un exemple de declaration:"
|
|
<< "\n#----------------"
|
|
<< "\n# K |"
|
|
<< "\n#----------------"
|
|
<< "\n# 160000 K_thermo_dependant_ CPL1D DdlP 0. 0. 1. 1. FdlP "
|
|
<< "\n# K_V_dependant_ CPL1D DdlP 0. 0. 1. 2. FdlP "
|
|
<< "\n#------------------------------------------------------------------------------------"
|
|
<< "\n# il est possible d'indiquer 2 parametres specifiques de limite inf "
|
|
<< "\n# limite_inf_Qeps_ : si Qeps < limite_inf_Qeps on considere que l'angle de phase et ses derivees sont nulles "
|
|
<< "\n# limite_inf_bIIb_ : si Dabs(inv.bIIb) < limite_inf_bIIb "
|
|
<< "\n# les derivees du potentiel sont calculees pas difference fini, sauf ceux relatif a la phase qui sont mises a 0 "
|
|
<< "\n# les mots cle limite_inf_Qeps_ suivi du facteur voulu et limite_inf_bIIb_ suivi du facteur "
|
|
<< "\n# doivent etre dans cet ordre "
|
|
<< "\n# ex: "
|
|
<< "\n# limite_inf_Qeps_ 8.5e-5 limite_inf_bIIb_ 36.e-10 "
|
|
<< "\n# ces mots cle doivent se situer avant le mot cle avec_regularisation_ "
|
|
<< "\n#------------------------------------------------------------------------------------"
|
|
<< "\n# il est possible d'indiquer un facteur de regularisation qui permet d'eviter "
|
|
<< "\n# de potentiels 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 le mot cle sortie_post_ "
|
|
<< "\n#------------------------------------------------------------------------------------"
|
|
<< "\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, 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#------------------------------------------------------------------------------------"
|
|
<< "\n# "
|
|
;
|
|
};
|
|
// appel de la classe Hyper3D
|
|
Hyper3D::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 IsoHyperBulk3::TestComplet()
|
|
{ int ret = LoiAbstraiteGeneral::TestComplet();
|
|
if (K == ConstMath::trespetit)
|
|
{ cout << " \n Le parametre K n'est pas defini pour la loi " << Nom_comp(id_comp)
|
|
<< '\n';
|
|
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 IsoHyperBulk3::Lecture_base_info_loi(ifstream& ent,const int cas
|
|
,LesReferences& lesRef,LesCourbes1D& lesCourbe1D,LesFonctions_nD& lesFonctionsnD)
|
|
{ string nom;
|
|
if (cas == 1)
|
|
{ ent >> nom >> K ;
|
|
// dépendance à la température
|
|
bool test; ent >> nom >> test;
|
|
if (!test)
|
|
{ if (F_K_T != NULL) {if (F_K_T->NomCourbe() == "_") delete F_K_T; F_K_T = NULL;};
|
|
}
|
|
else
|
|
{ ent >> nom; F_K_T = lesCourbe1D.Lecture_pour_base_info(ent,cas,F_K_T); };
|
|
// dépendance à V
|
|
ent >> nom >> test;
|
|
if (!test)
|
|
{ if (F_K_V != NULL) {if (F_K_V->NomCourbe() == "_") delete F_K_V; F_K_V = NULL;};
|
|
}
|
|
else
|
|
{ ent >> nom; F_K_V = lesCourbe1D.Lecture_pour_base_info(ent,cas,F_K_V); };
|
|
// prise en compte éventuelle de paramètres particulier: ex: régularisation
|
|
// géré par HyperD et Hyper3D
|
|
Hyper3D::Lecture_para_specifiques(ent,cas);
|
|
// gestion du post-traitement
|
|
ent >> nom >> sortie_post ;
|
|
};
|
|
// appel class mère
|
|
Loi_comp_abstraite::Lecture_don_base_info(ent,cas,lesRef,lesCourbe1D,lesFonctionsnD);
|
|
};
|
|
// cas donne le niveau de sauvegarde
|
|
// = 1 : on sauvegarde tout
|
|
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
|
|
void IsoHyperBulk3::Ecriture_base_info_loi(ofstream& sort,const int cas)
|
|
{ if (cas == 1)
|
|
{ sort << " module_dilatation " << K << " ";
|
|
if (F_K_T == NULL)
|
|
{ sort << " F_K_T " << " 0 ";}
|
|
else
|
|
{ sort << " F_K_T " << " 1 ";
|
|
LesCourbes1D::Ecriture_pour_base_info(sort,cas,F_K_T);
|
|
};
|
|
if (F_K_V == NULL)
|
|
{ sort << " F_K_V " << " 0 ";}
|
|
else
|
|
{ sort << " F_K_V " << " 1 ";
|
|
LesCourbes1D::Ecriture_pour_base_info(sort,cas,F_K_V);
|
|
};
|
|
// prise en compte éventuelle de paramètres particulier: ex: régularisation
|
|
// géré par HyperD et Hyper3D
|
|
Hyper3D::Ecriture_para_specifiques(sort,cas);
|
|
// gestion du post-traitement
|
|
sort << " sortie_post= "<< sortie_post << " ";
|
|
};
|
|
// appel de la classe mère
|
|
Loi_comp_abstraite::Ecriture_don_base_info(sort,cas);
|
|
};
|
|
|
|
// calcul d'un module d'young équivalent à la loi, ceci pour un
|
|
// chargement nul
|
|
double IsoHyperBulk3::Module_young_equivalent(Enum_dure temps,const Deformation & ,SaveResul * )
|
|
{ //return (9.*K*(mur+mu_inf)/((mur+mu_inf)+3.*K));
|
|
// normalement on devrait ramener 0, mais en fait c'est utiliser pour le calcul du pas de temps critique don
|
|
// ce qui est en réalité important, c'est la vitesse de l'onde de compression
|
|
// --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
|
|
double coef_T = 1.;
|
|
if (F_K_T != NULL) coef_T = F_K_T->Valeur(*temperature);
|
|
// --- cas d'une dépendance à une fonction de V
|
|
double coef_V = 1.;
|
|
if (F_K_V != NULL) coef_V = F_K_V->Valeur(1.);
|
|
|
|
return (3.* coef_T * coef_V * K); // le 3 je n'en suis pas sûr, mais ce n'est pas important
|
|
};
|
|
|
|
// récupération d'un module de compressibilité équivalent à la loi, ceci pour un chargement nul
|
|
// il s'agit ici de la relation -pression = sigma_trace/3. = module de compressibilité * I_eps
|
|
double IsoHyperBulk3::Module_compressibilite_equivalent(Enum_dure ,const Deformation & ,SaveResul * )
|
|
{
|
|
double coef_T = 1.;
|
|
if (F_K_T != NULL) coef_T = F_K_T->Valeur(*temperature);
|
|
// --- cas d'une dépendance à une fonction de V
|
|
double coef_V = 1.;
|
|
if (F_K_V != NULL) coef_V = F_K_V->Valeur(1.);
|
|
return (coef_T * coef_V * K/3.);
|
|
};
|
|
|
|
// =========== METHODES Protégées dérivant de virtuelles : ==============
|
|
|
|
// METHODES internes spécifiques à l'hyperélasticité isotrope découlant de
|
|
// méthodes virtuelles de Hyper3D
|
|
|
|
// calcul du potentiel tout seul sans la phase car Qeps est nul
|
|
// ou très proche de 0
|
|
double IsoHyperBulk3::PoGrenoble
|
|
(const double & ,const Invariant & inv)
|
|
{ // des variables intermédiaires
|
|
double logV = log(inv.V);
|
|
// --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
|
|
double coef_T = 1.;
|
|
if (F_K_T != NULL) coef_T = F_K_T->Valeur(*temperature);
|
|
// --- cas d'une dépendance à une fonction de V
|
|
double coef_V = 1.;
|
|
if (F_K_V != NULL) coef_V = F_K_V->Valeur(inv.V);
|
|
// le potentiel et ses dérivées
|
|
double E = coef_T * coef_V * K/6. * (logV)*(logV);
|
|
// retour
|
|
return E;
|
|
};
|
|
|
|
// calcul du potentiel tout seul avec la phase donc dans le cas où Qeps est non nul
|
|
double IsoHyperBulk3::PoGrenoble
|
|
(const Invariant0QepsCosphi & ,const Invariant & inv)
|
|
{ // dans le cas de l'existence de la phase,
|
|
double logV = log(inv.V);
|
|
// --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
|
|
double coef_T = 1.;
|
|
if (F_K_T != NULL) coef_T = F_K_T->Valeur(*temperature);
|
|
// --- cas d'une dépendance à une fonction de V
|
|
double coef_V = 1.;
|
|
if (F_K_V != NULL) coef_V = F_K_V->Valeur(inv.V);
|
|
// le potentiel et ses dérivées
|
|
double E = coef_T * coef_V * K/6. * (logV)*(logV);
|
|
// retour
|
|
return E;
|
|
};
|
|
|
|
// calcul du potentiel tout seul sans la phase car Qeps est nul
|
|
// ou très proche de 0, et de sa variation suivant V uniquement
|
|
Hyper3D::PoGrenoble_V IsoHyperBulk3::PoGrenoble_et_V
|
|
(const double & ,const Invariant & inv)
|
|
{ PoGrenoble_V ret;
|
|
double logV = log(inv.V);
|
|
// --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
|
|
double coef_T = 1.;
|
|
if (F_K_T != NULL) coef_T = F_K_T->Valeur(*temperature);
|
|
// --- cas d'une dépendance à une fonction de V
|
|
Courbe1D::ValDer valder_V;
|
|
valder_V.valeur = 1.; // initialisation par défaut
|
|
valder_V.derivee = 0.; // ""
|
|
if (F_K_V != NULL) valder_V=F_K_V->Valeur_Et_derivee(inv.V);
|
|
////// debug
|
|
//cout << "\n debug IsoHyperBulk3::PoGrenoble_et_V: ** inv.V= " << inv.V << ", valder_V.valeur= " << valder_V.valeur
|
|
// << ", valder_V.derivee= "<< valder_V.derivee << endl;
|
|
////// fin debug
|
|
// le potentiel et ses dérivées
|
|
double a = coef_T * K/6. * (logV)*(logV);
|
|
ret.E = a * valder_V.valeur ;
|
|
double a_V = coef_T * K/3.*logV/inv.V;
|
|
ret.EV = a_V * valder_V.valeur + a * valder_V.derivee;
|
|
// -- le module sécant
|
|
if (logV > ConstMath::unpeupetit)
|
|
{ret.Ks = coef_T * K / 3. * ( valder_V.valeur * (1.+ 0.5*logV)
|
|
+ valder_V.derivee * 0.5 * logV);}
|
|
else // si la variation de volume est trop faible on utilise le module sécant pour la valeur unpeupetite
|
|
{ double V_petit = ConstMath::unpeupetit; // on se fixe une petite valeur
|
|
if (F_K_V != NULL)
|
|
valder_V = F_K_V->Valeur_Et_derivee(1.+V_petit);
|
|
ret.Ks = coef_T * K / 3. * ( valder_V.valeur * (1.+ 0.5*log(1.+V_petit))
|
|
+ valder_V.derivee * 0.5 * log(1.+V_petit));
|
|
};
|
|
// a partir d'ici il ne faut plus utiliser valder_V, car il peut correspondre à V_petit
|
|
|
|
// retour
|
|
return ret;
|
|
};
|
|
|
|
// calcul du potentiel et de sa variation suivant V uniquement
|
|
Hyper3D::PoGrenoble_V IsoHyperBulk3::PoGrenoble_et_V
|
|
(const Invariant0QepsCosphi & ,const Invariant & inv)
|
|
{ Hyper3D::PoGrenoble_V ret;
|
|
// le potentiel et ses dérivées
|
|
double logV = log(inv.V);
|
|
// --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
|
|
double coef_T = 1.;
|
|
if (F_K_T != NULL) coef_T = F_K_T->Valeur(*temperature);
|
|
// --- cas d'une dépendance à une fonction de V
|
|
Courbe1D::ValDer valder_V;
|
|
valder_V.valeur = 1.; // initialisation par défaut
|
|
valder_V.derivee = 0.; // ""
|
|
if (F_K_V != NULL) valder_V=F_K_V->Valeur_Et_derivee(inv.V);
|
|
|
|
double a = coef_T * K/6. * (logV)*(logV);
|
|
ret.E = a * valder_V.valeur ;
|
|
double a_V = coef_T * K/3.*logV/inv.V;
|
|
ret.EV = a_V * valder_V.valeur + a * valder_V.derivee;
|
|
|
|
// -- le module sécant
|
|
if (logV > ConstMath::unpeupetit)
|
|
{ret.Ks = coef_T * K / 3. * ( valder_V.valeur * (1.+ 0.5*logV)
|
|
+ valder_V.derivee * 0.5 * logV);}
|
|
else // si la variation de volume est trop faible on utilise le module sécant pour la valeur unpeupetite
|
|
{ double V_petit = ConstMath::unpeupetit; // on se fixe une petite valeur
|
|
if (F_K_V != NULL)
|
|
valder_V = F_K_V->Valeur_Et_derivee(1.+V_petit);
|
|
ret.Ks = coef_T * K / 3. * ( valder_V.valeur * (1.+ 0.5*log(1.+V_petit))
|
|
+ valder_V.derivee * 0.5 * log(1.+V_petit));
|
|
};
|
|
// a partir d'ici il ne faut plus utiliser valder_V, car il peut correspondre à V_petit
|
|
|
|
// retour
|
|
return ret;
|
|
};
|
|
|
|
// calcul du potentiel tout seul sans la phase car Qeps est nul
|
|
// ou très proche de 0, et de ses variations première et seconde suivant V uniquement
|
|
Hyper3D::PoGrenoble_VV IsoHyperBulk3::PoGrenoble_et_VV
|
|
(const double & ,const Invariant & inv)
|
|
{ PoGrenoble_VV ret;
|
|
double logV = log(inv.V);
|
|
// --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
|
|
double coef_T = 1.;
|
|
if (F_K_T != NULL) coef_T = F_K_T->Valeur(*temperature);
|
|
// --- cas d'une dépendance à une fonction de V
|
|
Courbe1D::ValDer2 valder_V;
|
|
valder_V.valeur = 1.; // initialisation par défaut
|
|
valder_V.derivee = valder_V.der_sec = 0.; // ""
|
|
if (F_K_V != NULL) valder_V=F_K_V->Valeur_Et_der12(inv.V);
|
|
////// debug
|
|
//cout << "\n debug IsoHyperBulk3::PoGrenoble_et_VV: inv.V= " << inv.V << ", valder_V.valeur= " << valder_V.valeur
|
|
// << ", valder_V.derivee= "<< valder_V.derivee << endl;
|
|
////// fin debug
|
|
|
|
// le potentiel et ses dérivées premières
|
|
double a = coef_T * K/6. * (logV)*(logV);
|
|
ret.E = a * valder_V.valeur ;
|
|
double a_V = coef_T * K/3.*logV/inv.V;
|
|
ret.EV = a_V * valder_V.valeur + a * valder_V.derivee;
|
|
// dérivées secondes
|
|
double a_VV = coef_T * K/3. * (1.-logV) / (inv.V * inv.V);
|
|
ret.EVV = a_VV * valder_V.valeur + 2. * a_V * valder_V.derivee
|
|
+ a * valder_V.der_sec ;
|
|
// -- le module sécant
|
|
if (logV > ConstMath::unpeupetit)
|
|
{ret.Ks = coef_T * K / 3. * ( valder_V.valeur * (1.+ 0.5*logV)
|
|
+ valder_V.derivee * 0.5 * logV);}
|
|
else // si la variation de volume est trop faible on utilise le module sécant pour la valeur unpeupetite
|
|
{ double V_petit = ConstMath::unpeupetit; // on se fixe une petite valeur
|
|
if (F_K_V != NULL)
|
|
valder_V = F_K_V->Valeur_Et_der12(1.+V_petit);
|
|
ret.Ks = coef_T * K / 3. * ( valder_V.valeur * (1.+ 0.5*log(1.+V_petit))
|
|
+ valder_V.derivee * 0.5 * log(1.+V_petit));
|
|
};
|
|
// a partir d'ici il ne faut plus utiliser valder_V, car il peut correspondre à V_petit
|
|
|
|
// retour
|
|
return ret;
|
|
};
|
|
|
|
// calcul du potentiel et de sa variation première et seconde suivant V uniquement
|
|
Hyper3D::PoGrenoble_VV IsoHyperBulk3::PoGrenoble_et_VV
|
|
(const Invariant0QepsCosphi & ,const Invariant & inv)
|
|
{ Hyper3D::PoGrenoble_VV ret;
|
|
double logV = log(inv.V);
|
|
// --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
|
|
double coef_T = 1.;
|
|
if (F_K_T != NULL) coef_T = F_K_T->Valeur(*temperature);
|
|
// --- cas d'une dépendance à une fonction de V
|
|
Courbe1D::ValDer2 valder_V;
|
|
valder_V.valeur = 1.; // initialisation par défaut
|
|
valder_V.derivee = valder_V.der_sec = 0.; // ""
|
|
if (F_K_V != NULL) valder_V=F_K_V->Valeur_Et_der12(inv.V);
|
|
// le potentiel et ses dérivées premières
|
|
double a = coef_T * K/6. * (logV)*(logV);
|
|
ret.E = a * valder_V.valeur ;
|
|
double a_V = coef_T * K/3.*logV/inv.V;
|
|
ret.EV = a_V * valder_V.valeur + a * valder_V.derivee;
|
|
// dérivées secondes
|
|
double a_VV = coef_T * K/3. * (1.-logV) / (inv.V * inv.V);
|
|
ret.EVV = a_VV * valder_V.valeur + 2. * a_V * valder_V.derivee
|
|
+ a * valder_V.der_sec ;
|
|
// -- le module sécant
|
|
if (logV > ConstMath::unpeupetit)
|
|
{ret.Ks = coef_T * K / 3. * ( valder_V.valeur * (1.+ 0.5*logV)
|
|
+ valder_V.derivee * 0.5 * logV);}
|
|
else // si la variation de volume est trop faible on utilise le module sécant pour la valeur unpeupetite
|
|
{ double V_petit = ConstMath::unpeupetit; // on se fixe une petite valeur
|
|
if (F_K_V != NULL)
|
|
valder_V = F_K_V->Valeur_Et_der12(1.+V_petit);
|
|
ret.Ks = coef_T * K / 3. * ( valder_V.valeur * (1.+ 0.5*log(1.+V_petit))
|
|
+ valder_V.derivee * 0.5 * log(1.+V_petit));
|
|
};
|
|
// a partir d'ici il ne faut plus utiliser valder_V, car il peut correspondre à V_petit
|
|
|
|
// retour
|
|
return ret;
|
|
};
|
|
|
|
// calcul du potentiel et de ses dérivées non compris la phase
|
|
Hyper3D::PoGrenobleSansPhaseSansVar IsoHyperBulk3::PoGrenoble
|
|
(const InvariantQeps & ,const Invariant & inv)
|
|
{ PoGrenobleSansPhaseSansVar ret;
|
|
// le potentiel et ses dérivées
|
|
double logV = log(inv.V);
|
|
// --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
|
|
double coef_T = 1.;
|
|
if (F_K_T != NULL) coef_T = F_K_T->Valeur(*temperature);
|
|
// --- cas d'une dépendance à une fonction de V
|
|
Courbe1D::ValDer valder_V;
|
|
valder_V.valeur = 1.; // initialisation par défaut
|
|
valder_V.derivee = 0.; // ""
|
|
if (F_K_V != NULL) valder_V=F_K_V->Valeur_Et_derivee(inv.V);
|
|
|
|
double a = coef_T * K/6. * (logV)*(logV);
|
|
ret.E = a * valder_V.valeur ;
|
|
double a_V = coef_T * K/3.*logV/inv.V;
|
|
ret.EV = a_V * valder_V.valeur + a * valder_V.derivee;
|
|
|
|
// -- le module sécant
|
|
if (logV > ConstMath::unpeupetit)
|
|
{ret.Ks = coef_T * K / 3. * ( valder_V.valeur * (1.+ 0.5*logV)
|
|
+ valder_V.derivee * 0.5 * logV);}
|
|
else // si la variation de volume est trop faible on utilise le module sécant pour la valeur unpeupetite
|
|
{ double V_petit = ConstMath::unpeupetit; // on se fixe une petite valeur
|
|
if (F_K_V != NULL)
|
|
valder_V = F_K_V->Valeur_Et_derivee(1.+V_petit);
|
|
ret.Ks = coef_T * K / 3. * ( valder_V.valeur * (1.+ 0.5*log(1.+V_petit))
|
|
+ valder_V.derivee * 0.5 * log(1.+V_petit));
|
|
};
|
|
// a partir d'ici il ne faut plus utiliser valder_V, car il peut correspondre à V_petit
|
|
|
|
// retour
|
|
return ret;
|
|
};
|
|
|
|
// calcul du potentiel et de ses dérivées avec la phase
|
|
Hyper3D::PoGrenobleAvecPhaseSansVar IsoHyperBulk3::PoGrenoblePhase
|
|
(const InvariantQepsCosphi& ,const Invariant & inv)
|
|
{ PoGrenobleAvecPhaseSansVar ret;
|
|
// le potentiel et ses dérivées
|
|
double logV = log(inv.V);
|
|
// --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
|
|
double coef_T = 1.;
|
|
if (F_K_T != NULL) coef_T = F_K_T->Valeur(*temperature);
|
|
// --- cas d'une dépendance à une fonction de V
|
|
Courbe1D::ValDer valder_V;
|
|
valder_V.valeur = 1.; // initialisation par défaut
|
|
valder_V.derivee = 0.; // ""
|
|
if (F_K_V != NULL) valder_V=F_K_V->Valeur_Et_derivee(inv.V);
|
|
|
|
double a = coef_T * K/6. * (logV)*(logV);
|
|
ret.E = a * valder_V.valeur ;
|
|
double a_V = coef_T * K/3.*logV/inv.V;
|
|
ret.EV = a_V * valder_V.valeur + a * valder_V.derivee;
|
|
|
|
// -- le module sécant
|
|
if (logV > ConstMath::unpeupetit)
|
|
{ret.Ks = coef_T * K / 3. * ( valder_V.valeur * (1.+ 0.5*logV)
|
|
+ valder_V.derivee * 0.5 * logV);}
|
|
else // si la variation de volume est trop faible on utilise le module sécant pour la valeur unpeupetite
|
|
{ double V_petit = ConstMath::unpeupetit; // on se fixe une petite valeur
|
|
if (F_K_V != NULL)
|
|
valder_V = F_K_V->Valeur_Et_derivee(1.+V_petit);
|
|
ret.Ks = coef_T * K / 3. * ( valder_V.valeur * (1.+ 0.5*log(1.+V_petit))
|
|
+ valder_V.derivee * 0.5 * log(1.+V_petit));
|
|
};
|
|
// a partir d'ici il ne faut plus utiliser valder_V, car il peut correspondre à V_petit
|
|
|
|
// retour
|
|
return ret;
|
|
};
|
|
|
|
|
|
// calcul du potentiel sans phase et dérivées avec ses variations par rapport aux invariants
|
|
Hyper3D::PoGrenobleSansPhaseAvecVar IsoHyperBulk3::PoGrenoble_et_var
|
|
(const Invariant2Qeps& ,const Invariant & inv)
|
|
{ PoGrenobleSansPhaseAvecVar ret;
|
|
double logV = log(inv.V);
|
|
// --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
|
|
double coef_T = 1.;
|
|
if (F_K_T != NULL) coef_T = F_K_T->Valeur(*temperature);
|
|
// --- cas d'une dépendance à une fonction de V
|
|
Courbe1D::ValDer2 valder_V;
|
|
valder_V.valeur = 1.; // initialisation par défaut
|
|
valder_V.derivee = valder_V.der_sec = 0.; // ""
|
|
if (F_K_V != NULL) valder_V=F_K_V->Valeur_Et_der12(inv.V);
|
|
// le potentiel et ses dérivées premières
|
|
double a = coef_T * K/6. * (logV)*(logV);
|
|
ret.E = a * valder_V.valeur ;
|
|
double a_V = coef_T * K/3.*logV/inv.V;
|
|
ret.EV = a_V * valder_V.valeur + a * valder_V.derivee;
|
|
// dérivées secondes
|
|
double a_VV = coef_T * K/3. * (1.-logV) / (inv.V * inv.V);
|
|
ret.EVV = a_VV * valder_V.valeur + 2. * a_V * valder_V.derivee
|
|
+ a * valder_V.der_sec ;
|
|
// -- le module sécant
|
|
if (logV > ConstMath::unpeupetit)
|
|
{ret.Ks = coef_T * K / 3. * ( valder_V.valeur * (1.+ 0.5*logV)
|
|
+ valder_V.derivee * 0.5 * logV);}
|
|
else // si la variation de volume est trop faible on utilise le module sécant pour la valeur unpeupetite
|
|
{ double V_petit = ConstMath::unpeupetit; // on se fixe une petite valeur
|
|
if (F_K_V != NULL)
|
|
valder_V = F_K_V->Valeur_Et_der12(1.+V_petit);
|
|
ret.Ks = coef_T * K / 3. * ( valder_V.valeur * (1.+ 0.5*log(1.+V_petit))
|
|
+ valder_V.derivee * 0.5 * log(1.+V_petit));
|
|
};
|
|
// a partir d'ici il ne faut plus utiliser valder_V, car il peut correspondre à V_petit
|
|
|
|
ret.EQV = 0.;
|
|
// retour
|
|
return ret;
|
|
};
|
|
|
|
// calcul du potentiel avec phase et dérivées avec ses variations par rapport aux invariants
|
|
Hyper3D::PoGrenobleAvecPhaseAvecVar IsoHyperBulk3::PoGrenoblePhase_et_var
|
|
(const Invariant2QepsCosphi& ,const Invariant & inv)
|
|
{ Hyper3D::PoGrenobleAvecPhaseAvecVar ret;
|
|
double logV = log(inv.V);
|
|
// --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
|
|
double coef_T = 1.;
|
|
if (F_K_T != NULL) coef_T = F_K_T->Valeur(*temperature);
|
|
// --- cas d'une dépendance à une fonction de V
|
|
Courbe1D::ValDer2 valder_V;
|
|
valder_V.valeur = 1.; // initialisation par défaut
|
|
valder_V.derivee = valder_V.der_sec = 0.; // ""
|
|
if (F_K_V != NULL) valder_V=F_K_V->Valeur_Et_der12(inv.V);
|
|
// le potentiel et ses dérivées premières
|
|
double a = coef_T * K/6. * (logV)*(logV);
|
|
ret.E = a * valder_V.valeur ;
|
|
double a_V = coef_T * K/3.*logV/inv.V;
|
|
ret.EV = a_V * valder_V.valeur + a * valder_V.derivee;
|
|
// dérivées secondes
|
|
double a_VV = coef_T * K/3. * (1.-logV) / (inv.V * inv.V);
|
|
ret.EVV = a_VV * valder_V.valeur + 2. * a_V * valder_V.derivee
|
|
+ a * valder_V.der_sec ;
|
|
// -- le module sécant
|
|
if (logV > ConstMath::unpeupetit)
|
|
{ret.Ks = coef_T * K / 3. * ( valder_V.valeur * (1.+ 0.5*logV)
|
|
+ valder_V.derivee * 0.5 * logV);}
|
|
else // si la variation de volume est trop faible on utilise le module sécant pour la valeur unpeupetite
|
|
{ double V_petit = ConstMath::unpeupetit; // on se fixe une petite valeur
|
|
if (F_K_V != NULL)
|
|
valder_V = F_K_V->Valeur_Et_der12(1.+V_petit);
|
|
ret.Ks = coef_T * K / 3. * ( valder_V.valeur * (1.+ 0.5*log(1.+V_petit))
|
|
+ valder_V.derivee * 0.5 * log(1.+V_petit));
|
|
};
|
|
// a partir d'ici il ne faut plus utiliser valder_V, car il peut correspondre à V_petit
|
|
|
|
ret.EQV = 0.;
|
|
// retour
|
|
return ret;
|
|
};
|
|
|
|
|