rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/comportement/hysteresis/Hysteresis3D.cc
Gérard Rio 0460624e94 mise à jour 7.010
2023-05-03 17:23:49 +02:00

3434 lines
186 KiB
C++
Raw Blame History

// FICHIER : Hysteresis3D.cc
// CLASSE : Hysteresis3D
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
//#include "Debug.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <math.h>
#include <stdlib.h>
#include "Sortie.h"
#include "ConstMath.h"
#include "MatLapack.h"
#include "ExceptionsLoiComp.h"
#include "MotCle.h"
#include "CharUtil.h"
#include "Hysteresis3D.h"
#include "Enum_TypeQuelconque.h"
#include "TypeQuelconqueParticulier.h"
// $$$$$$$$$$$$$$$$$$$$$ a faire $$$$$$$$$$$$$$$$$
// a priori la sauvegarde de w_base n'est pas nécessaire car c'est un résultat
// mais on ne sans sert pas comme test, et à l'aide des listes on peut savoir si l'on est sur
// une première charge ou non, ce qui donne la valeur de w_base
// ========== fonctions pour la classe de sauvegarde des résultats =========
// constructeur par défaut
Hysteresis3D::SaveResulHysteresis3D::SaveResulHysteresis3D() :
sigma_barre_BH_t(),sigma_barre_BH_tdt(),sigma_barre_BH_R()
,oc_BH_R(),oc_BH_t(),oc_BH_tdt(),fonction_aide_t(0.),fonction_aide_tdt(0.)
,wBase_t(1),wBase_tdt(1)
,def_equi_at(0.),def_equi_atdt(0.)
,ip2(),fct_aide_t_a_tdt(),fct_aide()
,modif(0),sigma_barre_BH_R_t_a_tdt(),nb_coincidence(0)
,oc_BH_t_a_tdt(),def_equi_t_a_tdt(),def_equi()
,sigma_barre_BH_R_atrans(),oc_BH_R_atrans()
,indicateurs_resolution(),indicateurs_resolution_t()
// ,modif_sauve(0),sigma_barre_BH_R_sauve(),nb_ref_new_sauve(0)
// ,nb_coincidence_sauve(0),oc_BH_R_sauve(),nb_centre_new_sauve(0)
// ,def_equi_sauve()
{ // la première valeur de la déformation équivalente est 0
def_equi.push_front(0.);
// la première valeur de la fonction d'aide est l'infini
fct_aide.push_front(ConstMath::tresgrand);
};
// constructeur de copie
Hysteresis3D::SaveResulHysteresis3D::SaveResulHysteresis3D(const SaveResulHysteresis3D& sav):
sigma_barre_BH_t(sav.sigma_barre_BH_t),sigma_barre_BH_tdt(sav.sigma_barre_BH_tdt)
,sigma_barre_BH_R(sav.sigma_barre_BH_R)
,oc_BH_R(sav.oc_BH_R),oc_BH_t(sav.oc_BH_t),oc_BH_tdt(sav.oc_BH_tdt)
,fonction_aide_t(sav.fonction_aide_t),fonction_aide_tdt(sav.fonction_aide_tdt)
,wBase_t(sav.wBase_t),wBase_tdt(sav.wBase_tdt)
,def_equi_at(sav.def_equi_at),def_equi_atdt(sav.def_equi_atdt)
,modif(sav.modif),sigma_barre_BH_R_t_a_tdt(sav.sigma_barre_BH_R_t_a_tdt)
,nb_coincidence(sav.nb_coincidence),oc_BH_t_a_tdt(sav.oc_BH_t_a_tdt)
,def_equi_t_a_tdt(sav.def_equi_t_a_tdt),def_equi(sav.def_equi)
,ip2(),fct_aide_t_a_tdt(sav.fct_aide_t_a_tdt),fct_aide(sav.fct_aide)
,sigma_barre_BH_R_atrans(sav.sigma_barre_BH_R_atrans),oc_BH_R_atrans(sav.oc_BH_R_atrans)
,indicateurs_resolution(sav.indicateurs_resolution),indicateurs_resolution_t(sav.indicateurs_resolution_t)
// ,modif_sauve(sav.modif_sauve),sigma_barre_BH_R_sauve(sav.sigma_barre_BH_R_sauve)
// ,nb_ref_new_sauve(sav.nb_ref_new_sauve),nb_coincidence_sauve(sav.nb_coincidence_sauve)
// ,oc_BH_R_sauve(sav.oc_BH_R_sauve),nb_centre_new_sauve(sav.nb_centre_new_sauve)
// ,def_equi_sauve(sav.def_equi_sauve)
{ if (fct_aide.size() >= 2) // pointage de ip2
{ip2= fct_aide.end(); ip2--;ip2--; }
};
// affectation
Loi_comp_abstraite::SaveResul & Hysteresis3D::SaveResulHysteresis3D::operator = ( const Loi_comp_abstraite::SaveResul & a)
{ Hysteresis3D::SaveResulHysteresis3D& sav = *((Hysteresis3D::SaveResulHysteresis3D*) &a);
// recopie de toutes les grandeurs
oc_BH_t = sav.oc_BH_t;
oc_BH_tdt = sav.oc_BH_tdt;
def_equi_at = sav.def_equi_at;
def_equi_atdt = sav.def_equi_atdt;
oc_BH_t_a_tdt = sav.oc_BH_t_a_tdt;
def_equi_t_a_tdt = sav.def_equi_t_a_tdt;
oc_BH_R = sav.oc_BH_R;
def_equi = sav.def_equi;
sigma_barre_BH_R_atrans = sav.sigma_barre_BH_R_atrans;
oc_BH_R_atrans = sav.oc_BH_R_atrans;
sigma_barre_BH_t = sav.sigma_barre_BH_t;
sigma_barre_BH_tdt = sav.sigma_barre_BH_tdt;
fonction_aide_t = sav.fonction_aide_t;
fonction_aide_tdt = sav.fonction_aide_tdt;
wBase_t = sav.wBase_t;
wBase_tdt = sav.wBase_tdt;
fct_aide = sav.fct_aide;
if (fct_aide.size() >= 2) // pointage de ip2
{ip2= fct_aide.end(); ip2--;ip2--; };
modif = sav.modif;
sigma_barre_BH_R_t_a_tdt = sav.sigma_barre_BH_R_t_a_tdt;
nb_coincidence = sav.nb_coincidence;
fct_aide_t_a_tdt = sav.fct_aide_t_a_tdt;
sigma_barre_BH_R = sav.sigma_barre_BH_R;
indicateurs_resolution = sav.indicateurs_resolution;
indicateurs_resolution_t = sav.indicateurs_resolution_t;
return *this;
};
//------- lecture écriture dans base info -------
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Hysteresis3D::SaveResulHysteresis3D::Lecture_base_info (ifstream& ent,const int )
{ // ici toutes les données sont toujours a priori variables
string toto;
ent >> toto >> sigma_barre_BH_t ;sigma_barre_BH_tdt = sigma_barre_BH_t;
ent >> toto >> oc_BH_t; oc_BH_tdt=oc_BH_t;
ent >> toto >> wBase_t; wBase_tdt=wBase_t;
ent >> toto >> def_equi_at >> def_equi_atdt;
ent >> toto >> fonction_aide_t; fonction_aide_tdt=fonction_aide_t;
// ---- lecture liste fonction d'aide
ent >> toto;
#ifdef MISE_AU_POINT
if (toto != "list_fct_aide")
{ cout << "\n erreur dans la lecture de la list_io fonction d'aide, on ne trouve pas le mot cle: list_fct_aide "
<< " on a lu "<< toto
<< " avec auparavent: "
<< "\n fonction_aide_t= "<< fonction_aide_t
<< "\n def_equi_at= "<< def_equi_at
<< "\n def_equi_atdt= "<< def_equi_atdt
<< "\n wBase_t= "<< wBase_t
<< "\n Hysteresis3D::SaveResulHysteresis3D::Lecture_base_info (... ";
Sortie(1);
}
#endif
int taille;ent >> toto >> taille; // lecture de la taille
double un_elem;
// on vide la liste actuelle
fct_aide.clear();
for (int i=1;i<=taille;i++) // puis on lit
{ ent >> un_elem; // lecture
fct_aide.push_back(un_elem); // enregistrement
}
if (fct_aide.size() >= 2) // pointage de ip2
{ip2= fct_aide.end(); ip2--;ip2--; }
// ---- lecture des centre de cercle
ent >> toto;
#ifdef MISE_AU_POINT
if (toto != "list_oc_BH_R")
{ cout << "\n erreur dans la lecture de la list_io de centre, on ne trouve pas le mot cle: list_oc_BH_R "
<< "\n Hysteresis3D::SaveResulHysteresis3D::Lecture_base_info (... ";
Sortie(1);
}
#endif
ent >> toto >> taille; // lecture de la taille de la liste
Tenseur3BH elem;
// on vide la liste actuelle
oc_BH_R.clear();
for (int i=1;i<=taille;i++) // puis on lit
{ ent >> elem; // lecture
oc_BH_R.push_back(elem); // enregistrement
}
// initialisation pour le transport éventuel
oc_BH_R_atrans= oc_BH_R;
ent >> toto; // ---- lecture des points d'inversion
#ifdef MISE_AU_POINT
if (toto != "list_pt_inver")
{ cout << "\n erreur dans la lecture de la list_io: ref contrainte, on ne trouve pas le mot cle: list_pt_inver "
<< "\n Hysteresis3D::SaveResulHysteresis3D::Lecture_base_info (... ";
Sortie(1);
}
#endif
// on vide la listes actuelle et on lit
sigma_barre_BH_R.clear();
ent >> toto >> taille; // lecture de la taille du nombre de point d'inversion
for (int j=1;j<=taille;j++) // puis on lit
{ ent >> elem; // lecture
sigma_barre_BH_R.push_back(elem); // enregistrement
};
// initialisation pour le transport éventuel
sigma_barre_BH_R_atrans = sigma_barre_BH_R;
ent >> toto; // ---- lecture def équivalente
#ifdef MISE_AU_POINT
if (toto != "list_def_equi")
{ cout << "\n erreur dans la lecture de la list_io def equivalente, on ne trouve pas le mot cle: list_def_equi "
<< "\n Hysteresis3D::SaveResulHysteresis3D::Lecture_base_info (... ";
Sortie(1);
}
#endif
int taille_C;ent >> toto >> taille_C; // lecture de la taille
double un_elem_eps;
// on vide la liste actuelle
def_equi.clear();
for (int i=1;i<=taille_C;i++) // puis on lit
{ ent >> un_elem_eps; // lecture
def_equi.push_back(un_elem_eps); // enregistrement
}
//re-initialisation des variables de travail
TversTdt();
// Init_debut_calcul();
};
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables
//(supposées comme telles)
void Hysteresis3D::SaveResulHysteresis3D::Ecriture_base_info(ofstream& sort,const int )
{ // ici toutes les données sont toujours a priori variables
sort << " sigma_barre_BH_t " << sigma_barre_BH_t;
sort << "\n oc_BH_t " << oc_BH_t;
sort << "\n wBase_t " << wBase_t;
sort << "\n def_equi_at_et_tdt " << def_equi_at << " " << def_equi_atdt;
sort << " fct_aide_t " << fonction_aide_t;
// liste des fonctions d'aide
{sort << "\n list_fct_aide " << "taille= " << fct_aide.size() << " ";
List_io <double>::const_iterator iter_courant,iter_fin = fct_aide.end();
for (iter_courant=fct_aide.begin();iter_courant!=iter_fin;iter_courant++)
{ sort << setprecision(ParaGlob::NbdigdoCA()) << (*iter_courant) ; sort << " "; }
}
// listes: centre de cercle et point d'inversion
sort << "\n list_oc_BH_R " << "taille= " << oc_BH_R.size() << " ";
List_io <Tenseur3BH>::const_iterator iter_courant,iter_fin = oc_BH_R.end();
for (iter_courant=oc_BH_R.begin();iter_courant!=iter_fin;iter_courant++)
{ sort << setprecision(ParaGlob::NbdigdoCA()) << (*iter_courant) ; sort << " ";
};
int taille_sigma_barre_BH_R= sigma_barre_BH_R.size();
sort << "\n list_pt_inver " << "taille= " << taille_sigma_barre_BH_R << " ";
List_io <Tenseur3BH>::const_iterator jter_courant,jter_fin = sigma_barre_BH_R.end();
for (jter_courant=sigma_barre_BH_R.begin();jter_courant!=jter_fin;jter_courant++)
{ sort << setprecision(ParaGlob::NbdigdoCA()) << (*jter_courant) ;
sort << " ";
};
// les listes: def équivalente
sort << " list_def_equi " << "taille= " << def_equi.size() << " ";
List_io <double>::const_iterator kter_courant,kter_fin = def_equi.end();
for (kter_courant=def_equi.begin();kter_courant!=kter_fin;kter_courant++)
{ sort << setprecision(ParaGlob::NbdigdoCA()) << (*kter_courant) ; sort << " "; };
};
// mise à jour des informations transitoires
void Hysteresis3D::SaveResulHysteresis3D::TdtversT()
{ // partie générale
sigma_barre_BH_t = sigma_barre_BH_tdt;oc_BH_t=oc_BH_tdt;
wBase_t = wBase_tdt;
def_equi_at = def_equi_atdt; // def équivalente
fonction_aide_t=fonction_aide_tdt;
// partie spécifique
// en fait ici on pourrait simplifier car le cas 3 est toujours valide -> supprime l'utilité
// du paramètre modif !!
// int maxi_ref_en_plus = 0; // indique le maximum de ref que l'on a mis en plus dans la liste
//------- débug ---------
// vérif de la cohérence des centres et références: les rayons associés doivent être de tailles
// décroissantes
// Verif_centre_reference();
//-------- fin débug -----------
// ------- mise en place des modifs ----------
// modif_sauve = modif ; // pour le retour t -> tdt éventuel
// nb_coincidence_sauve = nb_coincidence; // idem
switch (modif)
{ case 0: // rien ne change sur le pas en terme de coincidence et d'inversion
{ break;
}
case 1: // cas où l'on a une ou plusieurs coincidences
{ // a chaque coincidence il faut supprimer 1 pt de ref et un centre de cercle
// sauf si l'on arrive au centre nul ou au point de référence null
List_io <Tenseur3BH>::iterator itens;List_io <Tenseur3BH>::iterator ioc_i;
for (int i=1;i<=nb_coincidence;i++)
{ itens = sigma_barre_BH_R.begin();
if (itens != sigma_barre_BH_R.end()) // si itens == sigma_barre_BH_R.end(), cela signifie
{//sigma_barre_BH_R_sauve.push_back(*itens); // on sauve avant de détruire
sigma_barre_BH_R.erase(itens); // que la référence est le tenseur nulle, on arrête de dépiler
};
ioc_i = oc_BH_R.begin();
if (ioc_i != oc_BH_R.end()) // si ioc_i == oc_BH_R.end(), cela signifie que le centre de référence
{//oc_BH_R_sauve.push_back(*ioc_i); // on sauve avant de détruire
oc_BH_R.erase(ioc_i); // est le tenseur nulle
};
// idem pour les def équivalentes
List_io <double>::iterator idouble;
idouble = def_equi.begin();
if (idouble != def_equi.end()) // si idouble == def_equi.end(), cela signifie que l'on est arrivé
{ //def_equi_sauve.push_back(*idouble); // on sauve avant de détruire
def_equi.erase(idouble); // sur la branche fondamentale
};
// idem pour la fonction d'aide
List_io <double>::iterator ifct;
ifct = fct_aide.begin();
if (ifct != fct_aide.end()) // si ifct == fct_aide.end(), cela signifie que l'on est arrivé
{ //fct_aide_sauve.push_back(*ifct); // on sauve avant de détruire
fct_aide.erase(ifct); // sur la branche fondamentale
};
};
break;
}
case 2: // cas où l'on a une ou plusieurs inversions
{ // on traite les centres différement des points d'inversions
int nb_centre_new = oc_BH_t_a_tdt.size(); // récup du nombre de nouveaux centres
// nb_centre_new_sauve = nb_centre_new; // on sauvegarde pour un retour t -> tdt éventuel
// on ajoute les différents nouveaux centres, en tenant compte du fait que le premier rentrée est
// le dernier dans la liste, d'où l'utilisation de reverse_iterator
List_io <Tenseur3BH>::reverse_iterator iifoi = oc_BH_t_a_tdt.rbegin();
for (int ii=1;ii<=nb_centre_new;ii++,iifoi++)
oc_BH_R.push_front(*iifoi);
// maintenant on traites les points d'inversions
int nb_ref_new = sigma_barre_BH_R_t_a_tdt.size(); // récup du nombre de nouveaux pt
// nb_ref_new_sauve = nb_ref_new; // on sauve pour le retour t -> tdt éventuel
// on ajoute les différents points d'inversions
List_io <Tenseur3BH>::reverse_iterator iitens = sigma_barre_BH_R_t_a_tdt.rbegin();
for (int ii=1;ii<=nb_ref_new;ii++,iitens++)
sigma_barre_BH_R.push_front(*iitens);
// pour les def équivalentes
List_io <double>::reverse_iterator iidouble = def_equi_t_a_tdt.rbegin();
for (int ij=1;ij<=nb_ref_new;ij++,iidouble++)
def_equi.push_front(*iidouble);
// cas de la fonction d'aide
int nb_ref = fct_aide.size(); // récup du nombre de pt de ref actuel
bool init_ip2 = false; if (nb_ref == 1) init_ip2=true; // pour gérer ip2
int nb_fct_new = fct_aide_t_a_tdt.size(); // récup du nombre de nouveau pt
// on ajoute les différentes valeurs
List_io <double>::iterator iifct = fct_aide_t_a_tdt.begin();
for (int ii=1;ii<=nb_ref_new;ii++,iitens++,iifct++)
{fct_aide.push_front(*iifct);
if (init_ip2) // uniquement pour mémoriser le W_a de la première charge
{ // cas où l'on doit initialiser ip2 (car ici le nombre de pt = 2)
ip2 = fct_aide.begin(); init_ip2 = false;
};
};
break;
}
case 3: // cas où l'on a une ou plusieurs coincidence(s) et inversion (s)
{ // les coïncidences sont forcéments au début puis on a les inversions qui sont
// au nombre d'éléments sur la liste secondaire
// a) on commence par traiter les coïncidences
// a chaque coincidence il faut supprimer 1 pt de ref et un centre de cercle
// sauf si l'on arrive au centre nul ou au point de référence null
List_io <Tenseur3BH>::iterator itens;List_io <Tenseur3BH>::iterator ioc_i;
for (int i=1;i<=nb_coincidence;i++)
{ itens = sigma_barre_BH_R.begin();
if (itens != sigma_barre_BH_R.end()) // si itens == sigma_barre_BH_R.end(), cela signifie
{//sigma_barre_BH_R_sauve.push_back(*itens); // on sauve avant de détruire
sigma_barre_BH_R.erase(itens); // que la référence est le tenseur nulle, on arrête de dépiler
};
ioc_i = oc_BH_R.begin();
if (ioc_i != oc_BH_R.end()) // si ioc_i == oc_BH_R.end(), cela signifie que le centre de référence
{//oc_BH_R_sauve.push_back(*ioc_i); // on sauve avant de détruire
oc_BH_R.erase(ioc_i); // est le tenseur nulle
};
// idem pour les def équivalentes
List_io <double>::iterator idouble;
idouble = def_equi.begin();
if (idouble != def_equi.end()) // si idouble == def_equi.end(), cela signifie que l'on est arrivé
{ //def_equi_sauve.push_back(*idouble); // on sauve avant de détruire
def_equi.erase(idouble); // sur la branche fondamentale
}
// idem pour la fonction d'aide
List_io <double>::iterator ifct;
ifct = fct_aide.begin();
if (ifct != fct_aide.end()) // si ifct == fct_aide.end(), cela signifie que l'on est arrivé
{ //fct_aide_sauve.push_back(*ifct); // on sauve avant de détruire
fct_aide.erase(ifct); // sur la branche fondamentale
};
};
// b) maintenant on s'occupe des inversions
// on traite les centres différemment des points d'inversions
int nb_centre_new = oc_BH_t_a_tdt.size(); // récup du nombre de nouveaux centres
// nb_centre_new_sauve = nb_centre_new; // on sauvegarde pour un retour t -> tdt éventuel
// on ajoute les différents nouveaux centres
List_io <Tenseur3BH>::reverse_iterator iifoi = oc_BH_t_a_tdt.rbegin();
for (int ii=1;ii<=nb_centre_new;ii++,iifoi++)
oc_BH_R.push_front(*iifoi);
// maintenant on traites les points d'inversions
int nb_ref_new = sigma_barre_BH_R_t_a_tdt.size(); // récup du nombre de nouveaux pt
// nb_ref_new_sauve = nb_ref_new; // on sauve pour le retour t -> tdt éventuel
// on ajoute les différents points d'inversions
List_io <Tenseur3BH>::reverse_iterator iitens = sigma_barre_BH_R_t_a_tdt.rbegin();
for (int ii=1;ii<=nb_ref_new;ii++,iitens++)
sigma_barre_BH_R.push_front(*iitens);
// pour les def équivalentes
List_io <double>::reverse_iterator iidouble = def_equi_t_a_tdt.rbegin();
for (int ij=1;ij<=nb_ref_new;ij++,iidouble++)
def_equi.push_front(*iidouble);
// cas de la fonction d'aide
int nb_ref = fct_aide.size(); // récup du nombre de pt de ref actuel
bool init_ip2 = false; if (nb_ref == 1) init_ip2=true; // pour gérer ip2
int nb_fct_new = fct_aide_t_a_tdt.size(); // récup du nombre de nouveau pt
// on ajoute les différentes valeurs
List_io <double>::iterator iifct = fct_aide_t_a_tdt.begin();
for (int ii=1;ii<=nb_ref_new;ii++,iitens++,iifct++)
{fct_aide.push_front(*iifct);
if (init_ip2) // uniquement pour mémoriser le W_a de la première charge
{ // cas où l'on doit initialiser ip2 (car ici le nombre de pt = 2)
ip2 = fct_aide.begin(); init_ip2 = false;
};
};
break;
}
default:
cout << "\n erreur dans la mise a jour des informations transitoire: modif= " << modif
<< "\n Hysteresis3D::SaveResulHysteresis3D::TversTdt() ";
Sortie(1);
}
// --------------------- très important: traitement de finition --------------------------
// si les rayons résultants que l'on a ajoute sont à une distance inférieure à la précision de la coincidence
// on les collapses !!
// finalement on va traiter directement au niveau des coincidences pour l'instant !!
// if (maxi_ref_en_plus != 0)
// {
// }
//------- débug ---------
// vérif de la cohérence des centres et références: les rayons associés doivent être de tailles
// décroissantes
// Verif_centre_reference(6);
//-------- fin débug -----------
// on sauve les grandeurs transportables
sigma_barre_BH_R_atrans = sigma_barre_BH_R;
oc_BH_R_atrans= oc_BH_R;
// on met à jour éventuellement les indicateurs de résolution
if (indicateurs_resolution.Taille())
{ indicateurs_resolution_t = indicateurs_resolution;
// on met les indicateurs à 0
indicateurs_resolution.Change_taille(5,0.);
};
//re-initialisation des variables de travail
Init_debut_calcul();
};
void Hysteresis3D::SaveResulHysteresis3D::TversTdt()
{ // partie générale
sigma_barre_BH_tdt = sigma_barre_BH_t;oc_BH_tdt=oc_BH_t;
wBase_tdt=wBase_t;
def_equi_atdt = def_equi_at; // def équivalente
// on supprime le transport éventuel
sigma_barre_BH_R = sigma_barre_BH_R_atrans;
oc_BH_R = oc_BH_R_atrans;
fonction_aide_tdt=fonction_aide_t;
// en fait le tant que le pas n'est pas validé, les différentes listes ne sont pas changées
// donc il n'y a pas à mettre en place une stratégie pour revenir en arrière
// une fois que le pas est validé, effectivement on ne peut pas revenir en arrière, mais
// c'est aussi vrai pour toutes les autres lois
// ceci étant la suite serait une solution pour revenir en arrière
// // maintenant on essaie de remettre les choses d'aplomb
// switch (modif_sauve)
// { case 0: // rien n'a changé sur le pas en terme de coincidence et d'inversion
// { break; // donc rien n'a faire !! ouf
// }
// case 1: // cas où l'on a eu une ou plusieurs coincidences
// { // ici il suffit de rajouter tous les tenseurs qui ont été supprimés
// List_io <Tenseur3BH>::iterator itens;List_io <Tenseur3BH>::iterator ioc_i;
// {List_io <Tenseur3BH>::iterator itens_fin=sigma_barre_BH_R_sauve.end();
// for (itens = sigma_barre_BH_R_sauve.begin(); itens != itens_fin;itens++)
// sigma_barre_BH_R.push_front(*itens);
// };
// {List_io <Tenseur3BH>::iterator itens_fin=oc_BH_R_sauve.end();
// for (itens = oc_BH_R_sauve.begin(); itens != itens_fin;itens++)
// oc_BH_R.push_front(*itens);
// };
// {List_io <double>::iterator idouble,idouble_fin= def_equi_sauve.end();
// for (idouble = def_equi_sauve.begin(); idouble != idouble_fin;idouble++)
// def_equi.push_front(*idouble);
// };
// // puis on supprime les sauvegardes histoire de ne pas rajouter une nouvelle fois
// sigma_barre_BH_R.clear();oc_BH_R_sauve.clear();def_equi_sauve.clear();
// break;
// }
// case 2: // cas où l'on a eu une ou plusieurs inversions
// { // pour les centres on en a rajouté nb_centre_new_sauve, on les supprimes
// List_io <Tenseur3BH>::iterator ioc_i;
// for (int i=1; i<= nb_centre_new_sauve;i++)
// { ioc_i = oc_BH_R.begin();
// oc_BH_R.erase(ioc_i);
// };
// // maintenant on traites les points d'inversions, même chose que les centres on supprime
// List_io <Tenseur3BH>::iterator iitens;
// for (int i=1; i<= nb_ref_new_sauve;i++)
// { iitens = sigma_barre_BH_R.begin();
// sigma_barre_BH_R.erase(iitens);
// };
// // pour les def équivalentes, même chose
// List_io <double>::iterator iidouble;
// for (int i=1; i<= nb_ref_new_sauve;i++)
// { iidouble = def_equi.begin();
// def_equi.erase(iidouble);
// };
// // on supprime les compteurs pour éviter une autre suppression future
// nb_centre_new_sauve=0;nb_ref_new_sauve=0;
// break;
// }
// case 3: // cas où l'on a eu une ou plusieurs coincidence(s) et inversion (s)
// { // on traite dans l'ordre inverse du cas tdt -> t
// // -- a) on s'occupe des inversions
// // pour les centres on en a rajouté nb_centre_new_sauve, on les supprimes
// {List_io <Tenseur3BH>::iterator ioc_i;
// for (int i=1; i<= nb_centre_new_sauve;i++)
// { ioc_i = oc_BH_R.begin();
// oc_BH_R.erase(ioc_i);
// };
// // maintenant on traites les points d'inversions, même chose que les centres on supprime
// List_io <Tenseur3BH>::iterator iitens;
// for (int i=1; i<= nb_ref_new_sauve;i++)
// { iitens = sigma_barre_BH_R.begin();
// sigma_barre_BH_R.erase(iitens);
// };
// // pour les def équivalentes, même chose
// List_io <double>::iterator iidouble;
// for (int i=1; i<= nb_ref_new_sauve;i++)
// { iidouble = def_equi.begin();
// def_equi.erase(iidouble);
// };
// // on supprime les compteurs pour éviter une autre suppression future
// nb_centre_new_sauve=0;nb_ref_new_sauve=0;
// };
// // -- b) on s'occupe des coincidences
// // ici il suffit de rajouter tous les tenseurs qui ont été supprimés
// {List_io <Tenseur3BH>::iterator itens;List_io <Tenseur3BH>::iterator ioc_i;
// {List_io <Tenseur3BH>::iterator itens_fin=sigma_barre_BH_R_sauve.end();
// for (itens = sigma_barre_BH_R_sauve.begin(); itens != itens_fin;itens++)
// sigma_barre_BH_R.push_front(*itens);
// };
// {List_io <Tenseur3BH>::iterator itens_fin=oc_BH_R_sauve.end();
// for (itens = oc_BH_R_sauve.begin(); itens != itens_fin;itens++)
// oc_BH_R.push_front(*itens);
// };
// {List_io <double>::iterator idouble,idouble_fin= def_equi_sauve.end();
// for (idouble = def_equi_sauve.begin(); idouble != idouble_fin;idouble++)
// def_equi.push_front(*idouble);
// };
// // puis on supprime les sauvegardes histoire de ne pas rajouter une nouvelle fois
// sigma_barre_BH_R.clear();oc_BH_R_sauve.clear();def_equi_sauve.clear();
// };
// break;
// }
// default:
// cout << "\n erreur dans la mise a jour des informations transitoire: modif= " << modif
// << "\n Hysteresis3D::SaveResulHysteresis3D::TversTdt() ";
// Sortie(1);
// };
//re-initialisation des variables de travail
Init_debut_calcul();
};
// affichage à l'écran des infos
void Hysteresis3D::SaveResulHysteresis3D::Affiche() const
{ cout << "\n SaveResulHysteresis3D: " ;
cout << "\n sigma_barre_BH_t= " << sigma_barre_BH_t << " sigma_barre_BH_tdt= " << sigma_barre_BH_tdt
<< " oc_BH_t= " << oc_BH_t << " oc_BH_tdt= " << oc_BH_tdt
<< " wBase_t= " << wBase_t << " wBase_tdt= " << wBase_tdt
<< " def_equi_at= " << def_equi_at << " def_equi_atdt= " << def_equi_atdt
<< " fonction_aide_t= " << fonction_aide_t << " fonction_aide_tdt= " << fonction_aide_tdt;
cout << "\n -- info de travail en cours: ";
cout << " modif= " << modif << "\n list sigma_barre_BH_R_t_a_tdt: " << sigma_barre_BH_R_t_a_tdt
<< "\n nb_coincidence= " << nb_coincidence
<< "\n list oc_BH_t_a_tdt: " << oc_BH_t_a_tdt
<< "\n list def_equi_t_a_tdt: " << def_equi_t_a_tdt;
cout << "\n -- memorisation discrete de 0 a t: ";
cout << "\n list sigma_barre_BH_R: " << sigma_barre_BH_R;
cout << "\n list oc_BH_R: " << oc_BH_R;
cout << "\n list def_equi: " << def_equi;
cout << "\n list fct_aide: " << fct_aide << " ";
cout << "\n .. fin SaveResulHysteresis3D ... ";
};
//changement de base de toutes les grandeurs internes tensorielles stockées
// beta(i,j) represente les coordonnees de la nouvelle base naturelle gpB dans l'ancienne gB
// gpB(i) = beta(i,j) * gB(j), i indice de ligne, j indice de colonne
// gpH(i) = gamma(i,j) * gH(j)
void Hysteresis3D::SaveResulHysteresis3D::ChBase_des_grandeurs(const Mat_pleine& beta,const Mat_pleine& gamma)
{ // on ne s'intéresse qu'aux grandeurs tensorielles
sigma_barre_BH_t.ChBase(beta,gamma);
sigma_barre_BH_tdt.ChBase(beta,gamma);
oc_BH_t.ChBase(beta,gamma);
oc_BH_tdt.ChBase(beta,gamma);
// encapsulage pour utiliser deux fois les mêmes itérators
{ List_io <Tenseur3BH>::iterator lit(sigma_barre_BH_R_t_a_tdt.begin()),
lend(sigma_barre_BH_R_t_a_tdt.end());
for(;lit!=lend;++lit) // ici les bornes ne changent pas
(*lit).ChBase(beta,gamma);
};
{ List_io <Tenseur3BH>::iterator lit(oc_BH_t_a_tdt.begin()),
lend(oc_BH_t_a_tdt.end());
for(;lit!=lend;++lit) // ici les bornes ne changent pas
(*lit).ChBase(beta,gamma);
};
{ List_io <Tenseur3BH>::iterator lit(sigma_barre_BH_R.begin()),
lend(sigma_barre_BH_R.end());
for(;lit!=lend;++lit) // ici les bornes ne changent pas
(*lit).ChBase(beta,gamma);
};
{ List_io <Tenseur3BH>::iterator lit(oc_BH_R.begin()),
lend(oc_BH_R.end());
for(;lit!=lend;++lit) // ici les bornes ne changent pas
(*lit).ChBase(beta,gamma);
};
{ List_io <Tenseur3BH>::iterator lit(sigma_barre_BH_R_atrans.begin()),
lend(sigma_barre_BH_R_atrans.end());
for(;lit!=lend;++lit) // ici les bornes ne changent pas
(*lit).ChBase(beta,gamma);
};
{ List_io <Tenseur3BH>::iterator lit(oc_BH_R_atrans.begin()),
lend(oc_BH_R_atrans.end());
for(;lit!=lend;++lit) // ici les bornes ne changent pas
(*lit).ChBase(beta,gamma);
};
};
// initialise les informations de travail concernant le pas de temps en cours
void Hysteresis3D::SaveResulHysteresis3D::Init_debut_calcul()
{ //initialisation des variables de travail
modif = 0; nb_coincidence=0;
sigma_barre_BH_R_t_a_tdt.clear();oc_BH_t_a_tdt.clear();def_equi_t_a_tdt.clear();
fct_aide_t_a_tdt.clear();
//---- debug
// cout << "\n Hysteresis3D::SaveResulHysteresis3D::Init_debut_calcul() "<< endl;
//---- fin debug
};
///----------***** fin de l'introduction de la fonction d'aide
// ========== fin des fonctions pour la classe de sauvegarde des résultats =========
Hysteresis3D::Hysteresis3D () : // Constructeur par defaut
Loi_comp_abstraite(HYSTERESIS_3D,CAT_MECANIQUE,3)
// ---- para matériau
,xnp(ConstMath::tresgrand),xnp_temperature(NULL),xnp_lue(ConstMath::tresgrand)
,Qzero(ConstMath::tresgrand),Qzero_temperature(NULL),Qzero_lue(ConstMath::tresgrand)
,xmu(ConstMath::tresgrand),xmu_temperature(NULL),xmu_lue(ConstMath::tresgrand)
// parmètres de phase éventuelles
,xnp_phase(NULL),Qzero_defEqui(NULL),xnp_defEqui(NULL),Qzero_phase(NULL),xmu_phase(NULL)
,avec_phaseDeltaSig(false),avec_phaseEps(NULL)
,avec_defEqui(false),avec_phase_paradefEqui(false),coef_paradefEqui(NULL)
,val_coef_paradefEqui(1.),mini_QepsilonBH(1.e-4)
,type_de_transport_memorisation(0)
,niveau_bascule_fct_aide(10.) //volontairement très grand => ne sert pas
// --- réglage résolution de l'équation constitutive
,tolerance_coincidence(),mini_rayon(ConstMath::pasmalpetit)
,tolerance_centre(0.001)
,min_angle_trajet_neutre(0.008),possibilite_cosAlphaNegatif(true) // environ 90° - 0.5°
,mini_Qsig_pour_phase_sigma_Oi_tdt(1.5) // 1.5 MPa
,type_resolution_equa_constitutive(1)
,type_calcul_comportement_tangent(1),avecVarWprimeS(false)
,nb_maxInvCoinSurUnPas(4),force_phi_zero_si_negatif(0.)
,depassement_Q0(2.)
// ---- réglage résolution avec linéarisation
,tolerance_residu(1.e-3),tolerance_residu_rel(1.e-5),nb_boucle_maxi(6),nb_dichotomie(4)
,maxi_delta_var_sig_sur_iter_pour_Newton(-1)
// ---- réglage résolution avec Kutta
,cas_kutta(5),erreurAbsolue(1.e-3),erreurRelative(1.e-5),nbMaxiAppel(1000)
// ---- affichage
,sortie_post(0)
// ---- init variable de travail
,sigma_t_barre_tdt(),sigma_i_barre_BH(),sigma_barre_BH_R()
,def_equi_R(0.),def_i_equi(0.),def_equi_atdt(0.),defEqui_maxi(0.)
,delta_sigma_barre_BH_Rat(),delta_sigma_barre_BH_Ra_i(),delta_sigma_barre_BH_Ratdt()
,delta_sigma_barre_tdt_BH(),residuBH()
,delta_epsBH(),delta_barre_epsBH(),delta_barre_alpha_epsBH()
,wBase(1),wprime(1),wprime_point(0.),trajet_neutre(false),d_wprime(),d_wprime_point()
,residu(9),derResidu(9,9,false,0.,GAUSS,RIEN_PRECONDITIONNEMENT)
,derResidu_adefConstant(9,9,false,0.,GAUSS,RIEN_PRECONDITIONNEMENT)
,alg_zero(),alg_edp()
,rdelta_sigma_barre_BH_Ratdt(),rdelta_sigma_barre_tdt_BH()
,sig_point(9),sigma_pointBH(),sigma_tauBH(),sigma_tau(9)
,delta_sigma_barre_R_a_tauBH(),delta_sigma_barre_t_a_tauBH()
,betaphideltasigHB(),deuxmudeltaepsHB()
,sig_initiale(9),dersig_initiale(9),sig_finale(9),dersig_finale(9),estime_erreur(9)
,val_initiale(9),racine(9)
,der_at_racine(9,9,false,0.,GAUSS,RIEN_PRECONDITIONNEMENT)
,centre_initial(true),aucun_pt_inversion(true)
,dRdsigMoinsun(9,9,false,0.,GAUSS,RIEN_PRECONDITIONNEMENT)
,dRdeps(9,9,false,0.,GAUSS,RIEN_PRECONDITIONNEMENT)
,MPC(9,9,false,0.,GAUSS,RIEN_PRECONDITIONNEMENT)
,dsig_ojef_HHHH()
,matriceH(9,9,false,0.,GAUSS,RIEN_PRECONDITIONNEMENT)
,matriceM(9,9,false,0.,GAUSS,RIEN_PRECONDITIONNEMENT)
,matHmoinsun(9,9,false,0.,GAUSS,RIEN_PRECONDITIONNEMENT)
,calcul_dResi_dsig(false)
{// initialisation des paramètres de la résolution de newton
alg_zero.Modif_prec_res_abs(tolerance_residu);
alg_zero.Modif_prec_res_rel(tolerance_residu_rel);
alg_zero.Modif_iter_max(nb_boucle_maxi);
alg_zero.Modif_nbMaxiIncre(nb_dichotomie);
tolerance_coincidence = tolerance_residu * 100;
tolerance_centre = tolerance_coincidence;
// idem avec kutta
alg_edp.Modif_nbMaxiAppel(nbMaxiAppel);
};
// Constructeur de copie
Hysteresis3D::Hysteresis3D (const Hysteresis3D& loi) :
Loi_comp_abstraite(loi)
// ---- para matériau
,xnp(loi.xnp),xmu(loi.xmu),Qzero(loi.Qzero)
,xnp_lue(loi.xnp_lue),xmu_lue(loi.xmu_lue),Qzero_lue(loi.Qzero_lue)
,xnp_temperature(loi.xnp_temperature),Qzero_temperature(loi.Qzero_temperature)
,xmu_temperature(loi.xmu_temperature)
// paramètres de phase éventuelles
,xnp_phase(loi.xnp_phase),Qzero_defEqui(loi.Qzero_defEqui)
,xnp_defEqui(loi.xnp_defEqui),Qzero_phase(loi.Qzero_phase),xmu_phase(loi.xmu_phase)
,avec_phaseDeltaSig(loi.avec_phaseDeltaSig),avec_phaseEps(loi.avec_phaseEps)
,avec_defEqui(loi.avec_defEqui)
,avec_phase_paradefEqui(loi.avec_phase_paradefEqui),coef_paradefEqui(loi.coef_paradefEqui)
,val_coef_paradefEqui(1.),mini_QepsilonBH(loi.mini_QepsilonBH)
,type_de_transport_memorisation(loi.type_de_transport_memorisation)
,niveau_bascule_fct_aide(loi.niveau_bascule_fct_aide)
// --- réglage résolution de l'équation constitutive
,tolerance_coincidence(loi.tolerance_coincidence),mini_rayon(loi.mini_rayon)
,tolerance_centre(loi.tolerance_centre)
,min_angle_trajet_neutre(loi.min_angle_trajet_neutre) // environ 90° - 0.5°
,possibilite_cosAlphaNegatif(loi.possibilite_cosAlphaNegatif)
,mini_Qsig_pour_phase_sigma_Oi_tdt(loi.mini_Qsig_pour_phase_sigma_Oi_tdt)
,type_resolution_equa_constitutive(loi.type_resolution_equa_constitutive)
,type_calcul_comportement_tangent(loi.type_calcul_comportement_tangent),avecVarWprimeS(loi.avecVarWprimeS)
,nb_maxInvCoinSurUnPas(loi.nb_maxInvCoinSurUnPas),force_phi_zero_si_negatif(loi.force_phi_zero_si_negatif)
,depassement_Q0(loi.depassement_Q0)
// ---- réglage résolution avec linéarisation
,tolerance_residu(loi.tolerance_residu),tolerance_residu_rel(loi.tolerance_residu_rel)
,nb_boucle_maxi(loi.nb_boucle_maxi),nb_dichotomie(loi.nb_dichotomie)
,maxi_delta_var_sig_sur_iter_pour_Newton(loi.maxi_delta_var_sig_sur_iter_pour_Newton)
// ---- réglage résolution avec Kutta
,cas_kutta(loi.cas_kutta),erreurAbsolue(loi.erreurAbsolue),erreurRelative(loi.erreurRelative)
,nbMaxiAppel(loi.nbMaxiAppel)
// ---- affichage
,sortie_post(loi.sortie_post)
// ---- intit variable de travail
,sigma_t_barre_tdt(loi.sigma_t_barre_tdt),sigma_i_barre_BH(loi.sigma_i_barre_BH)
,sigma_barre_BH_R(loi.sigma_barre_BH_R)
,def_equi_R(loi.def_equi_R),def_i_equi(loi.def_i_equi),def_equi_atdt(loi.def_equi_atdt)
,defEqui_maxi(loi.defEqui_maxi)
,delta_sigma_barre_BH_Rat(loi.delta_sigma_barre_BH_Rat)
,delta_sigma_barre_BH_Ra_i(loi.delta_sigma_barre_BH_Ra_i)
,delta_sigma_barre_BH_Ratdt(loi.delta_sigma_barre_BH_Ratdt)
,delta_sigma_barre_tdt_BH(loi.delta_sigma_barre_tdt_BH)
,residuBH(loi.residuBH),delta_epsBH(loi.delta_epsBH)
,delta_barre_epsBH(loi.delta_barre_epsBH)
,delta_barre_alpha_epsBH(loi.delta_barre_alpha_epsBH)
,wBase(loi.wBase),wprime(loi.wprime),trajet_neutre(loi.trajet_neutre),wprime_point(loi.wprime_point)
,d_wprime(loi.d_wprime),d_wprime_point(loi.d_wprime_point)
,residu(9),derResidu(loi.derResidu),derResidu_adefConstant(loi.derResidu_adefConstant),alg_zero(),alg_edp()
,rdelta_sigma_barre_BH_Ratdt(),rdelta_sigma_barre_tdt_BH()
,centre_initial(true),aucun_pt_inversion(true)
,dRdsigMoinsun(loi.dRdsigMoinsun),dRdeps(loi.dRdeps),MPC(loi.MPC)
,dsig_ojef_HHHH()
,matriceH(loi.matriceH), matriceM(loi.matriceM),matHmoinsun(loi.matHmoinsun)
,calcul_dResi_dsig(false)
,sig_point(9),sigma_pointBH(),sigma_tauBH(),sigma_tau(9)
,delta_sigma_barre_R_a_tauBH(),delta_sigma_barre_t_a_tauBH()
,betaphideltasigHB(),deuxmudeltaepsHB()
,sig_initiale(9),dersig_initiale(9),sig_finale(9),dersig_finale(9),estime_erreur(9)
,val_initiale(9),racine(9)
,der_at_racine(9,9,false,0.,GAUSS,RIEN_PRECONDITIONNEMENT)
{// initialisation des paramètres de la résolution de newton
alg_zero.Modif_prec_res_abs(tolerance_residu);
alg_zero.Modif_prec_res_rel(tolerance_residu_rel);
alg_zero.Modif_iter_max(nb_boucle_maxi);
alg_zero.Modif_nbMaxiIncre(nb_dichotomie);
// idem avec kutta
alg_edp.Modif_nbMaxiAppel(nbMaxiAppel);
// pour les pointeurs de courbes, on regarde s'il s'agit d'une courbe locale ou d'une courbe globale
if (xnp_temperature != NULL)
if (xnp_temperature->NomCourbe() == "_")
xnp_temperature = Courbe1D::New_Courbe1D(*(loi.xnp_temperature));
if (Qzero_temperature != NULL)
if (Qzero_temperature->NomCourbe() == "_")
Qzero_temperature = Courbe1D::New_Courbe1D(*(loi.Qzero_temperature));
if (xmu_temperature != NULL)
if (xmu_temperature->NomCourbe() == "_")
xmu_temperature = Courbe1D::New_Courbe1D(*(loi.xmu_temperature));
// pour la phase
if (xnp_phase != NULL)
if (xnp_phase->NomCourbe() == "_")
xnp_phase = Courbe1D::New_Courbe1D(*(loi.xnp_phase));
if (Qzero_phase != NULL)
if (Qzero_phase->NomCourbe() == "_")
Qzero_phase = Courbe1D::New_Courbe1D(*(loi.Qzero_phase));
if (xmu_phase != NULL)
if (xmu_phase->NomCourbe() == "_")
xmu_phase = Courbe1D::New_Courbe1D(*(loi.xmu_phase));
// pour la dépendance à la déformation équivalente
if (xnp_defEqui != NULL)
if (xnp_defEqui->NomCourbe() == "_")
xnp_defEqui = Courbe1D::New_Courbe1D(*(loi.xnp_defEqui));
// pour la dépendance à la déformation équivalente
if (Qzero_defEqui != NULL)
if (Qzero_defEqui->NomCourbe() == "_")
Qzero_defEqui = Courbe1D::New_Courbe1D(*(loi.Qzero_defEqui));
// pour la dépendance à la déformation totale
if (coef_paradefEqui != NULL)
if (coef_paradefEqui->NomCourbe() == "_")
coef_paradefEqui = Courbe1D::New_Courbe1D(*(loi.coef_paradefEqui));
};
Hysteresis3D::~Hysteresis3D ()
// Destructeur
{ if (xnp_temperature != NULL)
if (xnp_temperature->NomCourbe() == "_") delete xnp_temperature;
if (Qzero_temperature != NULL)
if (Qzero_temperature->NomCourbe() == "_") delete Qzero_temperature;
if (xmu_temperature != NULL)
if (xmu_temperature->NomCourbe() == "_") delete xmu_temperature;
if (xnp_phase != NULL)
if (xnp_phase->NomCourbe() == "_") delete xnp_phase;
if (xnp_defEqui != NULL)
if (xnp_defEqui->NomCourbe() == "_") delete xnp_defEqui;
if (Qzero_defEqui != NULL)
if (Qzero_defEqui->NomCourbe() == "_") delete Qzero_defEqui;
if (Qzero_phase != NULL)
if (Qzero_phase->NomCourbe() == "_") delete Qzero_phase;
if (xmu_phase != NULL)
if (xmu_phase->NomCourbe() == "_") delete xmu_phase;
if (coef_paradefEqui != NULL)
if (coef_paradefEqui->NomCourbe() == "_") delete coef_paradefEqui;
};
// Lecture des donnees de la classe sur fichier
void Hysteresis3D::LectureDonneesParticulieres (UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D
,LesFonctions_nD& lesFonctionsnD)
{ // ---- lecture du paramètre de prager -----
string nom;
*(entreePrinc->entree) >> nom; // lecture d'un identificateur
if(nom != "np=")
{ cout << "\n erreur en lecture du parametre de prager "
<< " on attendait la chaine : np= et on a lue " << nom;
cout << "\n Hysteresis3D::LectureDonneesParticulieres "
<< "(UtilLecture * entreePrinc) " << endl ;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// on regarde si le paramètre de prager est thermo dépendant
if(strstr(entreePrinc->tablcar,"np_thermo_dependant_")!=0)
{ thermo_dependant=true;
*(entreePrinc->entree) >> nom;
if (nom != "np_thermo_dependant_")
{ cout << "\n erreur en lecture de la thermodependance de np, on aurait du lire le mot cle np_thermo_dependant_"
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme "<< endl;
entreePrinc->MessageBuffer("**erreur2 Hysteresis3D::LectureDonneesParticulieres (...**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
// lecture de la loi d'évolution du paramètre de prager en fonction de la température
*(entreePrinc->entree) >> nom;
// on regarde si la courbe existe, si oui on récupère la référence
if (lesCourbes1D.Existe(nom))
{ xnp_temperature = lesCourbes1D.Trouve(nom);
}
else
{ // sinon il faut la lire maintenant
string non_courbe("_");
xnp_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
// lecture de la courbe
xnp_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
}
entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
}
else // sinon on lit directement le paramètre de prager
{*(entreePrinc->entree) >> xnp;
if (xnp <= 0)
{cout << "\n erreur en lecture du parametre de prager np= " << xnp
<< " il doit etre superieur a 0 ! ";
cout << "\n Hysteresis3D::LectureDonneesParticulieres "
<< "(UtilLecture * entreePrinc) " << endl ;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
};
// ---- lecture de mu : coefficient de lame ----
*(entreePrinc->entree) >> nom;
if(nom != "mu=")
{ cout << "\n erreur en lecture du coefficient mu de lame "
<< " on attendait la chaine : mu= et on a lue " << nom;
cout << "\n Hysteresis3D::LectureDonneesParticulieres "
<< "(UtilLecture * entreePrinc) " << endl ;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
// on regarde si le coefficient de lame est thermo dépendant
if(strstr(entreePrinc->tablcar,"mu_thermo_dependant_")!=0)
{ thermo_dependant=true;
*(entreePrinc->entree) >> nom;
if (nom != "mu_thermo_dependant_")
{ cout << "\n erreur en lecture de la thermodependance de mu, on aurait du lire le mot cle mu_thermo_dependant_"
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
entreePrinc->MessageBuffer("**erreur3 Hysteresis3D::LectureDonneesParticulieres (...**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
// lecture de la loi d'évolution du coefficient mu en fonction de la température
*(entreePrinc->entree) >> nom;
// on regarde si la courbe existe, si oui on récupère la référence
if (lesCourbes1D.Existe(nom))
{ xmu_temperature = lesCourbes1D.Trouve(nom);
}
else
{ // sinon il faut la lire maintenant
string non_courbe("_");
xmu_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
// lecture de la courbe
xmu_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
}
entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
}
else // sinon on lit directement le paramètre mu
{*(entreePrinc->entree) >> xmu;};
// ---- lecture de la limite de plasticité infini -----
*(entreePrinc->entree) >> nom;
if(nom != "Qzero=")
{ cout << "\n erreur en lecture du coefficient mu de lame "
<< " on attendait la chaine : Qzero= et on a lue " << nom;
cout << "\n Hysteresis3D::LectureDonneesParticulieres "
<< "(UtilLecture * entreePrinc) " << endl ;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
// on regarde si Qzero est thermo dépendant
if(strstr(entreePrinc->tablcar,"Qzero_thermo_dependant_")!=0)
{ thermo_dependant=true;
*(entreePrinc->entree) >> nom;
if (nom != "Qzero_thermo_dependant_")
{ cout << "\n erreur en lecture de la thermodependance de Qzero, on aurait du lire le mot cle Qzero_thermo_dependant_"
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
entreePrinc->MessageBuffer("**erreur4 Hysteresis3D::LectureDonneesParticulieres (...**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
// lecture de la loi d'évolution du coefficient Qzero en fonction de la température
*(entreePrinc->entree) >> nom;
// on regarde si la courbe existe, si oui on récupère la référence
if (lesCourbes1D.Existe(nom))
{ Qzero_temperature = lesCourbes1D.Trouve(nom);
}
else
{ // sinon il faut la lire maintenant
string non_courbe("_");
Qzero_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
// lecture de la courbe
Qzero_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
}
entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
}
else // sinon on lit directement le paramètre Qzero
{*(entreePrinc->entree) >> Qzero;};
// on garde en mémoire ce que l'on a lue
xnp_lue=xnp; Qzero_lue=Qzero; xmu_lue=xmu;
// --- lecture éventuelle d'une dépendance à la phase
if ((strstr(entreePrinc->tablcar,"avec_phaseDeltaSig")!=NULL)
|| (strstr(entreePrinc->tablcar,"avec_phaseEps")!=NULL))
{ string nom1,nom2;
int drapeau=0; // une variable intermédiaire
if (strstr(entreePrinc->tablcar,"avec_phaseDeltaSig")!=NULL) {drapeau=1;}
else { drapeau=2; }; // on oriente le type de dépendance (contrainte ou def)
// lecture des paramètres de phase
entreePrinc->NouvelleDonnee(); // passage d'une ligne
// cas de np
if (strstr(entreePrinc->tablcar,"xnp_phase=")!=NULL)
{drapeau +=10; // petite ope pour valider que l'on a bien lue qqchose
*(entreePrinc->entree) >> nom;
if (nom != "xnp_phase=")
{ cout << "\n erreur en lecture de la dependance a la phase de xnp, on aurait du lire"
<< " le mot cle xnp_phase="
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
entreePrinc->MessageBuffer("**erreur41 Hysteresis3D::LectureDonneesParticulieres (...**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
// lecture de la loi d'évolution du coefficient xnp en fonction de la phase
*(entreePrinc->entree) >> nom;
// on regarde si la courbe existe, si oui on récupère la référence
if (lesCourbes1D.Existe(nom))
{ xnp_phase = lesCourbes1D.Trouve(nom);
}
else
{ // sinon il faut la lire maintenant
string non_courbe("_");
xnp_phase = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
// lecture de la courbe
xnp_phase->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
}
entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
};
// cas de xmu
if (strstr(entreePrinc->tablcar,"xmu_phase=")!=NULL)
{drapeau +=10; // petite ope pour valider que l'on a bien lue qqchose
*(entreePrinc->entree) >> nom;
if (nom != "xmu_phase=")
{ cout << "\n erreur en lecture de la dependance a la phase de xmu, on aurait du lire"
<< " le mot cle xmu_phase="
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
entreePrinc->MessageBuffer("**erreur42 Hysteresis3D::LectureDonneesParticulieres (...**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
// lecture de la loi d'évolution du coefficient xmu en fonction de la phase
*(entreePrinc->entree) >> nom;
// on regarde si la courbe existe, si oui on récupère la référence
if (lesCourbes1D.Existe(nom))
{ xmu_phase = lesCourbes1D.Trouve(nom);
}
else
{ // sinon il faut la lire maintenant
string non_courbe("_");
xmu_phase = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
// lecture de la courbe
xmu_phase->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
}
entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
};
// cas de Qzero
if (strstr(entreePrinc->tablcar,"Qzero_phase=")!=NULL)
{drapeau +=10; // petite ope pour valider que l'on a bien lue qqchose
*(entreePrinc->entree) >> nom;
if (nom != "Qzero_phase=")
{ cout << "\n erreur en lecture de la dependance a la phase de Qzero, on aurait du lire"
<< " le mot cle Qzero_phase="
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
entreePrinc->MessageBuffer("**erreur43 Hysteresis3D::LectureDonneesParticulieres (...**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
// lecture de la loi d'évolution du coefficient Qzero en fonction de la phase
*(entreePrinc->entree) >> nom;
// on regarde si la courbe existe, si oui on récupère la référence
if (lesCourbes1D.Existe(nom))
{ Qzero_phase = lesCourbes1D.Trouve(nom);
}
else
{ // sinon il faut la lire maintenant
string non_courbe("_");
Qzero_phase = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
// lecture de la courbe
Qzero_phase->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
}
entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
};
// fin de la manip avec le drapeau
// si drapeau > 10 cela veut dire qu'il y a eu au moins une validation
// le reste de la division euclidienne = la valeur initiale
if ((drapeau % 10) == 1) {avec_phaseDeltaSig = true; avec_phaseEps = false; }
else if ((drapeau % 10) == 2) {avec_phaseDeltaSig = false; avec_phaseEps = true; }
else
// sinon, malgré la dépendance à la phase il n'y a aucun paramètre lue
// donc on désactive
{avec_phaseDeltaSig = false; avec_phaseEps = false; };
};
// --- lecture éventuelle d'une dépendance à la déformation équivalente
if (strstr(entreePrinc->tablcar,"avec_defEquivalente")!=NULL)
{ string nom1,nom2;
// lecture des de dépendance
entreePrinc->NouvelleDonnee(); // passage d'une ligne
// cas de np
if (strstr(entreePrinc->tablcar,"xnp_defEqui=")!=NULL)
{avec_defEqui=true;
*(entreePrinc->entree) >> nom;
if (nom != "xnp_defEqui=")
{ cout << "\n erreur en lecture de la dependance a la deformation equivalente de xnp, on aurait du lire"
<< " le mot cle xnp_defEqui="
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
entreePrinc->MessageBuffer("**erreur44 Hysteresis3D::LectureDonneesParticulieres (...**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
// lecture de la loi d'évolution du coefficient xnp en fonction de def Equi
*(entreePrinc->entree) >> nom;
// on regarde si la courbe existe, si oui on récupère la référence
if (lesCourbes1D.Existe(nom))
{ xnp_defEqui = lesCourbes1D.Trouve(nom);
}
else
{ // sinon il faut la lire maintenant
string non_courbe("_");
xnp_defEqui = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
// lecture de la courbe
xnp_defEqui->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
}
entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
}
else { xnp_defEqui=NULL;};
// cas de Qzero
if (strstr(entreePrinc->tablcar,"Qzero_defEqui=")!=NULL)
{avec_defEqui=true;
*(entreePrinc->entree) >> nom;
if (nom != "Qzero_defEqui=")
{ cout << "\n erreur en lecture de la dependance a la deformation equivalente de Qzero, on aurait du lire"
<< " le mot cle Qzero_defEqui="
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
entreePrinc->MessageBuffer("**erreur44 Hysteresis3D::LectureDonneesParticulieres (...**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
// lecture de la loi d'évolution du coefficient Qzero en fonction de def Equi
*(entreePrinc->entree) >> nom;
// on regarde si la courbe existe, si oui on récupère la référence
if (lesCourbes1D.Existe(nom))
{ Qzero_defEqui = lesCourbes1D.Trouve(nom);
}
else
{ // sinon il faut la lire maintenant
string non_courbe("_");
Qzero_defEqui = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
// lecture de la courbe
Qzero_defEqui->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
}
entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
}
else {Qzero_defEqui = NULL;} ;
};
// --- lecture éventuelle d'une dépendance à la phase de la déformation
if (strstr(entreePrinc->tablcar,"avec_phase_paradefEqui")!=NULL)
{ string nom1,nom2;
// pour l'instant ne fonctionne qu'avec la dépendance conjointe à la def équivalente
if (!avec_defEqui)
{ cout << "\n erreur la dependance a la phase de la deformation n'est licite que "
<< " conjointement avec la dependance la deformation equivalente de xnp qui n'est pas ici"
<< " activee on s'arrete donc !! ";
entreePrinc->MessageBuffer("**erreur444 Hysteresis3D::LectureDonneesParticulieres (...**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// lecture des de dépendance
entreePrinc->NouvelleDonnee(); // passage d'une ligne
// lecture de la fonction
if (strstr(entreePrinc->tablcar,"coef_paradefEqui=")!=NULL)
{avec_phase_paradefEqui=true;
*(entreePrinc->entree) >> nom;
if (nom != "coef_paradefEqui=")
{ cout << "\n erreur en lecture de la dependance a la phase de la deformation totale, "
<< " on aurait du lire le mot cle coef_paradefEqui="
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
entreePrinc->MessageBuffer("**erreur445 Hysteresis3D::LectureDonneesParticulieres (...**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
// lecture de la loi d'évolution du paradefEqui en fonction de cos(3phi) de la déformation totale
*(entreePrinc->entree) >> nom;
// on regarde si la courbe existe, si oui on récupère la référence
if (lesCourbes1D.Existe(nom))
{ coef_paradefEqui = lesCourbes1D.Trouve(nom);
}
else
{ // sinon il faut la lire maintenant
string non_courbe("_");
coef_paradefEqui = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
// lecture de la courbe
coef_paradefEqui->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
}
entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
}
else
{ cout << "\n erreur en lecture de la dependance a la phase de la deformation totale, "
<< " on devrait avoir sur la ligne courante le mot cle coef_paradefEqui="
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
entreePrinc->MessageBuffer("**erreur446 Hysteresis3D::LectureDonneesParticulieres (...**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
};
// --- lecture éventuelle des paramètres de réglage ----
// de l'algo de résolution de l'équation d'avancement temporel
if(strstr(entreePrinc->tablcar,"avec_parametres_de_reglage_")!=0)
{type_resolution_equa_constitutive = 0; // valeur voulant dire qu'il n'y a pas eu de lecture
entreePrinc->NouvelleDonnee(); // on se positionne sur un nouvel enreg
// on lit tant que l'on ne rencontre pas la ligne contenant "fin_parametres_reglage_Hysteresis_"
// ou un nouveau mot clé global auquel cas il y a pb !!
MotCle motCle; // ref aux mots cle
while (strstr(entreePrinc->tablcar,"fin_parametres_reglage_Hysteresis_")==0)
{
// si on a un mot clé global dans la ligne courante c-a-d dans tablcar --> erreur
if ( motCle.SimotCle(entreePrinc->tablcar))
{ cout << "\n erreur de lecture des parametre de reglage d'hysteresis: on n'a pas trouve le mot cle "
<< " fin_parametres_reglage_Hysteresis_ et par contre la ligne courante contient un mot cle global ";
entreePrinc->MessageBuffer("** erreur5 des parametres de reglage de la loi de comportement d'hyteresis**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// lecture d'un mot clé
*(entreePrinc->entree) >> nom;
if ((entreePrinc->entree)->rdstate() == 0)
{} // lecture normale
#ifdef ENLINUX
else if ((entreePrinc->entree)->fail())
// on a atteind la fin de la ligne et on appelle un nouvel enregistrement
{ entreePrinc->NouvelleDonnee(); // lecture d'un nouvelle enregistrement
*(entreePrinc->entree) >>nom;
}
#else
else if ((entreePrinc->entree)->eof())
// la lecture est bonne mais on a atteind la fin de la ligne
{ if(nom != "fin_parametres_reglage_Hysteresis_")
{entreePrinc->NouvelleDonnee(); *(entreePrinc->entree) >> nom;};
}
#endif
else // cas d'une erreur de lecture
{ cout << "\n erreur de lecture inconnue ";
entreePrinc->MessageBuffer("** erreur5 des parametres de reglage de la loi de comportement d'hyteresis**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// cas du type de résolution
if(nom == "type_de_resolution_")
{*(entreePrinc->entree) >> type_resolution_equa_constitutive;
if ((type_resolution_equa_constitutive < 1) || (type_resolution_equa_constitutive> 6)) // 6 valeur exploratoire
{ cout << "\n erreur en lecture du type de resolution, on attendait un nombre compris entre 1 et 6 "
<< " et on a lu : " << type_resolution_equa_constitutive << " ce cas n'est pas implante (cf. doc) "
<< "\n Hysteresis3D::LectureDonneesParticulieres(UtilLecture * entreePrinc) " << endl ;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
}
// type de calcul de la matrice tangente
else if (nom == "type_calcul_comportement_tangent_")
{*(entreePrinc->entree) >> type_calcul_comportement_tangent;
if ((type_calcul_comportement_tangent < 1) || (type_calcul_comportement_tangent> 2))
{ cout << "\n erreur en lecture du type de calcul du comportement tangent,"
<< " on attendait un nombre compris entre 1 et 2 "
<< " et on a lu : " << type_calcul_comportement_tangent << " ce cas n'est pas implante (cf. doc) "
<< "\n Hysteresis3D::LectureDonneesParticulieres(UtilLecture * entreePrinc) " << endl ;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
}
// nombre d'itération maxi
else if (nom == "nb_iteration_maxi_")
{*(entreePrinc->entree) >> nb_boucle_maxi;
alg_zero.Modif_iter_max(nb_boucle_maxi);
}
// nombre de dichotomie maxi
else if (nom == "nb_dichotomie_maxi_")
{*(entreePrinc->entree) >> nb_dichotomie;
alg_zero.Modif_nbMaxiIncre(nb_dichotomie);
}
// tolérance absolue sur le résidu
else if (nom == "tolerance_residu_")
{*(entreePrinc->entree) >> tolerance_residu;
alg_zero.Modif_prec_res_abs(tolerance_residu);
}
// tolérance relative sur le résidu
else if (nom == "tolerance_residu_rel_")
{*(entreePrinc->entree) >> tolerance_residu_rel;
alg_zero.Modif_prec_res_rel(tolerance_residu_rel);
}
// le maxi de variation que l'on tolère d'une itération à l'autre
else if (nom == "maxi_delta_var_sig_sur_iter_pour_Newton_")
{ *(entreePrinc->entree) >> maxi_delta_var_sig_sur_iter_pour_Newton;
}
// type d'algo de kutta
else if (nom == "cas_kutta_")
{*(entreePrinc->entree) >> cas_kutta;
}
// l'erreur absolue
else if (nom == "erreurAbsolue_")
{*(entreePrinc->entree) >> erreurAbsolue;
}
// l'erreur relative
else if (nom == "erreurRelative_")
{*(entreePrinc->entree) >> erreurRelative;
}
// le nombre d'appel maxi de la fonction f
else if (nom == "nbMaxiAppel_")
{*(entreePrinc->entree) >> nbMaxiAppel;
alg_edp.Modif_nbMaxiAppel(nbMaxiAppel);
}
// tolérance sur la coïncidence
else if (nom == "tolerance_coincidence_")
{*(entreePrinc->entree) >> tolerance_coincidence;
}
// tolérance sur le calcul de centre
else if (nom == "tolerance_centre_")
{*(entreePrinc->entree) >> tolerance_centre;
}
// minimun du rayon
else if (nom == "mini_rayon_")
{*(entreePrinc->entree) >> mini_rayon;
}
// nombre maxi d'inversion sur le pas
else if (nom == "nb_maxInvCoinSurUnPas_")
{*(entreePrinc->entree) >> nb_maxInvCoinSurUnPas;
}
else if (nom == "force_phi_zero_si_negatif_")
{*(entreePrinc->entree) >> force_phi_zero_si_negatif;
}
else if (nom == "depassement_Q0_")
{*(entreePrinc->entree) >> depassement_Q0;
}
else if (nom == "type_de_transport_memorisation_")
{*(entreePrinc->entree) >> type_de_transport_memorisation;
}
else if (nom == "niveau_bascule_fct_aide_")
{*(entreePrinc->entree) >> niveau_bascule_fct_aide;
}
// l'angle mini pour les trajets neutre
else if (nom == "min_angle_trajet_neutre_")
{*(entreePrinc->entree) >> min_angle_trajet_neutre;
if ((min_angle_trajet_neutre < 0.) || (min_angle_trajet_neutre > 1.))
{ cout << "\n erreur en lecture sur le l'angle mini pour les trajets neutre, "
<< "\n il doit etre compris entre 0 et 1 on a lu : " << min_angle_trajet_neutre
<< "\n Hysteresis3D::LectureDonneesParticulieres(UtilLecture * entreePrinc) " << endl ;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
}
// possibilité ou non d'accepter transitoirement un cosAlpha négatif
else if (nom == "possibilite_cosAlphaNegatif_")
{*(entreePrinc->entree) >> possibilite_cosAlphaNegatif;
}
else if (nom == "mini_Qsig_pour_phase_sigma_Oi_tdt_")
{*(entreePrinc->entree) >> mini_Qsig_pour_phase_sigma_Oi_tdt;
// if (mini_Qsig_pour_phase_sigma_Oi_tdt < 0.)
// { cout << "\n erreur en lecture sur mini_Qsig_pour_phase_sigma_Oi_tdt, "
// << "\n il doit etre positif on a lu : " << mini_Qsig_pour_phase_sigma_Oi_tdt
// << "\n Hysteresis3D::LectureDonneesParticulieres(UtilLecture * entreePrinc) " << endl ;
// throw (UtilLecture::ErrNouvelleDonnee(-1));
// Sortie(1);
// };
}
else if (nom == "mini_QepsilonBH_")
{*(entreePrinc->entree) >> mini_QepsilonBH;
// if (mini_QepsilonBH < 0.)
// { cout << "\n erreur en lecture sur mini_QepsilonBH, "
// << "\n il doit etre positif on a lu : " << mini_QepsilonBH
// << "\n Hysteresis3D::LectureDonneesParticulieres(UtilLecture * entreePrinc) " << endl ;
// throw (UtilLecture::ErrNouvelleDonnee(-1));
// Sortie(1);
// };
}
// prise en compte des variations de w' et w'point dans le calcul de l'évolution tangente
else if (nom == "avecVarWprimeS_")
{*(entreePrinc->entree) >> avecVarWprimeS;
}
// forcer un affichage particulier pour les méthodes
else if (nom == "permet_affichage_")
{Lecture_permet_affichage(entreePrinc,lesFonctionsnD);
alg_edp.Change_niveau_affichage(Permet_affichage());
}
// forcer un stockage des indicateurs de la résolution
else if (nom == "sortie_post_")
{*(entreePrinc->entree) >> sortie_post;
}
// sinon ce n'est pas un mot clé connu, on le signale
else if(nom != "fin_parametres_reglage_Hysteresis_")
{ cout << "\n erreur en lecture d'un parametre, le mot cle est inconnu "
<< " on a lu : " << nom << endl;
if (ParaGlob::NiveauImpression()>3)
cout << "\n Hysteresis3D::LectureDonneesParticulieres(UtilLecture * entreePrinc) " << endl ;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
}; //-- fin du while
}; //-- fin de la lecture des paramètres de réglage
// traitement de certains paramètres non initialisés
if (type_calcul_comportement_tangent == 0)
{ // == 0 signifie qu'il n'y a pas eu de lecture, on met donc les valeurs cohérentes par défaut
if (type_resolution_equa_constitutive == 1) {type_calcul_comportement_tangent = 1;}
else {type_calcul_comportement_tangent = 2;};
};
// le niveau d'affichage
alg_zero.Modif_affichage(Permet_affichage());
// appel au niveau de la classe mère
Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire
(*entreePrinc,lesFonctionsnD);
};
// affichage de la loi
void Hysteresis3D::Affiche() const
{ cout << " \n loi_de_comportement d'hysteresis3D " ;
if ( xnp_temperature != NULL) { cout << " np thermo dependant "
<< " courbe np=f(T): " << xnp_temperature->NomCourbe() <<" ";}
else { cout << " np= " << xnp_lue ;};
if ( Qzero_temperature != NULL) { cout << " Qzero thermo dependant "
<< " courbe np=f(T): " << Qzero_temperature->NomCourbe() <<" ";}
else { cout << " Qzero= " << Qzero_lue ;};
if ( xmu_temperature != NULL) { cout << " xmu thermo dependant "
<< " courbe xmu=f(T): " << xmu_temperature->NomCourbe() <<" ";}
else { cout << " mu= " << xmu_lue ;};
// -- éventuellement dépendance à la phase
if (avec_phaseDeltaSig || avec_phaseEps)
{if (avec_phaseDeltaSig ) { cout << " \n dependance a la phase de Delta_R^t_sigma ";}
else { cout << " \n dependance a la phase de la deformation ";};
if (xnp_phase != NULL) { cout << " np dependant de la phase "
<< " courbe np=f(3cos(phi)): " << xnp_phase->NomCourbe() <<" ";};
if (Qzero_phase != NULL) { cout << " Qzero dependant de la phase "
<< " courbe Qzero=f(3cos(phi)): " << Qzero_phase->NomCourbe() <<" ";};
if (xmu_phase != NULL) { cout << " xmu dependant de la phase "
<< " courbe xmu=f(3cos(phi)): " << xmu_phase->NomCourbe() <<" ";};
};
// -- éventuellement dépendance à la defEqui
if (avec_defEqui)
{if (xnp_defEqui != NULL) { cout << " np dependant de la deformation equivalente "
<< " courbe np=f(3cos(phi)): " << xnp_defEqui->NomCourbe() <<" ";};
if (Qzero_defEqui != NULL) { cout << " Qzero dependant de la deformation equivalente "
<< " courbe np=f(3cos(phi)): " << Qzero_defEqui->NomCourbe() <<" ";};
};
// -- éventuellement dépendance à la phase de la déformation totale
if (avec_phase_paradefEqui)
{if (coef_paradefEqui != NULL) { cout << " dependance a la phase de la deformation totale "
<< " courbe coef_paradefEqui=f(3cos(phi)): " << coef_paradefEqui->NomCourbe() <<" ";};
};
// --- paramètre de réglage
cout << "\n type_resolution_equa_constitutive " << type_resolution_equa_constitutive
<< " type_calcul_comportement_tangent " << type_calcul_comportement_tangent;
if (type_resolution_equa_constitutive == 1)
{ cout << " \n type de resolution: linearisation, nbmax iteration= " << nb_boucle_maxi
<< " nbmax_dichotonmie= " << nb_dichotomie
<< " tolerance_residu_absolue= " << tolerance_residu
<< " tolerance_residu_relative= " << tolerance_residu_rel
<< " maxi_delta_var_sig_sur_iter_pour_Newton= " << maxi_delta_var_sig_sur_iter_pour_Newton;
}
else //if ((type_resolution_equa_constitutive == 2) || (type_resolution_equa_constitutive == 3))
{ cout << " \n type de resolution: Runge_Kutta " << cas_kutta << " erreurAbsolue " << erreurAbsolue
<< " erreurRelative= " << erreurRelative ;
};
cout << " tolerance_coincidence= " << tolerance_coincidence << " mini_rayon " << mini_rayon
<< " tolerance_centre= " << tolerance_centre
<< " nb_maxInvCoinSurUnPas= " << nb_maxInvCoinSurUnPas
<< " min_angle_trajet_neutre= " << min_angle_trajet_neutre
<< " possibilite_cosAlphaNegatif= " << possibilite_cosAlphaNegatif
<< " mini_Qsig_pour_phase_sigma_Oi_tdt= " << mini_Qsig_pour_phase_sigma_Oi_tdt
<< " mini_QepsilonBH= " << mini_QepsilonBH
<< " force_phi_zero_si_negatif= " << force_phi_zero_si_negatif << " "
<< " depassement_Q0= " << depassement_Q0
<< " type_de_transport_memorisation= "<< type_de_transport_memorisation
<< " niveau_bascule_fct_aide= "<< niveau_bascule_fct_aide;
// niveau d'affichage
Affiche_niveau_affichage();
cout << " sortie_post "<< sortie_post
<< " ";
// appel de la classe mère
Loi_comp_abstraite::Affiche_don_classe_abstraite();
};
// affichage et definition interactive des commandes particulières à chaques lois
void Hysteresis3D::Info_commande_LoisDeComp(UtilLecture& entreePrinc)
{ ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
cout << "\n definition standart (rep o) ou exemples exhaustifs (rep n'importe quoi) ? ";
string rep = "_";
// procédure de lecture avec prise en charge d'un retour chariot
rep = lect_return_defaut(true,"o");
Qzero = 200.; xnp = 1.; xmu = 1000; // init à des exemples de valeurs
if ((rep != "o") && (rep != "O" ) && (rep != "0") )
{ sort << "\n#-------------------------------------------------------------------------"
<< "\n# ....... loi_de_comportement d'hysteresis 3D ........ |"
<< "\n# para de prager : mu : limite maxi de plasticite |"
<< "\n#-------------------------------------------------------------------------"
<< "\n np= " << setprecision(6) << xnp << " mu= " << setprecision(6) << xmu
<< " Qzero= "<< setprecision(6) << Qzero
<< "\n# il est possible de definir des parametres thermo-dependants (1 ou 2 ou 3 parametres)"
<< "\n# par exemple pour les trois parametres on ecrit: "
<< "\n#-----------------------------------"
<< "\n# np= np_thermo_dependant_ courbe1 "
<< "\n# mu= mu_thermo_dependant_ courbe4 "
<< "\n# Qzero= Qzero_thermo_dependant_ courbe3 "
<< "\n#-----------------------------------"
<< "\n# noter qu'apres la definition de chaque courbe, on change de ligne, d'une maniere inverse "
<< "\n# si la valeur du parametre est fixe, on poursuit sur la meme ligne. "
<< "\n# par exemple supposons np fixe, mu et Qzero thermo-dependant, on ecrit: "
<< "\n#-----------------------------------"
<< "\n# np= 2. mu= mu_thermo_dependant_ courbe4 "
<< "\n# Qzero= Qzero_thermo_dependant_ courbe3 "
<< "\n#-----------------------------------"
<< "\n# il est egalement possible de definir une dependance a la phase des parametres "
<< "\n# deux possibilites: soit une dependance a la phase du delta deviateur de contrainte "
<< "\n# entre le centre instantane et sa valeur a tdt"
<< "\n# soit une dependance a la phase a la phase de la deformation totale. "
<< "\n# Dans ce cas, a la suite du parametre Qzero on met le mot cle: avec_phaseDeltaSig ou avec_phaseDeltaSig"
<< "\n# puis sur la ligne qui suit on met les fonctions de controle de la dependance "
<< "\n# suit un exemple de declaration (il est possible d'ommettre une fonction "
<< "\n# mais il faut respecter l'ordre ). Comme pour toutes les courbes on peut soit mettre directement"
<< "\n# la courbe, soit mettre un nom de courbe. Ne pas oublier de passer a la ligne apres chaque courbe "
<< "\n# np= 1 mu= 4000 Qzero= 80 avec_phaseDeltaSig "
<< "\n# xnp_phase= courbe_xnp_phase "
<< "\n# xmu_phase= courbe_xmu_phase "
<< "\n# Qzero_phase= courbe_Qzero_phase "
<< "\n# "
<< "\n#-----------------------------------"
<< "\n# il est egalement possible de definir une dependance a la deformation equivalente (cf. doc)"
<< "\n# il s'agit ici d'une grandeur qui mesure une mesure de def equivalente a un trajet radial pur. "
<< "\n# Il s'agit :"
<< "\n# 1) d'une dependance du parametre de prager sous la forme suivante:"
<< "\n# xp = f(eps_equi * Q_deltaSigma_R_tdt * para) tel que para = (2*Qzero^2/(w'*mu). "
<< "\n# 2) d'une dependance de la saturation Qzero sous la forme suivante:"
<< "\n# Qzero = f(eps_equi) * Qzero "
<< "\n# Dans ce cas, a la suite du parametre Qzero (ou des parametres de phase et du type de transport ) "
<< "\n# on met le mot cle: avec_defEqui . "
<< "\n# puis sur la ligne qui suit on met la fonctions de controle de la dependance pour xnp et/ou pour Qzero. "
<< "\n# on peut mettre l'une ou l'autre ou les deux "
<< "\n# suit un exemple de declaration. Comme pour toutes les courbes on peut soit mettre directement"
<< "\n# la courbe, soit mettre un nom de courbe. Ne pas oublier de passer a la ligne apres chaque courbe "
<< "\n# np= 1 mu= 4000 Qzero= 80 avec_defEqui "
<< "\n# xnp_phase= courbe_xnp_defEqui Qzero_phase= courbe_Qzero_defEqui"
<< "\n# "
<< "\n#-----------------------------------"
<< "\n# il est egalement possible de definir une dependance a la phase de la deformation totale"
<< "\n# (cf. doc) pour para = (2*Qzero^2/(w'*mu) . Il s'agit d'une fonction multiplicatrice de para"
<< "\n# Cette dependance s'utilise donc conjointement avec la dependance a la deformation equivalente "
<< "\n# Dans le cas d'une dependance, a la suite de la dependance a la deformation equivalente "
<< "\n# on met le mot cle: avec_phase_paradefEqui . "
<< "\n# puis sur la ligne qui suit on met la fonctions de controle de la dependance. "
<< "\n# suit un exemple de declaration. Comme pour toutes les courbes on peut soit mettre directement"
<< "\n# la courbe, soit mettre un nom de courbe. Ne pas oublier de passer a la ligne apres chaque courbe "
<< "\n# np= 1 mu= 4000 Qzero= 80 avec_defEqui "
<< "\n# xnp_phase= courbe_xnp_defEqui "
<< "\n# avec_phase_paradefEqui "
<< "\n# coef_paradefEqui= courbe_coef_paradefEqui "
<< "\n# "
<< "\n#-----------------------------------"
<< "\n# il est egalement possible (mais pas obligatoire) de definir les parametres de reglage "
<< "\n# de la resolution. Dans ce cas, a la suite de la limite maxi de plasticite (si l'on est sans phase) "
<< "\n# ou sur la ligne qui suit le dernier parametre de phase on indique le mot cle: avec_parametres_de_reglage_ "
<< "\n# ensuite on defini (dans un ordre quelconque) les parametres que l'on souhaites "
<< "\n# chaque parametre est precede d'un mot cle, on a donc une succession de mot cle suivi d'une grandeur "
<< "\n# on peut avoir un ou plusieur couple parametre-grandeur sur chaque ligne "
<< "\n# par contre la derniere ligne doit comporter uniquement le mot cle: "
<< "\n# fin_parametres_reglage_Hysteresis_ "
<< "\n# les differents parametres sont: "
<< "\n# - le type de resolution: par linearisation(1) (valeur par defaut) ou integration directe via Runge_Kutta(2)"
<< "\n# s'il n'y a pas convergence avec (1) arret et generation d'une exception, avec 2, on bascule sur (1) et "
<< "\n# s'il n'y a pas de nouveau convergence on bascule sur un appel directe de kutta"
<< "\n# type (3) = idem que type (2) mais s'il n'y a pas convergence arret et genration d'une exception"
<< "\n# type (4) = idem que type (2) mais s'il n'y a pas convergence bascule sur la linearisation, et s'il n'y"
<< "\n# a pas convergence arret et generation d'une exception"
<< "\n# ex: type_de_resolution_ 2 "
<< "\n# - le nombre d'iteration (pour (1)) ex: nb_iteration_maxi_ 20 "
<< "\n# - le nombre de dichotomie(pour (1)) ex: nb_dichotomie_maxi_ 20 "
<< "\n# - la tolerance absolue sur le residu(pour (1)) ex: tolerance_residu_ 1.e-3 "
<< "\n# - la tolerance relative sur le residu(pour (1)) ex: tolerance_residu_rel_ 1.e-3 "
<< "\n# signifie que la precision sera tolerance_residu_ + ||sig_tdt|| * tolerance_residu_rel_"
<< "\n# la norme maximale du delta sigma qui est permise a chaque iteration de Newton "
<< "\n# par defaut = -1 , si on veut une autre valeur: exe: "
<< "\n# maxi_delta_var_sig_sur_iter_pour_Newton_ 2 # donc 2 MPa a chaque iter "
<< "\n# si on donne une valeur negative (val par defaut), il n'y a pas de limite "
<< "\n# "
// << "\n# si la valeur est negative il s'agit d'une presicion relative: exe -1.e-3 "
// << "\n# signifie que la precision sera max (0.001*||sig_tdt||,0.001) "
<< "\n# - le type de Runge_kutta (pour (2)): 3 pour une methode imbriquee 2-3, 4 pour 3-4, 5 pour 4-5, "
<< "\n# ex: cas_kutta_ 5 "
<< "\n# - l'erreur absolue sur la contrainte finale(pour (2)) ex: erreurAbsolue_ 1.e-3"
<< "\n# - l'erreur relative sur la contrainte finale(pour (2)) ex: erreurRelative_ 1.e-5"
<< "\n# - le nombre maxi d'appel de la fonction derivee (sigma_point) (pour (2)) ex: nbMaxiAppel_ 100"
<< "\n# "
<< "\n# - la tolerance sur la detection des coincidences ex: tolerance_coincidence_ 1.e-3"
<< "\n# si le nombre indique est negatif, cela signifie que la tolerance sera relative a la valeur "
<< "\n# de la norme de la contrainte de reference: exe -0.1 signifie que la tolerance sera "
<< "\n# max (0.1*||sig_R||,0.1) "
<< "\n# "
<< "\n# - la tolerance sur le calcul des hyper-centres de trajet neutre ex: tolerance_centre_ 1.e-3"
<< "\n# si le nombre indique est negatif, cela signifie que la tolerance sera relative a la valeur "
<< "\n# de la norme de la contrainte de reference: exe -0.1 signifie que la tolerance sera "
<< "\n# max (0.1*||sig_R||,0.1) "
<< "\n# "
<< "\n# -le mini en dessous duquel on considere delta_O_R et delta_R_Stdt nul ex: mini_rayon_ 1. e-8"
<< "\n# Meme comportement que pour mini_Qsig_pour_phase_sigma_Oi_tdt_, dans le cas ou mini_rayon est negatif"
<< "\n# ce parametre devient un parametre de regularisation "
<< "\n# "
<< "\n# -le maxi d'inversion ou de coincidence que l'on tolere sur un pas "
<< "\n# dans le cas ou ce maxi est un nombre negatif, on utilise sa valeur absolue et lorsque le maxi "
<< "\n# depasse ce nombre, on retient la valeur final de la contrainte, sinon cas normal: on genere une erreur "
<< "\n# ex nb_maxInvCoinSurUnPas_ -20"
<< "\n# "
<< "\n# - min_angle_trajet_neutre : indique le minimun du cos de l'angle en dessous duquel le trajet est neutre "
<< "\n# ex min_angle_trajet_neutre_ 0.008"
<< "\n# "
<< "\n# - possibilite_cosAlphaNegatif : indique si oui (diff de 0) on non (0) on accepte transitoirement une valeur "
<< "\n# de cosAlpha negative: ex: possibilite_cosAlphaNegatif_ 0 , si c'est non, c'est traite comme un cas neutre "
<< "\n# "
<< "\n#------------- mini_Qsig_pour_phase_sigma_Oi_tdt_ ------------------"
<< "\n# - mini_Qsig_pour_phase_sigma_Oi_tdt : indique le minimum de Qsig en dessous duquel on "
<< "\n# considere que la phase pour delta sigma de Oi a tdt, est nulle "
<< "\n# ex mini_Qsig_pour_phase_sigma_Oi_tdt_ 1.5 "
<< "\n# Dans le cas ou mini_Qsig_pour_phase_sigma_Oi_tdt_ est negatif, cela devient un parametre de regularisation "
<< "\n# Qsig est alors transforme en (Qsig-mini_Qsig_pour_phase_sigma_Oi_tdt) au niveau des divisions qui servent "
<< "\n# a calculer la phase. Dans ce cas l'angle de phase est toujours calculable, par contre pour les faibles "
<< "\n# valeur de Qsig, on peut avoir angle errone, mais ce n'est peut-etre pas un pb "
<< "\n# "
<< "\n#------------- mini_QepsilonBH_ ------------------"
<< "\n# - mini_QepsilonBH : indique le minimum de QepsilonBH en dessous duquel on "
<< "\n# considere que la phase pour la deformation totale, est nulle "
<< "\n# ex mini_QepsilonBH_ 1.e-4 "
<< "\n# Meme comportement que pour mini_Qsig_pour_phase_sigma_Oi_tdt_, dans le cas ou mini_QepsilonBH est negatif"
<< "\n# ce parametre devient un parametre de regularisation "
<< "\n# "
<< "\n#------------- force_phi_zero_si_negatif_ ------------------"
<< "\n# - au niveau de l'equation constitutive, phi doit-etre toujours positif, cependant pendant le processus "
<< "\n# de convergence il peut etre transitoirement negatif: on peut neanmoins forcer phi a etre toujours >= 0 "
<< "\n# avec le parametre : force_phi_zero_si_negatif_ "
<< "\n# Par defaut => force_phi_zero_si_negatif_ = 0. : on ne force pas la mise a 0"
<< "\n# si : force_phi_zero_si_negatif_ x , avec x diff de 0 : on force la mise a 0 "
<< "\n# si phi devient negatif et |phi| < x "
<< "\n#------------- type de transport ------------------"
<< "\n# - il est egalement possible de preciser un type de transport des grandeurs memorises "
<< "\n# (cf. doc) "
<< "\n# Dans ce cas, on met le mot cle: type_de_transport_memorisation_ suivi d'un entier signe 'i' "
<< "\n# i = 0 : transport historique en mixte (valeur par defaut pour l'instant) "
<< "\n# i = -1 : transport incremental ( a la fin de chaque increment) de maniere coherente avec "
<< "\n# la derivee de Jauman "
<< "\n#--------------- utilisation de la fonction d'aide -----------------"
<< "\n# "
<< "\n# - l'algorithme de gestion de la memorisation discrete s'effectue soit via le rayon des "
<< "\n# hypersphere representant les tenseurs OiSigma_tdt ceci pour de faibles rayons, "
<< "\n# soit via une fonction d'aide pour des rayons importants. Le passage entre ces deux modes "
<< "\n# de gestion s'effectue en fonction du parametre niveau_bascule_fct_aide_ qui est compris entre 0 et 1"
<< "\n# ex: niveau_bascule_fct_aide_ 0.5 # signifie que l'on bascule pour un rayon superieur a 50% "
<< "\n# # du rayon maxi "
<< "\n# "
<< "\n# "
<< "\n#-------------- limitation de l'intensite du deviateur ------------------"
<< "\n# "
<< "\n# - normalement l'intensite du deviateur des contraintes Qsig doit etre inferieure a la saturation Q_0 "
<< "\n# le parametre depassement_Q0 donne la valeur toleree de depassement, au-dessus de laquelle "
<< "\n# la contrainte n'est plus recevable "
<< "\n# ex: depassement_Q0_ 1.2 # signifie que l'on tolere 20% de deplacement"
<< "\n# "
<< "\n# "
<< "\n# -------------- calcul du comportement tangent ---------"
<< "\n# - Pour le type de resolution par linearisation, le comportement tangent est calcule par une methode coherente"
<< "\n# differente du cas de type de resolution par Kutta. Il est possible d'indiquer explicitement "
<< "\n# le type de calcul du comportement tangent: deux cas possibles, soit en utilisant l'equation linearise "
<< "\n# (cas = 1), soit en utilisant l'equation exacte sans linearisation (cas 2) "
<< "\n# Pour cela, par exemple apres la definition du cas de resolution , on indique le mot cle"
<< "\n# type_calcul_comportement_tangent_ suivi du cas : 1 ou 2 "
<< "\n# ex type_calcul_comportement_tangent_ 2"
<< "\n# Il est possible de tenir compte ou pas de la variation de l'angle de phase et de sa derivee danse le "
<< "\n# calcul du comportement tangent. Par defaut, il n'y a pas de prise en compte de ces variations. Pour "
<< "\n# en tenir compte il faut mettre le mot cle avecVarWprimeS_ suivi de 1 (0 etant la valeur par defaut) "
<< "\n# ex avecVarWprimeS_ 1"
<< "\n# "
<< "\n# -------------- affichage des erreurs et des warning ---------- "
<< "\n# - l'affichage normale est fonction du parametre global d'affichage gerer par le niveau d'affichage"
<< "\n# cependant pour des raisons par exemple de mise au point, il est possible de permettre l'affichage "
<< "\n# a un niveau particulier (mot cle : permet_affichage_ suivi d'un nombre entier) en plus de l'affichage normal. "
<< "\n# l'affichage s'effectuera donc en fonction de l'affichage normale et de l'affichage particulier."
<< "\n# Le fonctionnement de l'affichage particulier suit les mêmes règles que l'affichage globale"
<< "\n# soit permet_affichage_ est nulle (cas par defaut), dans ce cas l'affichage est fonction du niveau global"
<< "\n# soit permet_affichage_ vaut n par exemple, dans ce cas l'affichage est fonction uniquement de n "
<< "\n# "
<< "\n# ex: permet_affichage_ 5 "
<< "\n# --------------- acces aux indicateurs de la resolution par -------"
<< "\n# A chaque resolution, il est possible de stocker les indicateurs: nombre d'iteration, d'increment "
<< "\n# precision etc. les indicateurs sont renseignes en fonction du type de resolution "
<< "\n# le mot cle est sortie_post_ , par defaut il vaut 0, dans ce cas aucun indicateur n'est stoke"
<< "\n# s'il est different de 0, on peut acceder aux indicateurs en post-traitement"
<< "\n# seules les indicateurs en cours sont disponibles, il n'y a pas de stockage sur plusieurs increment "
<< "\n# "
<< "\n# ex: sortie_post_ 1 "
<< "\n# "
<< "\n# \n Exemple de declaration: sans la phase "
<< "\n#-------------------------------------------------------------------------"
<< "\n# ....... loi_de_comportement d'hysteresis 3D ........ |"
<< "\n# para de prager : mu : limite maxi de plasticite |"
<< "\n#-------------------------------------------------------------------------"
<< "\n# np= " << setprecision(6) << xnp << " mu= " << setprecision(6) << xmu
<< "\n# Qzero= "<< setprecision(6) << Qzero << " avec_parametres_de_reglage_ "
<< "\n# nb_iteration_maxi_ 20 nb_dichotomie_maxi_ 20 tolerance_residu_ 1.e-3 tolerance_residu_rel_ 1.e-5 "
<< "\n# tolerance_coincidence_ 1.e-3 mini_rayon_ 1. e-8 tolerance_centre_ 1. e-3 "
<< "\n# fin_parametres_reglage_Hysteresis_ "
<< "\n# "
<< "\n# \n Exemple de declaration pour une resolution avec une methode de Runge_Kutta: "
<< "\n#-------------------------------------------------------------------------"
<< "\n# ....... loi_de_comportement d'hysteresis 3D ........ |"
<< "\n# para de prager : mu : limite maxi de plasticite |"
<< "\n#-------------------------------------------------------------------------"
<< "\n# np= " << setprecision(6) << xnp << " mu= " << setprecision(6) << xmu
<< "\n# Qzero= "<< setprecision(6) << Qzero << " avec_parametres_de_reglage_ "
<< "\n# type_de_resolution_ 2 "
<< "\n# cas_kutta_ 5 erreurAbsolue_ 1.e-3 erreurRelative_ 1.e-5 nbMaxiAppel_ 100"
<< "\n# tolerance_coincidence_ 1.e-3 nb_maxInvCoinSurUnPas_ 20 min_angle_trajet_neutre_ 0.008"
<< "\n# possibilite_cosAlphaNegatif_ 0 mini_Qsig_pour_phase_sigma_Oi_tdt_ 1.5 "
<< "\n# fin_parametres_reglage_Hysteresis_ ";
}
else
{sort
<< "\n# \n Exemple de declaration pour une resolution avec une methode de Runge_Kutta: "
<< "\n#-------------------------------------------------------------------------"
<< "\n# ....... loi_de_comportement d'hysteresis 3D ........ |"
<< "\n# para de prager : mu : limite maxi de plasticite |"
<< "\n#-------------------------------------------------------------------------"
<< "\n np= " << setprecision(6) << xnp << " mu= " << setprecision(6) << xmu
<< " Qzero= "<< setprecision(6) << Qzero << " avec_parametres_de_reglage_ "
<< "\n type_de_resolution_ 2 "
<< "\n cas_kutta_ 5 erreurAbsolue_ 1.e-3 erreurRelative_ 1.e-5 nbMaxiAppel_ 3000"
<< "\n tolerance_coincidence_ 1.e-3 nb_maxInvCoinSurUnPas_ 20 min_angle_trajet_neutre_ 0.008"
<< "\n possibilite_cosAlphaNegatif_ 0 mini_Qsig_pour_phase_sigma_Oi_tdt_ 1.5 "
<< "\n fin_parametres_reglage_Hysteresis_ ";
};
sort << endl;
// appel de la classe mère
Loi_comp_abstraite::Info_commande_don_LoisDeComp(entreePrinc);
};
// test si la loi est complete
int Hysteresis3D::TestComplet()
{ int ret = LoiAbstraiteGeneral::TestComplet();
if ((xnp_temperature == NULL) && (xnp == ConstMath::tresgrand))
{ cout << " \n le parametre de prager n'est pas défini pour la loi " << Nom_comp(id_comp)
<< '\n';
ret = 0;
}
if ((xmu_temperature == NULL) && (xmu == ConstMath::tresgrand))
{ cout << " \n le parametre de lame mu n'est pas défini pour la loi " << Nom_comp(id_comp)
<< '\n';
ret = 0;
}
if ((Qzero_temperature == NULL) && (Qzero == ConstMath::tresgrand))
{ cout << " \n la limite de plasticite n'est pas défini pour la loi " << Nom_comp(id_comp)
<< '\n';
ret = 0;
}
return ret;
};
// calcul d'un module d'young équivalent à la loi, ceci pour un
// chargement nul
double Hysteresis3D::Module_young_equivalent(Enum_dure temps,const Deformation & ,SaveResul * )
{ // par défaut on prend un mu de 0.3 et on utilise l'équivalent d'une loi élastique
// mu = G = E/(2(1+nu)) -> E=2.6 * mu
if (xmu_temperature != NULL) xmu = xmu_temperature->Valeur(*temperature);
return (2.6 * xmu);
};
// récupération des grandeurs particulière (hors ddl )
// correspondant à liTQ
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
void Hysteresis3D::Grandeur_particuliere
(bool ,List_io<TypeQuelconque>& liTQ,Loi_comp_abstraite::SaveResul * saveDon,list<int>& decal) const
{ // ici on est en 3D et les grandeurs sont par principe en absolue, donc la variable absolue ne sert pas
// on passe en revue la liste
List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end();
list<int>::iterator idecal=decal.begin();
for (itq=liTQ.begin();itq!=itqfin;itq++,idecal++)
{TypeQuelconque& tipParticu = (*itq); // pour simplifier
if (tipParticu.EnuTypeQuelconque().Nom_vide()) // veut dire que c'est un enum pur
switch (tipParticu.EnuTypeQuelconque().EnumTQ())
{ case NB_INVERSION:
// a) ----- cas du nombre d'inversion actuelle
{ SaveResulHysteresis3D & save_resul = *((SaveResulHysteresis3D*) saveDon);
Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
tyTQ(1+(*idecal))=save_resul.sigma_barre_BH_R.size();
(*idecal)++; break;
}
case HYPER_CENTRE_HYSTERESIS:
// b) ----- cas du centre du cercle actuelle de référence
{ SaveResulHysteresis3D & save_resul = *((SaveResulHysteresis3D*) saveDon);
Tab_Grandeur_TenseurBH& tyTQ= *((Tab_Grandeur_TenseurBH*) (*itq).Grandeur_pointee()); // pour simplifier
if (save_resul.oc_BH_R.size() != 0)
{tyTQ(1+(*idecal))= *(save_resul.oc_BH_R.begin());}
else
{tyTQ(1+(*idecal)).Inita(0.);}
(*idecal)++; break;
}
case SIGMA_REF:
// c) ----- cas de la contrainte de référence actuelle
{ SaveResulHysteresis3D & save_resul = *((SaveResulHysteresis3D*) saveDon);
Tab_Grandeur_TenseurBH& tyTQ= *((Tab_Grandeur_TenseurBH*) (*itq).Grandeur_pointee()); // pour simplifier
if (save_resul.sigma_barre_BH_R.size() != 0)
{tyTQ(1+(*idecal))= *(save_resul.sigma_barre_BH_R.begin());}
else
{tyTQ(1+(*idecal)).Inita(0.);};
(*idecal)++; break;
}
// d) ----- Q_sigma actuel de Oi à T
case Q_SIG_HYST_Oi_A_R:
{ SaveResulHysteresis3D & save_resul = *((SaveResulHysteresis3D*) saveDon);
Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
Tenseur3BH delta__sigma_barre_BH_OiaR; // a priori le centre et la référence = 0: cas du début
if (save_resul.sigma_barre_BH_R.size() != 0) delta__sigma_barre_BH_OiaR=(*(save_resul.sigma_barre_BH_R.begin()));
if (save_resul.oc_BH_R.size() != 0) delta__sigma_barre_BH_OiaR -= *(save_resul.oc_BH_R.begin());
tyTQ(1+(*idecal)) = sqrt(delta__sigma_barre_BH_OiaR.II());
(*idecal)++; break;
}
// e) ----- Q_sigma actuel de R à T
case Q_SIG_HYST_R_A_T:
{ SaveResulHysteresis3D & save_resul = *((SaveResulHysteresis3D*) saveDon);
Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
Tenseur3BH delta__sigma_barre_BH_Ratdt (save_resul.sigma_barre_BH_tdt); // a priori la ref = 0: cas du début
if (save_resul.sigma_barre_BH_R.size() != 0) delta__sigma_barre_BH_Ratdt -= *(save_resul.sigma_barre_BH_R.begin());
tyTQ(1+(*idecal))=sqrt(delta__sigma_barre_BH_Ratdt.II());
(*idecal)++; break;
}
// f) ----- COS_ALPHA_HYSTERESIS actuel
case COS_ALPHA_HYSTERESIS:
{ SaveResulHysteresis3D & save_resul = *((SaveResulHysteresis3D*) saveDon);
Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
// le plus simple est de recalculer
double w__prime,w__prime_point; // grandeurs de retour
bool trajet_neutre=false;
Tenseur3BH delta__sigma_barre_BH_Ratdt (save_resul.sigma_barre_BH_tdt); // a priori la ref = 0: cas du début
if (save_resul.sigma_barre_BH_R.size() != 0) delta__sigma_barre_BH_Ratdt -= *(save_resul.sigma_barre_BH_R.begin());
double Q__deltaSiRatdt = sqrt(delta__sigma_barre_BH_Ratdt.II());
Tenseur3BH delta__sigma_barre_BH_OiaR; // a priori le centre et la référence = 0: cas du début
if (save_resul.sigma_barre_BH_R.size() != 0) delta__sigma_barre_BH_OiaR=(*(save_resul.sigma_barre_BH_R.begin()));
if (save_resul.oc_BH_R.size() != 0) delta__sigma_barre_BH_OiaR -= *(save_resul.oc_BH_R.begin());
double Q__OiaR = sqrt(delta__sigma_barre_BH_OiaR.II());
Cal_wprime(Q__deltaSiRatdt,delta__sigma_barre_BH_Ratdt,Q__OiaR,delta__sigma_barre_BH_OiaR
,save_resul.wBase_tdt,ZeroBH3,w__prime,w__prime_point,trajet_neutre);
tyTQ(1+(*idecal))=w__prime/save_resul.wBase_tdt;
(*idecal)++; break;
}
// g) ----- cos_3phi actuel pour la contrainte totale d'hystérésis
case COS3PHI_SIG_HYSTERESIS:
{ SaveResulHysteresis3D & save_resul = *((SaveResulHysteresis3D*) saveDon);
Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
double Qsig = sqrt(Dabs(save_resul.sigma_barre_BH_tdt.II()));
double Qsig3 = Qsig * Qsig * Qsig;
// if (Qsig > mini_Qsig_pour_phase_sigma_Oi_tdt )
{ // on peut calculer un cos3phi pas débile
double bIIIb = save_resul.sigma_barre_BH_tdt.III() / 3.;
if (mini_Qsig_pour_phase_sigma_Oi_tdt > 0.)
tyTQ(1+(*idecal)) = 3. * sqrt(6.) * bIIIb/ Qsig3;
else
tyTQ(1+(*idecal)) = 3. * sqrt(6.) * bIIIb/ (Qsig3-mini_Qsig_pour_phase_sigma_Oi_tdt);
};
// else tyTQ=0.; // sinon on le met à 0
(*idecal)++; break;
}
// h) ----- cos_3phi actuel pour l'incrément de contrainte totale d'hystérésis
case COS3PHI_DELTA_SIG_HYSTERESIS:
{ SaveResulHysteresis3D & save_resul = *((SaveResulHysteresis3D*) saveDon);
Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
Tenseur3BH delta__sigma_barre_BH_tatdt(save_resul.sigma_barre_BH_tdt-save_resul.sigma_barre_BH_t);
double Qsig = sqrt(delta__sigma_barre_BH_tatdt.II());
double Qsig3 = Qsig * Qsig * Qsig;
// if (Qsig > mini_Qsig_pour_phase_sigma_Oi_tdt )
{ // on peut calculer un cos3phi pas débile
double bIIIb = delta__sigma_barre_BH_tatdt.III() / 3.;
if (mini_Qsig_pour_phase_sigma_Oi_tdt > 0.)
tyTQ(1+(*idecal)) = 3. * sqrt(6.) * bIIIb/ Qsig3;
else
tyTQ(1+(*idecal)) = 3. * sqrt(6.) * bIIIb/ (Qsig3-mini_Qsig_pour_phase_sigma_Oi_tdt);
}
// else tyTQ=0.; // sinon on le met à 0
(*idecal)++; break;
}
// i) ----- Q_delta_sig d'hystérésis
case Q_DELTA_SIG_HYST:
{ SaveResulHysteresis3D & save_resul = *((SaveResulHysteresis3D*) saveDon);
Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
Tenseur3BH delta__sigma_barre_BH_tatdt(save_resul.sigma_barre_BH_tdt-save_resul.sigma_barre_BH_t);
tyTQ(1+(*idecal)) = sqrt(delta__sigma_barre_BH_tatdt.II());
(*idecal)++; break;
}
// ----- fonction d'aide
case FCT_AIDE:
{ SaveResulHysteresis3D & save_resul = *((SaveResulHysteresis3D*) saveDon);
Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
tyTQ(1+(*idecal)) = save_resul.fonction_aide_tdt;
(*idecal)++; break;
}
case NB_INCRE_TOTAL_RESIDU:
{ SaveResulHysteresis3D & save_resul = *((SaveResulHysteresis3D*) saveDon);
Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
if ((save_resul.indicateurs_resolution_t.Taille()))
tyTQ(1+(*idecal)) = save_resul.indicateurs_resolution_t(1);
else tyTQ(1+(*idecal)) = 0.;
(*idecal)++; break;
}
case NB_ITER_TOTAL_RESIDU:
{ SaveResulHysteresis3D & save_resul = *((SaveResulHysteresis3D*) saveDon);
Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
if ((save_resul.indicateurs_resolution_t.Taille()))
tyTQ(1+(*idecal)) = save_resul.indicateurs_resolution_t(2);
else tyTQ(1+(*idecal)) = 0.;
(*idecal)++; break;
}
case NB_APPEL_FCT:
{ SaveResulHysteresis3D & save_resul = *((SaveResulHysteresis3D*) saveDon);
Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
if ((save_resul.indicateurs_resolution_t.Taille()))
tyTQ(1+(*idecal)) = save_resul.indicateurs_resolution_t(3);
else tyTQ(1+(*idecal)) = 0.;
(*idecal)++; break;
}
case NB_STEP:
{ SaveResulHysteresis3D & save_resul = *((SaveResulHysteresis3D*) saveDon);
Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
if ((save_resul.indicateurs_resolution_t.Taille()))
tyTQ(1+(*idecal)) = save_resul.indicateurs_resolution_t(4);
else tyTQ(1+(*idecal)) = 0.;
(*idecal)++; break;
}
case ERREUR_RK:
{ SaveResulHysteresis3D & save_resul = *((SaveResulHysteresis3D*) saveDon);
Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
if ((save_resul.indicateurs_resolution_t.Taille()))
tyTQ(1+(*idecal)) = save_resul.indicateurs_resolution_t(5);
else tyTQ(1+(*idecal)) = 0.;
(*idecal)++; break;
}
default: ;// on ne fait rien
};
};
};
// récupération et création de la liste de tous les grandeurs particulières
// ces grandeurs sont ajoutées à la liste passées en paramètres
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
void Hysteresis3D::ListeGrandeurs_particulieres(bool absolue,List_io<TypeQuelconque>& liTQ) const
{// ici on est en 3D et les grandeurs sont par principe en absolue, donc la variable absolue ne sert pas
Tableau <double> tab_1(1);
Tab_Grandeur_scalaire_double grand_courant(tab_1);
// def d'un type quelconque représentatif à chaque grandeur
// a priori ces grandeurs sont défini aux points d'intégration identique à la contrainte par exemple
// enu_ddl_type_pt est définit dans la loi Abtraite générale
// on n'ajoute que si sortie_post est vraie, sinon aucune grandeur n'est sauvegardé, donc on ne peut
// plus y accèder
//on regarde si ce type d'info existe déjà: si oui on augmente la taille du tableau, si non on crée
// a) $$$ cas du nombre d'inversion actuelle
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == NB_INVERSION)
{ Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TypeQuelconque typQ1(NB_INVERSION,enu_ddl_type_pt,grand_courant);
liTQ.push_back(typQ1);
};
};
// b) $$$ cas du centre du cercle actuelle de référence
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == HYPER_CENTRE_HYSTERESIS)
{Tab_Grandeur_TenseurBH& tyTQ= *((Tab_Grandeur_TenseurBH*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TenseurBH* tens = NevezTenseurBH(3); // un tenseur typique
Tab_Grandeur_TenseurBH sigrefBH(*tens,1);
// def d'un type quelconque représentatif
TypeQuelconque typQ(HYPER_CENTRE_HYSTERESIS,SIG11,sigrefBH);
liTQ.push_back(typQ);
delete tens; // car on n'en a plus besoin
};
};
// c) $$$ cas de la contrainte de référence actuelle
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == SIGMA_REF)
{Tab_Grandeur_TenseurBH& tyTQ= *((Tab_Grandeur_TenseurBH*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TenseurBH* tens = NevezTenseurBH(3); // un tenseur typique
Tab_Grandeur_TenseurBH sigrefBH(*tens,1);
// def d'un type quelconque représentatif
TypeQuelconque typQ(SIGMA_REF,SIG11,sigrefBH);
liTQ.push_back(typQ);
delete tens; // car on n'en a plus besoin
};
};
// d) $$$ Q_sigma actuel de Oi à R
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == Q_SIG_HYST_Oi_A_R)
{Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TypeQuelconque typQ1(Q_SIG_HYST_Oi_A_R,SIG11,grand_courant);
liTQ.push_back(typQ1);
};
};
// e) $$$ Q_sigma actuel de R à T
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == Q_SIG_HYST_R_A_T)
{Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TypeQuelconque typQ1(Q_SIG_HYST_R_A_T,SIG11,grand_courant);
liTQ.push_back(typQ1);
};
};
// f) $$$ cos_alpha actuel
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == COS_ALPHA_HYSTERESIS)
{Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TypeQuelconque typQ1(COS_ALPHA_HYSTERESIS,SIG11,grand_courant);
liTQ.push_back(typQ1);
};
};
// g) ----- cos_3phi actuel pour la contrainte totale d'hystérésis
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == COS3PHI_SIG_HYSTERESIS)
{Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TypeQuelconque typQ1(COS3PHI_SIG_HYSTERESIS,SIG11,grand_courant);
liTQ.push_back(typQ1);
};
};
// h) ----- cos_3phi actuel pour l'incrément de contrainte totale d'hystérésis
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == COS3PHI_DELTA_SIG_HYSTERESIS)
{Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TypeQuelconque typQ1(COS3PHI_DELTA_SIG_HYSTERESIS,SIG11,grand_courant);
liTQ.push_back(typQ1);
};
};
// i) ----- Q_delta_sig d'hystérésis
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == Q_DELTA_SIG_HYST)
{Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TypeQuelconque typQ1(Q_DELTA_SIG_HYST,SIG11,grand_courant);
liTQ.push_back(typQ1);
};
};
// ----- fonction d'aide
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == FCT_AIDE)
{Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TypeQuelconque typQ1(FCT_AIDE,SIG11,grand_courant);
liTQ.push_back(typQ1);
};
};
// ---- la suite dépend de l'indicateur : sortie_post
if (sortie_post)
{ // j) ----- NB_INCRE_TOTAL_RESIDU
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == NB_INCRE_TOTAL_RESIDU)
{Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TypeQuelconque typQ1(NB_INCRE_TOTAL_RESIDU,SIG11,grand_courant);
liTQ.push_back(typQ1);
};
};
// k) ----- NB_ITER_TOTAL_RESIDU
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == NB_ITER_TOTAL_RESIDU)
{Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TypeQuelconque typQ1(NB_ITER_TOTAL_RESIDU,SIG11,grand_courant);
liTQ.push_back(typQ1);
};
};
// l) ----- NB_APPEL_FCT
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == NB_APPEL_FCT)
{Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TypeQuelconque typQ1(NB_APPEL_FCT,SIG11,grand_courant);
liTQ.push_back(typQ1);
};
};
// m) ----- NB_STEP
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == NB_STEP)
{Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TypeQuelconque typQ1(NB_STEP,SIG11,grand_courant);
liTQ.push_back(typQ1);
};
};
// n) ----- ERREUR_RK
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
for (itq=liTQ.begin();itq!=itqfin;itq++)
if ((*itq).EnuTypeQuelconque() == ERREUR_RK)
{Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
int taille = tyTQ.Taille()+1;
tyTQ.Change_taille(taille); nexistePas = false;
};
if (nexistePas)
{TypeQuelconque typQ1(ERREUR_RK,SIG11,grand_courant);
liTQ.push_back(typQ1);
};
};
}; // fin du cas ou sortie_post est actif, c-a-d que l'on veut des infos sur les indicateurs
// de résolution
};
// ========== codage des METHODES VIRTUELLES protegees:================
//----- lecture écriture de restart -----
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Hysteresis3D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
,LesFonctions_nD& lesFonctionsnD)
{if (cas == 1)
{ bool test;string nom;
// param_prager_(np)
ent >> nom >> test;
if (!test)
{ ent >> xnp;
if (xnp_temperature != NULL) {if (xnp_temperature->NomCourbe() == "_")
delete xnp_temperature; xnp_temperature = NULL;
};
}
else
{ ent >> nom; xnp_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,xnp_temperature); };
// limite_plasticite_(Q0)
ent >> nom >> test;
if (!test)
{ ent >> Qzero;
if (Qzero_temperature != NULL) {if (Qzero_temperature->NomCourbe() == "_")
delete Qzero_temperature; Qzero_temperature = NULL;
};
}
else
{ ent >> nom; Qzero_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,Qzero_temperature); };
// param_lame_(mu)
ent >> nom >> test;
if (!test)
{ ent >> xmu;
if (xmu_temperature != NULL) {if (xmu_temperature->NomCourbe() == "_")
delete xmu_temperature; xmu_temperature = NULL;
};
}
else
{ ent >> nom; xmu_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,xmu_temperature); };
// --- dépendance à la phase éventuelle
ent >> nom;
if (nom == "avec_phaseDeltaSig") {avec_phaseDeltaSig = true; avec_phaseEps = false; }
else if (nom == "avec_phaseEps") {avec_phaseDeltaSig = false; avec_phaseEps = true; }
else {avec_phaseDeltaSig = false; avec_phaseEps = false; };
if (avec_phaseDeltaSig || avec_phaseEps)
{// param_prager_(np)
ent >> nom >> test;
if (!test)
{ if (xnp_phase != NULL) {if (xnp_phase->NomCourbe() == "_") delete xnp_phase;
xnp_phase = NULL;
};
}
else
{ ent >> nom; xnp_phase = lesCourbes1D.Lecture_pour_base_info(ent,cas,xnp_phase); };
// xmu
ent >> nom >> test;
if (!test)
{ if (xmu_phase != NULL) {if (xmu_phase->NomCourbe() == "_") delete xmu_phase;
xmu_phase = NULL;
};
}
else
{ ent >> nom; xmu_phase = lesCourbes1D.Lecture_pour_base_info(ent,cas,xmu_phase); };
// Qzero
ent >> nom >> test;
if (!test)
{ if (Qzero_phase != NULL) {if (Qzero_phase->NomCourbe() == "_") delete Qzero_phase;
Qzero_phase = NULL;
};
}
else
{ ent >> nom; Qzero_phase = lesCourbes1D.Lecture_pour_base_info(ent,cas,Qzero_phase); };
};
// --- dépendance à la def Equi éventuelle
ent >> nom;
if (nom == "avec_defEqui")
{ // param_prager_(np)
ent >> test >> nom;
if ((!test) && (nom == "pas_de_fct_xnp_defEqui_"))
{ // pas de dépendance de xn à la defEqui
if (xnp_defEqui != NULL) {if (xnp_defEqui->NomCourbe() == "_") delete xnp_defEqui;
xnp_defEqui = NULL;
};
}
else if (test)
{ ent >> nom;
if (nom == "fonction_xnp_defEqui")
{xnp_defEqui = lesCourbes1D.Lecture_pour_base_info(ent,cas,xnp_defEqui);};
}
else
{ cout << "\n erreur en lecture de xnp_defEqui, on attendait de lire la chaine: pas_de_fct_xnp_defEqui_ et on a lue "
<< nom << endl;
Sortie(1);
};
// dépendance de Qzero
ent >> test >> nom;
if ((!test) && (nom == "pas_de_fct_Qzero_defEqui_"))
{ // pas de dépendance de Qzero à la defEqui
if (Qzero_defEqui != NULL) {if (Qzero_defEqui->NomCourbe() == "_") delete Qzero_defEqui;
Qzero_defEqui = NULL;
};
}
else if (test)
{ ent >> nom;
if (nom == "fonction_Qzero_defEqui")
{Qzero_defEqui = lesCourbes1D.Lecture_pour_base_info(ent,cas,Qzero_defEqui);};
}
else
{ cout << "\n erreur en lecture de Qzero_defEqui, on attendait de lire la chaine: pas_de_fct_Qzero_defEqui_ et on a lue "
<< nom << endl;
Sortie(1);
};
};
// --- dépendance à la phase de la déformation totale
ent >> nom;
if (nom == "avec_phase_paradefEqui")
{ent >> nom >> test;
// coef_paradefEqui
if (!test)
{ if (coef_paradefEqui != NULL) {if (coef_paradefEqui->NomCourbe() == "_") delete coef_paradefEqui;
coef_paradefEqui = NULL;
};
}
else
{ ent >> nom; coef_paradefEqui = lesCourbes1D.Lecture_pour_base_info(ent,cas,coef_paradefEqui); };
};
// les paramètres de réglage de l'algorithme
ent >> nom >> tolerance_residu >> nom >> tolerance_residu_rel
>> nom >> nb_boucle_maxi >> nom >> maxi_delta_var_sig_sur_iter_pour_Newton
>> nom >> nb_dichotomie
>> nom >> mini_rayon
>> nom >> tolerance_coincidence
>> nom >> tolerance_centre;
ent >> nom >> type_resolution_equa_constitutive
>> nom >> type_calcul_comportement_tangent
>> nom >> avecVarWprimeS
>> nom >> cas_kutta >> nom >> erreurAbsolue >> nom >> erreurRelative;
ent >> nom >> nb_maxInvCoinSurUnPas >> nom >> min_angle_trajet_neutre >> nom >> possibilite_cosAlphaNegatif
>> nom >> mini_Qsig_pour_phase_sigma_Oi_tdt
>> nom >> mini_QepsilonBH
>> nom >> force_phi_zero_si_negatif
>> nom >> depassement_Q0
>> nom >> type_de_transport_memorisation
>> nom >> niveau_bascule_fct_aide;
// le niveau d'affichage
Lecture_permet_affichage(ent,cas,lesFonctionsnD);
ent >> nom >> sortie_post;
};
// appel de la classe mère
Loi_comp_abstraite::Lecture_don_base_info(ent,cas,lesRef,lesCourbes1D,lesFonctionsnD);
};
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Hysteresis3D::Ecriture_base_info_loi(ofstream& sort,const int cas)
{ if (cas == 1)
{ sort << " HYSTERESIS_3D ";
sort << " param_prager_(np) ";
if (xnp_temperature == NULL)
{ sort << false << " " << xnp_lue << " ";}
else
{ sort << true << " fonction_xnp_temperature ";
LesCourbes1D::Ecriture_pour_base_info(sort,cas,xnp_temperature);
};
sort << " limite_plasticite_(Q0) ";
if (Qzero_temperature == NULL)
{ sort << false << " " << Qzero_lue << " ";}
else
{ sort << true << " fonction_Qzero_temperature ";
LesCourbes1D::Ecriture_pour_base_info(sort,cas,Qzero_temperature);
};
sort << " param_lame_(mu) ";
if (xmu_temperature == NULL)
{ sort << false << " " << xmu_lue << " ";}
else
{ sort << true << " fonction_xmu_temperature ";
LesCourbes1D::Ecriture_pour_base_info(sort,cas,xmu_temperature);
};
// --- dépendance à la phase éventuelle
if (avec_phaseDeltaSig || avec_phaseEps)
{if (avec_phaseDeltaSig == 1) {sort << " avec_phaseDeltaSig ";}
else {sort << " avec_phaseEps ";};
if (xnp_phase == NULL)
{ sort << false << " " ;}
else
{ sort << true << " fonction_xnp_phase ";
LesCourbes1D::Ecriture_pour_base_info(sort,cas,xnp_phase);
};
if (xmu_phase == NULL)
{ sort << false << " " ;}
else
{ sort << true << " fonction_xmu_phase ";
LesCourbes1D::Ecriture_pour_base_info(sort,cas,xmu_phase);
};
if (Qzero_phase == NULL)
{ sort << false << " " ;}
else
{ sort << true << " fonction_Qzero_phase ";
LesCourbes1D::Ecriture_pour_base_info(sort,cas,Qzero_phase);
};
}
else
{sort << " sans_phase ";};
// --- dépendance à la def Equi éventuelle
if (avec_defEqui)
{sort << " avec_defEqui ";
if (xnp_defEqui == NULL)
{ sort << false << " pas_de_fct_xnp_defEqui_ " ;}
else
{ sort << true << " fonction_xnp_defEqui ";
LesCourbes1D::Ecriture_pour_base_info(sort,cas,xnp_defEqui);
};
if (Qzero_defEqui == NULL)
{ sort << false << " pas_de_fct_Qzero_defEqui_ " ;}
else
{ sort << true << " fonction_Qzero_defEqui ";
LesCourbes1D::Ecriture_pour_base_info(sort,cas,Qzero_defEqui);
};
}
else
{sort << " sans_defEqui ";};
// --- dépendance à la phase de la déformation totale pour paradefEqui
if (avec_phase_paradefEqui)
{sort << " avec_phase_paradefEqui ";
if (coef_paradefEqui == NULL)
{ sort << false << " " ;}
else
{ sort << true << " fonction_coef_paradefEqui ";
LesCourbes1D::Ecriture_pour_base_info(sort,cas,coef_paradefEqui);
};
}
else
{sort << " sans_phaseEps ";};
// --- paramètre de réglage
sort << "\n tolerance_algo_newton_equadiff:_absolue= " << tolerance_residu
<< " relative= "<< tolerance_residu_rel
<< " nb_boucle_maxi " << nb_boucle_maxi
<< " maxi_delta_var_sig_sur_iter_pour_Newton " << maxi_delta_var_sig_sur_iter_pour_Newton
<< " nb_dichotomie " << nb_dichotomie
<< " tolerance_coincidence " << tolerance_coincidence
<< " tolerance_centre " << tolerance_centre
<< " mini_rayon " << mini_rayon;
sort << "\n type_resolution_equa_constitutive " << type_resolution_equa_constitutive
<< " type_calcul_comportement_tangent " << type_calcul_comportement_tangent
<< " avecVarWprimeS " << avecVarWprimeS
<< " cas_kutta " << cas_kutta
<< " erreurAbsolue " << erreurAbsolue << " erreurRelative " << erreurRelative << " ";
sort << " nb_maxInvCoinSurUnPas " << nb_maxInvCoinSurUnPas
<< " min_angle_trajet_neutre " << min_angle_trajet_neutre
<< " possibilite_cosAlphaNegatif " << possibilite_cosAlphaNegatif
<< " mini_Qsig_pour_phase_sigma_Oi_tdt " << mini_Qsig_pour_phase_sigma_Oi_tdt
<< " mini_QepsilonBH " << mini_QepsilonBH
<< " force_phi_zero_si_negatif " << force_phi_zero_si_negatif
<< " depassement_Q0 " << depassement_Q0
<< " type_de_transport_memorisation "<< type_de_transport_memorisation
<< " niveau_bascule_fct_aide "<< niveau_bascule_fct_aide;
// niveau d'affichage
Affiche_niveau_affichage(sort,cas);
sort << " sortie_post " << sortie_post
<< " ";
};
// appel de la classe mère
Loi_comp_abstraite::Ecriture_don_base_info(sort,cas);
};
// =============== fonction protegee ============
// --------------- méthodes internes ---------------:
// 1) affinage d'un point de coincidence à l'aide des rayons
// ramène true si le traitement est exactement terminé, sinon false, ce qui signifie qu'il
// faut encore continuer à utiliser l'équation d'évolution
// pt_sur_principal : indique si oui ou non le pointeur iatens pointe sur sa liste principale
// oi_sur_principal : indique si oui ou non le pointeur iaOi pointe sur sa liste principale
// iatens_princ et iaOi_princ: pointeurs sur les listes principales
// force_coincidence : on force la coincidence à la position actuelle
// le rayon peut-être modifié dans le cas particulier d'une coincidence à la précision près
bool Hysteresis3D::Coincidence(bool bascule_fct_aide,double& unSur_wBaseCarre
,const Tenseur3HH & gijHH,const Tenseur3BB & gijBB
,SaveResulHysteresis3D & save_resul,double& W_a
,List_io <Tenseur3BH>::iterator& iatens
,List_io <double>::iterator& iadef_equi
,List_io <double>::iterator& iafct
,bool& pt_sur_principal
,List_io <Tenseur3BH>::iterator& iaOi,bool& oi_sur_principal
,List_io <Tenseur3BH>::iterator& iatens_princ
,List_io <double>::iterator& iadef_equi_princ
,List_io <Tenseur3BH>::iterator& iaOi_princ
,List_io <double>::iterator& iafct_princ
,const double& rayon_tdt,bool force_coincidence)
{ // tout d'abord on vérifie que l'on n'est pas exactement à un point de
// coincidence à la précision près
// -- modif 10 juillet 2014:
// on calcul la grandeur cc qui est un des coef de l'équation du second degré permettant
// de trouver la coïncidence (voir après)
Tenseur3BH delta_sigma_oi_a_t_BH = sigma_i_barre_BH - oc_BH_R; // OB
double cc = (delta_sigma_oi_a_t_BH && delta_sigma_oi_a_t_BH) - Q_OiaR * Q_OiaR; // cc=OB*OB - r^2
// si cc est positif, cela signifie qu'au pas précédent on n'a pas bien détecté une coincidence
// ou que c'est un pb de zero
// on considère alors que le point actuel est un point de coïncidence à la précision près et donc
// on finit le traitement
double tol_coincidence_reelle = tolerance_coincidence;
if (tolerance_coincidence < 0) // si l'indication est négative , cela veut dire que l'on veut une grandeur relative
tol_coincidence_reelle = MaX(-tolerance_coincidence * Q_OiaR,-tolerance_coincidence);
// -- fin modif
if ((Abs(rayon_tdt - Q_OiaR) <= tol_coincidence_reelle) || force_coincidence
// || ((cc >= 0.) && (sqrt(Dabs(cc)) <= tol_coincidence_reelle)) ) // -- ajout 10 juillet 2014:
|| (cc >= 0.) ) // -- ajout 11 juillet 2014: on ne peut plus revenir sur les grandeurs à t
// donc le mieux est de valider la coïncidence ce qui simplifiera la suite du traitement
{ // on est dans le cas où l'on a une coïncidence exacte à la précision "tolerance_coincidence" près
// mais dans tous les cas on a rayon_tdt > Q_OiaR sinon on n'aurait pas de coïncidence
// on signale qu'il y a une coincidence exacte (pour le retour de la méthode Coincidence)
// gestion des pointeurs
do
{Gestion_pointeur_coincidence(unSur_wBaseCarre,save_resul,W_a
,iatens,iadef_equi,iafct,pt_sur_principal,iaOi,oi_sur_principal
,iatens_princ,iadef_equi_princ,iaOi_princ,iafct_princ);
}// on traite le cas où des autres coincidences existent à la précision près
while (Autre_coincidence_a_la_tolerance_pres(bascule_fct_aide,gijHH,gijBB
,pt_sur_principal,oi_sur_principal,iatens,iaOi));
return true;
};
// --- sinon on continue mais le traitement ne sera pas fini !!
// dans une première étape on tente de calculer plus précisemment le point d'inversion,
// en supposant une approximation linéaire de l'évolution de sigma sur le pas de temps:
bool bon_calcul = false; // permet de savoir si le calcul précis est correcte,
// pour l'instant on dit que non au niveau de l'init
// a-- calcul des coefficients de l'équation du second degré qui gère le point exact
double aa = delta_sigma_barre_tdt_BH && delta_sigma_barre_tdt_BH; // BA*BA
// aa doit être sup à 0, si ce n'est pas le cas du à des arrondis ou des pb de transport on le met à 0
if (aa < ConstMath::pasmalpetit)
{ aa = 0.;
if (Permet_affichage() > 0)
cout << "\n warning algo coincidence, dans la recherche des racines de l'equa 2 degre "
<< " on a sig_tdt : sig_tdt qui est negatif !! = " << aa <<" on le met a 0 mais ce n'est pas normal "
<< "\n Hysteresis3D::Coincidence(... ";
};
// delta_sigma_oi_a_tdt_BH c'est OA
double bb = 2. * (delta_sigma_oi_a_t_BH && delta_sigma_barre_tdt_BH); // OB*BA
// bb *= 2. * bb; // 2 (OB*BA)^2
// double cc = (delta_sigma_oi_a_t_BH && delta_sigma_oi_a_t_BH) - Q_OiaR * Q_OiaR; // OB*OB - r^2
// #ifdef MISE_AU_POINT
//**** le test qui suit ne sert plus compte tenu du choix fait plus haut sur cc
// if(!aucun_pt_inversion)
// if (cc > 0.) // signifie qu'au pas précédent on n'a pas bien détecté une coincidence
// // ou que c'est un pb de zero
// { // les 4 lignes qui suivent n'ont plus lieu d'être : -- modif 10 juillet 2014
//// if (Dabs(cc) <= tolerance_coincidence)
//// { cc = 0.;
//// }
//// else
// { if ( ((Permet_affichage()==0) && (ParaGlob::NiveauImpression() > 0)) || (Permet_affichage() > 0))
// cout << "\n erreur algo coincidence : 1 : cc positif ! "
// << "\n Hysteresis3D::Coincidence(... " << endl;
// if ( ((Permet_affichage()==0) && (ParaGlob::NiveauImpression() > 2)) || (Permet_affichage() > 2))
// { cout << "\n aa= " << aa << " bb= " << bb << " cc= " << cc;};
// if ( ((Permet_affichage()==0) && (ParaGlob::NiveauImpression() > 4)) || (Permet_affichage() > 4))
// { Affiche_debug(unSur_wBaseCarre,save_resul,iatens,iadef_equi,pt_sur_principal
// ,iaOi,oi_sur_principal,iatens_princ,iadef_equi_princ,iaOi_princ);
// };
// // on génère une exception
// throw ErrNonConvergence_loiDeComportement();
//// Sortie(1);
// };
// };
//
//****
// #endif
// b-- recherche de racine
double racine1,racine2; int cas;
alg_zero.SecondDegre(aa,bb,cc,racine1,racine2,cas);
// --- traitement suivant les différents cas de la résolution de l'équation du second degré ---
switch (cas)
{ case 1: // deux racines distinctes
{ // normalement les deux racines sont de signe opposé, seule la positive <=1 est recevable
if (racine1*racine2 <=0.)
{// on regarde si racine2 <= 1 ce qui est le cas normal
if (racine2 <= 1.) // racine2 est la plus grande donc positive
// cas normal, on valide la procédure
{ bon_calcul = true;}
#ifdef MISE_AU_POINT
else // sinon cela signifie que la méthode n'est pas bonne
{ if (Permet_affichage() > 0)
cout << "\n warning algo coincidence, dans la recherche des racines de l'equa 2 degre "
<< " la seconde racine " << racine2 <<" est superieur a 1"
<< "\n Hysteresis3D::Coincidence(... ";
}
#endif
}
else
{
#ifdef MISE_AU_POINT
// normalement aa >=0 donc avec cc <0 on ne doit pas avoir 2 racines du même signe
if(!aucun_pt_inversion) // sauf dans le cas de la première charge
{ if (Permet_affichage() > 0)
cout << "\n erreur algo coincidence, dans la recherche des racines de l'equa 2 degre "
<< " les deux racines sont du meme signe ??, a= " <<aa<<" c= " << cc << " racine1= "
<< racine1 << " racine2= " << racine1
<< "\n Hysteresis3D::Coincidence(... ";
}
#endif
// on regarde si une des racines convient
// a priori on garde la plus grande, si les deux conviennent
double la_plus_grande = MaX(racine1,racine2);
if ((la_plus_grande>0.) && (la_plus_grande<1.))
{ racine2=la_plus_grande; bon_calcul = true;}
else // sinon on test l'autre
{ double la_plus_petite = MiN(racine1,racine2);
if ((la_plus_petite>0.) && (la_plus_petite<1.))
{ racine2=la_plus_petite; bon_calcul = true;}
// sinon rien tous les autres cas sont mauvais
};
};
break;
}
case 2: // deux racines identiques
{ // normalement la racine doit être comprise entre 0 et 1, sinon non recevable
if ((racine2>=0.) && (racine2 <= 1.))
// cas normal, on valide la procédure
{ bon_calcul = true;};
// tous les autres cas sont mauvais
break;
}
case -3: // une racine simple
{ // normalement la racine doit être comprise entre 0 et 1, sinon non recevable
if ((racine1>=0.) && (racine1 <= 1.))
// cas normal, on valide la procédure
{ bon_calcul = true;
racine2=racine1; // pour la suite
};
// tous les autres cas sont mauvais
break;
}
// tous les autres cas sont mauvais donc la variable bon_calcul sera fausse
// et on utilisera une autre procedure de calcul par la suite
}; //-- fin du switch
// --- fin du traitement suivant les différents cas de la résolution de l'équation du second degré ---
if (!bon_calcul)
// cas où la recherche fine avec la résolution de l'équat du second degré n'a pas marché
{ // on utilise une interpolation plus grossière à l'aide de la fonction de charge
if (Permet_affichage() > 4)
cout << "\n (algo hysteresis) on passe par l'interpolation lineaire de l'equation du second degre";
double delta_r2 = rayon_tdt - Q_OiaR;
double delta_r1 = Q_OiaR - sqrt(delta_sigma_oi_a_t_BH.II());
racine2 = delta_r1 / (delta_r1 + delta_r2);
// normalement racine2 est compris entre 0 et 1
if ( (racine2 < 0.) || (racine2 > 1.))
{ if (Permet_affichage() > 0)
cout << "\n erreur algo coincidence, dans la recherche de racine2 simplifiee"
<< "\n racine2= " << racine2 << " delta_r2= " << delta_r2 << " delta_r1= " << delta_r1
<< " Q_OiaR= " << Q_OiaR << " -> divergence ! "
<< "\n Hysteresis3D::Coincidence(... " << endl;
// on génère une exception
throw ErrNonConvergence_loiDeComportement();
};
};
// c-- maintenant on traite les infos
// comme racine2 appartient à [0,1], que OiR > Oisigma_t et que OiR < Oisigma_tdt, normalement on doit avoir
// Oisigma_tdt > Oisigma_coinci
// -- cas où à l'issue du calcul racines est très proche de 1 ---
// dans ce cas on considère que la coïncidence est exacte
if (sqrt(((1.-racine2)*delta_sigma_barre_tdt_BH).II()) <= tol_coincidence_reelle)
{ // on est dans le cas où l'on a une coïncidence exacte à la précision "tolerance_coincidence" près
// mais dans tous les cas on a rayon_tdt > Q_OiaR sinon on n'aurait pas de coïncidence
// on signale qu'il y a une coincidence exacte (pour le retour de la méthode Coincidence)
// gestion des pointeurs
do
{Gestion_pointeur_coincidence(unSur_wBaseCarre,save_resul,W_a
,iatens,iadef_equi,iafct,pt_sur_principal,iaOi,oi_sur_principal
,iatens_princ,iadef_equi_princ,iaOi_princ,iafct_princ);
}// on traite le cas où des autres coincidences existent à la précision près
while (Autre_coincidence_a_la_tolerance_pres(bascule_fct_aide,gijHH,gijBB
,pt_sur_principal,oi_sur_principal,iatens,iaOi));
return true;
};
// calcul de la valeur de sigma au point de coincidence, qui servira pour un nouveau calcul
sigma_i_barre_BH += racine2 * delta_sigma_barre_tdt_BH;
// donc à partir d'ici on considère que l'on va valider la coïncidence, il faut donc que
// la contrainte au point de conïncidence corresponde "exactement" à celle correspondante au critère de
// coïncidence, on va donc vérifier que "racine2" est correcte
double nouveau_rayon_tdt = sqrt((sigma_i_barre_BH - oc_BH_R).II()); // Q_OiaR
if ((Abs(nouveau_rayon_tdt - Q_OiaR) > tol_coincidence_reelle) )
if (Permet_affichage() > 4)
{ cout << "\n erreur2 algo coincidence, dans la recherche de racine2 "
<< "\n racine2= " << racine2 << " nouveau_rayon_tdt= " << nouveau_rayon_tdt
<< " Q_OiaR= " << Q_OiaR << " -> divergence ! "
<< "\n Hysteresis3D::Coincidence(... " << endl;
// on génère une exception
throw ErrNonConvergence_loiDeComportement();
};
// calcul du reste d'incrément de déformation qu'il faut utiliser pour la suite
delta_barre_epsBH *= (1.-racine2); // (1.-racine2) est >= 0
// mise à jour des différents pointeurs
Gestion_pointeur_coincidence(unSur_wBaseCarre,save_resul,W_a
,iatens,iadef_equi,iafct,pt_sur_principal,iaOi,oi_sur_principal
,iatens_princ,iadef_equi_princ,iaOi_princ,iafct_princ);
// fin et retour, comme le calcul n'est pas fini on retourne false
return false;
};
// traitement des cas où des autres coincidences existent à la précision près
// ramène true si effectivement il y a une nouvelle coincidence
bool Hysteresis3D::Autre_coincidence_a_la_tolerance_pres(bool bascule_fct_aide
,const Tenseur3HH & gijHH,const Tenseur3BB & gijBB
,const bool& pt_sur_principal,const bool& oi_sur_principal
,List_io <Tenseur3BH>::iterator& iatens
,List_io <Tenseur3BH>::iterator& iaOi)
{ // choix entre gestion avec rayons ou avec fonction d'aide
if (!bascule_fct_aide)
{// on va calculer le nouveau rayon et voir s'il y a de nouveau coincidence ou pas
// -- 1) sigma_barre_BH_R : initialisé sur la liste principal, mais ensuite peut évoluer sur liste secondaire
if (aucun_pt_inversion) {sigma_barre_BH_R.Inita(0.);def_equi_R=0.;}
else {sigma_barre_BH_R = *iatens; // la contrainte de référence
};
delta_sigma_barre_BH_Rat = sigma_i_barre_BH - sigma_barre_BH_R;
// -- 2) centre et rayon de la première surface de coïncidence
if (centre_initial) {oc_BH_R.Inita(0.);}
else {oc_BH_R = *iaOi;};
delta_sigma_barre_BH_OiaR = sigma_barre_BH_R-oc_BH_R; // le tenseur rayon
// -- 3) calcul du rayon: la première fois le rayon est infini
if (aucun_pt_inversion) {Q_OiaR = ConstMath::tresgrand;}
else {Q_OiaR = sqrt(delta_sigma_barre_BH_OiaR.II());};
// calcul du rayon actuelle, avec le nouveau centre éventuelle
Tenseur3BH delta_sigma_oi_a_tdt_BH = sigma_t_barre_tdt - oc_BH_R; // OA
double nouveau_rayon_tdt = sqrt(delta_sigma_oi_a_tdt_BH.II());
// on test
bool retour;
if (nouveau_rayon_tdt < Q_OiaR) {retour = false;} // cas normal
else {retour = true; }; // cas où il y a une nouvelle coincidence
// une nouvelle coincidence est possible si l'ancien rayon de référence et le nouveau ont une
// différence inférieure à la précision de la coincidence !!
//--------débug- traçage
#ifdef MISE_AU_POINT
if ((Permet_affichage() == -77)&&retour)
{ cout << "\n nouvelle coïncidence: cas de points tres rapprochees "
<< endl ;
};
#endif
//----- fin débug
return retour;
}
else // cas d'une gestion avec la fonction d'aide
{// pour l'instant on ne fait rien, s'il y a plusieurs coïncidence à suivre
// on passera plusieurs fois dans l'algo coïncidence
return false;
};
};
// 2) affinage d'un point de coincidence à l'aide de la fonction d'aide
// ramène true si le traitement est exactement terminé, sinon false, ce qui signifie qu'il
// faut encore continuer à utiliser l'équation d'évolution
// premiere_charge : indique si c'est oui ou non une coincidence avec la première charge
// pt_sur_principal : indique si oui ou non les pointeurs iafct et iatens pointent sur les listes
// principales
// iatens_princ et iafct_princ: pointeurs sur les listes principales
bool Hysteresis3D::Coincidence(bool bascule_fct_aide,double& unSur_wBaseCarre
,const Tenseur3HH & gijHH,const Tenseur3BB & gijBB
,SaveResulHysteresis3D & save_resul,double& W_a
,List_io <Tenseur3BH>::iterator& iatens
,List_io <double>::iterator& iadef_equi
,List_io <double>::iterator& iafct
,bool& pt_sur_principal
,List_io <Tenseur3BH>::iterator& iaOi,bool& oi_sur_principal
,List_io <Tenseur3BH>::iterator& iatens_princ
,List_io <double>::iterator& iadef_equi_princ
,double& position_coincidence
,List_io <Tenseur3BH>::iterator& iaOi_princ
,List_io <double>::iterator& iafct_princ
,double& delta_W_a,bool force_coincidence)
{ // tout d'abord on vérifie que l'on n'est pas exactement à un point de
// coincidence à la précision près
double c = (W_a - delta_W_a) - *iafct;
bool coin_exacte = false; // drapeau indiquant si l'on a une coincidence exacte ou pas
// calcul de la précision
double tol_coincidence_reelle = tolerance_coincidence;
if (tolerance_coincidence < 0) // si l'indication est négative , cela veut dire que l'on veut une grandeur négative
tol_coincidence_reelle = MaX(-tolerance_coincidence * W_a,-tolerance_coincidence);
if ((Abs(W_a - *iafct) <= tol_coincidence_reelle) || force_coincidence
|| (c >= 0.) ) // on ne peut plus revenir sur les grandeurs à t
// donc le mieux est de valider la coïncidence ce qui simplifiera la suite du traitement
{ // on est dans le cas où l'on a une coïncidence exacte à la précision "tolerance_coincidence" près
// mais dans tous les cas on a rayon_tdt > Q_OiaR sinon on n'aurait pas de coïncidence
// on signale qu'il y a une coincidence exacte (pour le retour de la méthode Coincidence)
// gestion des pointeurs
do
{ // on prend pour W_a la valeur au moment de la coïncidence ce qui permet d'éviter des approximations futures
W_a = *iafct;
Gestion_pointeur_coincidence(unSur_wBaseCarre,save_resul,W_a
,iatens,iadef_equi,iafct,pt_sur_principal,iaOi,oi_sur_principal
,iatens_princ,iadef_equi_princ,iaOi_princ,iafct_princ);
}// on traite le cas où des autres coincidences existent à la précision près
while (Autre_coincidence_a_la_tolerance_pres(bascule_fct_aide,gijHH,gijBB,pt_sur_principal
,oi_sur_principal,iatens,iaOi));
coin_exacte = true;position_coincidence=1.;
return coin_exacte;
};
// --- sinon on continue
// recherche de racine
double racine2;
// // c doit-être négatif, à la limite nul
// if (c >= 0.)
// {// on détermine la proportion de déformation qu'il faut faire pour être exactement à la coïncidence
// double W_t=W_a - delta_W_a;
// racine2 = (W_a - *iafct) / delta_W_a;
// }
// else
{ // on utilise une interpolation assez grossière à l'aide de la fonction de charge
// cout << "\n on passe par l'interpolation de la fonction d'aide";
double W_t=W_a - delta_W_a;
racine2 = (*iafct - W_t) / delta_W_a;
#ifdef MISE_AU_POINT
// normalement racine2 est compris entre 0 et 1
if ( (racine2 < 0.) || (racine2 > 1.))
{ cout << "\n erreur algo coincidence, dans la recherche de racine2 a l'aide de la fonction de charge "
<< " W_ref= " <<*iafct<<" W_t= " << W_t << " delta_W_a= " << delta_W_a
<< "\n Hysteresis1D::Coincidence(... ";
Sortie(1);
}
#endif
}
// -- maintenant on traite les infos
// comme racine2 appartient à [0,1], que OiR > Oisigma_t et que OiR < Oisigma_tdt, normalement on doit avoir
// Oisigma_tdt > Oisigma_coinci
// -- cas où à l'issue du calcul racines est très proche de 1 ---
// dans ce cas on considère que la coïncidence est exacte
if (sqrt(((1.-racine2)*delta_sigma_barre_tdt_BH).II()) <= tol_coincidence_reelle)
{ // on est dans le cas où l'on a une coïncidence exacte à la précision "tolerance_coincidence" près
// mais dans tous les cas on a rayon_tdt > Q_OiaR sinon on n'aurait pas de coïncidence
// on signale qu'il y a une coincidence exacte (pour le retour de la méthode Coincidence)
// gestion des pointeurs
do
{// on prend pour W_a la valeur au moment de la coïncidence ce qui permet d'éviter des approximations futures
W_a = *iafct;
Gestion_pointeur_coincidence(unSur_wBaseCarre,save_resul,W_a
,iatens,iadef_equi,iafct,pt_sur_principal,iaOi,oi_sur_principal
,iatens_princ,iadef_equi_princ,iaOi_princ,iafct_princ);
}// on traite le cas où des autres coincidences existent à la précision près
while (Autre_coincidence_a_la_tolerance_pres(bascule_fct_aide,gijHH,gijBB
,pt_sur_principal,oi_sur_principal,iatens,iaOi));
coin_exacte = true;position_coincidence=1.;
return coin_exacte;
};
// -- sinon cela veut dire que la coïncidence n'est pas précise, au lieu de chercher à calculer
// le tenseur sigma à l'aide d'une péréquation, on ne valide pas la coïncidence, par contre
// on ramène la valeur de la proportion racine2 indiquant la position approximative de l'inversion exacte
// // calcul de la valeur de sigma au point de coincidence, qui servira pour un nouveau calcul
// sigma_i_barre_BH += racine2 * delta_sigma_barre_tdt_BH;
//
// // calcul du reste d'incrément de déformation qu'il faut utiliser pour la suite
// delta_barre_epsBH *= (1.-racine2); // (1.-racine2) est >= 0
// // mise à jour des différents pointeurs
// Gestion_pointeur_coincidence(unSur_wBaseCarre,save_resul
// ,iatens,iadef_equi,iafct,pt_sur_principal,iaOi,oi_sur_principal
// ,iatens_princ,iadef_equi_princ,iaOi_princ,iafct_princ);
//
// // fin et retour, comme le calcul n'est pas fini on retourne false
coin_exacte = false;position_coincidence=racine2;
return coin_exacte;
};
// calcul de wprime en fonction de grandeurs supposées déjà calculées
// --- méthode indépendante -----
// utilise : Q_OiaR, QdeltaSigmaRatdt,
// delta_sigma_barre_BH_Ratdt, delta_sigma_barre_BH_OiaR
// wBase
// trajet_neutre: indique si oui ou non, on est dans un chargement neutre à la précision près
void Hysteresis3D::Cal_wprime(const double& Q__deltaSiRatdt,const Tenseur3BH& delta__sig_barre_BH_Ratdt
,const double& Q__OiaR,const Tenseur3BH& delta__sig_barre_BH_OiaR
,const double& w__Base,Tenseur3BH& delta__sig_barre_BH_tatdt
, double& w__prime, double& w__prime_point,bool& trajet_neut) const
{ // -- calculs relatifs aux angles de phases
// ces calculs ne sont nécessaires que si l'on n'est pas sur une première charge
if (w__Base!=1)
{// si l'intensité du rayon est nulle, celui de seconde charge doit
// être également nulle, on considére un alpha nulle donc un cos = 1 d'où w__prime = 2.
if (Q__OiaR >= mini_rayon) // si mini_rayon est négatif (=> régularisation), l'expression est tjs vrai
{// si l'intensité de l'accroissement du déviateur de contrainte est nulle,
// on considére un alpha nulle donc un cos = 1 d'où w__prime = 2.
if (Q__deltaSiRatdt >= mini_rayon) // idem test si dessus pour le cas où mini_rayon est négatif
{// cas où on peut calculer l'angle
// -- calcul de w__prime
double unSurQ__OiaR ; //= 1./Q__OiaR;
double unSurQ__deltaSiRatdt ;//= 1./Q__deltaSiRatdt;
if (mini_rayon > 0.) // cas historique
{ unSurQ__OiaR = 1./Q__OiaR;
unSurQ__deltaSiRatdt = 1./Q__deltaSiRatdt;
}
else // cas avec régularisation
{ unSurQ__OiaR = 1./(Q__OiaR-mini_rayon);
unSurQ__deltaSiRatdt = 1./(Q__deltaSiRatdt-mini_rayon);
};
double cos_alpha = - (delta__sig_barre_BH_Ratdt && delta__sig_barre_BH_OiaR)
* unSurQ__OiaR * unSurQ__deltaSiRatdt;
// if (Dabs(cos_alpha)<= ConstMath::pasmalpetit)
if (Dabs(cos_alpha)<= min_angle_trajet_neutre)
{ // dans ce cas il s'agit d'un trajet neutre
// le cos_alpha, sa dérivée, les w_prime et w_prime_point n'auront pas au final d'importance
trajet_neut=true;
w__prime=0.; w__prime_point=0.;
}
else if ((cos_alpha <= - min_angle_trajet_neutre) && (!possibilite_cosAlphaNegatif))
{ // cas ou cos_alpha est négatif et que l'on veut traiter ce cas comme un cas neutre
// le cos_alpha, sa dérivée, les w_prime et w_prime_point n'auront pas au final d'importance
trajet_neut=true;
w__prime=0.; w__prime_point=0.;
}
else
{ // chargement non neutre
trajet_neut = false;
w__prime = w__Base * cos_alpha;
if ((w__prime <= 0) && (possibilite_cosAlphaNegatif))
{ // dans le cas où cos_alpha est négatif et que l'on admet "transitoirement" que le cos_alpha puisse
// être négatif, on lui change de signe (cf. les anciens commentaires qui suivent)
// C1- il y a problème car cela signifie que cos_alpha est négatif donc que les cercles s'accroissent
// C1- ceci peut être du à une erreur d'arrondi
// C1- on considère alors que l'on est au cas limite de cos_alpha = 0`
// C2-- non en fait ça peut-être tout-à-fait normale, juste avant une inversion on a un angle négatif et c'est normale
// C2-- pour éviter d'avoir des pb le plus simple est de considérer la partie positive de l'angle
// -- if (MaX(ParaGlob::NiveauImpression(),Permet_affichage()) >= 3)
// -- cout << "\n attention, angle de phase negatif en hysteresis ! ,";
// << " on le met a 0";
// if (MaX(ParaGlob::NiveauImpression(),Permet_affichage()) >= 4)
// cout << " Q__deltaSiRatdt= " << Q__deltaSiRatdt << " w__prime= " << w__prime;
// w__prime = 2.;w__prime_point=0.;
w__prime = - w__prime;
double Rsig_point_scalaire_Rsig = delta__sig_barre_BH_tatdt && delta__sig_barre_BH_Ratdt;
double ee = Rsig_point_scalaire_Rsig * unSurQ__deltaSiRatdt * unSurQ__deltaSiRatdt;
double cos_alpha_point = - unSurQ__OiaR * unSurQ__deltaSiRatdt
* (delta__sig_barre_BH_OiaR &&
(delta__sig_barre_BH_tatdt - ee * delta__sig_barre_BH_Ratdt )) ;
w__prime_point = - w__Base * cos_alpha_point;
}
else
{// -- calcul de w__prime_point
double Rsig_point_scalaire_Rsig = delta__sig_barre_BH_tatdt && delta__sig_barre_BH_Ratdt;
double ee = Rsig_point_scalaire_Rsig * unSurQ__deltaSiRatdt * unSurQ__deltaSiRatdt;
double cos_alpha_point = - unSurQ__OiaR * unSurQ__deltaSiRatdt
* (delta__sig_barre_BH_OiaR &&
(delta__sig_barre_BH_tatdt - ee * delta__sig_barre_BH_Ratdt )) ;
w__prime_point = w__Base * cos_alpha_point;
};
}; // fin du cas non neutre
} // fin du cas où on peut calculer l'angle
else
// cas ou l'intensité de l'accroissement du déviateur de contrainte est nulle
{w__prime = 2.;w__prime_point=0.;trajet_neut = false;}; // cas de cos(alpha)=1.
}
else
// cas ou l'intensité du déviateur de référence est nulle
{w__prime = 2.;w__prime_point=0.;trajet_neut = false;}; // cas de cos(alpha)=1.
}
else
// cas d'une première charge
{w__prime=1.;w__prime_point=0.;trajet_neut = false;};
};
// calcul de wprime et de sa variation par rapport aux coordonnées de delta sigma barre
// en fonction de grandeurs supposées déjà calculées
// utilise : Q_OiaR, QdeltaSigmaRatdt,
// delta_sigma_barre_BH_Ratdt, delta_sigma_barre_BH_OiaR
// wBase
// trajet_neut: indique si oui ou non, on est dans un chargement neutre à la précision près
// --- méthode indépendante -----
void Hysteresis3D::Cal_wprime_et_der(const double& Q__deltaSiRatdt,const Tenseur3BH& delta__sig_barre_BH_Ratdt
,const double& Q__OiaR,const Tenseur3BH& delta__sig_barre_BH_OiaR
,const double& w__Base,Tenseur3BH& delta__sig_barre_BH_tatdt
,double& w__prime, Tenseur3BH& d_w__prime
,double& w__prime_point,Tenseur3BH& d_w__prime_point,bool& trajet_neut) const
{ // -- calculs relatifs aux angles de phases
static const double untiers=1./3.;static const double troisRacineDe6=3.*sqrt(6.);
// ces calculs ne sont nécessaires que si l'on n'est pas sur une première charge
d_w__prime.Inita(0.); // init pour tous les cas ou d_w__prime n'est pas calculée
// cf les différents cas qui suivent
d_w__prime_point.Inita(0.); // idem pour le w__prime_point
if (w__Base!=1)
{// si l'intensité du rayon est nulle, celui de seconde charge doit
// être également nulle, on considére un alpha nulle donc un cos = 1 d'où w__prime = 2.
// d'où des variations nulles
if (Q__OiaR >= mini_rayon) // si mini_rayon est négatif (=> régularisation), l'expression est tjs vrai
{// si l'intensité de l'accroissement du déviateur de contrainte est nulle,
// on considére un alpha nulle donc un cos = 1 d'où w__prime = 2.
if (Q__deltaSiRatdt >= mini_rayon) // idem test si dessus pour le cas où mini_rayon est négatif
{// cas où on peut calculer l'angle
double unSurQ__OiaR ;//= 1./Q__OiaR;
double unSurQ__deltaSiRatdt;// = 1./Q__deltaSiRatdt;
if (mini_rayon > 0.) // cas historique
{ unSurQ__OiaR = 1./Q__OiaR;
unSurQ__deltaSiRatdt = 1./Q__deltaSiRatdt;
}
else // cas avec régularisation
{ unSurQ__OiaR = 1./(Q__OiaR-mini_rayon);
unSurQ__deltaSiRatdt = 1./(Q__deltaSiRatdt-mini_rayon);
}
double x1 = delta__sig_barre_BH_Ratdt && delta__sig_barre_BH_OiaR;
double cos_alpha = - x1* unSurQ__OiaR * unSurQ__deltaSiRatdt;;
// if (Dabs(cos_alpha)<= ConstMath::pasmalpetit)
if (Dabs(cos_alpha)<= min_angle_trajet_neutre)
{ // dans ce cas il s'agit d'un trajet neutre
// le cos_alpha, sa dérivée, les w_prime et w_prime_point n'auront pas au final d'importance
trajet_neut=true;
w__prime=0.; w__prime_point=0.;
}
else if ((cos_alpha <= - min_angle_trajet_neutre) && (!possibilite_cosAlphaNegatif))
{ // cas ou cos_alpha est négatif et que l'on veut traiter ce cas comme un cas neutre
// le cos_alpha, sa dérivée, les w_prime et w_prime_point n'auront pas au final d'importance
trajet_neut=true;
w__prime=0.; w__prime_point=0.;
}
else
{ // chargement non neutre
trajet_neut = false;
w__prime = w__Base * cos_alpha;
if ((w__prime <= 0) && (possibilite_cosAlphaNegatif))
{ // dans le cas où cos_alpha est négatif et que l'on admet "transitoirement" que le cos_alpha puisse
// être négatif, on lui change de signe (cf. les anciens commentaires qui suivent)
// C1- il y a problème car cela signifie que cos_alpha est négatif donc que les cercles s'accroissent
// C1- ceci peut être du à une erreur d'arrondi
// C1- on considère alors que l'on est au cas limite de cos_alpha = 0`
// C2-- non en fait ça peut-être tout-à-fait normale, juste avant une inversion on a un angle négatif et c'est normale
// C2-- pour éviter d'avoir des pb le plus simple est de considérer la partie positive de l'angle
// if (MaX(ParaGlob::NiveauImpression(),Permet_affichage()) >= 3)
// cout << "\n attention, angle de phase negatif en hysteresis ! ,";
// << " on le met a 0";
// if (MaX(ParaGlob::NiveauImpression(),Permet_affichage()) >= 6)
// cout << " Q__deltaSiRatdt= " << Q__deltaSiRatdt ;
// w__prime = 2.;w__prime_point=0.; */
w__prime = - w__prime;
// -- calcul de w__prime_point
double a ;//= Q__deltaSiRatdt * Q__deltaSiRatdt;
if (mini_rayon > 0.) // cas historique
{ a = Q__deltaSiRatdt * Q__deltaSiRatdt;}
else // cas avec régularisation
{ a = Q__deltaSiRatdt * Q__deltaSiRatdt-mini_rayon;};
double b = delta__sig_barre_BH_tatdt && delta__sig_barre_BH_Ratdt;
double ee = b/a;
double C = delta__sig_barre_BH_OiaR && (delta__sig_barre_BH_tatdt - ee * delta__sig_barre_BH_Ratdt);
double cos_alpha_point = (- unSurQ__OiaR * unSurQ__deltaSiRatdt) * C;
w__prime_point = - w__Base * cos_alpha_point;
// calcul de la variation de cos_alpha et donc de w__prime
Tenseur3BH d_aSur2_BH(delta__sig_barre_BH_Ratdt);
d_aSur2_BH.PermuteHautBas();
Tenseur3BH num_cos_BH(delta__sig_barre_BH_OiaR);num_cos_BH.PermuteHautBas();
d_w__prime = d_aSur2_BH * (cos_alpha * unSurQ__deltaSiRatdt * unSurQ__deltaSiRatdt*w__Base)
+ num_cos_BH * (unSurQ__deltaSiRatdt * unSurQ__OiaR*w__Base);
// d_w__prime = d_a_BH;
// d_w__prime *= (x1/(Q__deltaSiRatdt*Q__deltaSiRatdt)-1)/(Q__deltaSiRatdt*Q__OiaR);
// calcul de la variation de cos_alpha_point
Tenseur3BH d_b_BH(delta__sig_barre_BH_tatdt);
d_b_BH.PermuteHautBas();
d_b_BH += d_aSur2_BH;
double unSur_a2 = 1./(a*a);
Tenseur3BH d_e_BH = d_b_BH / a - (2.* b*unSur_a2)*d_aSur2_BH;
d_w__prime_point = (w__Base * unSurQ__OiaR) *
( (- unSurQ__deltaSiRatdt / a * C)*d_aSur2_BH
+ ((1.-ee)*unSurQ__deltaSiRatdt) * num_cos_BH
+ (-unSurQ__deltaSiRatdt * x1)* d_e_BH
);
}
else
{// -- calcul de w__prime_point
double a ;//= Q__deltaSiRatdt * Q__deltaSiRatdt;
if (mini_rayon > 0.) // cas historique
{ a = Q__deltaSiRatdt * Q__deltaSiRatdt;}
else // cas avec régularisation
{ a = Q__deltaSiRatdt * Q__deltaSiRatdt-mini_rayon;};
double b = delta__sig_barre_BH_tatdt && delta__sig_barre_BH_Ratdt;
double ee = b/a;
double C = delta__sig_barre_BH_OiaR && (delta__sig_barre_BH_tatdt - ee * delta__sig_barre_BH_Ratdt);
double cos_alpha_point = (- unSurQ__OiaR * unSurQ__deltaSiRatdt) * C;
w__prime_point = w__Base * cos_alpha_point;
// calcul de la variation de cos_alpha et donc de w__prime
Tenseur3BH d_aSur2_BH(delta__sig_barre_BH_Ratdt);
d_aSur2_BH.PermuteHautBas();
Tenseur3BH num_cos_BH(delta__sig_barre_BH_OiaR);num_cos_BH.PermuteHautBas();
d_w__prime = d_aSur2_BH * (- cos_alpha * unSurQ__deltaSiRatdt * unSurQ__deltaSiRatdt*w__Base)
- num_cos_BH * (unSurQ__deltaSiRatdt * unSurQ__OiaR*w__Base);
// d_w__prime = d_a_BH;
// d_w__prime *= (x1/(Q__deltaSiRatdt*Q__deltaSiRatdt)-1)/(Q__deltaSiRatdt*Q__OiaR);
// calcul de la variation de cos_alpha_point
Tenseur3BH d_b_BH(delta__sig_barre_BH_tatdt);
d_b_BH.PermuteHautBas(); d_b_BH += d_aSur2_BH;
double unSur_a2 = 1./(a*a);
Tenseur3BH d_e_BH = d_b_BH / a - (2.*b*unSur_a2)*d_aSur2_BH;
d_w__prime_point = (-w__Base * unSurQ__OiaR) *
( (- unSurQ__deltaSiRatdt / a * C)*d_aSur2_BH
+ ((1.-ee)*unSurQ__deltaSiRatdt) * num_cos_BH
+ (-unSurQ__deltaSiRatdt * x1)* d_e_BH
);
};
}// fin du cas non neutre
}// fin du cas où on peut calculer l'angle
else
// cas ou l'intensité de l'accroissement du déviateur de contrainte est nulle
{w__prime = 2.;w__prime_point=0.;trajet_neut = false;}; // cas de cos(alpha)=1.
}
else
// cas ou l'intensité du déviateur de référence est nulle
{w__prime = 2.;w__prime_point=0.;trajet_neut = false;}; // cas de cos(alpha)=1.
}
else
// cas d'une première charge
{w__prime=1.;w__prime_point=0.;trajet_neut = false;};
};
// calcul du centre d'inversion avec les données actuelles
// ramène un indicateur informant comment l'opération s'est passé et si elle est valide (= 0)
int Hysteresis3D::CentreCercle(Tenseur3BH& sig0i_BH,const Tenseur3BH& oc_BH_R
,const Tenseur3BH & delta_sigma_barre_BH_OiaR
,const Tenseur3BH& delta_sigma_barre_BH_Rat)
{ // on part du principe que c'est le point à t qui est le point d'inversion
// ceci a été déterminé par le fait que le rayon à tdt a été trouvé plus petit que celui a t
double rayon_t = sqrt((delta_sigma_barre_BH_OiaR + delta_sigma_barre_BH_Rat).II());
double delta_rayon2 = (rayon_t*rayon_t - Q_OiaR*Q_OiaR);
// ici ce n'est pas le vrai cos, mais le cos * les deux normes, mais le signe est le même
double cos_alpha_a_t = (delta_sigma_barre_BH_OiaR && delta_sigma_barre_BH_Rat);
// double gamma = 0.5 * (rayon_t*rayon_t - Q_OiaR*Q_OiaR)
// / (delta_sigma_barre_BH_OiaR && delta_sigma_barre_BH_Rat);
int retour = 0; // init du retour a priori
// --- mise à jour précision éventuelle
double tol_centre_reelle = tolerance_centre;
if (tolerance_centre < 0) // si l'indication est négative , cela veut dire que l'on veut une grandeur relative
tol_centre_reelle = MaX(-tolerance_centre * Q_OiaR,-tolerance_centre);
// ---
// en fait peut-être très proche de 0 du aux erreurs d'arrondi
if (Dabs(delta_rayon2) < tol_centre_reelle)
// à la tolérance près on a le même rayon, cela veut dire qu'à l'incrément précédent on était sur un trajet
// neutre à la précision près, donc pas de nouveau centre à calculer
{retour = 1;}
else if (delta_rayon2 > 0.) // et donc sup aussi à tol_centre_reelle compte tenu du test plus haut
// là il s'agit d'un comportement qui n'est pas normal, car normalement le nouveau rayon doit-être plus petit
// que l'ancien donc on n'a pas de point d'inversion probant (ce serait plutôt une coïncidence mal déterminée)
// il vaut mieux attendre un incrément de charge supérieure qui permettra d'avoir
// un point d'inversion correctement déterminé
{retour = 1;} // on signale que ce n'est pas la peine de calculer un nouveau centre
else if (Dabs(cos_alpha_a_t) < min_angle_trajet_neutre)
// maintenant il faut que le cos_alpha ne soit pas trop petit
// si oui on était alors sur un trajet neutre qui s'ignorait, là encore le point d'inversion n'est pas probant
// il vaut mieux attendre un incrément de charge supérieure qui permettra d'avoir
// un point d'inversion correctement déterminé
{retour = 1;} // on signale que ce n'est pas la peine de calculer un nouveau centre
else if (cos_alpha_a_t > 0.) // et donc sup aussi à min_angle_trajet_neutre compte tenu du test plus haut
// c'est pas non plus normal, cela veut dire que l'on se déplace vers l'extérieur de la sphére de ref
// donc ce n'est pas un point d'inversion correct
{retour = 1;} // on signale que ce n'est pas la peine de calculer un nouveau centre
else
// arrivée ici toutes les conditions sont bonnes pour calculer un point d'inversion correct
{double gamma = 0.5 * delta_rayon2 / cos_alpha_a_t;
sig0i_BH = oc_BH_R + gamma * delta_sigma_barre_BH_OiaR;
};
// message d'info au cas où
if (retour)
if (Permet_affichage() > 5)
{ double cosalpha = (delta_sigma_barre_BH_OiaR && delta_sigma_barre_BH_Rat)
/sqrt((delta_sigma_barre_BH_OiaR.II()*delta_sigma_barre_BH_Rat.II()));
cout << "\n info concernant le calcul de centre, le centre ne peut-etre calcule ce qui n'est peut-etre pas normal !! "
<< "\n Hysteresis3D::CentreCercle(..."
<< " rayon_t= " << rayon_t << " Q_OiaR= " <<Q_OiaR
<< " cos_alpha_a_t= cos (delta_sigma_barre_BH_OiaR, delta_sigma_barre_BH_Rat) "
<< cosalpha << endl;
//// -- debug
// cout << "\n debug Hysteresis3D::CentreCercle( ";
// Q_OiaR = sqrt(delta_sigma_barre_BH_OiaR.II());
// double delta_RT2 = delta_sigma_barre_BH_Rat && delta_sigma_barre_BH_Rat;
// double delta_oiaR2 = delta_sigma_barre_BH_OiaR && delta_sigma_barre_BH_OiaR;
// double oiaRfoisRat = delta_sigma_barre_BH_OiaR && delta_sigma_barre_BH_Rat;
// double rayont2 = (delta_sigma_barre_BH_OiaR + delta_sigma_barre_BH_Rat) && (delta_sigma_barre_BH_OiaR + delta_sigma_barre_BH_Rat);
// cout << "\n nouvelle valeur Q_OiaR = " << Q_OiaR << endl;
//// -- fin debug
};
// retour
return retour;
};
// gestion d'un dépilement des pointeurs dans les listes, dans le cas d'une coïncidence
// met à jour les booléens interne à l'instance : aucun_pt_inversion et centre_initial
void Hysteresis3D::Gestion_pointeur_coincidence(double& unSur_wBaseCarre
,SaveResulHysteresis3D & save_resul,double& W_a
,List_io <Tenseur3BH>::iterator& iatens
,List_io <double>::iterator& iadef_equi
,List_io <double>::iterator& iafct
,bool& pt_sur_principal
,List_io <Tenseur3BH>::iterator& iaOi,bool& oi_sur_principal
,List_io <Tenseur3BH>::iterator& iatens_princ
,List_io <double>::iterator& iadef_equi_princ
,List_io <Tenseur3BH>::iterator& iaOi_princ
,List_io <double>::iterator& iafct_princ)
{ // 1-- cas de pt de ref: si on pointe sur la liste secondaire on retire le dernier élément
if (!pt_sur_principal)
{
if (iatens != save_resul.sigma_barre_BH_R_t_a_tdt.begin())
{ if (Permet_affichage() > 0)
cout << "\n incoherence, on devrait avoir ici le premier element de la liste secondaire"
<< " des sig d'inversion"
<< "\n Hysteresis3D::Gestion_pointeur_coïncidence(..."<< endl;
if (Permet_affichage() > 4)
Affiche_debug(unSur_wBaseCarre,save_resul,iatens,iadef_equi,pt_sur_principal
,iaOi,oi_sur_principal,iatens_princ,iadef_equi_princ,iaOi_princ);
// on génère une exception
throw ErrNonConvergence_loiDeComportement();
};
// comme on est sur la liste secondaire, cela signifie qu'elle n'est pas vide en point d'inversion
// donc on peut supprimer une contrainte d'inversion
save_resul.sigma_barre_BH_R_t_a_tdt.erase(iatens); // normalement c'est le premier de la liste!
save_resul.def_equi_t_a_tdt.erase(iadef_equi); // idem pour def_equi qui suit la même logique
save_resul.fct_aide_t_a_tdt.erase(iafct); // idem pour la fonction d'aide
// save_resul.nb_coincidence--; // on dépile également le nombre de coïncidence active
if (save_resul.sigma_barre_BH_R_t_a_tdt.size()==0)
{// il ne reste plus d'élément on revient sur la liste principal
pt_sur_principal = true;
iatens = iatens_princ; iadef_equi=iadef_equi_princ;iafct=iafct_princ;
// on regarde si le pointeur est valide
if (iatens != save_resul.sigma_barre_BH_R.end())
{aucun_pt_inversion = false;}
else {aucun_pt_inversion = true;};
}
else // cas où il reste des éléments sur les listes secondaires
{iatens = save_resul.sigma_barre_BH_R_t_a_tdt.begin();aucun_pt_inversion = false;
iadef_equi = save_resul.def_equi_t_a_tdt.begin();
iafct = save_resul.fct_aide_t_a_tdt.begin();
};
}
else // cas où on pointe sur la liste principal, on se déplace dans la liste principal,
{ // sans éliminer d'élément : on update le pointage
if (iatens != save_resul.sigma_barre_BH_R.end())
{iatens++;iadef_equi++;// idem pour def_equi et iafct qui suivent une même logique
// mais il faut mettre à jour la fonction d'aide par rapport à la valeur
// qu'elle avait au point d'inversion précédent sinon, c'est perdue
W_a = *iafct;
iafct++; // idem pour def_equi et iafct qui suivent une même logique
// on regarde si le pointeur est valide
if (iatens != save_resul.sigma_barre_BH_R.end()) {aucun_pt_inversion = false;}
else {aucun_pt_inversion = true;};
save_resul.nb_coincidence++; // on acte la coïncidence
// comme on est sur la liste principale, on met à jour les pointeurs de la liste principale
iatens_princ = iatens;iadef_equi_princ=iadef_equi;iafct_princ = iafct;
}
else // sinon il y a un pb car comme c'est une coïncidence il devrait rester un pointeur valide
{if (Permet_affichage() > 0)
cout << "\n incoherence, il devrait rester un pointeur de valide sur la liste de pt de ref"
<< "\n Hysteresis3D::Gestion_pointeur_coincidence(..." << endl;
if (Permet_affichage() > 4)
Affiche_debug(unSur_wBaseCarre,save_resul,iatens,iadef_equi,pt_sur_principal
,iaOi,oi_sur_principal,iatens_princ,iadef_equi_princ,iaOi_princ);
// cout << "\n tapper quelque chose ";
// string toto; cin >> toto;
// on génère une exception
throw ErrNonConvergence_loiDeComportement();
};
};
// 2-- cas des centres : si on pointe sur la liste secondaire on retire le dernier élément
if (!oi_sur_principal)
{
if (iaOi != save_resul.oc_BH_t_a_tdt.begin())
{ if (Permet_affichage() > 0)
cout << "\n incoherence, on devrait avoir ici le premier element de la liste secondaire des centres"
<< "\n Hysteresis3D::Gestion_pointeur_coïncidence(..."<< endl;
if (Permet_affichage() > 4)
Affiche_debug(unSur_wBaseCarre,save_resul,iatens,iadef_equi,pt_sur_principal
,iaOi,oi_sur_principal,iatens_princ,iadef_equi_princ,iaOi_princ);
// on génère une exception
throw ErrNonConvergence_loiDeComportement();
};
// on regarde si on peut supprimer un centre
if (iaOi != save_resul.oc_BH_t_a_tdt.end()) // dans le cas où l'origine est 0, il n'y a rien de sauvegardé
save_resul.oc_BH_t_a_tdt.erase(iaOi); // sinon normalement c'est le premier de la liste!
if (save_resul.oc_BH_t_a_tdt.size()==0)
{// il ne reste plus d'élément on revient sur la liste principal
oi_sur_principal = true; iaOi = iaOi_princ;
// on regarde de nouveau si le pointeur de centre est valide
if ((iaOi != save_resul.oc_BH_R.end())) {centre_initial=false;} else {centre_initial=true;};
}
else // cas où il reste des éléments sur les nouvelles listes
{iaOi = save_resul.oc_BH_t_a_tdt.begin(); centre_initial = false;
};
}
else // cas où on pointe sur la liste principal, on se déplace dans la liste principal,
{ // sans éliminer d'élément : on update le pointage
if (iaOi != save_resul.oc_BH_R.end()) // si la liste est vide, c-a-d le centre est le tenseur nulle
iaOi++; // on n'avance pas
// on regarde de nouveau si le pointeur de centre est valide
if ((iaOi != save_resul.oc_BH_R.end())) {centre_initial=false;} else {centre_initial=true;};
// comme on est sur la liste principale, on met à jour les pointeurs de la liste principale
iaOi_princ=iaOi;
};
// 3-- traitement particulier dans le cas où on a rejoint la première charge
if (aucun_pt_inversion) // cas où l'on est sur la courbe de première charge
{ wBase = 1; unSur_wBaseCarre = 1./(wBase*wBase);
}
else
// on met à jour le centre du cercle de référence, en indiquant que l'on a rattrapé une courbe
{ wBase = 2; unSur_wBaseCarre = 1./(wBase*wBase);
};
// gestion du paramètre "modif" de saveresult
bool inversion = false;
Gestion_para_Saveresult_Modif(pt_sur_principal,save_resul,inversion);
//--------débug- traçage
#ifdef MISE_AU_POINT
if (Permet_affichage() == -77)
{ cout << "\ngestion de pointeur de coïncidence ";
cout << " aucun_pt_inversion= " << aucun_pt_inversion
<< " save_resul.nb_coincidence= " << save_resul.nb_coincidence;
cout << " \nsigR_sur_principal= " << pt_sur_principal << ", oi_sur_principal= " << oi_sur_principal
<< " save_resul.modif= " << save_resul.modif
<< " \n nb_Oi= "<<save_resul.oc_BH_R.size() << " nb_sigR= "<<save_resul.sigma_barre_BH_R.size()
<< " || nb_Oi_sec= " << save_resul.oc_BH_t_a_tdt.size()
<< " nb_sigR_sec= " << save_resul.sigma_barre_BH_R_t_a_tdt.size()
<< " || wBase= " << wBase
<< endl ;
};
#endif
//----- fin débug
};
/* // **********calcul d'une dérivée numérique-------------
double peti= 1.E-10;
double lambda_ver = lambda+peti;
double un_sur_1_plus_2_G_lambda_ver = 1. / (1. + deux_G*lambda_ver);
double un_sur_1_plus_2_G_lambda2_ver =
un_sur_1_plus_2_G_lambda_ver * un_sur_1_plus_2_G_lambda_ver;
double alphaa_ver = un_sur_1_plus_2_G_lambda_ver*deux_G;
double alphaa2_ver = un_sur_1_plus_2_G_lambda2_ver * deux_G_carre;
double omega_ver = alphaa_ver*K/(alphaa_ver+2.*K); double omega2_ver = omega_ver*omega_ver;
// a moins que lambda soit très grand on considère qu'omega est positif
// par contre lambda peut-être négatif
// if (lambda >= 0)
double delta_eps_equi_ver = 2.*lambda_ver*omega_ver * eps_elasBH(1,1);
// delta_eps_equi = 2.*lambda*omega * sqrt(c_c);
double epsilon_barre_ver = epsilon_barre_t + // def plastique cumulée
delta_eps_equi_ver;
// nouvelle valeur de la variation de sigma_barre
// et valeur de la tangente de la courbe d'écrouissage
Courbe1D::ValDer valder_ver = f_ecrouissage->Valeur_Et_derivee(epsilon_barre_ver);
double sig_equi_ver = valder_ver.valeur;
// calcul du résidu
double res_plas_ver = 3.*c_c*omega2_ver - sig_equi_ver * sig_equi_ver * un_tiers;
double der1 = 3.*c_c*(omega2_ver-omega2)/peti;
double dereps_barre = (epsilon_barre_ver -epsilon_barre)/peti;
double der2 = un_tiers*(- sig_equi_ver * sig_equi_ver - - sig_equi * sig_equi)/peti;
double der = (res_plas_ver - res_plas)/peti;
double delta_lambda_ver = - res_plas/der ;
// **********fin du calcul de la dérivée numérique------- */
// affichage des informations pour le débug
void Hysteresis3D::Affiche_debug(double& unSur_wBaseCarre
,SaveResulHysteresis3D & save_resul
,List_io <Tenseur3BH>::iterator& iatens
,List_io <double>::iterator& iadef_equi,bool& pt_sur_principal
,List_io <Tenseur3BH>::iterator& iaOi,bool& oi_sur_principal
,const List_io <Tenseur3BH>::iterator& iatens_princ
,const List_io <double>::iterator& iadef_equi_princ
,const List_io <Tenseur3BH>::iterator& iaOi_princ)
{ // affichage de la loi
Affiche();
// départ
cout << "\n -- valeurs initiales -- ";
cout << "\n sigma_barre_BH_t= " << save_resul.sigma_barre_BH_t; // sigma à t
cout << "\n def_equi_at= " << save_resul.def_equi_at; // sigma à t
// variables actuelles
cout << "\n -- variables actuelles -- ";
cout << "\n sigma_t_barre_tdt= " << sigma_t_barre_tdt; // sigma barre finale
cout << "\n sigma_i_barre_BH= " << sigma_i_barre_BH; // sigma barre de début de calcul (à t au début)
cout << "\n sigma_barre_BH_R= " << sigma_barre_BH_R; // sigma barre de Référence en cours
cout << "\n def_equi_R= " << def_equi_R; // déformation équivalente à R
cout << "\n def_i_equi= " << def_i_equi; // dernière déformation équivalente à t
cout << "\n defEqui_maxi= " << defEqui_maxi; // déformation équivalente maxi sur la courbe de première charge
cout << "\n def_equi_atdt= " << def_equi_atdt; // déformation équivalente à tdt
cout << "\n delta_sigma_barre_BH_Rat= " << delta_sigma_barre_BH_Rat; // deltat sigma barre de R a t
cout << "\n delta_sigma_barre_BH_Ratdt= " << delta_sigma_barre_BH_Ratdt; // deltat sigma barre de R a tdt
cout << "\n delta_sigma_barre_tdt_BH= " << delta_sigma_barre_tdt_BH; // delta sigma barre de t à tdt
cout << "\n delta_sigma_barre_BH_OiaR= " << delta_sigma_barre_BH_OiaR; // delta sigma barre de Oi à R
cout << "\n Q_OiaR= " << Q_OiaR; // norme de delta_sigma_barre_BH_OiaR
cout << "\n QdeltaSigmaRatdt= " << QdeltaSigmaRatdt; // norme de rdelta_sigma_barre_BH_Ratdt
cout << "\n oc_BH_R= " << oc_BH_R;
cout << "\n unSur_wBaseCarre= " << unSur_wBaseCarre;
cout << "\n centre_initial= " << centre_initial; // pour gérer le fait qu'au début le centre initial = tenseur nul
cout << "\n aucun_pt_inversion= " << aucun_pt_inversion; // pour gérer le fait qu'au début il n'y a pas de pt d'inversion !
// variables de liste
cout << "\n -- variables de liste -- ";
cout << "\n *iatens= " << *iatens;
cout << "\n *iadef_equi= " << *iadef_equi;
cout << "\n pt_sur_principal= " << pt_sur_principal;
cout << "\n *iaOi= " << *iaOi;
cout << "\n oi_sur_principal= " << oi_sur_principal;
cout << "\n *iatens_princ= " << *iatens_princ;
cout << "\n *iadef_equi_princ= " << *iadef_equi_princ;
cout << "\n *iaOi_princ= " << *iaOi_princ;
// les listes
cout << "\n -- les listes -- ";
cout << "\n save_resul.sigma_barre_BH_R_t_a_tdt= " << save_resul.sigma_barre_BH_R_t_a_tdt;
cout << "\n save_resul.sigma_barre_BH_R= " << save_resul.sigma_barre_BH_R;
cout << "\n save_resul.oc_BH_t_a_tdt= " << save_resul.oc_BH_t_a_tdt;
cout << "\n save_resul.oc_BH_R= " << save_resul.oc_BH_R;
// on vide le buffer
cout << endl;
};
Reference in a new issue View git blame Copy permalink