diff --git a/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.cc b/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.cc index eecc648..fcf3996 100644 --- a/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.cc +++ b/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.cc @@ -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 //\\//\\// diff --git a/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc b/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc index a5d463f..f2d6f4f 100644 --- a/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc +++ b/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc @@ -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 diff --git a/Parametres/EnteteParaGlob.h b/Parametres/EnteteParaGlob.h index 8c85734..597c9d5 100644 --- a/Parametres/EnteteParaGlob.h +++ b/Parametres/EnteteParaGlob.h @@ -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 diff --git a/References/Lect_reference.h b/References/Lect_reference.h index 41a8bc6..8f9eeed 100644 --- a/References/Lect_reference.h +++ b/References/Lect_reference.h @@ -37,7 +37,7 @@ #define LECT_REFERENCE_H -#include "Liste_T.cc +#include "Liste_T.cc" #include "Reference.h" #include "Tableau_T.h" diff --git a/comportement/Hyper_elastique/Hyper3D.cc b/comportement/Hyper_elastique/Hyper3D.cc index 3eeac58..5781cee 100644 --- a/comportement/Hyper_elastique/Hyper3D.cc +++ b/comportement/Hyper_elastique/Hyper3D.cc @@ -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= "<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 diff --git a/comportement/Hyper_elastique/Hyper3D.h b/comportement/Hyper_elastique/Hyper3D.h index 975a0f8..4187ac4 100644 --- a/comportement/Hyper_elastique/Hyper3D.h +++ b/comportement/Hyper_elastique/Hyper3D.h @@ -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 diff --git a/comportement/Hyper_elastique/IsoHyper3DFavier3.cc b/comportement/Hyper_elastique/IsoHyper3DFavier3.cc index f716591..5231e73 100644 --- a/comportement/Hyper_elastique/IsoHyper3DFavier3.cc +++ b/comportement/Hyper_elastique/IsoHyper3DFavier3.cc @@ -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 << " "; }; diff --git a/comportement/Hyper_elastique/IsoHyper3DOrgeas1.cc b/comportement/Hyper_elastique/IsoHyper3DOrgeas1.cc index 33b03f0..ce5d57d 100644 --- a/comportement/Hyper_elastique/IsoHyper3DOrgeas1.cc +++ b/comportement/Hyper_elastique/IsoHyper3DOrgeas1.cc @@ -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 << " "; }; diff --git a/comportement/Hyper_elastique/IsoHyper3DOrgeas2.cc b/comportement/Hyper_elastique/IsoHyper3DOrgeas2.cc index 968cd3d..6872c6c 100644 --- a/comportement/Hyper_elastique/IsoHyper3DOrgeas2.cc +++ b/comportement/Hyper_elastique/IsoHyper3DOrgeas2.cc @@ -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 << " "; }; diff --git a/comportement/Hyper_elastique/IsoHyperBulk3.cc b/comportement/Hyper_elastique/IsoHyperBulk3.cc index f371f36..8bc13f7 100644 --- a/comportement/Hyper_elastique/IsoHyperBulk3.cc +++ b/comportement/Hyper_elastique/IsoHyperBulk3.cc @@ -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 << " "; }; diff --git a/comportement/Hyper_elastique/IsoHyperBulk_gene.cc b/comportement/Hyper_elastique/IsoHyperBulk_gene.cc index fe81ca2..ddf3abf 100755 --- a/comportement/Hyper_elastique/IsoHyperBulk_gene.cc +++ b/comportement/Hyper_elastique/IsoHyperBulk_gene.cc @@ -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 << " "; };