3435 lines
186 KiB
C++
3435 lines
186 KiB
C++
|
// 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-2021 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) && (ParaGlob::NiveauImpression() > 3)) || (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) && (ParaGlob::NiveauImpression() > 3)) || (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) && (ParaGlob::NiveauImpression() > 3)) || (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()==0) && (ParaGlob::NiveauImpression() > 4)) || (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) && (ParaGlob::NiveauImpression() > 3)) || (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()==0) && (ParaGlob::NiveauImpression() > 4)) || (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()==0) && (ParaGlob::NiveauImpression() > 5)) || (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) && (ParaGlob::NiveauImpression() > 3)) || (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()==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();
|
||
|
|
};
|
||
|
|
|
||
|
|
// 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) && (ParaGlob::NiveauImpression() > 3)) || (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()==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);
|
||
|
|
// 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) && (ParaGlob::NiveauImpression() > 3)) || (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()==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();
|
||
|
|
};
|
||
|
|
// 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;
|
||
|
|
};
|
||
|
|
|