rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

V 7.017

Browse source 
- intro para limite_inf_bIIb_ et limite_inf_Qeps_ dans les potentiels de grenoble
- cor bug diff finie pour Qeps petit sur loi grenoble
- modif prise en compte de la regularisation loi grenoble (passage systématique en différence finie pour Qeps très faible)
This commit is contained in:
Gérard Rio 2023-07-06 08:42:57 +02:00
parent d05b1fd9ed
commit 3ccffa8899
11 changed files with 362 additions and 170 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.cc
View file

@ -1316,6 +1316,7 @@ void AlgoriRelaxDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// calcul de l'équilibrage initiale par le cpu 0
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
};
@ -2041,6 +2042,8 @@ Vecteur V_ext(F_int_tdt);
// on démarre avec le compteur à 0 et on sauvegarde la position finale à l'itération 0
lesMail->Quelconque_glob_vers_local(X1,X_tdt,typQ_XI_ITER_0);
// boucle de convergence sur un increment
Vecteur * sol; // pointeur du vecteur solution
for (compteur = 0; (compteur<= pa.Iterations())&&(!pa.EtatSortieEquilibreGlobal()); compteur++)
//---//\\//\\// début de la boucle sur les itérations d'équilibres //\\//\\//

34
Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc
View file

@ -579,8 +579,8 @@ void AlgoriNonDyna::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
{ Pilotage_du_temps(charge,arret_pilotage); // appel du Pilotage
if (arret_pilotage) break; // pilotage -> arret du calcul
#ifdef UTILISATION_MPI
// seule le process 0 s'occupe de la sortie
if (ParaGlob::Monde()->rank() == 0)
// seule le process 0 s'occupe de la sortie
if (ParaGlob::Monde()->rank() == 0)
#endif
if (aff_incr)
{cout << "\n======================================================================"
@ -640,8 +640,8 @@ void AlgoriNonDyna::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
else
{if (arret_pilotage) break; // pilotage -> arret du calcul
#ifdef UTILISATION_MPI
// seule le process 0 s'occupe de la sortie
if (ParaGlob::Monde()->rank() == 0)
// seule le process 0 s'occupe de la sortie
if (ParaGlob::Monde()->rank() == 0)
#endif
cout << "\n============================================================================="
<< "\n ....... re-analyse du contact ........ "
@ -916,12 +916,12 @@ void AlgoriNonDyna::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
// calcul de la variation de ddl / delta t
// delta_X = X_tdt; delta_X -= X_t; // X_tdt - X_t
Algori::Cal_Transfert_delta_et_var_X(max_delta_X,max_var_delta_X);
#ifdef UTILISATION_MPI
// cas d'un calcul //, pour l'instant seul le CPU 0 sont concerné
if ((ParaGlob::Monde()->rank() == 0)&&(permet_affichage > 3))
#else
if (permet_affichage > 3)
#endif
#ifdef UTILISATION_MPI
// cas d'un calcul //, pour l'instant seul le CPU 0 sont concerné
if ((ParaGlob::Monde()->rank() == 0)&&(permet_affichage > 3))
#else
if (permet_affichage > 3)
#endif
{ cout << "\n --- |max_var_DeltaDdl|= "<< max_var_delta_X
<< " , |max_deltaDdl|= " << max_delta_X << flush;};
// ---dans le cas du mode debug on sort éventuellement les infos au fil du calcul (un peu bricolé)
@ -951,9 +951,9 @@ decol = false; // pour debugger
bool arret_iteration = false;
#ifdef UTILISATION_MPI
// seule le process 0 s'occupe de la convergence
if (ParaGlob::Monde()->rank() == 0)
{
// seule le process 0 s'occupe de la convergence
if (ParaGlob::Monde()->rank() == 0)
{
#endif
if (Convergence(aff_iteration,last_var_ddl_max,vglobaal,maxPuissExt,maxPuissInt,maxReaction,compteur,arret_convergence)
&& !decol)
@ -968,7 +968,7 @@ decol = false; // pour debugger
else if (arret_convergence)
{arret_iteration = true; }; //break;} // cas ou la méthode Convergence() demande l'arret
#ifdef UTILISATION_MPI
};
};
temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
broadcast(*ParaGlob::Monde(), arret_iteration, 0);
temps_transfert_court.Arret_du_comptage(); // fin comptage cpu
@ -987,9 +987,9 @@ decol = false; // pour debugger
int nb_matrice_secondaire = tab_mato.Taille(); // = 1 par défaut, mais on peut en avoir d'autre
int niveau_substitution = 1; // par défaut on utilise la matrice de raideur matglob = tab_mato(1)
#ifdef UTILISATION_MPI
// seule le process 0 fait la résolution globale
if (ParaGlob::Monde()->rank() == 0)
{
// seule le process 0 fait la résolution globale
if (ParaGlob::Monde()->rank() == 0)
{
#endif
while (niveau_substitution <= nb_matrice_secondaire)
{ // on sauvegarde éventuellement le second membre

2
Parametres/EnteteParaGlob.h
View file

@ -41,7 +41,7 @@
EnumLangue ParaGlob::langueHZ = FRANCAIS; // langue utilisée pour les entrées sorties
int ParaGlob::nbComposantesTenseur = 1; // nombre de composantes par defaut a 1
int ParaGlob::nivImpression = 2; // niveau d'impression
string ParaGlob::nbVersion = "7.014" ; // numéro de version du logiciel
string ParaGlob::nbVersion = "7.017" ; // numéro de version du logiciel
string ParaGlob::NbVersionsurfichier = ""; // numéro de version lue en entrée fichier
int ParaGlob::nb_diggit_double_calcul= 17; // nombre de chiffre significatifs utilisé pour
// l'affichage des double précision pour l'archivage

2
References/Lect_reference.h
View file

@ -37,7 +37,7 @@
#define LECT_REFERENCE_H
#include "Liste_T.cc
#include "Liste_T.cc"
#include "Reference.h"
#include "Tableau_T.h"

273
comportement/Hyper_elastique/Hyper3D.cc
View file

@ -39,31 +39,35 @@ using namespace std; //introduces namespace std
//================== initialisation des variables static ======================
// indicateur utilisé par Verif_Potentiel_et_var
int Hyper3D::indic_Verif_Potentiel_et_var = 0;
double Hyper3D::limite_inf_Qeps = sqrt(2)*6.e-5 ; //001;
double Hyper3D::limite_inf_bIIb = 36.e-10; // limite en dessous de laquelles on fait une ope spécial
// ---------- classe Hyper3D ---------
Hyper3D::Hyper3D () : // Constructeur par defaut
HyperD(RIEN_COMP,RIEN_CATEGORIE_LOI_COMP,3,false)
,indic_Verif_Potentiel_et_var(0),limite_inf_Qeps(sqrt(2)*6.e-5)
,limite_inf_bIIb(36.e-10)
{};
// Constructeur utile si l'identificateur du nom de la loi
// de comportement et le paramètre phase sont connus
Hyper3D::Hyper3D (Enum_comp id_compor,Enum_categorie_loi_comp categorie_comp,bool avec_ph) :
HyperD(id_compor,categorie_comp,3,avec_ph)
,indic_Verif_Potentiel_et_var(0),limite_inf_Qeps(sqrt(2)*6.e-5)
,limite_inf_bIIb(36.e-10)
{} ;
// Constructeur utile si l'identificateur du nom de la loi
// de comportement et le paramètre phase sont connus
Hyper3D::Hyper3D (char* nom,Enum_categorie_loi_comp categorie_comp,bool avec_ph) :
HyperD(nom,categorie_comp,3,avec_ph)
,indic_Verif_Potentiel_et_var(0),limite_inf_Qeps(sqrt(2)*6.e-5)
,limite_inf_bIIb(36.e-10)
{} ;
// Constructeur de copie
Hyper3D::Hyper3D (const Hyper3D& loi) :
HyperD (loi)
,indic_Verif_Potentiel_et_var(loi.indic_Verif_Potentiel_et_var)
,limite_inf_Qeps(loi.limite_inf_Qeps)
,limite_inf_bIIb(loi.limite_inf_bIIb)
{};
@ -294,8 +298,8 @@ Hyper3D::PotenSansPhaseSansVar Hyper3D::Potentiel(const Invariant & inv,const do
PotenSansPhaseSansVar potret;
// récup du conteneur spécifique du point, pour sauvegarde éventuelle
SaveResulHyperD & save_resulHyperD = *((SaveResulHyperD*) saveResul);
// if (Dabs(inv.bIIb) > ConstMath::unpeupetit)
if ((Dabs(inv.bIIb) > limite_inf_bIIb)||(avec_regularisation))
// if ((Dabs(inv.bIIb) > limite_inf_bIIb)||(avec_regularisation))
if (Dabs(inv.bIIb) > limite_inf_bIIb)
{ // calcul du nouvel invariant sous la nouvelle forme
InvariantQeps inv_spes = InvariantSpecifSansPhase(inv);
// calcul du potentiel sous la forme polaire
@ -324,6 +328,7 @@ Hyper3D::PotenSansPhaseSansVar Hyper3D::Potentiel(const Invariant & inv,const do
// calcul du potentiel pour une petite variation suivant bIIb
Invariant inv_n = inv; inv_n.bIIb += limite_inf_bIIb;
double Qeps_n = Invariant0Qeps(inv_n);
double delta = limite_inf_bIIb; double unsurdelta = 1./delta;
// stockage éventuel des invariants et potentiel
if (sortie_post)
{ save_resulHyperD.invP->V= inv_n.V;
@ -336,7 +341,15 @@ Hyper3D::PotenSansPhaseSansVar Hyper3D::Potentiel(const Invariant & inv,const do
potret.E = pot.E * inv.V * jacobien0;
potret.Ks = pot.Ks;
potret.EV = jacobien0 * (inv.V * pot.EV + pot.E);
potret.EbIIb = jacobien0 * inv.V * (pot.E - E_n)/limite_inf_bIIb;
{double inter = (E_n - pot.E );
// on est obligé de faire ainsi car sinon on a des erreurs d'arrondi
// le potentiel doit-être croissant, on doit donc avoir toujours inter > 0
if (inter < ConstMath::trespetit)
{ potret.EbIIb = 0.; }
else
{potret.EbIIb = jacobien0 * inv.V * inter * unsurdelta;};
};
}
return potret;
};
@ -350,7 +363,8 @@ Hyper3D::PotenAvecPhaseSansVar Hyper3D::PotentielPhase(const Invariant& inv,cons
PotenAvecPhaseSansVar potret;
// récup du conteneur spécifique du point, pour sauvegarde éventuelle
SaveResulHyperD & save_resulHyperD = *((SaveResulHyperD*) saveResul);
if ((Dabs(inv.bIIb) > limite_inf_bIIb)||(avec_regularisation))
// if ((Dabs(inv.bIIb) > limite_inf_bIIb)||(avec_regularisation))
if (Dabs(inv.bIIb) > limite_inf_bIIb)
{ // calcul des invariants sous la nouvelle forme
InvariantQepsCosphi inv_spes = InvariantSpecif(inv);
// calcul du potentiel sous la forme polaire
@ -382,6 +396,7 @@ Hyper3D::PotenAvecPhaseSansVar Hyper3D::PotentielPhase(const Invariant& inv,cons
Invariant inv_n = inv; inv_n.bIIb += limite_inf_bIIb;
Invariant0QepsCosphi inv_spes_n = Invariant0Specif(inv_n);
double E_n = PoGrenoble(inv_spes_n,inv_n);
double delta = limite_inf_bIIb; double unsurdelta = 1./delta;
// stockage éventuel des invariants et du potentiel
if (sortie_post)
{ save_resulHyperD.invP->V= inv.V;
@ -394,7 +409,15 @@ Hyper3D::PotenAvecPhaseSansVar Hyper3D::PotentielPhase(const Invariant& inv,cons
potret.Ks = pot.Ks;
potret.EV = jacobien0 * (inv.V * pot.EV + pot.E);
potret.EIeps = 0.;
potret.EbIIb = jacobien0 * inv.V * (pot.E - E_n)/limite_inf_bIIb;
// potret.EbIIb = jacobien0 * inv.V * (-pot.E + E_n)/limite_inf_bIIb;
{double inter = (E_n-pot.E );
// on est obligé de faire ainsi car sinon on a des erreurs d'arrondi
// le potentiel doit-être croissant, on doit donc avoir toujours inter > 0
if (inter < ConstMath::trespetit)
{ potret.EbIIb = 0.; }
else
{potret.EbIIb = jacobien0 * inv.V * inter *unsurdelta;};
};
}
return potret;
@ -408,7 +431,8 @@ Hyper3D::PotenSansPhaseAvecVar Hyper3D::Potentiel_et_var(const Invariant& inv,co
PotenSansPhaseAvecVar potret;
// récup du conteneur spécifique du point, pour sauvegarde éventuelle
SaveResulHyperD & save_resulHyperD = *((SaveResulHyperD*) saveResul);
if ((Dabs(inv.bIIb) > ConstMath::petit)||(avec_regularisation))
// if ((Dabs(inv.bIIb) > ConstMath::petit)||(avec_regularisation))
if (Dabs(inv.bIIb) > limite_inf_bIIb)
{ // calcul des invariants sous la nouvelle forme
Invariant2Qeps inv_spes = Invariant2SpecifSansPhase(inv);
// calcul du potentiel sous la forme polaire
@ -452,6 +476,8 @@ Hyper3D::PotenSansPhaseAvecVar Hyper3D::Potentiel_et_var(const Invariant& inv,co
// calcul du potentiel pour une petite variation suivant bIIb
Invariant inv_n = inv_n0;
inv_n.bIIb += limite_inf_bIIb;
double delta = limite_inf_bIIb; double unsurdelta = 1./delta;
double Qeps_n = Invariant0Qeps(inv_n);
// stockage éventuel des invariants et du potentiel
if (sortie_post)
@ -471,33 +497,40 @@ Hyper3D::PotenSansPhaseAvecVar Hyper3D::Potentiel_et_var(const Invariant& inv,co
potret.EV = jacobien0 * (inv.V * pot.EV + pot.E);
{double inter = (pot_V.E - pot.E);
// on est obligé de faire ainsi car sinon on a des erreurs d'arrondi
// le potentiel doit-être croissant, on doit donc avoir toujours inter > 0
if (inter < ConstMath::trespetit)
{ potret.EbIIb = 0.; }
else
{potret.EbIIb = jacobien0 * inv.V * inter/limite_inf_bIIb;};
{potret.EbIIb = jacobien0 * inv.V * inter *unsurdelta;};
};
// potret.EbIIb = jacobien0 * inv.V * (pot_V.E - pot.E)/limite_inf_bIIb;
// dérivées secondes
potret.EVV = jacobien0 * (2. * pot.EV + inv.V * pot.EVV );
{double inter = ((E_n + pot.E) - 2.*pot_V.E );
// on est obligé de faire ainsi car sinon on a des erreurs d'arrondi
// la dérivée seconde du potentiel doit-être elle aussi > 0 (au moins à l'origine)
if (inter < ConstMath::trespetit)
{ potret.EbIIb2 = 0.; }
else
{potret.EbIIb2 = jacobien0 * inv.V * inter
/(limite_inf_bIIb * limite_inf_bIIb);};
* unsurdelta * unsurdelta;};
//cout << "\n debug ((E_n + pot.E) - 2.*pot_V.E )= " << ((E_n + pot.E) - 2.*pot_V.E ) << endl;
{double inter = (pot_V.EV - pot.EV);
// on est obligé de faire ainsi car sinon on a des erreurs d'arrondi
if (inter < ConstMath::trespetit)
{ potret.EbIIbV = potret.EbIIb / inv.V; }
else
{potret.EbIIbV = potret.EbIIb / inv.V
+ jacobien0 * inv.V * inter / limite_inf_bIIb;};
};
// pour la variation de la dérivée / V, a priori on peut avoir les deux signes
// donc on ne fait pas de filtrage
// {double inter = (pot_V.EV - pot.EV);
// // on est obligé de faire ainsi car sinon on a des erreurs d'arrondi
// if (inter < ConstMath::trespetit)
// { potret.EbIIbV = potret.EbIIb / inv.V; }
// else
// {potret.EbIIbV = potret.EbIIb / inv.V
// + jacobien0 * inv.V * inter * unsurdelta;};
// };
potret.EbIIbV = potret.EbIIb / inv.V
+ jacobien0 * inv.V * (pot_V.EV - pot.EV) * unsurdelta;
// potret.EbIIbV = potret.EbIIb / inv.V
// + jacobien0 * inv.V * (pot_V.EV - pot.EV) / limite_inf_bIIb;
};
// appel d'une vérification éventuelle
//+++verif*** Verif_Potentiel_et_var(inv,jacobien0,potret);
}
@ -514,8 +547,9 @@ Hyper3D::PotenAvecPhaseAvecVar Hyper3D::PotentielPhase_et_var(const Invariant& i
// récup du conteneur spécifique du point, pour sauvegarde éventuelle
SaveResulHyperD & save_resulHyperD = *((SaveResulHyperD*) saveResul);
// cout << "\n " << potret.E; // pour avoir a cces en debug ??
if ((Dabs(inv.bIIb) > limite_inf_bIIb)||avec_regularisation)
// if (Dabs(inv.bIIb) > limite_inf_Qeps*limite_inf_Qeps)
// if ((Dabs(inv.bIIb) > limite_inf_bIIb)||avec_regularisation)
if (Dabs(inv.bIIb) > limite_inf_bIIb)
// if (Dabs(inv.bIIb) > limite_inf_Qeps*limite_inf_Qeps)
{ // calcul des invariants sous la nouvelle forme
Invariant2QepsCosphi inv_spes = Invariant2Specif(inv);
// calcul du potentiel sous la forme polaire
@ -713,13 +747,33 @@ Hyper3D::PotenAvecPhaseAvecVar Hyper3D::PotentielPhase_et_var(const Invariant& i
// calcul de potret
potret.E = pot.E * inv.V * jacobien0;
potret.Ks = pot.Ks;
// dérivées premières
potret.EV = jacobien0 * (inv.V * pot.EV + pot.E);
potret.EbIIb = jacobien0 * inv.V * (pot.E - pot_V.E)*unsurdelta;
potret.EbIIb = jacobien0 * inv.V * ( pot_V.E - pot.E)*unsurdelta;
{double inter = (pot_V.E - pot.E);
// on est obligé de faire ainsi car sinon on a des erreurs d'arrondi
// le potentiel doit-être croissant, on doit donc avoir toujours inter > 0
if (inter < ConstMath::trespetit)
{ potret.EbIIb = 0.; }
else
{potret.EbIIb = jacobien0 * inv.V * inter * unsurdelta;};
};
// dérivées secondes
potret.EVV = jacobien0 * (2. * pot.EV + inv.V * pot.EVV );
potret.EbIIb2 = jacobien0 * inv.V * (E_n - 2.*pot_V.E + pot.E)
*unsurdelta*unsurdelta;
potret.EbIIbV = potret.EbIIb / inv.V
{double inter = ((E_n + pot.E) - 2.*pot_V.E ); //(E_n - 2.*pot_V.E + pot.E)
// on est obligé de faire ainsi car sinon on a des erreurs d'arrondi
// la dérivée seconde du potentiel doit-être elle aussi > 0 (au moins à l'origine)
if (inter < ConstMath::trespetit)
{ potret.EbIIb2 = 0.; }
else
{potret.EbIIb2 = jacobien0 * inv.V * inter
* unsurdelta * unsurdelta;};
//cout << "\n debug ((E_n + pot.E) - 2.*pot_V.E )= " << ((E_n + pot.E) - 2.*pot_V.E ) << endl;
}
// pour la variation de la dérivée / V, a priori on peut avoir les deux signes
// donc on ne fait pas de filtrage
potret.EbIIbV = potret.EbIIb / inv.V
+ jacobien0 * inv.V * (pot_V.EV - pot.EV) *unsurdelta;
// pour les dérivées selon l'angle tous les termes sont considéré nul
potret.EIeps = 0.;
@ -826,7 +880,7 @@ Hyper3D::InvariantQeps Hyper3D::InvariantSpecifSansPhase(const Invariant & inv)
// calcul des invariants Qeps,cos3phi, ainsi que leur variation par rapport
// aux trois invariants Ieps, V et bIIb
Hyper3D::InvariantQepsCosphi Hyper3D::InvariantSpecif(const Invariant & inv)
{ Hyper3D::InvariantQepsCosphi inv_ret; // def du retour
{ Hyper3D::InvariantQepsCosphi inv_ret; // def du retour, init à 0
// tout d'abord les nouveaux invariants
inv_ret.Qeps = sqrt(2. * inv.bIIb);
double inv_V = inv.V; // init pour être éventuellement modifié
@ -841,7 +895,8 @@ Hyper3D::InvariantQepsCosphi Hyper3D::InvariantSpecif(const Invariant & inv)
inv_ret.dQepsdbIIb = unsurQeps;
// --- angle de phase
// dans le cas ou Qeps est trop petit on laisse les 0
if ((inv_ret.Qeps >= limite_inf_Qeps)||(avec_regularisation))
// if ((inv_ret.Qeps >= limite_inf_Qeps)||(avec_regularisation))
if (inv_ret.Qeps >= limite_inf_Qeps)
{ double unsurQeps3 = unsurQeps * unsurQeps * unsurQeps;
double unsurQeps5 = unsurQeps3 * unsurQeps * unsurQeps;
double troisracine6 = 3. * sqrt(6.);
@ -866,7 +921,7 @@ Hyper3D::InvariantQepsCosphi Hyper3D::InvariantSpecif(const Invariant & inv)
// calcul de l'invariants Qeps ainsi que ses variations première et seconde
// par rapport à bIIb (Qeps doit être non nul)
Hyper3D::Invariant2Qeps Hyper3D::Invariant2SpecifSansPhase(const Invariant & inv)
{ Hyper3D::Invariant2Qeps inv_ret; // def du retour
{ Hyper3D::Invariant2Qeps inv_ret; // def du retour et init à 0
// tout d'abord les nouveaux invariants
inv_ret.Qeps = sqrt(2. * inv.bIIb);
double unsurQeps; // init = 1./inv_ret.Qeps; // pour simplifier
@ -886,7 +941,7 @@ Hyper3D::Invariant2Qeps Hyper3D::Invariant2SpecifSansPhase(const Invariant & inv
// calcul des invariants Qeps,cos3phi, ainsi que leur variation première et seconde
// par rapport aux trois invariants Ieps, V et bIIb
Hyper3D::Invariant2QepsCosphi Hyper3D::Invariant2Specif(const Invariant & inv)
{ Hyper3D::Invariant2QepsCosphi inv_ret; // def du retour
{ Hyper3D::Invariant2QepsCosphi inv_ret; // def du retour, init à 0
// tout d'abord les nouveaux invariants
inv_ret.Qeps = sqrt(2. * inv.bIIb);
double unsurQeps; // init = 1./inv_ret.Qeps; // pour simplifier
@ -903,33 +958,37 @@ Hyper3D::Invariant2QepsCosphi Hyper3D::Invariant2Specif(const Invariant & inv)
double unsurQeps3 = unsurQeps * unsurQeps * unsurQeps;
inv_ret.dQepsdbIIb2 = -1. * unsurQeps3;
// --- angle de phase
double unsurQeps5 = unsurQeps3 * unsurQeps * unsurQeps;
double unsurQeps7 = unsurQeps5 * unsurQeps * unsurQeps;
double racine6=sqrt(6.);
double troisracine6 = 3. * racine6;
double neufracine6 = 3. * troisracine6;
inv_ret.cos3phi = troisracine6 * inv.bIIIb * unsurQeps3;
if (inv_ret.cos3phi > 1.) inv_ret.cos3phi=1.;
if (inv_ret.cos3phi < -1.) inv_ret.cos3phi=-1.;
double unsurV3 = 1. / (inv_V * inv_V * inv_V);
// maintenant les variations
inv_ret.dcos3phidV = troisracine6 * unsurQeps3 * unsurV3 / 4. ;
inv_ret.dcos3phidIeps = troisracine6 * unsurQeps3 * (-0.25 + inv.bIIb*untiers
+ inv.Ieps*untiers - inv.Ieps * inv.Ieps/9.);
inv_ret.dcos3phidbIIb = - neufracine6 * unsurQeps5 * inv.bIIIb
+ troisracine6 * unsurQeps3 * (inv.Ieps*untiers - 0.5);
// les variations secondes
inv_ret.dcos3phidV2 = - neufracine6 * unsurQeps3 * unsurV3 / (4. * inv_V);
inv_ret.dcos3phidIeps2 = troisracine6 * unsurQeps3 * (1./3. - 2./9. * inv.Ieps);
inv_ret.dcos3phidbIIb2 = 15. * troisracine6 * inv.bIIIb * unsurQeps7
- 2.*neufracine6 * unsurQeps5 * (untiers * inv.Ieps - 0.5);
inv_ret.dcos3phidVdbIIb = - neufracine6 * unsurQeps5 * unsurV3 * 0.25;
inv_ret.dcos3phidIepsdbIIb = racine6 * unsurQeps3
- neufracine6 * unsurQeps5
* (-0.25 + inv.bIIb*untiers + untiers * inv.Ieps
- 1./9. * inv.Ieps * inv.Ieps );
// dans le cas ou Qeps est trop petit on laisse les 0
// if ((inv_ret.Qeps >= limite_inf_Qeps)||(avec_regularisation))
if (inv_ret.Qeps >= limite_inf_Qeps)
{ double unsurQeps5 = unsurQeps3 * unsurQeps * unsurQeps;
double unsurQeps7 = unsurQeps5 * unsurQeps * unsurQeps;
double racine6=sqrt(6.);
double troisracine6 = 3. * racine6;
double neufracine6 = 3. * troisracine6;
inv_ret.cos3phi = troisracine6 * inv.bIIIb * unsurQeps3;
if (inv_ret.cos3phi > 1.) inv_ret.cos3phi=1.;
if (inv_ret.cos3phi < -1.) inv_ret.cos3phi=-1.;
double unsurV3 = 1. / (inv_V * inv_V * inv_V);
// maintenant les variations
inv_ret.dcos3phidV = troisracine6 * unsurQeps3 * unsurV3 / 4. ;
inv_ret.dcos3phidIeps = troisracine6 * unsurQeps3 * (-0.25 + inv.bIIb*untiers
+ inv.Ieps*untiers - inv.Ieps * inv.Ieps/9.);
inv_ret.dcos3phidbIIb = - neufracine6 * unsurQeps5 * inv.bIIIb
+ troisracine6 * unsurQeps3 * (inv.Ieps*untiers - 0.5);
// les variations secondes
inv_ret.dcos3phidV2 = - neufracine6 * unsurQeps3 * unsurV3 / (4. * inv_V);
inv_ret.dcos3phidIeps2 = troisracine6 * unsurQeps3 * (1./3. - 2./9. * inv.Ieps);
inv_ret.dcos3phidbIIb2 = 15. * troisracine6 * inv.bIIIb * unsurQeps7
- 2.*neufracine6 * unsurQeps5 * (untiers * inv.Ieps - 0.5);
inv_ret.dcos3phidVdbIIb = - neufracine6 * unsurQeps5 * unsurV3 * 0.25;
inv_ret.dcos3phidIepsdbIIb = racine6 * unsurQeps3
- neufracine6 * unsurQeps5
* (-0.25 + inv.bIIb*untiers + untiers * inv.Ieps
- 1./9. * inv.Ieps * inv.Ieps );
};
//debug
//cout << "\n inv_ret.cos3phi= "<<inv_ret.cos3phi << "Hyper3D::Invariant2Specif(" << endl;
//fin debug
@ -937,7 +996,103 @@ Hyper3D::Invariant2QepsCosphi Hyper3D::Invariant2Specif(const Invariant & inv)
return inv_ret;
};
// Lecture des paramètre specifique sur fichier
void Hyper3D::LectParaSpecifiques(UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D,LesFonctions_nD& lesFonctionsnD)
{ string nom_class_methode("Hyper3D::LectParaSpecifiques");
// cas limite_inf_Qeps (variable stockée dans Hyper3D.h)
string nom1;
if (strstr(entreePrinc->tablcar,"limite_inf_Qeps_")!=NULL)
{ *(entreePrinc->entree) >> nom1 ;
if (nom1 != "limite_inf_Qeps_")
{ cout << "\n erreur en lecture du drapeau de limite_inf_Qeps, on attendait le mot cle "
<< " limite_inf_Qeps_ on a lue: " << nom1 ;
entreePrinc->MessageBuffer("**Hyper3D::LectParaSpecifiques((.....**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
*(entreePrinc->entree) >> limite_inf_Qeps;
};
// cas limite_inf_Qeps (variable stockée dans Hyper3D.h)
if (strstr(entreePrinc->tablcar,"limite_inf_bIIb_")!=NULL)
{ *(entreePrinc->entree) >> nom1 ;
if (nom1 != "limite_inf_bIIb_")
{ cout << "\n erreur en lecture du drapeau de limite_inf_bIIb, on attendait le mot cle "
<< " limite_inf_bIIb_ on a lue: " << nom1 ;
entreePrinc->MessageBuffer("**Hyper3D::LectParaSpecifiques((.....**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
*(entreePrinc->entree) >> limite_inf_bIIb;
};
// cas avec régularisation (variable stockée dans Hyper3D.h)
avec_regularisation = false; // par défaut
if (strstr(entreePrinc->tablcar,"avec_regularisation_")!=NULL)
{ *(entreePrinc->entree) >> nom1 ;
if (nom1 != "avec_regularisation_")
{ cout << "\n erreur en lecture du drapeau de regularisation, on attendait le mot cle "
<< " avec_regularisation_ on a lue: " << nom1 ;
entreePrinc->MessageBuffer("**Hyper3D::LectParaSpecifiques((.....**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
*(entreePrinc->entree) >> fact_regularisation;
avec_regularisation=true;
};
// lecture de l'indication éventuelle du post traitement
string le_mot_cle = "sortie_post_";
entreePrinc->Lecture_un_parametre_int(0,nom_class_methode,0,1,le_mot_cle,sortie_post);
};
// I/O des paramètres spécifiques: ex: régularisation, limite inf ...
void Hyper3D::Ecriture_para_specifiques(ofstream& sort,const int cas)
{ if (cas == 1)
{// la régularisation éventuelle
if (avec_regularisation)
sort << " avec_regularisation " << fact_regularisation;
else
sort << " sans_regularisation ";
// limites
sort << " limite_inf_Qeps= " << limite_inf_Qeps
<< " limite_inf_bIIb= " << limite_inf_bIIb << " " ;
};
};
void Hyper3D::Lecture_para_specifiques(ifstream& ent,const int cas)
{ if (cas == 1)
{// la régularisation éventuelle
string nom;
ent >> nom;
if (nom == "avec_regularisation")
{ent >> fact_regularisation;avec_regularisation=true;}
else if (nom == "sans_regularisation")
avec_regularisation=false;
else
{cout << "\n erreur en lecture du facteur de regularisation (loi hyperelastique) "
<< " on a lue: " << nom << " au lieu du mot cle: avec_regularisation ou sans_regularisation";
Sortie(1);
};
// limites
ent >> nom;
if (nom == "limite_inf_Qeps=")
ent >> limite_inf_Qeps;
else
{cout << "\n erreur en lecture de limite_inf_Qeps (loi hyperelastique) "
<< " on a lue: " << nom << " au lieu du mot cle: limite_inf_Qeps= ";
Sortie(1);
};
ent >> nom;
if (nom == "limite_inf_bIIb=")
ent >> limite_inf_bIIb;
else
{cout << "\n erreur en lecture de limite_inf_bIIb (loi hyperelastique) "
<< " on a lue: " << nom << " au lieu du mot cle: limite_inf_bIIb= ";
Sortie(1);
};
};
};
///=============== fonctions pour la vérification et la mise au point ===============
// vérif des dérivées du potentiels par rapport aux invariants, ceci par différences finies

12
comportement/Hyper_elastique/Hyper3D.h
View file

@ -314,6 +314,12 @@ protected :
virtual PoGrenobleAvecPhaseAvecVar PoGrenoblePhase_et_var
(const Invariant2QepsCosphi& inv,const Invariant & invariantVarDdl) = 0;
// Lecture des paramètre specifique sur fichier
void LectParaSpecifiques(UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D,LesFonctions_nD& lesFonctionsnD);
// I/O des paramètres spécifiques: ex: régularisation, limite inf ...
void Ecriture_para_specifiques(ofstream& sort,const int cas);
void Lecture_para_specifiques(ifstream& ent,const int cas);
///=============== fonctions pour la vérification et la mise au point ===============
// vérif des dérivées du potentiels par rapport aux invariants, ceci par différences finies
@ -324,9 +330,9 @@ protected :
// cas avec la phase
void Verif_Potentiel_et_var(const InvariantVarDdl& inv,const double& jacobien0
,const PotenAvecPhaseAvecVar& potret );
static int indic_Verif_Potentiel_et_var; // indicateur utilisé par Verif_Potentiel_et_var
static double limite_inf_Qeps; // limite en dessous de laquelles on néglige la phase
static double limite_inf_bIIb; // limite en dessous de laquelles on fait une ope spécial
int indic_Verif_Potentiel_et_var; // indicateur utilisé par Verif_Potentiel_et_var
double limite_inf_Qeps; // limite en dessous de laquelles on néglige la phase
double limite_inf_bIIb; // limite en dessous de laquelles on fait une ope spécial
};
/// @} // end of group

39
comportement/Hyper_elastique/IsoHyper3DFavier3.cc
View file

@ -207,7 +207,7 @@ IsoHyper3DFavier3::IsoHyper3DFavier3 (const IsoHyper3DFavier3& loi) :
// Lecture des donnees de la classe sur fichier
void IsoHyper3DFavier3::LectureDonneesParticulieres (UtilLecture * entreePrinc,LesCourbes1D&
void IsoHyper3DFavier3::LectureDonneesParticulieres (UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D
,LesFonctions_nD& lesFonctionsnD)
{ // --- lecture des quatres coefficients de la loi
string nom_class_methode("IsoHyper3DFavier3::LectureDonneesParticulieres");
@ -399,23 +399,10 @@ void IsoHyper3DFavier3::LectureDonneesParticulieres (UtilLecture * entreePrinc,L
*(entreePrinc->entree) >> nQor >> gammaQor >> n_mu_inf >> gamma_mu_inf ;
avec_phase=true;
};
// cas avec régularisation (variable stockée dans Hyper3D.h)
string nom1;
if (strstr(entreePrinc->tablcar,"avec_regularisation_")!=NULL)
{ *(entreePrinc->entree) >> nom1 ;
if (nom1 != "avec_regularisation_")
{ cout << "\n erreur en lecture du drapeau de regularisation, on attendait le mot cles "
<< " avec_regularisation_ on a lue: " << nom1 ;
entreePrinc->MessageBuffer("**9--IsoHyper3DOrgeas1::LectureDonneesParticulieres(.....**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
*(entreePrinc->entree) >> fact_regularisation;
avec_regularisation=true;
};
// lecture de l'indication du post traitement
nom_class_methode = "IsoHyper3DFavier3";string le_mot_cle = "sortie_post_";
entreePrinc->Lecture_un_parametre_int(0,nom_class_methode,0,1,le_mot_cle,sortie_post);
// 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);
@ -513,6 +500,16 @@ void IsoHyper3DFavier3::Info_commande_LoisDeComp(UtilLecture& entreePrinc)
<< "\n#"
<< "\n#------------------------------------------------------------------------------------"
<< "\n#------------------------------------------------------------------------------------"
<< "\n# il est possible d'indiquer 2 parametres specifiques de limite inf "
<< "\n# limite_inf_Qeps_ : si Qeps < limite_inf_Qeps et sans regularisation: on considere Qeps nul, et l'angle de phase aussi "
<< "\n# limite_inf_bIIb_ : si Dabs(inv.bIIb) < limite_inf_bIIb et sans regularisation "
<< "\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 "
@ -786,6 +783,9 @@ void IsoHyper3DFavier3::Lecture_base_info_loi(ifstream& ent,const int cas,LesRef
{ ent >> toto >> nQor >> toto >> gammaQor >> toto
>> n_mu_inf >> toto >> gamma_mu_inf;
};
// 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 >> toto >> sortie_post ;
};
@ -833,6 +833,9 @@ void IsoHyper3DFavier3::Ecriture_base_info_loi(ofstream& sort,const int cas)
{ sort << "\n nQor= " << nQor << " gammaQor= " << gammaQor << " n_mu_inf= "
<< n_mu_inf << " gamma_mu_inf= " << gamma_mu_inf;
};
// 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 << " ";
};

47
comportement/Hyper_elastique/IsoHyper3DOrgeas1.cc
View file

@ -394,23 +394,9 @@ void IsoHyper3DOrgeas1::LectureDonneesParticulieres
};
};
};
// cas avec régularisation (variable stockée dans Hyper3D.h)
string nom1;
if (strstr(entreePrinc->tablcar,"avec_regularisation_")!=NULL)
{ *(entreePrinc->entree) >> nom1 ;
if (nom1 != "avec_regularisation_")
{ cout << "\n erreur en lecture du drapeau de regularisation, on attendait le mot cles "
<< " avec_regularisation_ on a lue: " << nom1 ;
entreePrinc->MessageBuffer("**9--IsoHyper3DOrgeas1::LectureDonneesParticulieres(.....**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
*(entreePrinc->entree) >> fact_regularisation;
avec_regularisation=true;
};
// lecture de l'indication éventuelle du post traitement
string nom_class_methode = "IsoHyper3DOrgeas1";string le_mot_cle = "sortie_post_";
entreePrinc->Lecture_un_parametre_int(0,nom_class_methode,0,1,le_mot_cle,sortie_post);
// 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
@ -537,6 +523,26 @@ void IsoHyper3DOrgeas1::Info_commande_LoisDeComp(UtilLecture& entreePrinc)
<< "\n # cas_Q0e_thermo_dependant_ 2 courbe_evol_Q0e "
<< "\n # ici courbe_evol_Q0e est le nom d'une courbe qui doit avoir ete definit auparavant "
<< "\n#------------------------------------------------------------------------------------"
<< "\n# il est possible d'indiquer 2 parametres specifiques de limite inf "
<< "\n# limite_inf_Qeps_ : si Qeps < limite_inf_Qeps et sans regularisation: on considere Qeps nul, et l'angle de phase aussi "
<< "\n# limite_inf_bIIb_ : si Dabs(inv.bIIb) < limite_inf_bIIb et sans regularisation "
<< "\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 2 parametres specifiques de limite inf "
<< "\n# limite_inf_Qeps_ : si Qeps < limite_inf_Qeps et sans regularisation: on considere Qeps nul, et l'angle de phase aussi "
<< "\n# limite_inf_bIIb_ : si Dabs(inv.bIIb) < limite_inf_bIIb et sans regularisation "
<< "\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 "
@ -724,6 +730,9 @@ void IsoHyper3DOrgeas1::Lecture_base_info_loi(ifstream& ent,const int cas,LesRef
alpha1_2 = Sqr(alpha1);
alpha3_2 = Sqr(alpha3);
// mu1_2 = Sqr(mu1);
// 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 >> toto >> sortie_post ;
};
@ -787,6 +796,10 @@ void IsoHyper3DOrgeas1::Ecriture_base_info_loi(ofstream& sort,const int cas)
<< "\n nMu2= " << nMu2 << " gammaMu2= " << gammaMu2
<< "\n nMu3= " << nMu3 << " gammaMu3= " << gammaMu3;
};
// 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 << " ";
};

45
comportement/Hyper_elastique/IsoHyper3DOrgeas2.cc
View file

@ -771,26 +771,15 @@ void IsoHyper3DOrgeas2::LectureDonneesParticulieres
// entreePrinc->NouvelleDonnee(); // passage d'une ligne
};
// cas avec régularisation (variable stockée dans Hyper3D.h)
string nom1;
if (strstr(entreePrinc->tablcar,"avec_regularisation_")!=NULL)
{ *(entreePrinc->entree) >> nom1 ;
if (nom1 != "avec_regularisation_")
{ cout << "\n erreur en lecture du drapeau de regularisation, on attendait le mot cles "
<< " avec_regularisation_ on a lue: " << nom1 ;
entreePrinc->MessageBuffer("**9--IsoHyper3DOrgeas1::LectureDonneesParticulieres(.....**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
*(entreePrinc->entree) >> fact_regularisation;
avec_regularisation=true;
};
// au cas où on passe une ligne
if ( (strstr(entreePrinc->tablcar,"fin_parametres_avec_phase_")!=NULL)
|| (strstr(entreePrinc->tablcar,"fin_parametres_avec_nD_")!=NULL))
entreePrinc->NouvelleDonnee();
// Lecture des paramètre specifique sur fichier (exe: regularisation sortie_post...
Hyper3D::LectParaSpecifiques(entreePrinc,lesCourbes1D,lesFonctionsnD);
// lecture de l'indication du post traitement
string le_mot_cle = "sortie_post_";
// lecture de l'indication éventuelle du post traitement
entreePrinc->Lecture_un_parametre_int(0,nom_class_methode,0,1,le_mot_cle,sortie_post);
// appel au niveau de la classe mère
Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire
(*entreePrinc,lesFonctionsnD,true);
@ -1012,6 +1001,16 @@ void IsoHyper3DOrgeas2::Info_commande_LoisDeComp(UtilLecture& entreePrinc)
<< "\n # des parametres initiaux (ou de ceux obtenus apres dependance a la temperature et/ou "
<< "\n # la phase) "
<< "\n # "
<< "\n#------------------------------------------------------------------------------------"
<< "\n# il est possible d'indiquer 2 parametres specifiques de limite inf "
<< "\n# limite_inf_Qeps_ : si Qeps < limite_inf_Qeps et sans regularisation: on considere Qeps nul, et l'angle de phase aussi "
<< "\n# limite_inf_bIIb_ : si Dabs(inv.bIIb) < limite_inf_bIIb et sans regularisation "
<< "\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#--------------------------- dependance facteur de regularisation ---------------"
<< "\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 "
@ -1237,6 +1236,9 @@ void IsoHyper3DOrgeas2::Lecture_base_info_loi(ifstream& ent,const int cas,LesRef
alpha1_2 = Sqr(alpha1);
alpha3_2 = Sqr(alpha3);
avec_phase=true; // variable définit dans une classe mère, ici = vrai par défaut
// 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 >> toto >> sortie_post ;
};
@ -1324,7 +1326,10 @@ void IsoHyper3DOrgeas2::Ecriture_base_info_loi(ofstream& sort,const int cas)
if (Q0e_nD == NULL) { sort << " Q0e_nD= " << false << " " ;}
else { sort << " Q0e_nD= " << true << " ";
LesFonctions_nD::Ecriture_pour_base_info(sort,cas,Q0e_nD);};
// 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 << " ";
};

38
comportement/Hyper_elastique/IsoHyperBulk3.cc
View file

@ -132,24 +132,10 @@ void IsoHyperBulk3::LectureDonneesParticulieres
};
// entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
};
// Lecture des paramètre specifique sur fichier (exe: regularisation sortie_post...
Hyper3D::LectParaSpecifiques(entreePrinc,lesCourbes1D,lesFonctionsnD);
// cas avec régularisation (variable stockée dans Hyper3D.h)
string nom1;
if (strstr(entreePrinc->tablcar,"avec_regularisation_")!=NULL)
{ *(entreePrinc->entree) >> nom1 ;
if (nom1 != "avec_regularisation_")
{ cout << "\n erreur en lecture du drapeau de regularisation, on attendait le mot cles "
<< " avec_regularisation_ on a lue: " << nom1 ;
entreePrinc->MessageBuffer("**9--IsoHyper3DOrgeas1::LectureDonneesParticulieres(.....**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
*(entreePrinc->entree) >> fact_regularisation;
avec_regularisation=true;
};
// lecture de l'indication du post traitement
string nom_class_methode = "IsoHyperBulk3";string le_mot_cle = "sortie_post_";
entreePrinc->Lecture_un_parametre_int(0,nom_class_methode,0,1,le_mot_cle,sortie_post);
// appel au niveau de la classe mère
Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire
@ -224,6 +210,16 @@ void IsoHyperBulk3::Info_commande_LoisDeComp(UtilLecture& entreePrinc)
<< "\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 et sans regularisation: on considere Qeps nul, et l'angle de phase aussi "
<< "\n# limite_inf_bIIb_ : si Dabs(inv.bIIb) < limite_inf_bIIb et sans regularisation "
<< "\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 "
@ -288,6 +284,11 @@ void IsoHyperBulk3::Lecture_base_info_loi(ifstream& ent,const int cas
}
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);
@ -310,6 +311,9 @@ void IsoHyperBulk3::Ecriture_base_info_loi(ofstream& sort,const int cas)
{ 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 << " ";
};

37
comportement/Hyper_elastique/IsoHyperBulk_gene.cc
View file

@ -135,23 +135,10 @@ void IsoHyperBulk_gene::LectureDonneesParticulieres
thermo_dependant = true;
};
// cas avec régularisation (variable stockée dans Hyper3D.h)
string nom1;
if (strstr(entreePrinc->tablcar,"avec_regularisation_")!=NULL)
{ *(entreePrinc->entree) >> nom1 ;
if (nom1 != "avec_regularisation_")
{ cout << "\n erreur en lecture du drapeau de regularisation, on attendait le mot cles "
<< " avec_regularisation_ on a lue: " << nom1 ;
entreePrinc->MessageBuffer("**9--IsoHyper3DOrgeas1::LectureDonneesParticulieres(.....**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
*(entreePrinc->entree) >> fact_regularisation;
avec_regularisation=true;
};
// lecture de l'indication du post traitement
string nom_class_methode = "IsoHyperBulk_gene";string le_mot_cle = "sortie_post_";
entreePrinc->Lecture_un_parametre_int(0,nom_class_methode,0,1,le_mot_cle,sortie_post);
// 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
@ -211,6 +198,16 @@ void IsoHyperBulk_gene::Info_commande_LoisDeComp(UtilLecture& entreePrinc)
<< "\n# omega_V= CPL1D DdlP 0. 0. 1. 1. FdlP "
<< "\n# omega_thermo_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 et sans regularisation: on considere Qeps nul, et l'angle de phase aussi "
<< "\n# limite_inf_bIIb_ : si Dabs(inv.bIIb) < limite_inf_bIIb et sans regularisation "
<< "\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 "
@ -274,6 +271,9 @@ void IsoHyperBulk_gene::Lecture_base_info_loi(ifstream& ent,const int cas
}
else
{ ent >> nom; F_w_T = lesCourbe1D.Lecture_pour_base_info(ent,cas,F_w_T); };
// 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 ;
};
@ -297,6 +297,9 @@ void IsoHyperBulk_gene::Ecriture_base_info_loi(ofstream& sort,const int cas)
{ sort << " F_w_T " << " 1 ";
LesCourbes1D::Ecriture_pour_base_info(sort,cas,F_w_T);
};
// 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 << " ";
};