1833 lines
94 KiB
C++
1833 lines
94 KiB
C++
|
// FICHIER : Loi_maxwell2D_C.cp
|
||
|
|
// CLASSE : Loi_maxwell2D_C
|
||
|
|
|
||
|
|
|
||
|
|
// 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 "TypeConsTens.h"
|
||
|
|
#include "ParaGlob.h"
|
||
|
|
#include "ConstMath.h"
|
||
|
|
#include "CharUtil.h"
|
||
|
|
|
||
|
|
|
||
|
|
#include "Loi_maxwell2D_C.h"
|
||
|
|
|
||
|
|
#include "Enum_TypeQuelconque.h"
|
||
|
|
#include "TypeQuelconqueParticulier.h"
|
||
|
|
|
||
|
|
|
||
|
|
// ========== fonctions pour la classe de sauvegarde des résultats =========
|
||
|
|
|
||
|
|
//------- 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 Loi_maxwell2D_C::SaveResul_Loi_maxwell2D_C::Lecture_base_info
|
||
|
|
(ifstream& ent,const int )
|
||
|
|
{ // ici toutes les données sont toujours a priori variables
|
||
|
|
string toto;
|
||
|
|
ent >> toto >> eps33_t >> toto >> Deps33_t;
|
||
|
|
};
|
||
|
|
|
||
|
|
// cas donne le niveau de sauvegarde
|
||
|
|
// = 1 : on sauvegarde tout
|
||
|
|
// = 2 : on sauvegarde uniquement les données variables
|
||
|
|
//(supposées comme telles)
|
||
|
|
void Loi_maxwell2D_C::SaveResul_Loi_maxwell2D_C::Ecriture_base_info
|
||
|
|
(ofstream& sort,const int )
|
||
|
|
{ // ici toutes les données sont toujours a priori variables
|
||
|
|
sort << " eps33_t " << eps33_t << " Deps33_t " << Deps33_t << " " ;
|
||
|
|
};
|
||
|
|
|
||
|
|
// ========== fin des fonctions pour la classe de sauvegarde des résultats =========
|
||
|
|
|
||
|
|
Loi_maxwell2D_C::Loi_maxwell2D_C () : // Constructeur par defaut
|
||
|
|
Loi_comp_abstraite(MAXWELL2D_C,CAT_THERMO_MECANIQUE,2),E(-ConstMath::trespetit),nu(-2.*ConstMath::trespetit)
|
||
|
|
,mu(-ConstMath::trespetit),mu_p(-ConstMath::trespetit),existe_mu_p(false),depend_de_D(0)
|
||
|
|
,E_temperature(NULL),mu_temperature(NULL),mu_p_temperature(NULL),fac_mu_cissionD(NULL),fac_E_cissionD(NULL)
|
||
|
|
,depend_de_eps(0),fac_mu_Mises_Eps(NULL),fac_E_Mises_Eps(NULL)
|
||
|
|
,type_derive(-1),seule_deviatorique(false)
|
||
|
|
// --- dépendance éventuelle à la cristalinité
|
||
|
|
,depend_cristalinite(false),nc(0.),tauStar(0.),D1(0.),D2(0.),D3(0.),A1(0.),At2(0.),C1(0.)
|
||
|
|
,taux_crista(0.),volumique_visqueux(false),crista_aux_noeuds(false) { };
|
||
|
|
|
||
|
|
// Constructeur de copie
|
||
|
|
Loi_maxwell2D_C::Loi_maxwell2D_C (const Loi_maxwell2D_C& loi) :
|
||
|
|
Loi_comp_abstraite(loi),E(loi.E),nu(loi.nu)
|
||
|
|
,mu(loi.mu),mu_p(loi.mu_p),existe_mu_p(loi.existe_mu_p)
|
||
|
|
,type_derive(loi.type_derive),depend_de_D(loi.depend_de_D)
|
||
|
|
,E_temperature(loi.E_temperature),mu_temperature(loi.mu_temperature)
|
||
|
|
,mu_p_temperature(loi.mu_p_temperature)
|
||
|
|
,fac_mu_cissionD(loi.fac_mu_cissionD),fac_E_cissionD(loi.fac_E_cissionD)
|
||
|
|
,depend_de_eps(loi.depend_de_eps)
|
||
|
|
,fac_mu_Mises_Eps(loi.fac_mu_Mises_Eps),fac_E_Mises_Eps(loi.fac_E_Mises_Eps)
|
||
|
|
,seule_deviatorique(loi.seule_deviatorique)
|
||
|
|
// --- dépendance éventuelle à la cristalinité
|
||
|
|
,depend_cristalinite(loi.depend_cristalinite),nc(loi.nc),tauStar(loi.tauStar)
|
||
|
|
,D1(loi.D1),D2(loi.D2),D3(loi.D3),A1(loi.A1),At2(loi.At2),C1(loi.C1)
|
||
|
|
,taux_crista(0.),volumique_visqueux(loi.volumique_visqueux),crista_aux_noeuds(loi.crista_aux_noeuds)
|
||
|
|
{// on regarde s'il s'agit d'une courbe locale ou d'une courbe globale
|
||
|
|
//--- dependance à la température éventuelle
|
||
|
|
if (E_temperature != NULL)
|
||
|
|
if (E_temperature->NomCourbe() == "_")
|
||
|
|
E_temperature = Courbe1D::New_Courbe1D(*(loi.E_temperature));
|
||
|
|
if (mu_temperature != NULL)
|
||
|
|
if (mu_temperature->NomCourbe() == "_")
|
||
|
|
mu_temperature = Courbe1D::New_Courbe1D(*(loi.mu_temperature));
|
||
|
|
if (mu_p_temperature != NULL)
|
||
|
|
if (mu_p_temperature->NomCourbe() == "_")
|
||
|
|
mu_p_temperature = Courbe1D::New_Courbe1D(*(loi.mu_p_temperature));
|
||
|
|
//--- dependance à D éventuelle
|
||
|
|
if (fac_mu_cissionD != NULL)
|
||
|
|
if (fac_mu_cissionD->NomCourbe() == "_")
|
||
|
|
fac_mu_cissionD = Courbe1D::New_Courbe1D(*(loi.fac_mu_cissionD));;
|
||
|
|
if (fac_E_cissionD != NULL)
|
||
|
|
if (fac_E_cissionD->NomCourbe() == "_")
|
||
|
|
fac_E_cissionD = Courbe1D::New_Courbe1D(*(loi.fac_E_cissionD));;
|
||
|
|
//--- dependance à epsilon éventuelle
|
||
|
|
if (fac_mu_Mises_Eps != NULL)
|
||
|
|
if (fac_mu_Mises_Eps->NomCourbe() == "_")
|
||
|
|
fac_mu_Mises_Eps = Courbe1D::New_Courbe1D(*(loi.fac_mu_Mises_Eps));;
|
||
|
|
if (fac_E_Mises_Eps != NULL)
|
||
|
|
if (fac_E_Mises_Eps->NomCourbe() == "_")
|
||
|
|
fac_E_Mises_Eps = Courbe1D::New_Courbe1D(*(loi.fac_E_Mises_Eps));;
|
||
|
|
};
|
||
|
|
|
||
|
|
Loi_maxwell2D_C::~Loi_maxwell2D_C ()
|
||
|
|
// Destructeur
|
||
|
|
{
|
||
|
|
//--- dependance à la température éventuelle
|
||
|
|
if (E_temperature != NULL)
|
||
|
|
if (E_temperature->NomCourbe() == "_") delete E_temperature;
|
||
|
|
if (mu_temperature != NULL)
|
||
|
|
if (mu_temperature->NomCourbe() == "_") delete mu_temperature;
|
||
|
|
if (mu_p_temperature != NULL)
|
||
|
|
if (mu_p_temperature->NomCourbe() == "_") delete mu_p_temperature;
|
||
|
|
//--- dependance à D éventuelle
|
||
|
|
if (fac_mu_cissionD != NULL)
|
||
|
|
if (fac_mu_cissionD->NomCourbe() == "_") delete fac_mu_cissionD;
|
||
|
|
if (fac_E_cissionD != NULL)
|
||
|
|
if (fac_E_cissionD->NomCourbe() == "_") delete fac_E_cissionD;
|
||
|
|
//--- dependance à epsilon éventuelle
|
||
|
|
if (fac_mu_Mises_Eps != NULL)
|
||
|
|
if (fac_mu_Mises_Eps->NomCourbe() == "_") delete fac_mu_Mises_Eps;
|
||
|
|
if (fac_E_Mises_Eps != NULL)
|
||
|
|
if (fac_E_Mises_Eps->NomCourbe() == "_") delete fac_E_Mises_Eps;
|
||
|
|
};
|
||
|
|
|
||
|
|
// Lecture des donnees de la classe sur fichier
|
||
|
|
void Loi_maxwell2D_C::LectureDonneesParticulieres (UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D
|
||
|
|
,LesFonctions_nD& lesFonctionsnD)
|
||
|
|
{ // module d'young
|
||
|
|
string nom;*(entreePrinc->entree) >> nom;
|
||
|
|
if (nom != "E=")
|
||
|
|
{ cout << "\n erreur en lecture du module d'young, on aurait du lire le mot E=";
|
||
|
|
entreePrinc->MessageBuffer("**erreur1 Loi_maxwell2D_C::LectureDonneesParticulieres (...**");
|
||
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
// on regarde si le module d'young est thermo dépendant
|
||
|
|
if(strstr(entreePrinc->tablcar,"E_thermo_dependant_")!=0)
|
||
|
|
{ thermo_dependant=true;
|
||
|
|
*(entreePrinc->entree) >> nom;
|
||
|
|
if (nom != "E_thermo_dependant_")
|
||
|
|
{ cout << "\n erreur en lecture de la thermodependance de E, on aurait du lire le mot cle E_thermo_dependant_"
|
||
|
|
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
|
||
|
|
entreePrinc->MessageBuffer("**erreur2 Loi_maxwell2D_C::LectureDonneesParticulieres (...**");
|
||
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
// lecture de la loi d'évolution du module d'young 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))
|
||
|
|
{ E_temperature = lesCourbes1D.Trouve(nom);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ // sinon il faut la lire maintenant
|
||
|
|
string non_courbe("_");
|
||
|
|
E_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
|
||
|
|
// lecture de la courbe
|
||
|
|
E_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
|
||
|
|
};
|
||
|
|
entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ // lecture du module d'young
|
||
|
|
*(entreePrinc->entree) >> E ;
|
||
|
|
};
|
||
|
|
|
||
|
|
// lecture du coefficient de poisson
|
||
|
|
*(entreePrinc->entree) >> nom;
|
||
|
|
if (nom != "nu=")
|
||
|
|
{ cout << "\n erreur en lecture du coefficient de poisson, on aurait du lire le mot nu=";
|
||
|
|
entreePrinc->MessageBuffer("**erreur3 Loi_maxwell2D_C::LectureDonneesParticulieres (...**");
|
||
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||
|
|
Sortie(1);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ *(entreePrinc->entree) >> nu;}; // lecture de la valeur
|
||
|
|
|
||
|
|
// lecture de la viscosité
|
||
|
|
// lecture de la viscosité
|
||
|
|
*(entreePrinc->entree) >> nom;
|
||
|
|
if ((nom != "mu=") && (nom != "depend_cristalinite_"))
|
||
|
|
{ cout << "\n erreur en lecture de la viscosite, on aurait du lire le mot mu= ou depend_cristalinite_ "
|
||
|
|
<< " et on a lue: " << nom;
|
||
|
|
entreePrinc->MessageBuffer("**erreur4 Loi_maxwell2D_C::LectureDonneesParticulieres (...**");
|
||
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
|
||
|
|
// maintenant deux cas suivant que l'on a une dépendance à la cristalinité ou non
|
||
|
|
if (nom == "mu=")
|
||
|
|
{depend_cristalinite = false;
|
||
|
|
// on regarde si la viscosité est thermo dépendante
|
||
|
|
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 et on a lue: " << nom;
|
||
|
|
entreePrinc->MessageBuffer("**erreur5 Loi_maxwell2D_C::LectureDonneesParticulieres (...**");
|
||
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
// lecture de la loi d'évolution 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))
|
||
|
|
{ mu_temperature = lesCourbes1D.Trouve(nom);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ // sinon il faut la lire maintenant
|
||
|
|
string non_courbe("_");
|
||
|
|
mu_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
|
||
|
|
// lecture de la courbe
|
||
|
|
mu_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
|
||
|
|
};
|
||
|
|
// prepa du flot de lecture
|
||
|
|
entreePrinc->NouvelleDonnee();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ // lecture de mu
|
||
|
|
*(entreePrinc->entree) >> mu ;
|
||
|
|
};
|
||
|
|
// on regarde si éventuellement il y a une viscosité sur la trace du tenseur des contraintes
|
||
|
|
if(strstr(entreePrinc->tablcar,"mu_p=")!=0)
|
||
|
|
{// lecture de la viscosité pour la trace
|
||
|
|
existe_mu_p=true;
|
||
|
|
*(entreePrinc->entree) >> nom;
|
||
|
|
if (nom != "mu_p=")
|
||
|
|
{ cout << "\n erreur en lecture de la viscosite pour la trace, on aurait du lire le mot mu_p="
|
||
|
|
<< " et on a lue: " << nom
|
||
|
|
<< "\n la viscosite pour la trace de sigma doit se trouver apres celle pour la partie"
|
||
|
|
<< " deviatoire ";
|
||
|
|
entreePrinc->MessageBuffer("**erreur6 Loi_maxwell2D_C::LectureDonneesParticulieres (...**");
|
||
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
// on regarde si la viscosité est thermo dépendante
|
||
|
|
if(strstr(entreePrinc->tablcar,"mu_p_thermo_dependant_")!=0)
|
||
|
|
{ thermo_dependant=true;
|
||
|
|
*(entreePrinc->entree) >> nom;
|
||
|
|
if (nom != "mu_p_thermo_dependant_")
|
||
|
|
{ cout << "\n erreur en lecture de la thermodependance de mu_p, on aurait du lire le mot cle"
|
||
|
|
<< " mu_p_thermo_dependant_ (et on a lue: " << nom
|
||
|
|
<< " ) suivi du nom d'une courbe de charge ou de la courbe elle meme ";
|
||
|
|
entreePrinc->MessageBuffer("**erreur7 Loi_maxwell2D_C::LectureDonneesParticulieres (...**");
|
||
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
// lecture de la loi d'évolution 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))
|
||
|
|
{ mu_p_temperature = lesCourbes1D.Trouve(nom);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ // sinon il faut la lire maintenant
|
||
|
|
string non_courbe("_");
|
||
|
|
mu_p_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
|
||
|
|
// lecture de la courbe
|
||
|
|
mu_p_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
|
||
|
|
};
|
||
|
|
// prepa du flot de lecture
|
||
|
|
entreePrinc->NouvelleDonnee();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ // lecture de mu_p
|
||
|
|
*(entreePrinc->entree) >> mu_p ;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else // venant du if (nom == "mu=")
|
||
|
|
{// ici on est forcément dans le cas où nom == depend_cristalinite_
|
||
|
|
depend_cristalinite = true;
|
||
|
|
thermo_dependant=true;
|
||
|
|
entreePrinc->NouvelleDonnee(); // on passe une ligne
|
||
|
|
// lecture exhaustive de tous les paramètres
|
||
|
|
string nom1,nom2,nom3,nom4,nom5,nom6,nom7,nom8;
|
||
|
|
*(entreePrinc->entree) >> nom1 >> nc >> nom2 >> tauStar >> nom3 >> D1
|
||
|
|
>> nom4 >> D2 ;
|
||
|
|
entreePrinc->NouvelleDonnee(); // on passe une ligne
|
||
|
|
*(entreePrinc->entree) >> nom5 >> D3 >> nom6 >> A1
|
||
|
|
>> nom7 >> At2 >> nom8 >> C1;
|
||
|
|
// gestion des erreurs éventuelles
|
||
|
|
if ((nom1 != "nc=")||(nom2 != "tauStar=")||(nom3 != "D1=")||(nom4 != "D2=")
|
||
|
|
||(nom5 != "D3=")||(nom6 != "A1=")||(nom7 != "At2=")||(nom8 != "C1=") )
|
||
|
|
{ cout << "\n **** lecture incorecte pour les parametres de dependance de la cristalinite "
|
||
|
|
<< " un (ou plusieurs) identificateur de parametre est errone !! , ceux-ci sont: "
|
||
|
|
<< " nc= tauStar= D1= D2= D3= A1= At2= C1= , et on a lue: "
|
||
|
|
<< nom1 << " " << nom2 << " " << nom3 << " " << nom4 << " "
|
||
|
|
<< nom5 << " " << nom6 << " " << nom7 << " " << nom8 << " ";
|
||
|
|
entreePrinc->MessageBuffer("**erreur9 Loi_maxwell2D_C::LectureDonneesParticulieres (...**");
|
||
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
// on regarde si la partie volumique est visqueuse ou pas
|
||
|
|
if(strstr(entreePrinc->tablcar,"volumique_visqueux_")!=0)
|
||
|
|
{ volumique_visqueux=true;};
|
||
|
|
// on regarde si la cristalinité provient des noeuds ou des points d'intégration
|
||
|
|
if(strstr(entreePrinc->tablcar,"crista_aux_noeuds_")!=0)
|
||
|
|
{ crista_aux_noeuds=true;};
|
||
|
|
|
||
|
|
// prépa du flot
|
||
|
|
entreePrinc->NouvelleDonnee(); // on passe une ligne
|
||
|
|
};
|
||
|
|
// on regarde ensuite si le type de dérivée est indiqué
|
||
|
|
string toto;
|
||
|
|
if (strstr(entreePrinc->tablcar,"type_derivee")!=NULL)
|
||
|
|
{ // lecture du type
|
||
|
|
*(entreePrinc->entree) >> toto >> type_derive;
|
||
|
|
if ((type_derive!=0)&&(type_derive!=-1)&&(type_derive!=1))
|
||
|
|
{ cout << "\n le type de derivee indique pour la loi de maxwell2D_C: "<< type_derive
|
||
|
|
<< " n'est pas acceptable (uniquement -1 ou 0 ou 1), on utilise le type par defaut (-1 -> Jauman)"
|
||
|
|
<< " qui correspond à la derivee de lie deux fois covariantes";
|
||
|
|
type_derive = -1;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// on regarde s'il y a un coefficient multiplicateur de la viscosité de cission
|
||
|
|
// 1) ---- facteur fonction de D ----
|
||
|
|
depend_de_D = 0; // par défaut
|
||
|
|
if (strstr(entreePrinc->tablcar,"fac_mu_cissionD=")!=NULL)
|
||
|
|
{ *(entreePrinc->entree) >> toto ; //>> fac_mu_cissionD= ;
|
||
|
|
depend_de_D = 1;
|
||
|
|
#ifdef MISE_AU_POINT
|
||
|
|
if (toto != "fac_mu_cissionD=")
|
||
|
|
{ cout << "\n erreur en lecture de la loi de maxwell2D_C, on attendait fac_mu_cissionD= ";
|
||
|
|
entreePrinc->MessageBuffer("**erreur8 Loi_maxwell2D_C::LectureDonneesParticulieres (...**");
|
||
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
// on regarde également la cohérence
|
||
|
|
if (depend_cristalinite)
|
||
|
|
{ cout << "\n **** utilisation d'une viscosite non lineaire (fac_mu_cissionD= ) qui est "
|
||
|
|
<< " incoherente avec l'utilisation de la cristalinite, il faut utiliser l'un ou l'autre !!! ";
|
||
|
|
entreePrinc->MessageBuffer("**erreur10 Loi_maxwell2D_C::LectureDonneesParticulieres (...**");
|
||
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
// lecture de la loi d'évolution du facteur multiplicatif en fonction de Sqrt(D_barre:D_barre)
|
||
|
|
*(entreePrinc->entree) >> nom;
|
||
|
|
// on regarde si la courbe existe, si oui on récupère la référence
|
||
|
|
if (lesCourbes1D.Existe(nom)) { fac_mu_cissionD = lesCourbes1D.Trouve(nom);}
|
||
|
|
else { // sinon il faut la lire maintenant
|
||
|
|
string non_courbe("_");
|
||
|
|
fac_mu_cissionD = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
|
||
|
|
// lecture de la courbe
|
||
|
|
fac_mu_cissionD->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
|
||
|
|
}
|
||
|
|
// prepa du flot de lecture
|
||
|
|
entreePrinc->NouvelleDonnee();
|
||
|
|
};
|
||
|
|
if (strstr(entreePrinc->tablcar,"fac_E_cissionD=")!=NULL)
|
||
|
|
{ *(entreePrinc->entree) >> toto ; //>> fac_E_cissionD= ;
|
||
|
|
if (depend_de_D==1) {depend_de_D = 3;}else{depend_de_D =2;};
|
||
|
|
#ifdef MISE_AU_POINT
|
||
|
|
if (toto != "fac_E_cissionD=")
|
||
|
|
{ cout << "\n erreur en lecture de la loi de maxwell2D_C, on attendait fac_E_cissionD= ";
|
||
|
|
entreePrinc->MessageBuffer("**erreur8 Loi_maxwell2D_C::LectureDonneesParticulieres (...**");
|
||
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
// lecture de la loi d'évolution du facteur multiplicatif en fonction de Sqrt(D_barre:D_barre)
|
||
|
|
*(entreePrinc->entree) >> nom;
|
||
|
|
// on regarde si la courbe existe, si oui on récupère la référence
|
||
|
|
if (lesCourbes1D.Existe(nom)) { fac_E_cissionD = lesCourbes1D.Trouve(nom);}
|
||
|
|
else { // sinon il faut la lire maintenant
|
||
|
|
string non_courbe("_");
|
||
|
|
fac_E_cissionD = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
|
||
|
|
// lecture de la courbe
|
||
|
|
fac_E_cissionD->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
|
||
|
|
};
|
||
|
|
// prepa du flot de lecture
|
||
|
|
entreePrinc->NouvelleDonnee();
|
||
|
|
};
|
||
|
|
|
||
|
|
// 2) ----- facteur fonction de eps -----
|
||
|
|
depend_de_eps = 0; // par défaut
|
||
|
|
if (strstr(entreePrinc->tablcar,"fac_mu_Mises_Eps=")!=NULL)
|
||
|
|
{ *(entreePrinc->entree) >> toto ; //>> fac_mu_Mises_Eps= ;
|
||
|
|
depend_de_eps = 1;
|
||
|
|
#ifdef MISE_AU_POINT
|
||
|
|
if (toto != "fac_mu_Mises_Eps=")
|
||
|
|
{ cout << "\n erreur en lecture de la loi de maxwell2D_C, on attendait fac_mu_Mises_Eps= ";
|
||
|
|
entreePrinc->MessageBuffer("**erreur9 Loi_maxwell2D_C::LectureDonneesParticulieres (...**");
|
||
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
// on regarde également la cohérence
|
||
|
|
if (depend_cristalinite)
|
||
|
|
{ cout << "\n **** utilisation d'une viscosite non lineaire (fac_mu_Mises_Eps= ) qui est "
|
||
|
|
<< " incoherente avec l'utilisation de la cristalinite, il faut utiliser l'un ou l'autre !!! ";
|
||
|
|
entreePrinc->MessageBuffer("**erreur10 Loi_maxwell2D_C::LectureDonneesParticulieres (...**");
|
||
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
// lecture de la loi d'évolution du facteur multiplicatif en fonction de Sqrt(D_barre:D_barre)
|
||
|
|
*(entreePrinc->entree) >> nom;
|
||
|
|
// on regarde si la courbe existe, si oui on récupère la référence
|
||
|
|
if (lesCourbes1D.Existe(nom)) { fac_mu_Mises_Eps = lesCourbes1D.Trouve(nom);}
|
||
|
|
else { // sinon il faut la lire maintenant
|
||
|
|
string non_courbe("_");
|
||
|
|
fac_mu_Mises_Eps = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
|
||
|
|
// lecture de la courbe
|
||
|
|
fac_mu_Mises_Eps->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
|
||
|
|
};
|
||
|
|
// prepa du flot de lecture
|
||
|
|
entreePrinc->NouvelleDonnee();
|
||
|
|
};
|
||
|
|
|
||
|
|
if (strstr(entreePrinc->tablcar,"fac_E_Mises_Eps=")!=NULL)
|
||
|
|
{ *(entreePrinc->entree) >> toto ; //>> fac_E_Mises_Eps= ;
|
||
|
|
if (depend_de_eps==1) {depend_de_eps = 3;}else{depend_de_eps =2;};
|
||
|
|
#ifdef MISE_AU_POINT
|
||
|
|
if (toto != "fac_E_Mises_Eps=")
|
||
|
|
{ cout << "\n erreur en lecture de la loi de maxwell2D_C, on attendait fac_E_Mises_Eps= ";
|
||
|
|
entreePrinc->MessageBuffer("**erreur10 Loi_maxwell2D_C::LectureDonneesParticulieres (...**");
|
||
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
// lecture de la loi d'évolution du facteur multiplicatif en fonction de sqrt(2/3*Eps_barre:Eps_barre)
|
||
|
|
*(entreePrinc->entree) >> nom;
|
||
|
|
// on regarde si la courbe existe, si oui on récupère la référence
|
||
|
|
if (lesCourbes1D.Existe(nom)) { fac_E_Mises_Eps = lesCourbes1D.Trouve(nom);}
|
||
|
|
else { // sinon il faut la lire maintenant
|
||
|
|
string non_courbe("_");
|
||
|
|
fac_E_Mises_Eps = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
|
||
|
|
// lecture de la courbe
|
||
|
|
fac_E_Mises_Eps->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
|
||
|
|
};
|
||
|
|
// prepa du flot de lecture
|
||
|
|
entreePrinc->NouvelleDonnee();
|
||
|
|
};
|
||
|
|
|
||
|
|
// on regarde si le calcul est éventuellement uniquement déviatorique
|
||
|
|
seule_deviatorique = false; // par défaut
|
||
|
|
if (strstr(entreePrinc->tablcar,"seule_deviatorique")!=NULL)
|
||
|
|
{seule_deviatorique=true;};
|
||
|
|
|
||
|
|
// prepa du flot de lecture
|
||
|
|
if(strstr(entreePrinc->tablcar,"fin_coeff_MAXWELL2D_C")==0)
|
||
|
|
{entreePrinc->NouvelleDonnee();}
|
||
|
|
|
||
|
|
// appel au niveau de la classe mère
|
||
|
|
Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire
|
||
|
|
(*entreePrinc,lesFonctionsnD);
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
// affichage de la loi
|
||
|
|
void Loi_maxwell2D_C::Affiche() const
|
||
|
|
{ cout << " \n loi de comportement maxwell2D_C ";
|
||
|
|
if ( E_temperature != NULL) { cout << " module d'young thermo dependant "
|
||
|
|
<< " courbe E=f(T): " << E_temperature->NomCourbe() <<" ";}
|
||
|
|
else { cout << " module d'young E = " << E ;};
|
||
|
|
// coeff de poisson
|
||
|
|
cout << " nu= " << nu << endl;
|
||
|
|
// viscosité déviatorique
|
||
|
|
if ( mu_temperature != NULL) { cout << " viscosite deviatorique thermo dependante "
|
||
|
|
<< " courbe mu=f(T): " << mu_temperature->NomCourbe() <<" ";}
|
||
|
|
else { cout << " viscosite deviatorique mu= " << mu ;}
|
||
|
|
// viscosité sphérique
|
||
|
|
if ( mu_p_temperature != NULL) { cout << " viscosite spherique thermo dependante "
|
||
|
|
<< " courbe mu_p=f(T): " << mu_p_temperature->NomCourbe() <<" ";}
|
||
|
|
else { cout << " viscosite spherique mu_p= " << mu_p ;}
|
||
|
|
switch (type_derive)
|
||
|
|
{ case -1: cout << ", et derivee de jauman pour la contrainte" << endl;break;
|
||
|
|
case 0: cout << ", et derivee de lie deux fois covariantes (Rivlin) pour la contrainte" << endl; break;
|
||
|
|
case 1: cout << ", et derivee de lie deux fois contravariantes (Oldroyd) pour la contrainte" << endl; break;
|
||
|
|
};
|
||
|
|
//--- facteur multiplicatif dépendant de D ----
|
||
|
|
if ((depend_de_D==1)||(depend_de_D==3))
|
||
|
|
{ cout << " coef multiplicatif de la viscosite (pour une evolution non lineaire) "
|
||
|
|
<< " courbe fac_mu_cissionD=f(D_barre:D_barre): " << fac_mu_cissionD->NomCourbe() <<" ";
|
||
|
|
};
|
||
|
|
if ((depend_de_D==2)||(depend_de_D==3))
|
||
|
|
{ cout << " coef multiplicatif du module d'young (pour une evolution non lineaire) "
|
||
|
|
<< " courbe fac_E_cissionD=f(D_barre:D_barre): " << fac_E_cissionD->NomCourbe() <<" ";
|
||
|
|
};
|
||
|
|
//--- facteur multiplicatif dépendant de eps ----
|
||
|
|
if ((depend_de_eps==1)||(depend_de_eps==3))
|
||
|
|
{ cout << " coef multiplicatif de la viscosite (pour une evolution non lineaire) "
|
||
|
|
<< " courbe fac_mu_Mises_Eps=f(sqrt(2/3*Eps_barre:Eps_barre)): " << fac_mu_Mises_Eps->NomCourbe() <<" ";
|
||
|
|
};
|
||
|
|
if ((depend_de_eps==2)||(depend_de_eps==3))
|
||
|
|
{ cout << " coef multiplicatif du module d'young (pour une evolution non lineaire) "
|
||
|
|
<< " courbe fac_E_Mises_Eps=f(sqrt(2/3*Eps_barre:Eps_barre)): " << fac_E_Mises_Eps->NomCourbe() <<" ";
|
||
|
|
};
|
||
|
|
|
||
|
|
cout << " seule_deviatorique= " << seule_deviatorique << " ";
|
||
|
|
//------- cas éventuel de dépendance à la cristalinité ----------
|
||
|
|
if (depend_cristalinite)
|
||
|
|
{ cout << "\n dependance a la cristalinite: parametres de la dependance= "
|
||
|
|
<< "nc=" << nc << "tauStar=" << tauStar << "D1=" << D1 << "D2=" << D2
|
||
|
|
<< "D3=" << D3 << "A1=" << A1 << "At2=" << At2 << "C1=" << C1
|
||
|
|
<< " volumique_visqueux= " << volumique_visqueux << " " << crista_aux_noeuds << " ";
|
||
|
|
};
|
||
|
|
|
||
|
|
cout << endl;
|
||
|
|
// appel de la classe mère
|
||
|
|
Loi_comp_abstraite::Affiche_don_classe_abstraite();
|
||
|
|
};
|
||
|
|
|
||
|
|
// affichage et definition interactive des commandes particulières à chaques lois
|
||
|
|
void Loi_maxwell2D_C::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");
|
||
|
|
if (E == -ConstMath::trespetit)
|
||
|
|
{ // on initialise à une valeur arbitraire
|
||
|
|
E = 110000;};
|
||
|
|
if (nu == -2.*ConstMath::trespetit) { nu = 0.3;}; // valeur arbitraire
|
||
|
|
if (mu == -ConstMath::trespetit) { mu = 0.15; }// on initialise à une valeur arbitraire
|
||
|
|
if (mu_p == -ConstMath::trespetit) { mu_p = 0.15; }// on initialise à une valeur arbitraire
|
||
|
|
fac_mu_cissionD = NULL; // pas de facteur multiplicatif de non linéarité pour mu en fonction de D
|
||
|
|
fac_E_cissionD = NULL; // pas de facteur multiplicatif de non linéarité pour E en fonction de D
|
||
|
|
fac_mu_Mises_Eps = NULL; // pas de facteur multiplicatif de non linéarité pour mu en fonction de Eps
|
||
|
|
fac_E_Mises_Eps = NULL; // pas de facteur multiplicatif de non linéarité pour E en fonction de Eps
|
||
|
|
//-------- cristalinité éventuelle ------
|
||
|
|
nc=0.3452; tauStar = 1.128e4; D1=2.780e14; D2= -15.; D3= 1.4e-7; A1= 29.94; At2 = 51.6; C1= 2171;
|
||
|
|
volumique_visqueux = false;
|
||
|
|
sort << "\n# ....... loi de comportement maxwell 2D contraintes planes ............................................................."
|
||
|
|
<< "\n# | module d'Young | coeff |viscosite sur Dbarre| type de derivee objective utilisee |et eventuellement une fonction |"
|
||
|
|
<< "\n# | | de | mu(obligatoire) | pour le calcul de la contrainte | multiplicative de la viscosite |"
|
||
|
|
<< "\n# | E |Poisson |puis sur trace(D) | type_derivee (facultatif) | pour une evolution non lineaire|"
|
||
|
|
<< "\n# | | |mu_p(optionnelle) | | f(D) ou f(eps) |"
|
||
|
|
<< "\n#........................................................................................................................."
|
||
|
|
<< "\n# de maniere independante des parametres deja cites: il est possible d'indiquer que l'on souhaite"
|
||
|
|
<< "\n# un calcul uniquement deviatorique: pour cela il suffit de mettre a la fin des donnees le mot cle : seule_deviatorique "
|
||
|
|
<< "\n E= "<< setprecision(8) << E << " nu= " << setprecision(8) << nu
|
||
|
|
<< " mu= " << setprecision(8) << mu << " mu_p= " << setprecision(8) << mu_p
|
||
|
|
<< " type_derivee " << type_derive << " fac_mu_cissionD= " << "courbe_fac_mu_cissionD "
|
||
|
|
<< "\n fin_coeff_MAXWELL2D_C " << endl;
|
||
|
|
if ((rep != "o") && (rep != "O" ) && (rep != "0") )
|
||
|
|
{ sort << "\n# le type de derivee est optionnel: = -1 -> derivee de jauman (valeur par defaut), "
|
||
|
|
<< "\n# = 0 -> derivee deux fois covariantes (ou de Rivlin), "
|
||
|
|
<< "\n# = 1 -> derivee deux fois contravariantes (ou d'Oldroyd)"
|
||
|
|
<< "\n# dans le cas ou l'on veut une valeur differente de la valeur par defaut il faut mettre le mot cle"
|
||
|
|
<< "\n# <type_deriveee> suivi de la valeur -1 ou 0 ou 1"
|
||
|
|
<< "\n# \n# chaque parametre peut etre remplace par une fonction dependante de la temperature "
|
||
|
|
<< "\n# pour ce faire on utilise un mot cle puis une nom de courbe ou la courbe directement comme avec "
|
||
|
|
<< "\n# les autre loi de comportement "
|
||
|
|
<< "\n# exemple pour le module d'young: E= E_thermo_dependant_ courbe1 "
|
||
|
|
<< "\n# exemple pour la viscosite sur Dbarre: mu= mu_thermo_dependant_ courbe2 "
|
||
|
|
<< "\n# exemple pour la viscosite sur trace(D): mu_p= mu_p_thermo_dependant_ courbe2 "
|
||
|
|
<< "\n# dans le cas d'une thermo-dependance et d'une dependance a D : mu = mu(T) * fac_mu_cissionD "
|
||
|
|
<< "\n# idem pour E dependant de T et de D : E = E(T) * fac_E_cissionD "
|
||
|
|
<< "\n# dans le cas ou on a une viscosite sur la partie spherique et une dependance a D et a T, la dependance "
|
||
|
|
<< "\n# pour mu_p est la meme que pour mu a savoir: mu_p = mu_p(T) * fac_mu_cissionD "
|
||
|
|
<< "\n# IMPORTANT: a chaque fois qu'il y a une thermodependence, il faut passer une ligne apres la description"
|
||
|
|
<< "\n# de la grandeur thermodependante, mais pas de passage à la ligne si se n'est pas thermo dependant "
|
||
|
|
<< "\n# Noter que la dependance a D est en fait une dependance a sqrt(D_barre:D_barre) "
|
||
|
|
<< "\n# D'une maniere equivalente on peut avoir une dependance a sqrt(2/3*Eps_barre:Eps_barre) "
|
||
|
|
<< "\n# Le fonctionnement est identique a la dependance a D, les mots cles associes sont: "
|
||
|
|
<< "\n# fac_E_Mises_Eps fac_mu_Mises_Eps"
|
||
|
|
<< "\n# "
|
||
|
|
<< "\n# --- dependance a la cristalinite ----"
|
||
|
|
<< "\n# Il est egalement possible de definir une viscosite dependante de la cristalinite, de la pression et de la"
|
||
|
|
<< "\n# temperature selon une evolution proposee par Hieber, S.Han et K.K.Wang (voir doc pour plus d'info)"
|
||
|
|
<< "\n# Dans le cas ou on veut activer cette option, en lieu et place du mot cle mu= il faut indiquer "
|
||
|
|
<< "\n# le mot cle: depend_cristalinite_ , puis passer une ligne et sur la ligne qui suit, la liste exhaustive de tous "
|
||
|
|
<< "\n# les parametres demandes a savoir 8 grandeurs:"
|
||
|
|
<< "\n# nc tauStar D1 D2 D3 A1 At2 C1 ensuite on passe une nouvelle ligne et on continue avec "
|
||
|
|
<< "\n# les parametres : type_derivee et eventuellement seule_deviatorique, "
|
||
|
|
<< "\n# par contre il est incoherent de definir avec la cristalinie, le parametre fac_mu_cissionD ou fac_mu_Mises_Eps !"
|
||
|
|
<< "\n# "
|
||
|
|
<< "\n# exemple d'utilisation: "
|
||
|
|
<< "\n# E= "<< setprecision(8) << E << " nu= " << setprecision(8) << nu
|
||
|
|
<< "depend_cristalinite_ "
|
||
|
|
<< "\n# nc=" << nc << "tauStar=" << tauStar << "D1=" << D1 << "D2=" << D2
|
||
|
|
<< "\n# D3=" << D3 << "A1=" << A1 << "At2=" << At2 << "C1=" << C1 << " "
|
||
|
|
<< " volumique_visqueux_ # crista_aux_noeuds_ "
|
||
|
|
<< "\n type_derivee " << type_derive << " seule_deviatorique "
|
||
|
|
<< "\n# Remarques importantes: dans le cas de l'utilisation de la cristalinite"
|
||
|
|
<< "\n# 1) par defaut seule la partie deviatorique depend de la viscosite."
|
||
|
|
<< "\n# 2) il n'est pas possible d'utiliser les mots cles: mu= , mu_p= , fac_mu_cissionD ou fac_mu_Mises_Eps"
|
||
|
|
<< "\n# 3) il est possible d'indiquer que l'on veut egalement de la viscosite sur la partie volumique"
|
||
|
|
<< "\n# pour cela, apres le dernier parametre (c-a-d C1) on indique le mot cle volumique_visqueux_ "
|
||
|
|
<< "\n# 4) dans le cas ou les parametres volumique_visqueux_ et seule_deviatorique existent"
|
||
|
|
<< "\n# conjointement, on ne tient pas compte de la viscosite volumique !"
|
||
|
|
<< "\n# 5) Par defaut, la cristalinite est suppose connue au point d'integration (celui qui sert pour le "
|
||
|
|
<< "\n# calcul de la loi). Il doit donc etre calcule par ailleurs, par exemple via la loi de"
|
||
|
|
<< "\n# Hoffman (cf. documentation). Mais il est possible d'utiliser une cristalinite connue aux"
|
||
|
|
<< "\n# noeuds (donc pouvant etre lue en entree. Pour ce faire il faut utiliser le mot cle "
|
||
|
|
<< "\n# crista_aux_noeuds_ (a la suite ou avant le mot cle volumique_visqueux_) "
|
||
|
|
<< "\n# "
|
||
|
|
<< "\n# "
|
||
|
|
<< "\n# "
|
||
|
|
<< "\n# la derniere ligne doit contenir uniquement le mot cle: fin_coeff_MAXWELL2D_C "
|
||
|
|
<< endl;
|
||
|
|
};
|
||
|
|
// appel de la classe mère
|
||
|
|
Loi_comp_abstraite::Info_commande_don_LoisDeComp(entreePrinc);
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
// test si la loi est complete
|
||
|
|
int Loi_maxwell2D_C::TestComplet()
|
||
|
|
{ int ret = LoiAbstraiteGeneral::TestComplet();
|
||
|
|
if (E_temperature == NULL)
|
||
|
|
{if (E == -ConstMath::trespetit)
|
||
|
|
{ cout << " \n le module d'young n'est pas defini pour la loi " << Nom_comp(id_comp)
|
||
|
|
<< '\n';
|
||
|
|
ret = 0;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
if (nu == -2.*ConstMath::trespetit)
|
||
|
|
{ cout << " \n le coefficient de poisson n'est pas défini pour la loi " << Nom_comp(id_comp)
|
||
|
|
<< '\n';
|
||
|
|
ret = 0;
|
||
|
|
};
|
||
|
|
if (!depend_cristalinite)
|
||
|
|
if ((mu_temperature == NULL) && (mu == -ConstMath::trespetit))
|
||
|
|
{ cout << " \n la viscosite n'est pas defini pour la loi " << Nom_comp(id_comp)
|
||
|
|
<< '\n';
|
||
|
|
ret = 0;
|
||
|
|
};
|
||
|
|
return ret;
|
||
|
|
};
|
||
|
|
|
||
|
|
// calcul d'un module d'young équivalent à la loi
|
||
|
|
double Loi_maxwell2D_C::Module_young_equivalent(Enum_dure temps,const Deformation & def,SaveResul * )
|
||
|
|
{ if (seule_deviatorique)
|
||
|
|
return 0.; // dans le cas d'un calcul uniquement déviatorique, E équivalent = 0
|
||
|
|
double deltat=ParaGlob::Variables_de_temps().IncreTempsCourant();
|
||
|
|
if (thermo_dependant) temperature_tdt = def.DonneeInterpoleeScalaire(TEMP,temps);
|
||
|
|
|
||
|
|
// intégration du coeff multiplicateur de la viscosité si nécessaire
|
||
|
|
// ***** mais ici on considère que la vitesse et la déformation sont nulle *****
|
||
|
|
double coe_mu=1.; // coeff multiplicateur par défaut
|
||
|
|
double coe_E=1.; // coeff multiplicateur par défaut
|
||
|
|
double II_D_barre = 0.; // init
|
||
|
|
if ((depend_de_D!=0) || depend_cristalinite)
|
||
|
|
{ switch (depend_de_D)
|
||
|
|
{ case 1:coe_mu=fac_mu_cissionD->Valeur(sqrt(II_D_barre));break;
|
||
|
|
case 2:coe_E=fac_E_cissionD->Valeur(sqrt(II_D_barre));break;
|
||
|
|
case 3:coe_mu=fac_mu_cissionD->Valeur(sqrt(II_D_barre));
|
||
|
|
coe_E=fac_E_cissionD->Valeur(sqrt(II_D_barre));break;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// idem dans le cas d'une dépendance à eps
|
||
|
|
double II_eps_barre = 0.;double eps_mises = 0.; // init
|
||
|
|
if (depend_de_eps!=0)
|
||
|
|
{ switch (depend_de_eps)
|
||
|
|
{ case 1:coe_mu *= fac_mu_Mises_Eps->Valeur(eps_mises);break;
|
||
|
|
case 2:coe_E *= fac_E_Mises_Eps->Valeur(eps_mises);break;
|
||
|
|
case 3:coe_mu *= fac_mu_Mises_Eps->Valeur(eps_mises);
|
||
|
|
coe_E *= fac_E_Mises_Eps->Valeur(eps_mises);break;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
|
||
|
|
if (E_temperature != NULL) E = E_temperature->Valeur(*temperature);
|
||
|
|
if (depend_cristalinite) // cas d'une dépendance à la température via la cristalinité,
|
||
|
|
// ici on considère que la pression est nulle
|
||
|
|
{ double P = 0.;
|
||
|
|
// gamma = 2 D_12, si on a un essai de cisaillement pur en 1 2: II_D_barre = 2*(D^1_2)**2
|
||
|
|
// d'où gamm_point
|
||
|
|
double gamma_point = 0.;
|
||
|
|
mu = mu_p = ViscositeCristaline(P,gamma_point);
|
||
|
|
}
|
||
|
|
else // sinon c'est le cas classique de dépendance ou non à la température
|
||
|
|
{if (mu_temperature != NULL) mu = mu_temperature->Valeur(*temperature);
|
||
|
|
if (mu_p_temperature != NULL) mu_p = mu_p_temperature->Valeur(*temperature);
|
||
|
|
};
|
||
|
|
|
||
|
|
double mu_coe = mu * coe_mu; // pour simplifier
|
||
|
|
double E_coe = E * coe_E; // pour simplifier
|
||
|
|
|
||
|
|
// module d'young équivalent
|
||
|
|
double E_equi = (E_coe*mu_coe/(mu_coe+E_coe*deltat));
|
||
|
|
return E_equi;
|
||
|
|
};
|
||
|
|
|
||
|
|
//----- 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 Loi_maxwell2D_C::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
|
||
|
|
,LesFonctions_nD& lesFonctionsnD)
|
||
|
|
{ string nom;
|
||
|
|
if (cas == 1)
|
||
|
|
{ ent >> nom;
|
||
|
|
if (nom != "maxwell2D_C")
|
||
|
|
{ cout << "\n erreur en lecture de la loi : maxwell2D_C, on attendait le mot cle : maxwell2D_C "
|
||
|
|
<< "\n Loi_maxwell2D_C::Lecture_base_info_loi(...";
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
// ensuite normalement il n'y a pas de pb de lecture puisque c'est écrit automatiquement (sauf en debug)
|
||
|
|
ent >> nom >> type_derive >> nom >> seule_deviatorique;
|
||
|
|
ent >> nom; // module_d_young
|
||
|
|
bool test; ent >> test;
|
||
|
|
if (!test)
|
||
|
|
{ ent >> E;
|
||
|
|
if (E_temperature != NULL) {if (E_temperature->NomCourbe() == "_") delete E_temperature; E_temperature = NULL;};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ ent >> nom; E_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,E_temperature); };
|
||
|
|
// le coeff de poisson
|
||
|
|
ent >> nom >> nu;
|
||
|
|
// viscosité déviatoire
|
||
|
|
ent >> nom >> test;
|
||
|
|
if (!test)
|
||
|
|
{ ent >> mu;
|
||
|
|
if (mu_temperature != NULL) {if (mu_temperature->NomCourbe() == "_") delete mu_temperature; mu_temperature = NULL;};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ ent >> nom; mu_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,mu_temperature); };
|
||
|
|
// viscosité sphérique
|
||
|
|
ent >> nom >> test >> existe_mu_p;
|
||
|
|
if (!test)
|
||
|
|
{ ent >> mu_p;
|
||
|
|
if (mu_p_temperature != NULL) {if (mu_p_temperature->NomCourbe() == "_") delete mu_p_temperature; mu_p_temperature = NULL;};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ ent >> nom; mu_p_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,mu_p_temperature); };
|
||
|
|
|
||
|
|
// la fonction multiplicative de la viscosité de cission
|
||
|
|
// --- dépendance à D
|
||
|
|
ent >> nom >> depend_de_D ;
|
||
|
|
if ((depend_de_D==1)||(depend_de_D==3))
|
||
|
|
{ ent >> nom; fac_mu_cissionD = lesCourbes1D.Lecture_pour_base_info(ent,cas,fac_mu_cissionD); };
|
||
|
|
// la fonction multiplicative de E fonction dans ce cas de D
|
||
|
|
if ((depend_de_D==2)||(depend_de_D==3))
|
||
|
|
{ ent >> nom; fac_E_cissionD = lesCourbes1D.Lecture_pour_base_info(ent,cas,fac_E_cissionD); };
|
||
|
|
// --- dépendance à eps
|
||
|
|
ent >> nom >> depend_de_eps ;
|
||
|
|
if ((depend_de_eps==1)||(depend_de_eps==3))
|
||
|
|
{ ent >> nom; fac_mu_Mises_Eps = lesCourbes1D.Lecture_pour_base_info(ent,cas,fac_mu_Mises_Eps); };
|
||
|
|
// la fonction multiplicative de E fonction dans ce cas de eps
|
||
|
|
if ((depend_de_eps==2)||(depend_de_eps==3))
|
||
|
|
{ ent >> nom; fac_E_Mises_Eps = lesCourbes1D.Lecture_pour_base_info(ent,cas,fac_E_Mises_Eps); };
|
||
|
|
|
||
|
|
// --- cas éventuel de la cristalinité ---
|
||
|
|
ent >> nom >> depend_cristalinite;
|
||
|
|
if (depend_cristalinite)
|
||
|
|
{ ent >> nom >> nc >> nom >> tauStar >> nom >> D1 >> nom >> D2
|
||
|
|
>> nom >> D3 >> nom >> A1 >> nom >> At2 >> nom >> C1
|
||
|
|
>> volumique_visqueux >> crista_aux_noeuds ;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
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 Loi_maxwell2D_C::Ecriture_base_info_loi(ofstream& sort,const int cas)
|
||
|
|
{ if (cas == 1)
|
||
|
|
{ sort << " maxwell2D_C " << " type_derivee " << type_derive << " ";
|
||
|
|
sort << "\n module_d_young ";
|
||
|
|
if (E_temperature == NULL)
|
||
|
|
{ sort << false << " " << E << " ";}
|
||
|
|
else
|
||
|
|
{ sort << true << " fonction_E_temperature ";
|
||
|
|
LesCourbes1D::Ecriture_pour_base_info(sort,cas,E_temperature);
|
||
|
|
};
|
||
|
|
sort << " nu " << nu << " ";
|
||
|
|
sort << "\n viscosite_deviatoire ";
|
||
|
|
if (mu_temperature == NULL)
|
||
|
|
{ sort << false << " " << mu << " ";}
|
||
|
|
else
|
||
|
|
{ sort << true << " fonction_mu_temperature ";
|
||
|
|
LesCourbes1D::Ecriture_pour_base_info(sort,cas,mu_temperature);
|
||
|
|
};
|
||
|
|
sort << "\n viscosite_spherique " << existe_mu_p << " ";
|
||
|
|
if (mu_p_temperature == NULL)
|
||
|
|
{ sort << false << " " << mu_p << " ";}
|
||
|
|
else
|
||
|
|
{ sort << true << " fonction_mu_p_temperature ";
|
||
|
|
LesCourbes1D::Ecriture_pour_base_info(sort,cas,mu_p_temperature);
|
||
|
|
};
|
||
|
|
// --- dépendance à D
|
||
|
|
sort << "\n depend_de_D " << depend_de_D << " ";
|
||
|
|
if ((depend_de_D==1)||(depend_de_D==3)) // cas ou il y a une fonction multiplicative
|
||
|
|
{ sort << " fonction_fac_mu_cissionD ";
|
||
|
|
LesCourbes1D::Ecriture_pour_base_info(sort,cas,fac_mu_cissionD);
|
||
|
|
};
|
||
|
|
if ((depend_de_D==2)||(depend_de_D==3)) // cas ou il y a une fonction multiplicative pour E
|
||
|
|
{ sort << " fonction_fac_E_cissionD ";
|
||
|
|
LesCourbes1D::Ecriture_pour_base_info(sort,cas,fac_E_cissionD);
|
||
|
|
};
|
||
|
|
// --- dépendance à Eps
|
||
|
|
sort << "\n depend_de_Eps " << depend_de_eps << " ";
|
||
|
|
if ((depend_de_eps==1)||(depend_de_eps==3)) // cas ou il y a une fonction multiplicative
|
||
|
|
{ sort << " fonction_fac_mu_Mises_Eps ";
|
||
|
|
LesCourbes1D::Ecriture_pour_base_info(sort,cas,fac_mu_Mises_Eps);
|
||
|
|
};
|
||
|
|
if ((depend_de_eps==2)||(depend_de_eps==3)) // cas ou il y a une fonction multiplicative pour E
|
||
|
|
{ sort << " fonction_fac_E_Mises_Eps ";
|
||
|
|
LesCourbes1D::Ecriture_pour_base_info(sort,cas,fac_E_Mises_Eps);
|
||
|
|
};
|
||
|
|
// --- cas éventuel de la cristalinité ---
|
||
|
|
if (depend_cristalinite)
|
||
|
|
{ sort << "\n cristalinite 1 ";
|
||
|
|
sort << "nc=" << nc << "tauStar=" << tauStar << "D1=" << D1 << "D2=" << D2
|
||
|
|
<< "D3=" << D3 << "A1=" << A1 << "At2=" << At2 << "C1=" << C1 << " "
|
||
|
|
<< " volumique_visqueux= " << volumique_visqueux << " " << crista_aux_noeuds << " ";
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ sort << "\n cristalinite 0 ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// appel de la classe mère
|
||
|
|
Loi_comp_abstraite::Ecriture_don_base_info(sort,cas);
|
||
|
|
};
|
||
|
|
|
||
|
|
// récupération de la dernière déformation d'épaisseur calculée: cette déformaion n'est utile que pour des lois en contraintes planes ou doublement planes
|
||
|
|
// - pour les lois 3D : retour d'un nombre très grand, indiquant que cette fonction est invalide
|
||
|
|
// - pour les lois 2D def planes: retour de 0
|
||
|
|
// les infos nécessaires à la récupération de la def, sont stockées dans saveResul
|
||
|
|
// qui est le conteneur spécifique au point où a été calculé la loi
|
||
|
|
double Loi_maxwell2D_C::Eps33BH(SaveResul * saveResul) const
|
||
|
|
{ // tout d'abord on récupère le conteneur
|
||
|
|
SaveResul_Loi_maxwell2D_C & save_resul = *((SaveResul_Loi_maxwell2D_C*) saveResul);
|
||
|
|
// On considère qu'il s'agit d'une def logarithmique ... au cas où
|
||
|
|
return save_resul.eps33;
|
||
|
|
};
|
||
|
|
|
||
|
|
// récupération de la variation relative d'épaisseur calculée: h/h0
|
||
|
|
// cette variation n'est utile que pour des lois en contraintes planes
|
||
|
|
// - pour les lois 3D : retour d'un nombre très grand, indiquant que cette fonction est invalide
|
||
|
|
// - pour les lois 2D def planes: retour de 0
|
||
|
|
// les infos nécessaires à la récupération , sont stockées dans saveResul
|
||
|
|
// qui est le conteneur spécifique au point où a été calculé la loi
|
||
|
|
double Loi_maxwell2D_C::HsurH0(SaveResul * saveResul) const
|
||
|
|
{ // tout d'abord on récupère le conteneur
|
||
|
|
SaveResul_Loi_maxwell2D_C & save_resul = *((SaveResul_Loi_maxwell2D_C*) saveResul);
|
||
|
|
// On considère qu'il s'agit d'une def logarithmique ... au cas où
|
||
|
|
return exp(save_resul.eps33);
|
||
|
|
// return (save_resul.eps33);
|
||
|
|
};
|
||
|
|
|
||
|
|
// 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 Loi_maxwell2D_C::Grandeur_particuliere
|
||
|
|
(bool absolue,List_io<TypeQuelconque>& liTQ,Loi_comp_abstraite::SaveResul * saveDon,list<int>& decal) const
|
||
|
|
{ // tout d'abord on récupère le conteneur
|
||
|
|
SaveResul_Loi_maxwell2D_C & save_resul = *((SaveResul_Loi_maxwell2D_C*) saveDon);
|
||
|
|
// maintenant on s'occupe des grandeurs de la loi elle même,
|
||
|
|
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 DEF_EPAISSEUR :// -----cas de la déformation d'épaisseur à t
|
||
|
|
{ Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
|
||
|
|
tyTQ(1+(*idecal)) = save_resul.eps33;
|
||
|
|
(*idecal)++; break;
|
||
|
|
}
|
||
|
|
case D_EPAISSEUR: // -----cas de la vitesse de déformation d'épaisseur à t
|
||
|
|
{ Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
|
||
|
|
tyTQ(1+(*idecal)) = save_resul.Deps33;
|
||
|
|
(*idecal)++; break;
|
||
|
|
}
|
||
|
|
|
||
|
|
default: ;// on ne fait rien
|
||
|
|
};
|
||
|
|
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// récupération de la liste de tous les grandeurs particulières
|
||
|
|
// ces grandeurs sont ajoutées à la liste passées en paramètres
|
||
|
|
void Loi_maxwell2D_C::ListeGrandeurs_particulieres(bool absolue,List_io<TypeQuelconque>& liTQ) const
|
||
|
|
{
|
||
|
|
// pour le stockage
|
||
|
|
Tableau <double> tab_double(1);
|
||
|
|
Tab_Grandeur_scalaire_double grand_courant(tab_double);
|
||
|
|
// -----cas de la déformation d'épaisseur à t uniquement
|
||
|
|
//on regarde si ce type d'info existe déjà: si oui on augmente la taille du tableau, si non on crée
|
||
|
|
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
|
||
|
|
for (itq=liTQ.begin();itq!=itqfin;itq++)
|
||
|
|
if ((*itq).EnuTypeQuelconque() == DEF_EPAISSEUR)
|
||
|
|
{ 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(DEF_EPAISSEUR,EPS11,grand_courant);
|
||
|
|
liTQ.push_back(typQ1);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// -----cas de la vitesse de déformation d'épaisseur à t uniquement
|
||
|
|
//on regarde si ce type d'info existe déjà: si oui on augmente la taille du tableau, si non on crée
|
||
|
|
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
|
||
|
|
for (itq=liTQ.begin();itq!=itqfin;itq++)
|
||
|
|
if ((*itq).EnuTypeQuelconque() == D_EPAISSEUR)
|
||
|
|
{ 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(D_EPAISSEUR,EPS11,grand_courant);
|
||
|
|
liTQ.push_back(typQ1);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
// ========== codage des METHODES VIRTUELLES protegees:================
|
||
|
|
// calcul des contraintes a t+dt
|
||
|
|
void Loi_maxwell2D_C::Calcul_SigmaHH (TenseurHH& sigHH_t,TenseurBB& DepsBB_,DdlElement &
|
||
|
|
,TenseurBB & gijBB_t,TenseurHH & ,BaseB& ,BaseH& ,TenseurBB& epsBB_
|
||
|
|
,TenseurBB& , TenseurBB& gijBB_
|
||
|
|
,TenseurHH & gijHH_,Tableau <TenseurBB *>& ,double& ,double& ,TenseurHH & sigHH_
|
||
|
|
,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double& module_cisaillement
|
||
|
|
,const Met_abstraite::Expli_t_tdt& )
|
||
|
|
{
|
||
|
|
#ifdef MISE_AU_POINT
|
||
|
|
if (DepsBB_.Dimension() != 2)
|
||
|
|
{ cout << "\nErreur : la dimension devrait etre 2 !\n";
|
||
|
|
cout << " Loi_maxwell2D_C::Calcul_SigmaHH\n";
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
const Tenseur2BB & epsBB = *((Tenseur2BB*) &epsBB_); // passage en dim 2
|
||
|
|
const Tenseur2BB & DepsBB = *((Tenseur2BB*) &DepsBB_); // passage en dim 2
|
||
|
|
const Tenseur2HH & gijHH = *((Tenseur2HH*) &gijHH_); // " " " "
|
||
|
|
const Tenseur2BB & gijBB = *((Tenseur2BB*) &gijBB_); // " " " "
|
||
|
|
Tenseur2HH & sigHH = *((Tenseur2HH*) &sigHH_); // " " " "
|
||
|
|
Tenseur2HH & sigHH_nn = *((Tenseur2HH*) &sigHH_t); // " " " "
|
||
|
|
// récupération de eps33 et Deps33 - ici on considère que g^33=g_33=1 !!
|
||
|
|
SaveResul_Loi_maxwell2D_C & save_resul = *((SaveResul_Loi_maxwell2D_C*) saveResul);
|
||
|
|
|
||
|
|
// tenseur intermédiaires utilisées selon les cas (par forcément dans tous les cas !!)
|
||
|
|
Tenseur2BH sigBH_n;Tenseur2HH sigHH_n; Tenseur2BB sigBB_n;Tenseur2BB sig_interBB_n;
|
||
|
|
switch (type_derive) //case 1: cas d'une dérivée de lie deux fois contravariante : cas par défaut
|
||
|
|
{case -1: // cas d'une dérivée de jauman: 1/2 deux fois covariants + deux fois contra
|
||
|
|
{sig_interBB_n = gijBB_t * sigHH_nn * gijBB_t;
|
||
|
|
sigBH_n = 0.5*( sig_interBB_n * gijHH + gijBB * sigHH_nn) ;
|
||
|
|
sigHH_n = gijHH * sigBH_n ;
|
||
|
|
sigBB_n = sigBH_n * gijBB; break;}
|
||
|
|
case 0: // cas d'une dérivée de lie deux fois covariantes
|
||
|
|
{sigBB_n = gijBB_t * sigHH_nn * gijBB_t;
|
||
|
|
sigBH_n = sigBB_n * gijHH ;
|
||
|
|
sigHH_n = gijHH * sigBH_n ; break;}
|
||
|
|
case 1: // cas d'une dérivée de lie deux fois contravariantes
|
||
|
|
{sigHH_n = sigHH_nn;
|
||
|
|
sigBH_n = gijBB * sigHH_n;
|
||
|
|
sigBB_n = sigBH_n * gijBB;
|
||
|
|
break;}
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
// ---- calcul relatif aux déviateurs : déformations et vitesse de déformation -----
|
||
|
|
static const double untier=1./3.;
|
||
|
|
Tenseur2BH DepsBH = DepsBB * gijHH;
|
||
|
|
// recup de l'incrément de temps
|
||
|
|
double deltat=ParaGlob::Variables_de_temps().IncreTempsCourant();
|
||
|
|
double unSurDeltat=0;
|
||
|
|
if (Abs(deltat) >= ConstMath::trespetit)
|
||
|
|
{unSurDeltat = 1./deltat;}
|
||
|
|
else
|
||
|
|
// si l'incrément de temps est tres petit on remplace 1/deltat par un nombre tres grand
|
||
|
|
// {unSurDeltat = Signe(deltat)*ConstMath::tresgrand;}
|
||
|
|
{ // non un pas de temps doit être positif !! or certaine fois il peut y avoir des pb
|
||
|
|
if (unSurDeltat < 0)
|
||
|
|
{ cout << "\n le pas de temps est négatif !! "; };
|
||
|
|
unSurDeltat = ConstMath::tresgrand;
|
||
|
|
};
|
||
|
|
|
||
|
|
// on commence par définir une trace approximative qui s'appuie
|
||
|
|
// sur la valeur précédemment calculée, ceci pour calculer les fonctions éventuelles
|
||
|
|
double IDeps_imoinsun=DepsBH.Trace()+ save_resul.Deps33_t;
|
||
|
|
Tenseur2BH Deps_barre_BH = DepsBH - (untier * IDeps_imoinsun) * IdBH2;
|
||
|
|
// intégration du coeff multiplicateur de la viscosité si nécessaire
|
||
|
|
double II_D_barre=0;
|
||
|
|
double Q_Deps = 0.;
|
||
|
|
Courbe1D::ValDer valder_mu;Courbe1D::ValDer valder_E;
|
||
|
|
valder_mu.valeur = 1.; valder_mu.derivee = 0.;// initialisation par défaut
|
||
|
|
valder_E.valeur = 1.; valder_E.derivee = 0.;// initialisation par défaut
|
||
|
|
|
||
|
|
if ((depend_de_D!=0) || depend_cristalinite)
|
||
|
|
{ II_D_barre = Deps_barre_BH.II();
|
||
|
|
Q_Deps = sqrt(II_D_barre);
|
||
|
|
switch (depend_de_D)
|
||
|
|
{ case 1:valder_mu=fac_mu_cissionD->Valeur_Et_derivee(Q_Deps);break;
|
||
|
|
case 2:valder_E=fac_E_cissionD->Valeur_Et_derivee(Q_Deps);break;
|
||
|
|
case 3:valder_mu=fac_mu_cissionD->Valeur_Et_derivee(Q_Deps);
|
||
|
|
valder_E=fac_E_cissionD->Valeur_Et_derivee(Q_Deps);break;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// idem dans le cas d'une dépendance à eps
|
||
|
|
Tenseur2BH epsBH = epsBB * gijHH; // deformation en mixte
|
||
|
|
double Ieps_imoinsun = epsBH.Trace()+ save_resul.eps33_t;
|
||
|
|
double eps_mises_imoinsun = 0.;
|
||
|
|
{Tenseur2BH eps_barre_BH = epsBH - (untier * Ieps_imoinsun) * IdBH2;
|
||
|
|
double II_eps_barre = 0.; // init
|
||
|
|
if (depend_de_eps!=0)
|
||
|
|
{ II_eps_barre = eps_barre_BH.II();
|
||
|
|
eps_mises_imoinsun = sqrt(2./3. * II_eps_barre);
|
||
|
|
Courbe1D::ValDer valder_mu_inter;Courbe1D::ValDer valder_E_inter;
|
||
|
|
valder_mu_inter.valeur = 1.; valder_mu_inter.derivee = 0.;// initialisation par défaut
|
||
|
|
valder_E_inter.valeur = 1.; valder_E_inter.derivee = 0.;// initialisation par défaut
|
||
|
|
switch (depend_de_eps)
|
||
|
|
{ case 1:valder_mu_inter =fac_mu_Mises_Eps->Valeur_Et_derivee(eps_mises_imoinsun);break;
|
||
|
|
case 2:valder_E_inter =fac_E_Mises_Eps->Valeur_Et_derivee(eps_mises_imoinsun);break;
|
||
|
|
case 3:valder_mu_inter =fac_mu_Mises_Eps->Valeur_Et_derivee(eps_mises_imoinsun);
|
||
|
|
valder_E_inter =fac_E_Mises_Eps->Valeur_Et_derivee(eps_mises_imoinsun);break;
|
||
|
|
};
|
||
|
|
// calcul du résultat combiné
|
||
|
|
// pour la dérivée
|
||
|
|
valder_mu.derivee = valder_mu.valeur * valder_mu_inter.derivee
|
||
|
|
+ valder_mu.derivee * valder_mu_inter.valeur;
|
||
|
|
valder_E.derivee = valder_E.valeur * valder_E_inter.derivee
|
||
|
|
+ valder_E.derivee * valder_E_inter.valeur;
|
||
|
|
// pour la valeur finale
|
||
|
|
valder_mu.valeur *= valder_mu_inter.valeur;
|
||
|
|
valder_E.valeur *= valder_E_inter.valeur;
|
||
|
|
};
|
||
|
|
}; // fin de l'encapsulation
|
||
|
|
|
||
|
|
// --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
|
||
|
|
if (E_temperature != NULL) E = E_temperature->Valeur(*temperature);
|
||
|
|
if (depend_cristalinite) // cas d'une dépendance à la température via la cristalinité
|
||
|
|
{ double P = untier * (gijBB && sigHH); // pour la pression on utilise la trace précédente
|
||
|
|
// gamma = 2 D_12, si on a un essai de cisaillement pur en 1 2: II_D_barre = 2*(D^1_2)**2
|
||
|
|
// d'où gamm_point
|
||
|
|
double gamma_point = sqrt(2.*II_D_barre);
|
||
|
|
mu = mu_p = ViscositeCristaline(P,gamma_point);
|
||
|
|
//---- debug
|
||
|
|
// cout << " " << mu << endl;
|
||
|
|
//---- debug
|
||
|
|
}
|
||
|
|
else // sinon c'est le cas classique de dépendance ou non à la température
|
||
|
|
{if (mu_temperature != NULL) mu = mu_temperature->Valeur(*temperature);
|
||
|
|
if (mu_p_temperature != NULL) mu_p = mu_p_temperature->Valeur(*temperature);
|
||
|
|
};
|
||
|
|
// calcul des coefficients généraux de la loi 3D
|
||
|
|
double E_coe = E * valder_E.valeur; // pour simplifier
|
||
|
|
double troisK=E_coe/(1-2.*nu);
|
||
|
|
double deuxG=E_coe/(1.+nu);
|
||
|
|
double mu_coe = mu * valder_mu.valeur; // pour simplifier
|
||
|
|
double mu_p_coe = mu_p * valder_mu.valeur; // pour simplifier
|
||
|
|
double unSurmu_coe = 1./mu_coe;
|
||
|
|
double co1 = deltat * deuxG * mu_coe/(mu_coe + deuxG * deltat);
|
||
|
|
double co3 = unSurDeltat/deuxG;
|
||
|
|
|
||
|
|
// --- on détermine la déformation et la vitesse de déformation
|
||
|
|
// suivant l'axe 3 compte tenu de la condition de contrainte plane
|
||
|
|
double deuxGdeltat = deuxG * deltat;
|
||
|
|
double troisKdeltat = troisK * deltat;
|
||
|
|
double alpa = troisKdeltat * mu_p_coe /(mu_p_coe+ troisKdeltat);
|
||
|
|
double betaa = deuxGdeltat * mu_coe / (mu_coe+ deuxGdeltat);
|
||
|
|
double c1 = 0.; double c2 = 0.; double c3 = 0. ; // initialisation
|
||
|
|
double Isig_n = sigBH_n.Trace(); // vrai mais il faut garder en tête qu'il y a une opération
|
||
|
|
// de transport, donc la trace a évoluer avec le transport
|
||
|
|
// par contre la condition de contrainte plane est conservée c-a-d sigBH_n(3,i)=0
|
||
|
|
if (!(existe_mu_p))
|
||
|
|
// cas où il n'y a pas de viscosité sphérique => élasticité linéaire
|
||
|
|
// la variable de D_33 n'a pas d'importance car g_33 = g^{33}=g_3^3 = 1
|
||
|
|
{
|
||
|
|
// c1 = (betaa -troisKdeltat) / (troisKdeltat+2.*betaa);
|
||
|
|
// c2 = - 3.*betaa / ((troisKdeltat+2.*betaa) * deuxGdeltat);
|
||
|
|
// c3 = - 1. / (troisKdeltat+2.*betaa);
|
||
|
|
c1 = betaa / (troisKdeltat+2.*betaa);
|
||
|
|
c2 = - troisK / (troisKdeltat+2.*betaa);
|
||
|
|
c3 = betaa / ((troisKdeltat+2.*betaa) * deuxGdeltat);
|
||
|
|
save_resul.Deps33 = c1 * DepsBH.Trace() + c2*(epsBH.Trace()+ save_resul.eps33_t) + c3 * Isig_n;
|
||
|
|
}
|
||
|
|
else // cas où on a une partie sphérique et qu'elle contient une partie visqueuse
|
||
|
|
{
|
||
|
|
c1 = (betaa -alpa) / (alpa+2.*betaa);
|
||
|
|
c2 = - 3.*betaa / ((alpa+2.*betaa) * deuxGdeltat);
|
||
|
|
c3 = - alpa / ((alpa+2.*betaa) * troisKdeltat);
|
||
|
|
save_resul.Deps33 = c1 * DepsBH.Trace() + c3 * Isig_n;
|
||
|
|
}
|
||
|
|
// les coefficients ci peuvent permettrent également de calculer un opérateur tangent
|
||
|
|
// expression théorique save_resul.Deps33 = c1 * epsBH.Trace() + c2 * sigBH_n(3,3) + c3 * Isig_n;
|
||
|
|
// mais normalement sigBH_n(3,3) = 0
|
||
|
|
save_resul.eps33 = save_resul.eps33_t + save_resul.Deps33 * deltat ;
|
||
|
|
|
||
|
|
// --- on détermine la forme définitive du tenseur de def et D
|
||
|
|
double IDeps=DepsBH.Trace()+ save_resul.Deps33;
|
||
|
|
Deps_barre_BH = DepsBH - (untier * IDeps) * IdBH2;
|
||
|
|
double Ieps = epsBH.Trace()+ save_resul.eps33;
|
||
|
|
Tenseur2BH eps_barre_BH = epsBH - (untier * Ieps) * IdBH2;
|
||
|
|
|
||
|
|
// --- on peut maintenant utiliser les relations générales 3D
|
||
|
|
|
||
|
|
// cas d'une viscosité sur la partie sphérique et le fait que la partie sphérique est prise en compte
|
||
|
|
double co2=0.; double co4=0.;
|
||
|
|
if (((existe_mu_p) ||(volumique_visqueux)) && (!seule_deviatorique))
|
||
|
|
{ co2=deltat * troisK * mu_p_coe /(mu_p_coe + troisK * deltat); // ne sert pas toujours
|
||
|
|
co4 = unSurDeltat/troisK;
|
||
|
|
};
|
||
|
|
|
||
|
|
// ---- calcul de la partie sphérique du tenseur des contraintes -----
|
||
|
|
Tenseur2BH SBH_n = sigBH_n - (untier * Isig_n) * IdBH2;
|
||
|
|
// cas de la partie sphérique
|
||
|
|
double Isigma=0;module_compressibilite=0.;
|
||
|
|
if (!seule_deviatorique)
|
||
|
|
{ if (!(existe_mu_p || volumique_visqueux ))
|
||
|
|
{ Isigma = troisK * Ieps;
|
||
|
|
// on va définir un module de compressibilité tangent comme il sera utilisé par exemple
|
||
|
|
// pour la variation d'épaisseur
|
||
|
|
double delta_Isigma = troisK * (IDeps*deltat);
|
||
|
|
if (IDeps*deltat > ConstMath::petit)
|
||
|
|
{module_compressibilite = delta_Isigma * untier /(IDeps*deltat);}
|
||
|
|
else // cas où cela ne bouge pas, on choisit le module sécant
|
||
|
|
{module_compressibilite = troisK * untier;}
|
||
|
|
} // cas où il n'y a pas de viscosité sphérique
|
||
|
|
else
|
||
|
|
{ // cas ou la partie sphérique est visqueuse, comme c'est un scalaire pas de pb de type de derivée
|
||
|
|
Isigma = co2 * (IDeps + co4 * Isig_n);
|
||
|
|
if (Ieps > ConstMath::petit) {module_compressibilite = Isigma/(3. * Ieps);}
|
||
|
|
else {module_compressibilite = troisK * mu_p_coe /(mu_p_coe + troisK * deltat);};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// --- calcul de la partie déviatorique du tenseur des contraintes ----
|
||
|
|
// puis du tenseur total
|
||
|
|
// en fait dans le cas d'une linéarisation seul le transport de la contrainte à de l'importance
|
||
|
|
Tenseur2HH SHH = co1 * gijHH * (Deps_barre_BH + co3 * SBH_n );
|
||
|
|
if (seule_deviatorique)
|
||
|
|
{ sigHH = SHH; }
|
||
|
|
else
|
||
|
|
{ sigHH = SHH + (untier * Isigma) * gijHH ;};
|
||
|
|
|
||
|
|
// ---- traitement des énergies ----
|
||
|
|
energ.Inita(0.); double ener_elas=0.; double ener_visqueux = energ_t.DissipationVisqueuse();
|
||
|
|
// on peut raisonner en supposant une décomposition de la vitesse de déformation
|
||
|
|
// ... partie sphérique
|
||
|
|
if (!seule_deviatorique)
|
||
|
|
{ if (!(existe_mu_p || volumique_visqueux ))
|
||
|
|
// cas où il n'y a pas de viscosité sphérique => élasticité linéaire
|
||
|
|
// 0.5 car on considère que sur le pas sig augmente proportionnellement
|
||
|
|
{ ener_elas = 0.5 * (Isigma * Ieps); }
|
||
|
|
else if (!seule_deviatorique)
|
||
|
|
// cas où on a une partie sphérique et qu'elle contient une partie visqueuse
|
||
|
|
// I_{D_vis}=I_sig / mu*f; I_{D_elas} = I_sig / (3*K);
|
||
|
|
{ ener_elas = 0.5 * (Isigma * Isigma) / troisK; // partie élastique
|
||
|
|
if (Dabs(mu_p_coe) > ConstMath::trespetit) // partie visqueuse
|
||
|
|
{ener_visqueux += (Isigma * Isigma) * deltat / mu_p_coe;};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// ... partie déviatorique
|
||
|
|
// {si mu_coe = 0} => {SHH = 0} d'où une énergie visqueuse nulle, sinon
|
||
|
|
// on calcul D_barre_visqueux = SHH/mu_coe d'où le calcul de l'énergie qui suit
|
||
|
|
Tenseur2BH SBH = IdBB2 * SHH;
|
||
|
|
double S2= (SBH && SBH); // pour simplifier
|
||
|
|
ener_elas += 0.5 * S2 /deuxG; // partie élastique
|
||
|
|
if (Dabs(mu_coe) > ConstMath::trespetit) // partie visqueuse
|
||
|
|
{ener_visqueux += S2 * deltat / mu_coe;};
|
||
|
|
// ... mise à jour de energ
|
||
|
|
energ.ChangeEnergieElastique(ener_elas);
|
||
|
|
energ.ChangeDissipationVisqueuse(ener_visqueux);
|
||
|
|
|
||
|
|
// on libère les tenseurs intermédiaires
|
||
|
|
LibereTenseur();
|
||
|
|
};
|
||
|
|
|
||
|
|
// calcul des contraintes a t+dt et de ses variations
|
||
|
|
void Loi_maxwell2D_C::Calcul_DsigmaHH_tdt (TenseurHH& sigHH_t,TenseurBB& DepsBB_,DdlElement & tab_ddl
|
||
|
|
,BaseB& ,TenseurBB & gijBB_t,TenseurHH &
|
||
|
|
,BaseB& ,Tableau <BaseB> & ,BaseH& ,Tableau <BaseH> &
|
||
|
|
,TenseurBB & epsBB_tdt,Tableau <TenseurBB *>& d_epsBB,TenseurBB &
|
||
|
|
,TenseurBB & gijBB_tdt,TenseurHH & gijHH_tdt
|
||
|
|
,Tableau <TenseurBB *>& d_gijBB_tdt
|
||
|
|
,Tableau <TenseurHH *>& d_gijHH_tdt,double& , double&
|
||
|
|
,Vecteur& ,TenseurHH& sigHH_tdt,Tableau <TenseurHH *>& d_sigHH
|
||
|
|
,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite
|
||
|
|
,double& module_cisaillement,const Met_abstraite::Impli& ex)
|
||
|
|
{
|
||
|
|
#ifdef MISE_AU_POINT
|
||
|
|
if (DepsBB_.Dimension() != 2)
|
||
|
|
{ cout << "\nErreur : la dimension devrait etre 2 !\n";
|
||
|
|
cout << " Loi_maxwell2D_C::Calcul_DsigmaHH_tdt\n";
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
if (tab_ddl.NbDdl() != d_gijBB_tdt.Taille())
|
||
|
|
{ cout << "\nErreur : le nb de ddl est != de la taille de d_gijBB_tdt !\n";
|
||
|
|
cout << " Loi_maxwell2D_C::Calcul_SDsigmaHH_tdt\n";
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
const Tenseur2BB & epsBB = *((Tenseur2BB*) &epsBB_tdt); // passage en dim 2
|
||
|
|
const Tenseur2BB & DepsBB = *((Tenseur2BB*) &DepsBB_); // passage en dim 2
|
||
|
|
const Tenseur2HH & gijHH = *((Tenseur2HH*) &gijHH_tdt); // " " " "
|
||
|
|
const Tenseur2BB & gijBB = *((Tenseur2BB*) &gijBB_tdt); // " " " "
|
||
|
|
Tenseur2HH & sigHH = *((Tenseur2HH*) &sigHH_tdt); // " " " "
|
||
|
|
Tenseur2HH & sigHH_nn = *((Tenseur2HH*) &sigHH_t); // " " " "
|
||
|
|
// récupération de eps33 et Deps33 - ici on considère que g^33=g_33=1 !!
|
||
|
|
SaveResul_Loi_maxwell2D_C & save_resul = *((SaveResul_Loi_maxwell2D_C*) saveResul);
|
||
|
|
|
||
|
|
// tenseur intermédiaires utilisées selon les cas (par forcément dans tous les cas !!)
|
||
|
|
Tenseur2BH sigBH_n;Tenseur2HH sigHH_n; Tenseur2BB sigBB_n;Tenseur2BB sig_interBB_n;
|
||
|
|
switch (type_derive) //case 1: cas d'une dérivée de Lie deux fois contravariante : cas par défaut
|
||
|
|
{case -1: // cas d'une dérivée de jauman: 1/2 deux fois covariant + deux fois contra
|
||
|
|
{sig_interBB_n = gijBB_t * sigHH_nn * gijBB_t;
|
||
|
|
sigBH_n = 0.5*( sig_interBB_n * gijHH + gijBB * sigHH_nn) ;
|
||
|
|
sigHH_n = gijHH * sigBH_n ;
|
||
|
|
sigBB_n = sigBH_n * gijBB; break;}
|
||
|
|
case 0: // cas d'une dérivée de Lie deux fois covariantes
|
||
|
|
{sigBB_n = gijBB_t * sigHH_nn * gijBB_t;
|
||
|
|
sigBH_n = sigBB_n * gijHH ;
|
||
|
|
sigHH_n = gijHH * sigBH_n ; break;}
|
||
|
|
case 1: // cas d'une dérivée de Lie deux fois covariantes
|
||
|
|
{sigHH_n = sigHH_nn;
|
||
|
|
sigBH_n = gijBB * sigHH_n;
|
||
|
|
sigBB_n = sigBH_n * gijBB;
|
||
|
|
break;}
|
||
|
|
};
|
||
|
|
|
||
|
|
// normalement le tenseur 3D équivalent est également en contrainte plane : on a sigma_n(i,3)=0
|
||
|
|
|
||
|
|
////----debug
|
||
|
|
//cout << "\n debug Loi_maxwell2D_C::Calcul_DsigmaHH_tdt ";
|
||
|
|
//cout <<"\n sigHH_nn ";
|
||
|
|
//sigHH_nn.Ecriture(cout);
|
||
|
|
//cout <<"\n sigBB_nn ";
|
||
|
|
//sigBB_n.Ecriture(cout);
|
||
|
|
//cout <<"\n sigBH_nn ";
|
||
|
|
//sigBH_n.Ecriture(cout);
|
||
|
|
////---fin debug
|
||
|
|
|
||
|
|
// ---- calcul relatif aux déviateurs : déformations et vitesse de déformation -----
|
||
|
|
static const double untier=1./3.;
|
||
|
|
Tenseur2BH DepsBH = DepsBB * gijHH;
|
||
|
|
// recup de l'incrément de temps
|
||
|
|
double deltat=ParaGlob::Variables_de_temps().IncreTempsCourant();
|
||
|
|
double unSurDeltat=0;
|
||
|
|
if (Abs(deltat) >= ConstMath::trespetit)
|
||
|
|
{unSurDeltat = 1./deltat;}
|
||
|
|
else
|
||
|
|
// si l'incrément de temps est tres petit on remplace 1/deltat par un nombre tres grand
|
||
|
|
// {unSurDeltat = Signe(deltat)*ConstMath::tresgrand;}
|
||
|
|
{ // non un pas de temps doit être positif !! or certaine fois il peut y avoir des pb
|
||
|
|
if (unSurDeltat < 0)
|
||
|
|
{ cout << "\n le pas de temps est négatif !! "; };
|
||
|
|
unSurDeltat = ConstMath::tresgrand;
|
||
|
|
};
|
||
|
|
|
||
|
|
// on commence par définir une trace approximative qui s'appuie
|
||
|
|
// sur la valeur précédemment calculée, ceci pour calculer les fonctions éventuelles
|
||
|
|
double IDeps_imoinsun=DepsBH.Trace()+ save_resul.Deps33_t;
|
||
|
|
Tenseur2BH Deps_barre_BH = DepsBH - (untier * IDeps_imoinsun) * IdBH2;
|
||
|
|
// intégration du coeff multiplicateur de la viscosité si nécessaire
|
||
|
|
double II_D_barre=0;
|
||
|
|
double Q_Deps = 0.;
|
||
|
|
Courbe1D::ValDer valder_mu;Courbe1D::ValDer valder_E;
|
||
|
|
valder_mu.valeur = 1.; valder_mu.derivee = 0.;// initialisation par défaut
|
||
|
|
valder_E.valeur = 1.; valder_E.derivee = 0.;// initialisation par défaut
|
||
|
|
|
||
|
|
if ((depend_de_D!=0) || depend_cristalinite)
|
||
|
|
{ II_D_barre = Deps_barre_BH.II();
|
||
|
|
Q_Deps = sqrt(II_D_barre);
|
||
|
|
switch (depend_de_D)
|
||
|
|
{ case 1:valder_mu=fac_mu_cissionD->Valeur_Et_derivee(Q_Deps);break;
|
||
|
|
case 2:valder_E=fac_E_cissionD->Valeur_Et_derivee(Q_Deps);break;
|
||
|
|
case 3:valder_mu=fac_mu_cissionD->Valeur_Et_derivee(Q_Deps);
|
||
|
|
valder_E=fac_E_cissionD->Valeur_Et_derivee(Q_Deps);break;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// idem dans le cas d'une dépendance à eps
|
||
|
|
Tenseur2BH epsBH = epsBB * gijHH; // deformation en mixte
|
||
|
|
double Ieps_imoinsun = epsBH.Trace()+ save_resul.eps33_t;
|
||
|
|
double eps_mises_imoinsun = 0.;
|
||
|
|
{Tenseur2BH eps_barre_BH = epsBH - (untier * Ieps_imoinsun) * IdBH2;
|
||
|
|
double II_eps_barre = 0.; // init
|
||
|
|
if (depend_de_eps!=0)
|
||
|
|
{ II_eps_barre = eps_barre_BH.II();
|
||
|
|
eps_mises_imoinsun = sqrt(2./3. * II_eps_barre);
|
||
|
|
Courbe1D::ValDer valder_mu_inter;Courbe1D::ValDer valder_E_inter;
|
||
|
|
valder_mu_inter.valeur = 1.; valder_mu_inter.derivee = 0.;// initialisation par défaut
|
||
|
|
valder_E_inter.valeur = 1.; valder_E_inter.derivee = 0.;// initialisation par défaut
|
||
|
|
switch (depend_de_eps)
|
||
|
|
{ case 1:valder_mu_inter =fac_mu_Mises_Eps->Valeur_Et_derivee(eps_mises_imoinsun);break;
|
||
|
|
case 2:valder_E_inter =fac_E_Mises_Eps->Valeur_Et_derivee(eps_mises_imoinsun);break;
|
||
|
|
case 3:valder_mu_inter =fac_mu_Mises_Eps->Valeur_Et_derivee(eps_mises_imoinsun);
|
||
|
|
valder_E_inter =fac_E_Mises_Eps->Valeur_Et_derivee(eps_mises_imoinsun);break;
|
||
|
|
};
|
||
|
|
// calcul du résultat combiné
|
||
|
|
// pour la dérivée
|
||
|
|
valder_mu.derivee = valder_mu.valeur * valder_mu_inter.derivee
|
||
|
|
+ valder_mu.derivee * valder_mu_inter.valeur;
|
||
|
|
valder_E.derivee = valder_E.valeur * valder_E_inter.derivee
|
||
|
|
+ valder_E.derivee * valder_E_inter.valeur;
|
||
|
|
// pour la valeur finale
|
||
|
|
valder_mu.valeur *= valder_mu_inter.valeur;
|
||
|
|
valder_E.valeur *= valder_E_inter.valeur;
|
||
|
|
};
|
||
|
|
}; // fin de l'encapsulation
|
||
|
|
|
||
|
|
// --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
|
||
|
|
if (E_temperature != NULL) E = E_temperature->Valeur(*temperature);
|
||
|
|
if (depend_cristalinite) // cas d'une dépendance à la température via la cristalinité
|
||
|
|
{ double P = untier * (gijBB && sigHH); // pour la pression on utilise la trace précédente
|
||
|
|
// gamma = 2 D_12, si on a un essai de cisaillement pur en 1 2: II_D_barre = 2*(D^1_2)**2
|
||
|
|
// d'où gamm_point
|
||
|
|
double gamma_point = sqrt(2.*II_D_barre);
|
||
|
|
mu = mu_p = ViscositeCristaline(P,gamma_point);
|
||
|
|
//---- debug
|
||
|
|
// cout << " " << mu << endl;
|
||
|
|
//---- debug
|
||
|
|
}
|
||
|
|
else // sinon c'est le cas classique de dépendance ou non à la température
|
||
|
|
{if (mu_temperature != NULL) mu = mu_temperature->Valeur(*temperature);
|
||
|
|
if (mu_p_temperature != NULL) mu_p = mu_p_temperature->Valeur(*temperature);
|
||
|
|
};
|
||
|
|
// calcul des coefficients généraux de la loi 3D
|
||
|
|
double E_coe = E * valder_E.valeur; // pour simplifier
|
||
|
|
double troisK=E_coe/(1-2.*nu);
|
||
|
|
double deuxG=E_coe/(1.+nu);
|
||
|
|
double mu_coe = mu * valder_mu.valeur; // pour simplifier
|
||
|
|
double mu_p_coe = mu_p * valder_mu.valeur; // pour simplifier
|
||
|
|
double unSurmu_coe = 1./mu_coe;
|
||
|
|
double co1 = deltat * deuxG * mu_coe/(mu_coe + deuxG * deltat);
|
||
|
|
double co3 = unSurDeltat/deuxG;
|
||
|
|
|
||
|
|
// --- on détermine la déformation et la vitesse de déformation
|
||
|
|
// suivant l'axe 3 compte tenu de la condition de contrainte plane
|
||
|
|
double deuxGdeltat = deuxG * deltat;
|
||
|
|
double troisKdeltat = troisK * deltat;
|
||
|
|
double alpa = troisKdeltat * mu_p_coe/(mu_p_coe+ troisKdeltat);
|
||
|
|
double betaa = deuxGdeltat * mu_coe / (mu_coe+ deuxGdeltat);
|
||
|
|
double c1 = 0.; double c2 = 0.; double c3 = 0. ; // initialisation
|
||
|
|
double Isig_n = sigBH_n.Trace(); // vrai mais il faut garder en tête qu'il y a une opération
|
||
|
|
// de transport, donc la trace a évoluer avec le transport
|
||
|
|
// par contre la condition de contrainte plane est conservée c-a-d sigBH_n(3,i)=0
|
||
|
|
if (!(existe_mu_p))
|
||
|
|
// cas où il n'y a pas de viscosité sphérique => élasticité linéaire
|
||
|
|
// la variable de D_33 n'a pas d'importance car g_33 = g^{33}=g_3^3 = 1
|
||
|
|
{
|
||
|
|
// c1 = (betaa -troisKdeltat) / (troisKdeltat+2.*betaa);
|
||
|
|
// c2 = - 3.*betaa / ((troisKdeltat+2.*betaa) * deuxGdeltat);
|
||
|
|
// c3 = - 1. / (troisKdeltat+2.*betaa);
|
||
|
|
c1 = betaa / (troisKdeltat+2.*betaa);
|
||
|
|
c2 = - troisK / (troisKdeltat+2.*betaa);
|
||
|
|
c3 = betaa / ((troisKdeltat+2.*betaa) * deuxGdeltat);
|
||
|
|
save_resul.Deps33 = c1 * DepsBH.Trace() + c2*(epsBH.Trace()+ save_resul.eps33_t) + c3 * Isig_n;
|
||
|
|
}
|
||
|
|
else // cas où on a une partie sphérique et qu'elle contient une partie visqueuse
|
||
|
|
{
|
||
|
|
c1 = (betaa -alpa) / (alpa+2.*betaa);
|
||
|
|
c2 = - 3.*betaa / ((alpa+2.*betaa) * deuxGdeltat);
|
||
|
|
c3 = - alpa / ((alpa+2.*betaa) * troisKdeltat);
|
||
|
|
save_resul.Deps33 = c1 * epsBH.Trace() + (c3-c2/3.) * Isig_n;
|
||
|
|
}
|
||
|
|
// les coefficients ci peuvent permettrent également de calculer un opérateur tangent
|
||
|
|
|
||
|
|
// expression théorique save_resul.Deps33 = c1 * epsBH.Trace() + c2 * sigBH_n(3,3) + c3 * Isig_n;
|
||
|
|
// mais normalement sigBH_n(3,3) = 0, donc S33 = - I_sig/3
|
||
|
|
// d'où la forme (c3-c2/3.)I_sig
|
||
|
|
save_resul.eps33 = save_resul.eps33_t + save_resul.Deps33 * deltat ;
|
||
|
|
|
||
|
|
// --- on détermine la forme définitive du tenseur de def et D
|
||
|
|
double IDeps=DepsBH.Trace()+ save_resul.Deps33;
|
||
|
|
Deps_barre_BH = DepsBH - (untier * IDeps) * IdBH2;
|
||
|
|
double Ieps = epsBH.Trace()+ save_resul.eps33;
|
||
|
|
Tenseur2BH eps_barre_BH = epsBH - (untier * Ieps) * IdBH2;
|
||
|
|
////----debug
|
||
|
|
//cout << "\n debug Loi_maxwell2D_C::Calcul_DsigmaHH_tdt ";
|
||
|
|
//if (!(existe_mu_p))
|
||
|
|
// // cas où il n'y a pas de viscosité sphérique => élasticité linéaire
|
||
|
|
// // la variable de D_33 n'a pas d'importance car g_33 = g^{33}=g_3^3 = 1
|
||
|
|
// {//double sig33 = betaa * (2./3. * save_resul.Deps33 - untier *DepsBH.Trace()
|
||
|
|
// // + (- Isig_n / 3. ) /deuxGdeltat )
|
||
|
|
// // + untier * (troisKdeltat * IDeps + Isig_n);
|
||
|
|
//double sig33 = betaa * (2./3. * save_resul.Deps33 - untier *DepsBH.Trace()
|
||
|
|
// - (Isig_n/3.) /deuxGdeltat )
|
||
|
|
//// + untier * troisKdeltat * Ieps;
|
||
|
|
// + untier * troisK * (epsBH.Trace() + save_resul.eps33_t + save_resul.Deps33 * deltat);
|
||
|
|
//double D33_s = (betaa-troisKdeltat)/(troisKdeltat+2.*betaa)*DepsBH.Trace();
|
||
|
|
//cout << "\n sig33= "<<sig33 << " save_resul.Deps33= "<<save_resul.Deps33
|
||
|
|
// << " D33_s= "<<D33_s
|
||
|
|
// << " save_resul.eps33= "<<save_resul.eps33
|
||
|
|
// << "\n Isig_n= "<<Isig_n<< " eps_1^1= "<<epsBH(1,1)<< " eps_2^2= "<<epsBH(2,2)<< " IDeps= "<< IDeps
|
||
|
|
// << endl;
|
||
|
|
// }
|
||
|
|
//else
|
||
|
|
// {double sig33 = betaa * (2./3. * save_resul.Deps33 - untier *DepsBH.Trace() )
|
||
|
|
// + untier * alpa * (IDeps + Isig_n / troisKdeltat);
|
||
|
|
////double D33_s = (betaa-troisKdeltat)/(troisKdeltat+2.*betaa)*DepsBH.Trace();
|
||
|
|
//cout << "\n sig33= "<<sig33 << " save_resul.Deps33= "<<save_resul.Deps33
|
||
|
|
// << " save_resul.eps33= "<<save_resul.eps33
|
||
|
|
//// << " D33_s= "<<D33_s
|
||
|
|
// << "\n Isig_n= "<<Isig_n << " IDeps= "<< IDeps
|
||
|
|
// << endl;
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
////--- fin debug
|
||
|
|
|
||
|
|
// --- on peut maintenant utiliser les relations générales 3D
|
||
|
|
|
||
|
|
// cas d'une viscosité sur la partie sphérique et le fait que la partie sphérique est prise en compte
|
||
|
|
double co2=0.; double co4=0.;
|
||
|
|
if (((existe_mu_p) ||(volumique_visqueux)) && (!seule_deviatorique))
|
||
|
|
{ co2=deltat * troisK * mu_p_coe /(mu_p_coe + troisK * deltat); // ne sert pas toujours
|
||
|
|
co4 = unSurDeltat/troisK;
|
||
|
|
};
|
||
|
|
|
||
|
|
// ---- calcul de la partie sphérique du tenseur des contraintes -----
|
||
|
|
Tenseur2BH SBH_n = sigBH_n - (untier * Isig_n) * IdBH2; // bien voir que SBH_n(3,3) est non nul
|
||
|
|
// comme le transport n'affecte pas la condition de contrainte plane,
|
||
|
|
// on a SBH_n(3,3) = - (untier * Isig_n)
|
||
|
|
// et SBH_n est bien un tenseur déviatorique
|
||
|
|
|
||
|
|
// cas de la partie sphérique
|
||
|
|
double Isigma=0;module_compressibilite=0.;
|
||
|
|
if (!seule_deviatorique)
|
||
|
|
{ if (!(existe_mu_p || volumique_visqueux ))
|
||
|
|
{ Isigma = troisK * Ieps;
|
||
|
|
// on va définir un module de compressibilité tangent comme il sera utilisé par exemple
|
||
|
|
// pour la variation d'épaisseur
|
||
|
|
double delta_Isigma = troisK * (IDeps*deltat);
|
||
|
|
if (IDeps*deltat > ConstMath::petit)
|
||
|
|
{module_compressibilite = delta_Isigma * untier /(IDeps*deltat);}
|
||
|
|
else // cas où cela ne bouge pas, on choisit le module sécant
|
||
|
|
{module_compressibilite = troisK * untier;}
|
||
|
|
} // cas où il n'y a pas de viscosité sphérique
|
||
|
|
else
|
||
|
|
{ // cas ou la partie sphérique est visqueuse, comme c'est un scalaire pas de pb de type de derivée
|
||
|
|
Isigma = co2 * (IDeps + co4 * Isig_n);
|
||
|
|
if (Ieps > ConstMath::petit) {module_compressibilite = Isigma/(3. * Ieps);}
|
||
|
|
else {module_compressibilite = troisK * mu_p_coe /(mu_p_coe + troisK * deltat);};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
////----debug
|
||
|
|
//cout << "\n debug Loi_maxwell2D_C::Calcul_DsigmaHH_tdt ";
|
||
|
|
//double delta_vol = Isigma/3. / module_compressibilite;
|
||
|
|
//double epaisseur = (* ex.jacobien_0) / ((*ex.jacobien_tdt) * (1.- delta_vol));
|
||
|
|
//cout << "\n epaisseur= "<<epaisseur << " Ieps= " << Ieps << " delta_vol= "<<delta_vol<< " Isigma= "<<Isigma
|
||
|
|
// << "\n (* ex.jacobien_0)= "<< (* ex.jacobien_0) << " (*ex.jacobien_tdt)= " << (*ex.jacobien_tdt)
|
||
|
|
// << " module_compressibilite= "<< module_compressibilite << endl;
|
||
|
|
//
|
||
|
|
////--- fin debug
|
||
|
|
|
||
|
|
// --- calcul de la partie déviatorique du tenseur des contraintes ----
|
||
|
|
// puis du tenseur total
|
||
|
|
// en fait dans le cas d'une linéarisation seul le transport de la contrainte à de l'importance
|
||
|
|
// Tenseur2BH SBH = co1 * (Deps_barre_BH + co3 * SBH_n ) ;
|
||
|
|
// ensuite pour changer de variance il faut la forme complète 3D du tenseur donc
|
||
|
|
// Tenseur3BH S3BH; S3BH
|
||
|
|
|
||
|
|
|
||
|
|
Tenseur2HH SHH = co1 * gijHH * (Deps_barre_BH + co3 * SBH_n ) ;
|
||
|
|
if (seule_deviatorique)
|
||
|
|
{ sigHH = SHH; }
|
||
|
|
else
|
||
|
|
{ sigHH = SHH + (untier * Isigma) * gijHH ;};
|
||
|
|
////----debug
|
||
|
|
//cout << "\n debug Loi_maxwell2D_C::Calcul_DsigmaHH_tdt ";
|
||
|
|
////Tenseur2BH SBH = co1 * (Deps_barre_BH + co3 * SBH_n ) ;
|
||
|
|
////Tenseur2BH sogBH = SBH + (untier * Isigma) * ;
|
||
|
|
//double sigo33 = (untier * Isigma) + co1 * (save_resul.Deps33 - IDeps/3 - co3 * Isig_n / 3.);
|
||
|
|
//
|
||
|
|
//double Isigma_2 = sigHH && gijBB;
|
||
|
|
//double truc = gijHH && gijBB;
|
||
|
|
//cout << "\n Isigma_2= "<<Isigma_2 << " gijHH && gijBB= "<< truc
|
||
|
|
// << " SHH && gijBB= " << (SHH && gijBB)
|
||
|
|
// << " (sigHH * gijBB).Trace()=" << (sigHH * gijBB).Trace()
|
||
|
|
// << " sigo33= " << sigo33
|
||
|
|
// << endl;
|
||
|
|
//
|
||
|
|
////--- fin debug
|
||
|
|
|
||
|
|
|
||
|
|
// ---- maintenant calcul de l'opérateur tangent -----
|
||
|
|
// remarque : même dans le cas d'une cristalinité, on ne tiens pas compte de la variation de mu
|
||
|
|
// par rapport aux ddl
|
||
|
|
int nbddl = d_gijBB_tdt.Taille();
|
||
|
|
Tenseur2BH d_DepsBH,d_Deps_barre_BH; // tenseurs de travail
|
||
|
|
Tenseur2BH d_epsBH,d_eps_barre_BH; // tenseurs de travail
|
||
|
|
|
||
|
|
Tenseur2BH dsigBH_n,d_SBH_n; // tenseurs de travail
|
||
|
|
Tenseur_ns2HH d_SHH; // tenseurs de travail
|
||
|
|
double racine_2tier = sqrt(2./3.);
|
||
|
|
|
||
|
|
// maintenant calcul de l'opérateur tangent
|
||
|
|
for (int i = 1; i<= nbddl; i++)
|
||
|
|
{// on fait uniquement une égalité d'adresse pour ne pas utiliser
|
||
|
|
// le constructeur d'ou la profusion d'* et de ()
|
||
|
|
Tenseur2HH & dsigHH = *((Tenseur2HH*) (d_sigHH(i))); // passage en dim 2
|
||
|
|
const Tenseur2BB & dgijBB = *((Tenseur2BB*)(d_gijBB_tdt(i))); // passage en dim 2
|
||
|
|
const Tenseur2HH & dgijHH = *((Tenseur2HH*)(d_gijHH_tdt(i))) ; // pour simplifier l'ecriture
|
||
|
|
const Tenseur2BB & depsBB = *((Tenseur2BB *) (d_epsBB(i))); // "
|
||
|
|
// variation de la vitesse de déformation uniquement ici pour la partie 2D
|
||
|
|
d_DepsBH = ( unSurDeltat) * depsBB * gijHH + DepsBB * dgijHH;
|
||
|
|
d_epsBH = depsBB * gijHH + epsBB * dgijHH;
|
||
|
|
// variation de la trace 2D
|
||
|
|
double d_IDeps_2D = d_DepsBH.Trace();
|
||
|
|
// idem pour la déformation
|
||
|
|
double d_Ieps_2D = d_epsBH.Trace();
|
||
|
|
|
||
|
|
// variation de sigma_n
|
||
|
|
switch (type_derive)
|
||
|
|
{ case -1: // // cas d'une dérivée de jauman: 1/2 deux fois covariant + deux fois contra
|
||
|
|
{// pour info sigBH_n = 0.5*(gijBB * sigHH_n + (gijBB_t * sigHH_n * gijBB_t) * gijHH)
|
||
|
|
dsigBH_n = 0.5*(sig_interBB_n * dgijHH + dgijBB * sigHH_nn );
|
||
|
|
break;}
|
||
|
|
case 0: // cas d'une dérivée de Lie deux fois covariantes
|
||
|
|
{// pour info sigBH_n = (gijBB_t * sigHH_n * gijBB_t) * gijHH
|
||
|
|
dsigBH_n = sigBB_n * dgijHH;
|
||
|
|
break;}
|
||
|
|
case 1: // cas d'une dérivée de Lie deux fois contravariantes
|
||
|
|
{// pour info sigBH_n = gijBB * sigHH_n
|
||
|
|
dsigBH_n = dgijBB * sigHH_n; break;}
|
||
|
|
};
|
||
|
|
// variation de la trace de sigma_n due au transport
|
||
|
|
// sig33 n'intervient pas car il est nul à cause de la condition de contrainte plane
|
||
|
|
double dIsig_n = dsigBH_n.Trace();
|
||
|
|
// variation du déviateur due au transport
|
||
|
|
d_SBH_n = dsigBH_n - (untier * dIsig_n) * IdBH2;
|
||
|
|
|
||
|
|
// -- variation de D33
|
||
|
|
double d_D33 = 0.; // init
|
||
|
|
if (!(existe_mu_p))
|
||
|
|
// cas où il n'y a pas de viscosité sphérique => élasticité linéaire
|
||
|
|
// la variable de D_33 n'a pas d'importance car g_33 = g^{33}=g_3^3 = 1
|
||
|
|
{d_D33 = c1 * d_IDeps_2D + c2*d_Ieps_2D + c3 * dIsig_n;
|
||
|
|
}
|
||
|
|
else // cas où on a une partie sphérique et qu'elle contient une partie visqueuse
|
||
|
|
{d_D33 = c1 * d_IDeps_2D + (c3-c2/3.) * dIsig_n;
|
||
|
|
};
|
||
|
|
|
||
|
|
// double d_D33 = c1 * d_IDeps_2D + (c3-c2/3.) * dIsig_n;
|
||
|
|
// double d_D33 = c1 * d_IDeps_2D + c2*d_Ieps_2D + c3 * dIsig_n;
|
||
|
|
|
||
|
|
double d_eps33 = d_D33 * deltat ;
|
||
|
|
// -- variation complète des tenseurs eps et D
|
||
|
|
// IDeps=DepsBH.Trace()+ save_resul.Deps33;
|
||
|
|
// Deps_barre_BH = DepsBH - (untier * IDeps) * IdBH2;
|
||
|
|
// Ieps = epsBH.Trace()+ save_resul.eps33;
|
||
|
|
// eps_barre_BH = epsBH - (untier * Ieps) * IdBH2;
|
||
|
|
double d_IDeps = d_IDeps_2D + d_D33;
|
||
|
|
// variation du déviateur
|
||
|
|
d_Deps_barre_BH = d_DepsBH - (d_IDeps/3.) * IdBH2;
|
||
|
|
|
||
|
|
// -- variation de la trace de sigma actuel
|
||
|
|
double dIsigma = 0; // initialisation
|
||
|
|
if (!seule_deviatorique)
|
||
|
|
{ if (!(existe_mu_p || volumique_visqueux ))
|
||
|
|
{ dIsigma = troisK * d_IDeps * deltat;} // cas où il n'y a pas de viscosité sphérique
|
||
|
|
else // cas ou la partie sphérique est visqueuse, comme c'est un scalaire pas de pb de type de derivée
|
||
|
|
{ dIsigma = co2 * (d_IDeps + co4 *dIsig_n);}
|
||
|
|
};
|
||
|
|
// variation du déviateur des contraintes
|
||
|
|
d_SHH = co1 * dgijHH * (Deps_barre_BH + SBH_n * co3)
|
||
|
|
+co1 * gijHH * (d_Deps_barre_BH + d_SBH_n * co3);
|
||
|
|
|
||
|
|
// -- si la viscosité et/ou le module d'young est dépendant de D, il faut tenir compte de la variation des coefs
|
||
|
|
// si la vitesse de déformation est nulle on aura une division par zéro dans les formules de dérivation
|
||
|
|
// du au fait que Q_Deps = à la racine carré de (Deps:Deps), d'où le test
|
||
|
|
if ((Q_Deps > ConstMath::pasmalpetit)&&(depend_de_D != 0))
|
||
|
|
{ double d_Q_Deps = ((d_Deps_barre_BH && Deps_barre_BH) + (Deps_barre_BH && d_Deps_barre_BH)) / (2.*Q_Deps);
|
||
|
|
double d_coe_mu = 0.;
|
||
|
|
// préparation du cas où il y a de la viscosité dépendante de Q_Deps
|
||
|
|
if ((depend_de_D == 1) || (depend_de_D == 3))
|
||
|
|
d_coe_mu = valder_mu.derivee * d_Q_Deps;
|
||
|
|
double un_sur_mu_plus_deuxG_foic_deltat = 1./(mu_coe + deuxG * deltat); // pour simplifier
|
||
|
|
|
||
|
|
// cas ou mu et/ou mu_p dépend de D
|
||
|
|
if ((depend_de_D==1)||(depend_de_D==3))
|
||
|
|
{ // == tout d'abord la partie déviatorique
|
||
|
|
// variation du coef multiplicatif de la viscosité
|
||
|
|
// co1 = deltat * deuxG * mu_coe/(mu_coe + deuxG * deltat);
|
||
|
|
double d_co1 = deltat * deuxG * mu * d_coe_mu *
|
||
|
|
( 1. - mu_coe * un_sur_mu_plus_deuxG_foic_deltat) * un_sur_mu_plus_deuxG_foic_deltat;
|
||
|
|
// l'élément à ajouter est proportionnel à SHH, donc au lieu de recalculer le tenseur on divise par co1
|
||
|
|
// SHH = co1 * gijHH * (Deps_barre_BH + co3 * SBH_n );
|
||
|
|
d_SHH += (d_co1/co1) * SHH;
|
||
|
|
// == maintenant éventuellement la partie sphérique si elle est visqueuse
|
||
|
|
if (!seule_deviatorique && (existe_mu_p || volumique_visqueux ))
|
||
|
|
{ double d_mu_p_coe = mu_p * d_coe_mu;
|
||
|
|
//Isigma = co2 * (IDeps + co4 * Isig_n);
|
||
|
|
//co2=deltat * troisK * mu_p_coe /(mu_p_coe + troisK * deltat);
|
||
|
|
double d_co2 = deltat * troisK * d_mu_p_coe * (1. - mu_p_coe / (mu_p_coe + troisK * deltat))
|
||
|
|
/(mu_p_coe + troisK * deltat);
|
||
|
|
//Isigma = co2 * (IDeps + co4 * Isig_n);
|
||
|
|
dIsigma += d_co2 * (IDeps + co4 * Isig_n);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// cas variation du coef multiplicatif de E
|
||
|
|
if (((depend_de_D==2)||(depend_de_D==3))&&(!seule_deviatorique))
|
||
|
|
{ double d_coe_E = valder_E.derivee * d_Q_Deps;
|
||
|
|
double d_troisK=E * d_coe_E /(1.-2.*nu);
|
||
|
|
double d_deuxG = E / (1.+nu) * d_coe_E;
|
||
|
|
// == tout d'abord la partie déviatorique
|
||
|
|
// SHH = co1 * gijHH * (Deps_barre_BH + co3 * SBH_n );
|
||
|
|
// co1 = deltat * deuxG * mu_coe/(mu_coe + deuxG * deltat);
|
||
|
|
double d_co1 = deltat * d_deuxG * mu_coe *
|
||
|
|
(1.- troisK * un_sur_mu_plus_deuxG_foic_deltat ) * un_sur_mu_plus_deuxG_foic_deltat;
|
||
|
|
// l'élément à ajouter est proportionnel à SHH, donc au lieu de recalculer le tenseur on divise par co1
|
||
|
|
d_SHH += (d_co1/co1) * SHH;
|
||
|
|
// on a également G donc deuxG donc co3 qui dépend de E; co3 = unSurDeltat/deuxG
|
||
|
|
double d_co3 = -d_deuxG*unSurDeltat/deuxG/deuxG;
|
||
|
|
d_SHH += (co1 * d_co3) * gijHH * SBH_n;
|
||
|
|
|
||
|
|
// == maintenant la partie sphérique si elle existe
|
||
|
|
if (!seule_deviatorique)
|
||
|
|
// on choisit entre non visqueux et visqueux
|
||
|
|
{ if (!(existe_mu_p || volumique_visqueux ))
|
||
|
|
//Isigma = troisK * Ieps;
|
||
|
|
{ dIsigma += d_troisK * Ieps;}
|
||
|
|
else // cas ou la partie sphérique est visqueuse, comme c'est un scalaire pas de pb de type de derivée
|
||
|
|
//Isigma = co2 * (IDeps + co4 * Isig_n);
|
||
|
|
{ //co2=deltat * troisK * mu_p_coe /(mu_p_coe + troisK * deltat);
|
||
|
|
double d_co2 = deltat * d_troisK * mu_p_coe * (1. - deltat*troisK / (mu_p_coe + troisK * deltat))
|
||
|
|
/(mu_p_coe + troisK * deltat);
|
||
|
|
//co4 = unSurDeltat/troisK;
|
||
|
|
double d_co4 = - unSurDeltat * d_troisK / (troisK*troisK);
|
||
|
|
dIsigma += d_co2 * (IDeps + co4 * Isig_n)
|
||
|
|
+ co2 * d_co4 * Isig_n;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// -- si la viscosité et/ou le module d'young est dépendant de eps, il faut tenir compte de la variation des coefs
|
||
|
|
// si la déformation est nulle on aura une division par zéro dans les formules de dérivation
|
||
|
|
// du au fait que eps_mises_imoinsun = à la racine carré de (eps:eps), d'où le test
|
||
|
|
if ((eps_mises_imoinsun > ConstMath::pasmalpetit)&&(depend_de_eps != 0))
|
||
|
|
{ // on calcul la variation en fonction de eps, via d_Deps, et on multipli par delta_t
|
||
|
|
double d_eps_mises_imoinsun = racine_2tier * deltat * 0.5 /eps_mises_imoinsun *
|
||
|
|
((d_Deps_barre_BH && eps_barre_BH) + (eps_barre_BH && d_Deps_barre_BH)) ;
|
||
|
|
double d_coe_mu = 0.;
|
||
|
|
// préparation du cas où il y a de la viscosité dépendante de eps_mises_imoinsun
|
||
|
|
if ((depend_de_eps == 1) || (depend_de_eps == 3))
|
||
|
|
d_coe_mu = valder_mu.derivee * d_eps_mises_imoinsun;
|
||
|
|
double un_sur_mu_plus_deuxG_foic_deltat = 1./(mu_coe + deuxG * deltat); // pour simplifier
|
||
|
|
|
||
|
|
// cas ou mu et/ou mu_p dépend de eps_mises_imoinsun
|
||
|
|
if ((depend_de_eps==1)||(depend_de_eps==3))
|
||
|
|
{ // == tout d'abord la partie déviatorique
|
||
|
|
// variation du coef multiplicatif de la viscosité
|
||
|
|
// co1 = deltat * deuxG * mu_coe/(mu_coe + deuxG * deltat);
|
||
|
|
double d_co1 = deltat * deuxG * mu * d_coe_mu *
|
||
|
|
( 1. - mu_coe * un_sur_mu_plus_deuxG_foic_deltat) * un_sur_mu_plus_deuxG_foic_deltat;
|
||
|
|
// l'élément à ajouter est proportionnel à SHH, donc au lieu de recalculer le tenseur on divise par co1
|
||
|
|
// SHH = co1 * gijHH * (Deps_barre_BH + co3 * SBH_n );
|
||
|
|
d_SHH += (d_co1/co1) * SHH;
|
||
|
|
// == maintenant éventuellement la partie sphérique si elle est visqueuse
|
||
|
|
if (!seule_deviatorique && (existe_mu_p || volumique_visqueux ))
|
||
|
|
{ double d_mu_p_coe = mu_p * d_coe_mu;
|
||
|
|
//Isigma = co2 * (IDeps + co4 * Isig_n);
|
||
|
|
//co2=deltat * troisK * mu_p_coe /(mu_p_coe + troisK * deltat);
|
||
|
|
double d_co2 = deltat * troisK * d_mu_p_coe * (1. - mu_p_coe / (mu_p_coe + troisK * deltat))
|
||
|
|
/(mu_p_coe + troisK * deltat);
|
||
|
|
//Isigma = co2 * (IDeps + co4 * Isig_n);
|
||
|
|
dIsigma += d_co2 * (IDeps + co4 * Isig_n);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// cas variation du coef multiplicatif de E
|
||
|
|
if (((depend_de_eps==2)||(depend_de_eps==3))&&(!seule_deviatorique))
|
||
|
|
{ double d_coe_E = valder_E.derivee * d_eps_mises_imoinsun;
|
||
|
|
double d_troisK=E * d_coe_E /(1.-2.*nu);
|
||
|
|
double d_deuxG = E / (1.+nu) * d_coe_E;
|
||
|
|
// == tout d'abord la partie déviatorique
|
||
|
|
// SHH = co1 * gijHH * (Deps_barre_BH + co3 * SBH_n );
|
||
|
|
// co1 = deltat * deuxG * mu_coe/(mu_coe + deuxG * deltat);
|
||
|
|
double d_co1 = deltat * d_deuxG * mu_coe *
|
||
|
|
(1.- troisK * un_sur_mu_plus_deuxG_foic_deltat ) * un_sur_mu_plus_deuxG_foic_deltat;
|
||
|
|
// l'élément à ajouter est proportionnel à SHH, donc au lieu de recalculer le tenseur on divise par co1
|
||
|
|
d_SHH += (d_co1/co1) * SHH;
|
||
|
|
// on a également G donc deuxG donc co3 qui dépend de E; co3 = unSurDeltat/deuxG
|
||
|
|
double d_co3 = -d_deuxG*unSurDeltat/deuxG/deuxG;
|
||
|
|
d_SHH += (co1 * d_co3) * gijHH * SBH_n;
|
||
|
|
|
||
|
|
// == maintenant la partie sphérique si elle existe
|
||
|
|
if (!seule_deviatorique)
|
||
|
|
// on choisit entre non visqueux et visqueux
|
||
|
|
{ if (!(existe_mu_p || volumique_visqueux ))
|
||
|
|
//Isigma = troisK * Ieps;
|
||
|
|
{ dIsigma += d_troisK * Ieps;}
|
||
|
|
else // cas ou la partie sphérique est visqueuse, comme c'est un scalaire pas de pb de type de derivée
|
||
|
|
//Isigma = co2 * (IDeps + co4 * Isig_n);
|
||
|
|
{ //co2=deltat * troisK * mu_p_coe /(mu_p_coe + troisK * deltat);
|
||
|
|
double d_co2 = deltat * d_troisK * mu_p_coe * (1. - deltat*troisK / (mu_p_coe + troisK * deltat))
|
||
|
|
/(mu_p_coe + troisK * deltat);
|
||
|
|
//co4 = unSurDeltat/troisK;
|
||
|
|
double d_co4 = - unSurDeltat * d_troisK / (troisK*troisK);
|
||
|
|
dIsigma += d_co2 * (IDeps + co4 * Isig_n)
|
||
|
|
+ co2 * d_co4 * Isig_n;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
if (seule_deviatorique) { dsigHH = d_SHH; }
|
||
|
|
else
|
||
|
|
{ dsigHH = d_SHH + (untier * dIsigma) * gijHH
|
||
|
|
+ (untier * Isigma) * dgijHH ;};
|
||
|
|
};
|
||
|
|
// ---- traitement des énergies ----
|
||
|
|
energ.Inita(0.); double ener_elas=0.; double ener_visqueux = energ_t.DissipationVisqueuse();
|
||
|
|
// on peut raisonner en supposant une décomposition de la vitesse de déformation
|
||
|
|
// ... partie sphérique
|
||
|
|
if (!seule_deviatorique)
|
||
|
|
{ if (!(existe_mu_p || volumique_visqueux ))
|
||
|
|
// cas où il n'y a pas de viscosité sphérique => élasticité linéaire
|
||
|
|
// 0.5 car on considère que sur le pas sig augmente proportionnellement
|
||
|
|
{ ener_elas = 0.5 * (Isigma * Ieps); }
|
||
|
|
else if (!seule_deviatorique)
|
||
|
|
// cas où on a une partie sphérique et qu'elle contient une partie visqueuse
|
||
|
|
// I_{D_vis}=I_sig / mu*f; I_{D_elas} = I_sig / (3*K);
|
||
|
|
{ ener_elas = 0.5 * (Isigma * Isigma) / troisK; // partie élastique
|
||
|
|
if (Dabs(mu_p_coe) > ConstMath::trespetit) // partie visqueuse
|
||
|
|
{ener_visqueux += (Isigma * Isigma) * deltat / mu_p_coe;};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// ... partie déviatorique
|
||
|
|
// {si mu_coe = 0} => {SHH = 0} d'où une énergie visqueuse nulle, sinon
|
||
|
|
// on calcul D_barre_visqueux = SHH/mu_coe d'où le calcul de l'énergie qui suit
|
||
|
|
Tenseur2BH SBH = IdBB2 * SHH;
|
||
|
|
double S2= (SBH && SBH); // pour simplifier
|
||
|
|
ener_elas += 0.5 * S2 /deuxG; // partie élastique
|
||
|
|
if (Dabs(mu_coe) > ConstMath::trespetit) // partie visqueuse
|
||
|
|
{ener_visqueux += S2 * deltat / mu_coe;};
|
||
|
|
// ... mise à jour de energ
|
||
|
|
energ.ChangeEnergieElastique(ener_elas);
|
||
|
|
energ.ChangeDissipationVisqueuse(ener_visqueux);
|
||
|
|
|
||
|
|
// on libère les tenseurs intermédiaires
|
||
|
|
LibereTenseur();
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
// activation des données des noeuds et/ou elements nécessaires au fonctionnement de la loi
|
||
|
|
// ici concerne de la vérification d'existence, mais c'est appelé une fois, c'est ça l'intérêt
|
||
|
|
void Loi_maxwell2D_C::Activation_donnees(Tableau<Noeud *>& tabnoeud,bool ,LesPtIntegMecaInterne& lesPtMecaInt)
|
||
|
|
{ // on vérifie l'existance de la critallinité au noeud si nécessaire
|
||
|
|
if (depend_cristalinite)
|
||
|
|
{ if (crista_aux_noeuds)
|
||
|
|
{ int nbnoeud = tabnoeud.Taille();
|
||
|
|
for (int i=1;i<=nbnoeud;i++)
|
||
|
|
{ // on vérifie que la variable type_grandeur existe sinon erreur
|
||
|
|
if ((tabnoeud(i)->Existe_ici(PROP_CRISTA)))
|
||
|
|
{tabnoeud(i)->Met_en_service(PROP_CRISTA);}
|
||
|
|
else
|
||
|
|
{ cout << "\n erreur: la grandeur " << Nom_ddl(PROP_CRISTA) << " n'existe pas "
|
||
|
|
<< " il n'est pas possible d'utiliser une loi de maxwell avec cette grandeur supposee"
|
||
|
|
<< " definie aux noeuds. Il manque sans doute des donnees !!! "
|
||
|
|
<< "\n Loi_maxwell2D_C::Activation_donnees(...";
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// appel de la méthode de la classe mère
|
||
|
|
Loi_comp_abstraite::Activ_donnees(tabnoeud,dilatation,lesPtMecaInt);
|
||
|
|
};
|
||
|
|
|
||
|
|
//---------------------------------------- méthodes internes ----------------------------------
|
||
|
|
|
||
|
|
// calcul récup de la cristalinité si besoin est
|
||
|
|
void Loi_maxwell2D_C::CalculGrandeurTravail
|
||
|
|
(const PtIntegMecaInterne&
|
||
|
|
,const Deformation & def,Enum_dure temps,const ThermoDonnee& dTP
|
||
|
|
,const Met_abstraite::Impli* ex_impli
|
||
|
|
,const Met_abstraite::Expli_t_tdt* ex_expli_tdt
|
||
|
|
,const Met_abstraite::Umat_cont* ex_umat
|
||
|
|
,const List_io<Ddl_etendu>* exclure_dd_etend
|
||
|
|
,const List_io<const TypeQuelconque *>* exclure_Q
|
||
|
|
)
|
||
|
|
{ // récupération éventuelle de la cristalinité
|
||
|
|
if (depend_cristalinite)
|
||
|
|
{ if (crista_aux_noeuds)
|
||
|
|
// cas d'une proportion provenant d'une interpolation aux noeuds
|
||
|
|
{ taux_crista = def.DonneeInterpoleeScalaire(PROP_CRISTA,temps); }
|
||
|
|
else
|
||
|
|
{
|
||
|
|
#ifdef MISE_AU_POINT
|
||
|
|
if (dTP.TauxCrista() == NULL)
|
||
|
|
{cout << "\n erreur, le taux de cristalinite n'est pas disponible au point d'integration "
|
||
|
|
<< " il n'est pas possible de calculer la viscosite dependante de la cristalinite "
|
||
|
|
<< "\n Loi_maxwell2D_C::CalculGrandeurTravail(.... ";
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
taux_crista= *dTP.TauxCrista();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// calcul de la viscosité dépendante de la cristalinité
|
||
|
|
double Loi_maxwell2D_C::ViscositeCristaline(double & P, double & gamma_point)
|
||
|
|
{ double A2p= At2 + D3 * P;
|
||
|
|
double TmoinsTstar = (*temperature)-(D2+D3);
|
||
|
|
double mu0_TP = D1 * exp(-(A1*TmoinsTstar)/(A2p + TmoinsTstar));
|
||
|
|
// on essaie de limiter l'exponentiel
|
||
|
|
// double mu0_TP_alpha = mu0_TP * exp(C1*taux_crista*taux_crista);
|
||
|
|
// on choisit limite maxi exp() à exp(20)
|
||
|
|
double mu0_TP_alpha = mu0_TP * exp(20.*tanh(C1*taux_crista*taux_crista/20.));
|
||
|
|
|
||
|
|
|
||
|
|
double mu_TP_alpha = mu0_TP_alpha / (1.+ pow((mu0_TP_alpha * gamma_point/tauStar),(1.-nc)));
|
||
|
|
//---- debug
|
||
|
|
// if (mu_TP_alpha > 1.e10)
|
||
|
|
// cout << " " << mu << " " << taux_crista << " " << endl;
|
||
|
|
//---- debug
|
||
|
|
return mu_TP_alpha;
|
||
|
|
};
|
||
|
|
|
||
|
|
|