V 7.017
- 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:
parent
d05b1fd9ed
commit
3ccffa8899
|
|
@ -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 //\\//\\//
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@
|
|||
#define LECT_REFERENCE_H
|
||||
|
||||
|
||||
#include "Liste_T.cc
|
||||
#include "Liste_T.cc"
|
||||
#include "Reference.h"
|
||||
#include "Tableau_T.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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 << " ";
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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 << " ";
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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 << " ";
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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 << " ";
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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 << " ";
|
||||
};
|
||||
|
|
|
|||
Loading…
Reference in a new issue