2290 lines
104 KiB
C++
2290 lines
104 KiB
C++
// FICHIER : Hypo_hooke3D.cc
|
|
// CLASSE : Hypo_hooke3D
|
|
|
|
|
|
// This file is part of the Herezh++ application.
|
|
//
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
// of mechanics for large transformations of solid structures.
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
//
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
//
|
|
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
|
// AUTHOR : Gérard Rio
|
|
// E-MAIL : gerardrio56@free.fr
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License,
|
|
// or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
//
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
|
|
|
|
|
//#include "Debug.h"
|
|
|
|
# include <iostream>
|
|
using namespace std; //introduces namespace std
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
#include "Sortie.h"
|
|
#include "TypeConsTens.h"
|
|
#include "ParaGlob.h"
|
|
#include "ConstMath.h"
|
|
#include "TypeQuelconqueParticulier.h"
|
|
#include "CharUtil.h"
|
|
|
|
|
|
#include "Hypo_hooke3D.h"
|
|
|
|
// constructeur par défaut à ne pas utiliser
|
|
Hypo_hooke3D::SaveResulLoi_Hypo3D::SaveResulLoi_Hypo3D() :
|
|
Kc(0.),Kc_t(0.),mu(0.),mu_t(0.),eps_cumulBB(),eps_cumulBB_t()
|
|
{ cout << "\n erreur, le constructeur par defaut ne doit pas etre utilise !"
|
|
<< "\n Hypo_hooke3D::SaveResulLoi_Hypo3D::SaveResulLoi_Hypo3D()";
|
|
Sortie(1);
|
|
};
|
|
|
|
// le constructeur courant
|
|
Hypo_hooke3D::SaveResulLoi_Hypo3D::SaveResulLoi_Hypo3D
|
|
(SaveResul* ):
|
|
Kc(0.),Kc_t(0.),mu(0.),mu_t(0.),eps_cumulBB(),eps_cumulBB_t()
|
|
{ };
|
|
|
|
|
|
// 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 Hypo_hooke3D::SaveResulLoi_Hypo3D::Lecture_base_info
|
|
(istream& ent,const int cas)
|
|
{ // ici toutes les données sont toujours a priori variables
|
|
// ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas
|
|
string toto; ent >> toto;
|
|
#ifdef MISE_AU_POINT
|
|
if (toto != "HYPO_E_ISO_3D")
|
|
{ cout << "\n erreur en lecture du conteneur pour la loi 3D, on a lue: "
|
|
<<toto
|
|
<< " au lieu de HYPO_E_ISO_3D "
|
|
<< " \n Hypo_hooke3D::SaveResulLoi_Hypo3D::Lecture_base_info(..";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
|
|
// lecture des données de la loi
|
|
ent >> toto >> Kc >> toto >> mu
|
|
>> toto >> eps_cumulBB;
|
|
Kc_t = Kc; mu_t=mu;eps_cumulBB_t = eps_cumulBB;
|
|
};
|
|
|
|
|
|
// cas donne le niveau de sauvegarde
|
|
// = 1 : on sauvegarde tout
|
|
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
|
|
void Hypo_hooke3D::SaveResulLoi_Hypo3D::Ecriture_base_info
|
|
(ostream& sort,const int cas)
|
|
{ // ici toutes les données sont toujours a priori variables
|
|
// ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas
|
|
sort << "\n HYPO_E_ISO_3D ";
|
|
// données de la loi
|
|
sort << "\n Kc= "<< Kc << " mu= " << mu
|
|
<< " eps_cumulBB= "<<eps_cumulBB
|
|
<< " ";
|
|
};
|
|
|
|
//changement de base de toutes les grandeurs internes tensorielles stockées
|
|
// beta(i,j) represente les coordonnees de la nouvelle base naturelle gpB dans l'ancienne gB
|
|
// gpB(i) = beta(i,j) * gB(j), i indice de ligne, j indice de colonne
|
|
// gpH(i) = gamma(i,j) * gH(j)
|
|
void Hypo_hooke3D::SaveResulLoi_Hypo3D::ChBase_des_grandeurs(const Mat_pleine& beta,const Mat_pleine& gamma)
|
|
{ // on ne s'intéresse qu'aux grandeurs tensorielles
|
|
// cas de la déformation cumulée associée au type d'intégration
|
|
eps_cumulBB.ChBase(beta);
|
|
eps_cumulBB_t.ChBase(beta);
|
|
};
|
|
// def d'une instance de données spécifiques, et initialisation
|
|
Hypo_hooke3D::SaveResul * Hypo_hooke3D::New_et_Initialise()
|
|
{ // on crée éventuellement le conteneur pour la loi
|
|
SaveResul* le_SaveResul = NULL;
|
|
// on ramène la bonne instance
|
|
Hypo_hooke3D::SaveResul * retour = new Hypo_hooke3D::SaveResulLoi_Hypo3D(le_SaveResul);
|
|
// retour
|
|
return retour;
|
|
};
|
|
|
|
|
|
Hypo_hooke3D::Hypo_hooke3D () : // Constructeur par defaut
|
|
Loi_comp_abstraite(HYPO_ELAS3D,CAT_THERMO_MECANIQUE,3),mu(-ConstMath::trespetit)
|
|
,Kc(-ConstMath::tresgrand),compress_thermophysique(false)
|
|
,mu_temperature(NULL),Kc_temperature(NULL),type_derive(-1),cas_calcul(0)
|
|
,mu_IIeps(NULL),Kc_IIeps(NULL)
|
|
,mu_nD(NULL),Kc_nD(NULL) ,I_x_I_HHHH(),I_xbarre_I_HHHH(),I_x_eps_HHHH(),I_x_D_HHHH(),I_xbarre_D_HHHH(),d_sig_t_HHHH()
|
|
,d_spherique_sig_t_HHHH()
|
|
{ };
|
|
|
|
|
|
// Constructeur de copie
|
|
Hypo_hooke3D::Hypo_hooke3D (const Hypo_hooke3D& loi) :
|
|
Loi_comp_abstraite(loi),mu(loi.mu),Kc(loi.Kc),compress_thermophysique(false)
|
|
,mu_temperature(loi.mu_temperature),Kc_temperature(loi.Kc_temperature)
|
|
,mu_IIeps(loi.mu_IIeps),Kc_IIeps(loi.Kc_IIeps)
|
|
,mu_nD(loi.mu_nD),Kc_nD(loi.Kc_nD)
|
|
,type_derive(loi.type_derive)
|
|
,cas_calcul(loi.cas_calcul)
|
|
,I_x_I_HHHH(),I_xbarre_I_HHHH(),I_x_eps_HHHH(),I_x_D_HHHH(),I_xbarre_D_HHHH(),d_sig_t_HHHH()
|
|
,d_spherique_sig_t_HHHH()
|
|
{// on regarde s'il s'agit d'une courbe locale ou d'une courbe globale
|
|
if (mu_temperature != NULL)
|
|
if (mu_temperature->NomCourbe() == "_")
|
|
mu_temperature = Courbe1D::New_Courbe1D(*(loi.mu_temperature));
|
|
if (Kc_temperature != NULL)
|
|
if (Kc_temperature->NomCourbe() == "_")
|
|
Kc_temperature = Courbe1D::New_Courbe1D(*(loi.Kc_temperature));;
|
|
if (mu_IIeps != NULL)
|
|
if (mu_IIeps->NomCourbe() == "_")
|
|
mu_IIeps = Courbe1D::New_Courbe1D(*(loi.mu_IIeps));;
|
|
if (Kc_IIeps != NULL)
|
|
if (Kc_IIeps->NomCourbe() == "_")
|
|
Kc_IIeps = Courbe1D::New_Courbe1D(*(loi.Kc_IIeps));;
|
|
// idem pour les fonctions nD
|
|
if (mu_nD != NULL)
|
|
if (mu_nD->NomFonction() == "_")
|
|
{// comme il s'agit d'une fonction locale on la redéfinie (sinon pb lors du destructeur de loi)
|
|
string non_courbe("_");
|
|
mu_nD = Fonction_nD::New_Fonction_nD(*loi.mu_nD);
|
|
};
|
|
if (Kc_nD != NULL)
|
|
if (Kc_nD->NomFonction() == "_")
|
|
{// comme il s'agit d'une fonction locale on la redéfinie (sinon pb lors du destructeur de loi)
|
|
string non_courbe("_");
|
|
Kc_nD = Fonction_nD::New_Fonction_nD(*loi.Kc_nD);
|
|
};
|
|
};
|
|
|
|
Hypo_hooke3D::~Hypo_hooke3D ()
|
|
// Destructeur
|
|
{ if (mu_temperature != NULL)
|
|
if (mu_temperature->NomCourbe() == "_") delete mu_temperature;
|
|
if (Kc_temperature != NULL)
|
|
if (Kc_temperature->NomCourbe() == "_") delete Kc_temperature;
|
|
if (mu_IIeps != NULL)
|
|
if (mu_IIeps->NomCourbe() == "_") delete mu_IIeps;
|
|
if (Kc_IIeps != NULL)
|
|
if (Kc_IIeps->NomCourbe() == "_") delete Kc_IIeps;
|
|
if (mu_nD != NULL)
|
|
if (mu_nD->NomFonction() == "_") delete mu_nD;
|
|
if (Kc_nD != NULL)
|
|
if (Kc_nD->NomFonction() == "_") delete Kc_nD;
|
|
};
|
|
|
|
// Lecture des donnees de la classe sur fichier
|
|
void Hypo_hooke3D::LectureDonneesParticulieres (UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D
|
|
,LesFonctions_nD& lesFonctionsnD)
|
|
{ string nom;
|
|
string nom_class_methode("Hypo_hooke3D::LectureDonneesParticulieres");
|
|
// lecture de la compressibilité instantanée
|
|
*(entreePrinc->entree) >> nom ;
|
|
#ifdef MISE_AU_POINT
|
|
if (nom != "Kc=")
|
|
{ cout << "\n erreur en lecture de la loi de HYPO_ELAS3D, on attendait Kc= suivi d'un nombre "
|
|
<< " ou du mot cle Kc_thermo_dependant_ et ensuite une courbe ";
|
|
entreePrinc->MessageBuffer("**erreur1 Hypo_hooke3D::LectureDonneesParticulieres (...**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
|
|
// gestion d'erreur de syntaxe non permise
|
|
if(((strstr(entreePrinc->tablcar,"Kc_thermo_dependant_")!=0) ||
|
|
(strstr(entreePrinc->tablcar,"Kc_fonction_nD:")!=0)
|
|
)
|
|
&&
|
|
(strstr(entreePrinc->tablcar,"Kc_avec_compressibilite_externe")!=0)
|
|
)
|
|
{ cout << "\n erreur en lecture de la loi de HYPO_ELAS3D, il n'est pas possible d'avoir une compressibilite externe "
|
|
<< " et une compressibilite thermo_dependante simultanement: incoherent !! ";
|
|
entreePrinc->MessageBuffer("**erreur1 Hypo_hooke3D::LectureDonneesParticulieres (...**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
|
|
// on regarde si Kc est thermo dépendant
|
|
if(strstr(entreePrinc->tablcar,"Kc_thermo_dependant_")!=0)
|
|
{ thermo_dependant=true; *(entreePrinc->entree) >> nom;
|
|
if (nom != "Kc_thermo_dependant_")
|
|
{ cout << "\n erreur en lecture de la thermodependance de Kc, on aurait du lire le mot cle Kc_thermo_dependant_"
|
|
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
|
|
entreePrinc->MessageBuffer("**erreur2 Hypo_hooke3D::LectureDonneesParticulieres (...**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
// lecture de la loi d'évolution de Kc 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)) { Kc_temperature = lesCourbes1D.Trouve(nom);}
|
|
else { // sinon il faut la lire maintenant
|
|
string non_courbe("_");
|
|
Kc_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
|
|
// lecture de la courbe
|
|
Kc_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
|
|
}
|
|
// prepa du flot de lecture
|
|
entreePrinc->NouvelleDonnee();
|
|
}
|
|
// sinon on regarde si la compressibilité sera fourni en externe
|
|
else if (strstr(entreePrinc->tablcar,"Kc_avec_compressibilite_externe")!=0)
|
|
{*(entreePrinc->entree) >> nom;
|
|
compress_thermophysique=true;
|
|
}
|
|
// sinon on regarde si le module dépend d'une fonction nD
|
|
else if(strstr(entreePrinc->tablcar,"Kc_fonction_nD:")!=0)
|
|
{ string nom;
|
|
string mot_cle2="Kc_fonction_nD:";
|
|
|
|
// on lit le nom de la fonction
|
|
string nom_fonct;
|
|
bool lec = entreePrinc->Lecture_mot_cle_et_string(nom_class_methode,mot_cle2,nom_fonct);
|
|
if (!lec )
|
|
{ entreePrinc->MessageBuffer("**erreur02 en lecture** "+mot_cle2);
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
// maintenant on définit la fonction
|
|
if (lesFonctionsnD.Existe(nom_fonct))
|
|
{Kc_nD = lesFonctionsnD.Trouve(nom_fonct);
|
|
}
|
|
else
|
|
{// sinon il faut la lire maintenant
|
|
string non("_");
|
|
Kc_nD = Fonction_nD::New_Fonction_nD(non, Id_Nom_Fonction_nD(nom_fonct));
|
|
// lecture de la courbe
|
|
Kc_nD->LectDonnParticulieres_Fonction_nD (non,entreePrinc);
|
|
// maintenant on vérifie que la fonction est utilisable
|
|
if (Kc_nD->NbComposante() != 1 )
|
|
{ cout << "\n erreur en lecture de Kc, la fonction " << nom_fonct
|
|
<< " est une fonction vectorielle a " << Kc_nD->NbComposante()
|
|
<< " composante alors qu'elle devrait etre scalaire ! "
|
|
<< " elle n'est donc pas utilisable !! ";
|
|
string message("\n**erreur03** \n"+nom_class_methode+"(...");
|
|
entreePrinc->MessageBuffer(message);
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
};
|
|
// on regarde si la fonction nD intègre la température
|
|
const Tableau <Ddl_enum_etendu>& tab_enu = Kc_nD->Tab_enu_etendu();
|
|
if (tab_enu.Contient(TEMP))
|
|
thermo_dependant=true;
|
|
// prepa du flot de lecture
|
|
entreePrinc->NouvelleDonnee();
|
|
}
|
|
// sinon c'est directement le module que l'on lit
|
|
else
|
|
{ // lecture du coeff
|
|
*(entreePrinc->entree) >> Kc ;
|
|
};
|
|
|
|
// on regarde si le module dépend du deuxième invariant
|
|
if(strstr(entreePrinc->tablcar,"Kc_IIeps_")!=0)
|
|
{ // on vérifie que Kc_avec_compressibilite_externe n'est pas valide car dans ce cas
|
|
// la dépendance au deuxième invariant de la déformation n'est pas valide
|
|
if (compress_thermophysique)
|
|
{ cout << "\n erreur on ne peut pas avoir Kc_avec_compressibilite_externe "
|
|
<< " et Kc dependant du deuxieme invariant d'epsilon, ";
|
|
entreePrinc->MessageBuffer("**erreur5 Hypo_hooke3D::LectureDonneesParticulieres (...**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
// si tout est ok on lit
|
|
*(entreePrinc->entree) >> nom;
|
|
if (nom != "Kc_IIeps_")
|
|
{ cout << "\n erreur en lecture de la dependance de Kc au deuxieme invariant d'epsilon, "
|
|
<< " on aurait du lire le mot cle Kc_IIeps_"
|
|
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
|
|
entreePrinc->MessageBuffer("**erreur6 Hypo_hooke3D::LectureDonneesParticulieres (...**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
// lecture de la loi d'évolution en fonction du deuxième invariant
|
|
*(entreePrinc->entree) >> nom;
|
|
// on regarde si la courbe existe, si oui on récupère la référence
|
|
if (lesCourbes1D.Existe(nom))
|
|
{ Kc_IIeps = lesCourbes1D.Trouve(nom);
|
|
}
|
|
else
|
|
{ // sinon il faut la lire maintenant
|
|
string non_courbe("_");
|
|
Kc_IIeps = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
|
|
// lecture de la courbe
|
|
Kc_IIeps->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
|
|
}
|
|
// prepa du flot de lecture
|
|
if(strstr(entreePrinc->tablcar,"fin_loi_HYPO_ELAS3D")==0) entreePrinc->NouvelleDonnee();
|
|
};
|
|
|
|
|
|
// ---- lecture du coef de cisaillement instantané
|
|
*(entreePrinc->entree) >> nom;
|
|
if (nom != "mu=")
|
|
{ cout << "\n erreur en lecture du coef de cisaillement instantane , on aurait du lire le mot mu=";
|
|
entreePrinc->MessageBuffer("**erreur3 Hypo_hooke3D::LectureDonneesParticulieres (...**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
// on regarde si le cisaillement 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 ";
|
|
entreePrinc->MessageBuffer("**erreur3 Hypo_hooke3D::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
|
|
if(strstr(entreePrinc->tablcar,"fin_loi_HYPO_ELAS3D")==0) entreePrinc->NouvelleDonnee();
|
|
}
|
|
// sinon on regarde si mu dépend d'une fonction nD
|
|
else if(strstr(entreePrinc->tablcar,"mu_fonction_nD:")!=0)
|
|
{ string nom;
|
|
string mot_cle2="mu_fonction_nD:";
|
|
|
|
// on lit le nom de la fonction
|
|
string nom_fonct;
|
|
bool lec = entreePrinc->Lecture_mot_cle_et_string(nom_class_methode,mot_cle2,nom_fonct);
|
|
if (!lec )
|
|
{ entreePrinc->MessageBuffer("**erreur02 en lecture** "+mot_cle2);
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
// maintenant on définit la fonction
|
|
if (lesFonctionsnD.Existe(nom_fonct))
|
|
{mu_nD = lesFonctionsnD.Trouve(nom_fonct);
|
|
}
|
|
else
|
|
{// sinon il faut la lire maintenant
|
|
string non("_");
|
|
mu_nD = Fonction_nD::New_Fonction_nD(non, Id_Nom_Fonction_nD(nom_fonct));
|
|
// lecture de la courbe
|
|
mu_nD->LectDonnParticulieres_Fonction_nD (non,entreePrinc);
|
|
// maintenant on vérifie que la fonction est utilisable
|
|
if (mu_nD->NbComposante() != 1 )
|
|
{ cout << "\n erreur en lecture de f , la fonction " << nom_fonct
|
|
<< " est une fonction vectorielle a " << mu_nD->NbComposante()
|
|
<< " composante alors qu'elle devrait etre scalaire ! "
|
|
<< " elle n'est donc pas utilisable !! ";
|
|
string message("\n**erreur03** \n"+nom_class_methode+"(...");
|
|
entreePrinc->MessageBuffer(message);
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
};
|
|
// on regarde si la fonction nD intègre la température
|
|
const Tableau <Ddl_enum_etendu>& tab_enu = mu_nD->Tab_enu_etendu();
|
|
if (tab_enu.Contient(TEMP))
|
|
thermo_dependant=true;
|
|
// prepa du flot de lecture
|
|
if(strstr(entreePrinc->tablcar,"fin_loi_HYPO_ELAS3D")==0) entreePrinc->NouvelleDonnee();
|
|
}
|
|
else
|
|
{ // sinon lecture de mu
|
|
*(entreePrinc->entree) >> mu ;
|
|
};
|
|
// on regarde si le cisaillement dépend du deuxième invariant
|
|
if(strstr(entreePrinc->tablcar,"mu_IIeps_")!=0)
|
|
{ *(entreePrinc->entree) >> nom;
|
|
if (nom != "mu_IIeps_")
|
|
{ cout << "\n erreur en lecture de la dependance de mu au deuxieme invariant d'epsilon, "
|
|
<< " on aurait du lire le mot cle mu_IIeps_"
|
|
<< " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
|
|
entreePrinc->MessageBuffer("**erreur4 Hypo_hooke3D::LectureDonneesParticulieres (...**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
// lecture de la loi d'évolution en fonction du deuxième invariant
|
|
*(entreePrinc->entree) >> nom;
|
|
// on regarde si la courbe existe, si oui on récupère la référence
|
|
if (lesCourbes1D.Existe(nom))
|
|
{ mu_IIeps = lesCourbes1D.Trouve(nom);
|
|
}
|
|
else
|
|
{ // sinon il faut la lire maintenant
|
|
string non_courbe("_");
|
|
mu_IIeps = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
|
|
// lecture de la courbe
|
|
mu_IIeps->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
|
|
}
|
|
// prepa du flot de lecture
|
|
if(strstr(entreePrinc->tablcar,"fin_loi_HYPO_ELAS3D")==0) entreePrinc->NouvelleDonnee();
|
|
};
|
|
|
|
// ---- 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 Hypo_hooke3D: "<< type_derive
|
|
<< " n'est pas acceptable (uniquement -1 ou 0 ou 1), on utilise le type par defaut (-1)"
|
|
<< " qui correspond à la derivee de Jauman ";
|
|
type_derive = -1;
|
|
}
|
|
}
|
|
// on regarde si le calcul est éventuellement uniquement déviatorique
|
|
cas_calcul = 0; // par défaut
|
|
if (strstr(entreePrinc->tablcar,"seule_deviatorique")!=NULL)
|
|
{cas_calcul=1;};
|
|
// idem pour la partie sphérique
|
|
if (strstr(entreePrinc->tablcar,"seule_spherique")!=NULL)
|
|
{if (cas_calcul == 1) {cas_calcul=0;} else {cas_calcul = 2;};};
|
|
// prepa du flot de lecture
|
|
if(strstr(entreePrinc->tablcar,"fin_loi_HYPO_ELAS3D")==0) entreePrinc->NouvelleDonnee();
|
|
// appel au niveau de la classe mère
|
|
Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire
|
|
(*entreePrinc,lesFonctionsnD,false);
|
|
// prepa du flot de lecture
|
|
if(strstr(entreePrinc->tablcar,"fin_loi_HYPO_ELAS3D")!=0) entreePrinc->NouvelleDonnee();
|
|
|
|
};
|
|
|
|
// affichage de la loi
|
|
void Hypo_hooke3D::Affiche() const
|
|
{ cout << " \n loi de comportement HYPO_ELAS 3D ";
|
|
|
|
if (Kc_temperature != NULL) { cout << " coef Kc thermo dependant "
|
|
<< " courbe Kc=f(T): " << Kc_temperature->NomCourbe() <<" ";}
|
|
else if(compress_thermophysique) { cout << " compressibilite calculee avec une loi thermophysique " ;}
|
|
else if (Kc_nD != NULL)
|
|
{cout << "\n compressibilite calculee avec une fonction nD: ";
|
|
cout << "Kc_fonction_nD:" << " ";
|
|
if (Kc_nD->NomFonction() != "_")
|
|
cout << Kc_nD->NomFonction();
|
|
else
|
|
Kc_nD->Affiche();
|
|
}
|
|
else { cout << " coef Kc= " << Kc ;}
|
|
if ( Kc_IIeps != NULL) { cout << " compressibilite dependant multiplicativement du deuxieme invariant d'epsilon "
|
|
<< " courbe Kc_final=Kc*f(eps:eps): " << Kc_IIeps->NomCourbe() <<" ";};
|
|
if ( mu_temperature != NULL) { cout << " cisaillement thermo dependant "
|
|
<< " courbe mu=f(T): " << mu_temperature->NomCourbe() <<" ";}
|
|
else if (mu_nD != NULL)
|
|
{cout << "\n fonction f calculee avec une fonction nD: ";
|
|
cout << "f_fonction_nD:" << " ";
|
|
if (mu_nD->NomFonction() != "_")
|
|
cout << mu_nD->NomFonction();
|
|
else
|
|
mu_nD->Affiche();
|
|
}
|
|
else { cout << " cisaillement mu= " << mu ;}
|
|
if ( mu_IIeps != NULL) { cout << " cisaillement dependant multiplicativement du deuxieme invariant d'epsilon "
|
|
<< " courbe mu_final=mu*f(eps:eps): " << mu_IIeps->NomCourbe() <<" ";};
|
|
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 pour la contrainte" << endl; break;
|
|
case 1: cout << ", et derivee de Lie deux fois contravariantes pour la contrainte" << endl; break;
|
|
}
|
|
// indicateur de cas de calcul
|
|
if (cas_calcul != 0)
|
|
{ if (cas_calcul == 1)
|
|
{cout << " calcul uniquement deviatorique ";}
|
|
else if (cas_calcul == 2)
|
|
{cout << " calcul uniquement spherique ";}
|
|
else
|
|
{cout << " cas de calcul mal defini !! ";};
|
|
}
|
|
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 Hypo_hooke3D::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 (Kc == -ConstMath::tresgrand)
|
|
{ // on initialise à une valeur arbitraire
|
|
Kc = 10.;}
|
|
if (mu == -ConstMath::trespetit)
|
|
{ // on initialise à une valeur arbitraire
|
|
mu = 0.15;}
|
|
sort << "\n# ......................... loi de comportement HYPO_ELAS 3D ........................."
|
|
<< "\n# | coef compressibilite | coef cisaillement | type de derivee objective utilisee |"
|
|
<< "\n# | instantane | instantane | pour le calcul de la contrainte |"
|
|
<< "\n# | Kc | mu |type_derivee (facultatif) |"
|
|
<< "\n#......................................................................................"
|
|
<< "\n Kc= " << setprecision(8) << Kc << " mu= " << setprecision(8) << mu
|
|
<< " type_derivee " << type_derive
|
|
<< "\n fin_loi_HYPO_ELAS3D " << endl;
|
|
if ((rep != "o") && (rep != "O" ) && (rep != "0") )
|
|
{sort
|
|
<< "\n# --------- type de derivee ----------"
|
|
<< "\n# le type de derivee est optionnel: = -1 -> derivee de Jauman (valeur par defaut), "
|
|
<< "\n# = 0 -> derivee deux fois covariantes , "
|
|
<< "\n# = 1 -> derivee deux fois contravariantes"
|
|
<< "\n# dans le cas ou l'on veut une valeur differente de la valeur par defaut"
|
|
<< "\n# il faut mettre le mot cle"
|
|
<< "\n# <type_derivee> suivi de la valeur -1 ou 0 ou 1"
|
|
<< "\n# ";
|
|
sort << "\n# --------- Kc calcule via une loi thermophysique ---------"
|
|
<< "\n# pour le module de compressibilite: Kc, il est possible d'indiquer que"
|
|
<< "\n# le module sera fourni "
|
|
<< "\n# par une loi thermophysique (celle associee au meme element), pour ce faire"
|
|
<< "\n# on indique uniquement: "
|
|
<< "\n# Kc= Kc_avec_compressibilite_externe "
|
|
<< "\n# NB: ensuite aucune autre info concernant Kc ne doit etre fournie. "
|
|
<< "\n# ";
|
|
sort << "\n# ------- dependance explicite a la temperature ----------"
|
|
<< "\n# \n# chacun des 2 parametres materiau Kc et mu "
|
|
<< "\n# peut etre remplace par une fonction dependante de la temperature "
|
|
<< "\n# (sauf si le cas Kc_avec_compressibilite_externe est actif, si oui "
|
|
<< "\n# aucune info complementaire ne peut-etre fournie pour Kc) "
|
|
<< "\n# pour ce faire on utilise un mot cle puis une nom de courbe ou la courbe"
|
|
<< "\n# directement comme avec les autre loi de comportement "
|
|
<< "\n# exemple pour Kc: Kc= Kc_thermo_dependant_ courbe3 "
|
|
<< "\n# exemple pour f: mu= mu_thermo_dependant_ courbe2 "
|
|
<< "\n# IMPORTANT: a chaque fois qu'il y a une thermodependance, il faut passer une ligne "
|
|
<< "\n# apres la description de la grandeur thermodependante, mais pas de passage "
|
|
<< "\n# a la ligne si ce n'est pas thermo dependant"
|
|
<< "\n# "
|
|
<< "\n# -------- dependance a une fonction nD -------------"
|
|
<< "\n# Kc et mu peuvent au choix dependre d'une fonction nD. "
|
|
<< "\n# Dans ce cas Kc et mu ne doivent pas avoir ete declare thermodependant, "
|
|
<< "\n# mais on peut inclure une thermo-dependance dans la fonction nD, "
|
|
<< "\n# Exemple pour Kc : "
|
|
<< "\n# Kc= Kc_fonction_nD: fonction_1 "
|
|
<< "\n# "
|
|
<< "\n# Exemple pour mu : "
|
|
<< "\n# mu= mu_fonction_nD: fonction_2 "
|
|
<< "\n# "
|
|
<< "\n# La declaration des fonctions suit la meme logique que pour les courbes 1D "
|
|
<< "\n# "
|
|
<< "\n# -------- dependance directe a (Eps:Eps) -------------"
|
|
<< "\n# il est également possible de definir un facteur multiplicatif pour Kc et mu "
|
|
<< "\n# fonction explicite du deuxieme invariant de la deformation = (Eps:Eps) "
|
|
<< "\n# = eps_1^1 * eps_1^1 + eps_2^2 * eps_2^2 + eps_3^3 * eps_3^3 "
|
|
<< "\n# Ceci permet d'obtenir une evolution finale non lineaire dont l'operateur tangent"
|
|
<< "\n# prend en compte les variations de la deformation."
|
|
<< "\n# pour cela on indique le mot cle Kc_IIeps_ suivi du nom d'une courbe"
|
|
<< "\n# suivi d'un passage a la ligne."
|
|
<< "\n# Exemple de declaration d'un Kc thermo dependant et fonction "
|
|
<< "\n# egalement du deuxieme invariant "
|
|
<< "\n# Kc= Kc_thermo_dependant_ courbe2 "
|
|
<< "\n# Kc_IIeps_ courbe5 "
|
|
<< "\n# "
|
|
<< "\n# Exemple de declaration d'un Kc non thermo-dependant, "
|
|
<< "\n# mais fonction du deuxieme invariant"
|
|
<< "\n# Kc= 10000 Kc_IIeps_ courbe4 "
|
|
<< "\n# "
|
|
<< "\n# NB: 1) on peut cumuler une dependance a une fonction nD et une dependance "
|
|
<< "\n# explicite multiplicative a (Eps:Eps)"
|
|
<< "\n# 2) a la fin de la definition de Kc_IIeps_ , il faut passer une ligne "
|
|
<< "\n# "
|
|
<< "\n# de la meme maniere on peut definir un facteur multiplicatif pour mu "
|
|
<< "\n# fonction du deuxieme invariant de la deformation = (Eps:Eps) . "
|
|
<< "\n# pour cela on indique le mot cle mu_IIeps_ suivi du nom d'une "
|
|
<< "\n# courbe suivi d'un passage a la ligne"
|
|
<< "\n# Exemple de declaration d'un mu thermo dependant et fonction egalement "
|
|
<< "\n# du deuxieme invariant "
|
|
<< "\n# mu= mu_thermo_dependant_ courbe2 "
|
|
<< "\n# mu_IIeps_ courbe4 "
|
|
<< "\n# "
|
|
<< "\n# Exemple de declaration d'un mu non thermo-dependant, mais fonction "
|
|
<< "\n# du deuxieme invariant "
|
|
<< "\n# mu= 1200 mu_IIeps_ courbe4 "
|
|
<< "\n# "
|
|
<< "\n# NB: 1) comme pour Kc, on peut cumuler une dependance a une fonction nD et "
|
|
<< "\n# une dependance explicite multiplicative a (Eps:Eps)"
|
|
<< "\n# 2) a la fin de la definition de mu_IIeps_ , il faut passer une ligne "
|
|
<< "\n# "
|
|
<< "\n# "
|
|
<< "\n# NB: pour toutes les definition de courbe ou de fct nD il est aussi possible"
|
|
<< "\n# d'introduire directement la courbe a la place de son nom, comme pour "
|
|
<< "\n# toutes les autres lois "
|
|
<< "\n#";
|
|
sort << "\n# ------- restriction partie spherique ou deviatorique ----------"
|
|
<< "\n# Il est ensuite possible d'indiquer que l'on souhaite calculer "
|
|
<< "\n# seulement la partie spherique de la loi"
|
|
<< "\n# pour cela on met le mot cle: seule_spherique a la fin des donnees "
|
|
<< "\n# sur la meme ligne que le dernier enreg "
|
|
<< "\n# D'une maniere identique il est possible d'indiquer que l'on souhaite "
|
|
<< "\n# calculer seulement la partie deviatorique de la loi, "
|
|
<< "\n# pour cela on met le mot cle: seule_deviatorique "
|
|
<< "\n# "
|
|
<< "\n# "
|
|
<< "\n# ----------- fin des parametres --------"
|
|
<< "\n# la derniere ligne doit contenir uniquement le mot cle: "
|
|
<< "\n# fin_loi_HYPO_ELAS3D "
|
|
<< "\n# ";
|
|
};
|
|
sort << endl;
|
|
// appel de la classe mère
|
|
Loi_comp_abstraite::Info_commande_don_LoisDeComp(entreePrinc);
|
|
};
|
|
|
|
// test si la loi est complete
|
|
int Hypo_hooke3D::TestComplet()
|
|
{ int ret = LoiAbstraiteGeneral::TestComplet();
|
|
if (!compress_thermophysique &&((Kc_temperature == NULL) && (Kc == -ConstMath::tresgrand)) && (Kc_nD == NULL)
|
|
)
|
|
{ cout << " \n le coef de compressibilite instantane n'est pas defini pour la loi " << Nom_comp(id_comp)
|
|
<< '\n';
|
|
ret = 0;
|
|
}
|
|
if ((mu_temperature == NULL) && (mu == -ConstMath::trespetit)
|
|
&& (mu_nD == NULL)
|
|
)
|
|
{ cout << " \n le coef de cisaillement instantane mu n'est pas defini pour la loi " << Nom_comp(id_comp)
|
|
<< '\n';
|
|
ret = 0;
|
|
}
|
|
// test du cas de calcul
|
|
if ((cas_calcul < 0) || (cas_calcul > 2))
|
|
{ cout << "\n l'indicateur de calcul cas_calcul= " << cas_calcul << " n'est pas correcte "
|
|
<< "\n ceci pour la Hypo_hooke3D";
|
|
Affiche();
|
|
ret = 0;
|
|
}
|
|
return ret;
|
|
};
|
|
//----- 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 Hypo_hooke3D::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef
|
|
,LesCourbes1D& lesCourbes1D
|
|
,LesFonctions_nD& lesFonctionsnD)
|
|
{ string nom;
|
|
if (cas == 1)
|
|
{ ent >> nom;
|
|
if (nom != "HYPO_ELAS3D")
|
|
{ cout << "\n erreur en lecture de la loi : Hypo_hooke3D, on attendait le mot cle : HYPO_ELAS3D "
|
|
<< "\n Hypo_hooke3D::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;
|
|
int test; // sert pour le test des courbes
|
|
// compressibilité
|
|
ent >> nom >> compress_thermophysique ;
|
|
if (!compress_thermophysique)
|
|
{ ent >> test;
|
|
switch (test)
|
|
{case 1: // cas d'une valeur numérique
|
|
ent >> Kc; break;
|
|
case 2: // cas d'une fonction nD
|
|
{ent >> nom ;
|
|
if (nom != " Kc_fonction_nD: ")
|
|
{ cout << "\n erreur en lecture de la fonction nD, on attendait "
|
|
<< " Kc_fonction_nD: et on a lue " << nom
|
|
<< "\n Hypo_hooke3D::Lecture_base_info_loi(...";
|
|
Sortie(1);
|
|
};
|
|
Kc_nD = lesFonctionsnD.Lecture_pour_base_info(ent,cas,Kc_nD);
|
|
break;
|
|
}
|
|
case 3: // cas d'une fonction_Kc_temperature
|
|
{ent >> nom;
|
|
if (nom != " fonction_Kc_temperature ")
|
|
{ cout << "\n erreur en lecture de la fonction Kc_temperature, on attendait "
|
|
<< " fonction_Kc_temperature et on a lue " << nom
|
|
<< "\n Hypo_hooke3D::Lecture_base_info_loi(...";
|
|
Sortie(1);
|
|
};
|
|
Kc_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,Kc_temperature);
|
|
break;
|
|
}
|
|
default:
|
|
{ cout << "\n erreur en lecture de Kc, on attendait un nombre 1,2 ou 3 "
|
|
<< " et on a lue " << test
|
|
<< "\n Hypo_hooke3D::Lecture_base_info_loi(...";
|
|
Sortie(1);
|
|
};
|
|
};
|
|
|
|
// dépendance multiplicative à IIeps éventuelle
|
|
ent >> nom >> test;
|
|
if (!test)
|
|
{ if (Kc_IIeps != NULL) {if (Kc_IIeps->NomCourbe() == "_")
|
|
delete Kc_IIeps; Kc_IIeps = NULL;};
|
|
}
|
|
else
|
|
{ ent >> nom; Kc_IIeps = lesCourbes1D.Lecture_pour_base_info(ent,cas,Kc_IIeps); };
|
|
};
|
|
|
|
// cisaillement
|
|
ent >> nom >> test;
|
|
|
|
switch (test)
|
|
{case 1: // cas d'une valeur numérique
|
|
ent >> mu; break;
|
|
case 2: // cas d'une fonction nD
|
|
{ent >> nom ;
|
|
if (nom != " mu_fonction_nD: ")
|
|
{ cout << "\n erreur en lecture de la fonction nD, on attendait "
|
|
<< " mu_fonction_nD: et on a lue " << nom
|
|
<< "\n Hypo_hooke3D::Lecture_base_info_loi(...";
|
|
Sortie(1);
|
|
};
|
|
mu_nD = lesFonctionsnD.Lecture_pour_base_info(ent,cas,mu_nD);
|
|
break;
|
|
}
|
|
case 3: // cas d'une fonction_mu_temperature
|
|
{ent >> nom;
|
|
if (nom != " fonction_mu_temperature ")
|
|
{ cout << "\n erreur en lecture de la fonction mu_temperature, on attendait "
|
|
<< " fonction_mu_temperature et on a lue " << nom
|
|
<< "\n Hypo_hooke3D::Lecture_base_info_loi(...";
|
|
Sortie(1);
|
|
};
|
|
mu_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,mu_temperature);
|
|
break;
|
|
}
|
|
default:
|
|
{ cout << "\n erreur en lecture de mu, on attendait un nombre 1,2 ou 3 "
|
|
<< " et on a lue " << test
|
|
<< "\n Hypo_hooke3D::Lecture_base_info_loi(...";
|
|
Sortie(1);
|
|
};
|
|
};
|
|
// dépendance multiplicative à IIeps éventuelle
|
|
ent >> nom >> test;
|
|
if (!test)
|
|
{ if (mu_IIeps != NULL) {if (mu_IIeps->NomCourbe() == "_")
|
|
delete mu_IIeps; mu_IIeps = NULL;};
|
|
}
|
|
else
|
|
{ ent >> nom; mu_IIeps = lesCourbes1D.Lecture_pour_base_info(ent,cas,mu_IIeps); };
|
|
// indicateur pour les calculs partielles
|
|
ent >> nom >> cas_calcul ;
|
|
}
|
|
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 Hypo_hooke3D::Ecriture_base_info_loi(ostream& sort,const int cas)
|
|
{ if (cas == 1)
|
|
{ sort << " HYPO_ELAS3D " << " type_derivee " << type_derive << " " ;
|
|
sort << "\n compressibilite ";
|
|
sort << " compress_thermophysique= " << compress_thermophysique << " ";
|
|
if (!compress_thermophysique)
|
|
{if ((Kc_temperature == NULL)&&(Kc_nD == NULL))
|
|
{ sort << " 1 " << " " << Kc << " ";}
|
|
else if (Kc_nD != NULL)
|
|
{sort << " 2 Kc_fonction_nD: " << " ";
|
|
LesFonctions_nD::Ecriture_pour_base_info(sort, cas,Kc_nD);
|
|
}
|
|
else
|
|
{ sort << " 3 " << " fonction_Kc_temperature ";
|
|
LesCourbes1D::Ecriture_pour_base_info(sort,cas,Kc_temperature);
|
|
};
|
|
if (Kc_IIeps == NULL)
|
|
{ sort << " " << false << " " ;}
|
|
else
|
|
{ sort << " " << true << " Kc_IIeps ";
|
|
LesCourbes1D::Ecriture_pour_base_info(sort,cas,Kc_IIeps);
|
|
};
|
|
};
|
|
|
|
sort << "\n cisaillement ";
|
|
if ((mu_temperature == NULL) && (mu_nD == NULL))
|
|
{ sort << " 1 " << mu << " ";}
|
|
else if (mu_nD != NULL)
|
|
{sort << " 2 mu_fonction_nD: " << " ";
|
|
LesFonctions_nD::Ecriture_pour_base_info(sort, cas,mu_nD);
|
|
}
|
|
else
|
|
{sort << " 3 " << " fonction_mu_temperature ";
|
|
LesCourbes1D::Ecriture_pour_base_info(sort,cas,mu_temperature);
|
|
};
|
|
if (mu_IIeps == NULL)
|
|
{sort << " " << false << " " ;}
|
|
else
|
|
{sort << " " << true << " fonction_epseps ";
|
|
LesCourbes1D::Ecriture_pour_base_info(sort,cas,mu_IIeps);
|
|
};
|
|
|
|
// indicateur pour les calculs partielles
|
|
sort << " cas_calcul " << cas_calcul << " ";
|
|
}
|
|
// appel de la classe mère
|
|
Loi_comp_abstraite::Ecriture_don_base_info(sort,cas);
|
|
};
|
|
|
|
// 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 Hypo_hooke3D::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
|
|
SaveResulLoi_Hypo3D & save_resul = *((SaveResulLoi_Hypo3D*) saveDon);
|
|
// on passe en revue la liste
|
|
List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end();
|
|
list<int>::iterator idecal=decal.begin();
|
|
for (itq=liTQ.begin();itq!=itqfin;itq++,idecal++)
|
|
{TypeQuelconque& tipParticu = (*itq); // pour simplifier
|
|
if (tipParticu.EnuTypeQuelconque().Nom_vide()) // veut dire que c'est un enum pur
|
|
{switch (tipParticu.EnuTypeQuelconque().EnumTQ())
|
|
{
|
|
// 1) -----cas du module de compressibilité dépendant de la température
|
|
case MODULE_COMPRESSIBILITE:
|
|
{ Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
|
|
tyTQ(1+(*idecal))=save_resul.Kc/3.;(*idecal)++;
|
|
break;
|
|
}
|
|
case MODULE_CISAILLEMENT:
|
|
{ Tab_Grandeur_scalaire_double& tyTQ= *((Tab_Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
|
|
tyTQ(1+(*idecal))=0.5*save_resul.mu;(*idecal)++;
|
|
break;
|
|
}
|
|
case DEF_ASSO_LOI:
|
|
{ Tab_Grandeur_TenseurBB& tyTQ= *((Tab_Grandeur_TenseurBB*) (*itq).Grandeur_pointee()); // pour simplifier
|
|
tyTQ(1+(*idecal))=save_resul.eps_cumulBB;(*idecal)++;
|
|
break;
|
|
}
|
|
|
|
default: ;// on ne fait rien
|
|
};
|
|
}; // fin du if
|
|
}; // fin de la boucle
|
|
};
|
|
|
|
// récupération et création de la liste de tous les grandeurs particulières
|
|
// ces grandeurs sont ajoutées à la liste passées en paramètres
|
|
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
|
|
void Hypo_hooke3D::ListeGrandeurs_particulieres(bool absolue,List_io<TypeQuelconque>& liTQ) const
|
|
{//on commence par définir une grandeur_scalaire_double
|
|
Tableau <double> tab_1(1);
|
|
Tab_Grandeur_scalaire_double grand_courant(tab_1);
|
|
// def d'un type quelconque représentatif à chaque grandeur
|
|
// a priori ces grandeurs sont défini aux points d'intégration identique à la contrainte par exemple
|
|
// enu_ddl_type_pt est définit dans la loi Abtraite générale
|
|
//on regarde si ce type d'info existe déjà: si oui on augmente la taille du tableau, si non on crée
|
|
// $$$ cas de MODULE_COMPRESSIBILITE: intéressant quand il dépend de la température
|
|
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
|
|
for (itq=liTQ.begin();itq!=itqfin;itq++)
|
|
if ((*itq).EnuTypeQuelconque() == MODULE_COMPRESSIBILITE)
|
|
{ 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(MODULE_COMPRESSIBILITE,enu_ddl_type_pt,grand_courant);
|
|
liTQ.push_back(typQ1);
|
|
};
|
|
};
|
|
// $$$ cas de MODULE_CISAILLEMENT: intéressant quand il dépend de la température
|
|
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
|
|
for (itq=liTQ.begin();itq!=itqfin;itq++)
|
|
if ((*itq).EnuTypeQuelconque() == MODULE_CISAILLEMENT)
|
|
{ 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 typQ2(MODULE_CISAILLEMENT,enu_ddl_type_pt,grand_courant);
|
|
liTQ.push_back(typQ2);
|
|
};
|
|
};
|
|
// $$$ cas de la déformation cumulée associée à la loi, c-a-d au type d'intégration
|
|
{List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end(); bool nexistePas = true;
|
|
for (itq=liTQ.begin();itq!=itqfin;itq++)
|
|
if ((*itq).EnuTypeQuelconque() == DEF_ASSO_LOI)
|
|
{Tab_Grandeur_TenseurBB& tyTQ= *((Tab_Grandeur_TenseurBB*) (*itq).Grandeur_pointee()); // pour simplifier
|
|
int taille = tyTQ.Taille()+1;
|
|
tyTQ.Change_taille(taille); nexistePas = false;
|
|
};
|
|
if (nexistePas)
|
|
{TenseurBB* tens = NevezTenseurBB(3); // un tenseur typique
|
|
Tab_Grandeur_TenseurBB epsassoBB(*tens,1);
|
|
// def d'un type quelconque représentatif
|
|
TypeQuelconque typQ(DEF_ASSO_LOI,EPS11,epsassoBB);
|
|
liTQ.push_back(typQ);
|
|
delete tens; // car on n'en a plus besoin
|
|
};
|
|
};
|
|
};
|
|
|
|
// calcul d'un module d'young équivalent à la loi
|
|
double Hypo_hooke3D::Module_young_equivalent(Enum_dure temps,const Deformation & ,SaveResul * saveDon)
|
|
{ // on récupère le conteneur
|
|
SaveResulLoi_Hypo3D & save_resul = *((SaveResulLoi_Hypo3D*) saveDon);
|
|
// au niveau instantané on a: E=(3*Kc*mu)/(2*Kc+mu);
|
|
// et nu = (Kc-mu)/(2*Kc+mu)
|
|
double E=0.;
|
|
switch (temps)
|
|
{case TEMPS_0 : // rien n'a été calculé on utilise les grandeurs initiales
|
|
E=(3*Kc*mu)/(2*Kc+mu);
|
|
break;
|
|
case TEMPS_t : // on utilise les grandeurs stockées à t
|
|
{double Kc_actuelle = save_resul.Kc_t;
|
|
double mu_actuelle = save_resul.mu_t;
|
|
|
|
E= (3*Kc_actuelle*mu_actuelle)/(2*Kc_actuelle+mu_actuelle);
|
|
break;
|
|
}
|
|
case TEMPS_tdt : // on utilise les grandeurs stockées à tdt
|
|
{double Kc_actuelle = save_resul.Kc;
|
|
double mu_actuelle = save_resul.mu;
|
|
|
|
E= (3*Kc_actuelle*mu_actuelle)/(2*Kc_actuelle+mu_actuelle);
|
|
break;
|
|
}
|
|
};
|
|
|
|
return E;
|
|
};
|
|
|
|
// récupération d'un module de compressibilité équivalent à la loi, ceci pour un chargement nul
|
|
// il s'agit ici de la relation -pression = sigma_trace/3. = module de compressibilité * I_eps
|
|
// >>> en fait ici il s'agit du dernier module tangent calculé !!
|
|
double Hypo_hooke3D::Module_compressibilite_equivalent
|
|
(Enum_dure temps,const Deformation & def,SaveResul * saveDon)
|
|
{ // ici le module correspond à Kc, cependant Kc est un module tangent et non
|
|
// sécant ... peut-être sera changé par la suite
|
|
// compte tenu du fait que l'on ne connait pas la métrique etc... on ramène le module en cours
|
|
|
|
// on récupère le conteneur
|
|
SaveResulLoi_Hypo3D & save_resul = *((SaveResulLoi_Hypo3D*) saveDon);
|
|
double K=0.;
|
|
switch (temps)
|
|
{case TEMPS_0 : // rien n'a été calculé on utilise les grandeurs initiales
|
|
K=Kc/3.;
|
|
break;
|
|
case TEMPS_t : // on utilise les grandeurs stockées à t
|
|
{K=save_resul.Kc_t/3.;
|
|
break;
|
|
}
|
|
case TEMPS_tdt : // on utilise les grandeurs stockées à tdt
|
|
{K = save_resul.Kc/3.;
|
|
break;
|
|
}
|
|
};
|
|
|
|
return K;
|
|
};
|
|
|
|
// ========== codage des METHODES VIRTUELLES protegees:================
|
|
// calcul des contraintes a t+dt
|
|
//void Calcul_SigmaHH (TenseurHH & sigHH_t,TenseurBB& DepsBB,DdlElement & tab_ddl
|
|
// ,TenseurBB & gijBB_t,TenseurHH & gijHH_t,BaseB& giB,BaseH& gi_H, TenseurBB & epsBB_
|
|
// ,TenseurBB & delta_epsBB_
|
|
// ,TenseurBB & gijBB_,TenseurHH & gijHH_,Tableau <TenseurBB *>& d_gijBB_
|
|
// ,double& jacobien_0,double& jacobien,TenseurHH & sigHH
|
|
// ,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double& module_cisaillement
|
|
// ,const Met_abstraite::Expli_t_tdt& ex);
|
|
void Hypo_hooke3D::Calcul_SigmaHH (TenseurHH& sigHH_t,TenseurBB& DepsBB_,DdlElement &
|
|
,TenseurBB & gijBB_t_,TenseurHH & gijHH_t_,BaseB& ,BaseH& ,TenseurBB& epsBB_
|
|
,TenseurBB& delta_epsBB_
|
|
, 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& ex)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if (Permet_affichage() > 3)
|
|
{cout << "\n --- loi de comportement Hypo_hooke3D Calcul_SigmaHH --- ";
|
|
Signature_pti_encours(cout);
|
|
};
|
|
if (DepsBB_.Dimension() != 3)
|
|
{ cout << "\nErreur : la dimension devrait etre 3 !\n";
|
|
cout << " Hypo_hooke3D::Calcul_SigmaHH\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
const Tenseur3BB & epsBB = *((Tenseur3BB*) &epsBB_); // passage en dim 3
|
|
const Tenseur3BB & DepsBB = *((Tenseur3BB*) &DepsBB_); // passage en dim 3
|
|
const Tenseur3BB & delta_epsBB = *((Tenseur3BB*) &delta_epsBB_); // passage en dim 3
|
|
const Tenseur3HH & gijHH = *((Tenseur3HH*) &gijHH_); // " " " "
|
|
const Tenseur3BB & gijBB = *((Tenseur3BB*) &gijBB_); // " " " "
|
|
const Tenseur3HH & gijHH_t = *((Tenseur3HH*) &gijHH_t_); // " " " "
|
|
const Tenseur3BB & gijBB_t = *((Tenseur3BB*) &gijBB_t_); // " " " "
|
|
Tenseur3HH & sigHH = *((Tenseur3HH*) &sigHH_); // " " " "
|
|
Tenseur3HH & sigHH_nn = *((Tenseur3HH*) &sigHH_t); // " " " "
|
|
|
|
SaveResulLoi_Hypo3D & save_resul = *((SaveResulLoi_Hypo3D*) saveResul);
|
|
// tenseur intermédiaires utilisées selon les cas (par forcément dans tous les cas !!)
|
|
Tenseur3BH sigBH_n;Tenseur3HH sigHH_n; Tenseur3BB sigBB_n;Tenseur3BB sig_interBB_n;
|
|
switch (type_derive)
|
|
{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;
|
|
// pour la déformation cumulée associée,
|
|
Tenseur3HH eps_interHH_n = gijHH_t * save_resul.eps_cumulBB_t * gijHH_t;
|
|
Tenseur3BB epsBB_n = 0.5*( gijBB * eps_interHH_n * gijBB + save_resul.eps_cumulBB_t);
|
|
save_resul.eps_cumulBB = delta_epsBB + epsBB_n;
|
|
break;
|
|
}
|
|
case 0: //cas d'une dérivée de Lie deux fois covariante
|
|
{sigBB_n = gijBB_t * sigHH_nn * gijBB_t;
|
|
sigBH_n = sigBB_n * gijHH ;
|
|
sigHH_n = gijHH * sigBH_n ;
|
|
// pour la déformation cumulée associée, on sait que cela donne directement la def d'Almansi
|
|
// mais la def passée en paramètre pourrait ne pas être d'Almansi, donc on calcule
|
|
// quand même la def cumulée
|
|
save_resul.eps_cumulBB = save_resul.eps_cumulBB_t + delta_epsBB;
|
|
break;
|
|
}
|
|
case 1: // cas d'une dérivée de Lie deux fois contravariante
|
|
{sigHH_n = sigHH_nn;
|
|
sigBH_n = gijBB * sigHH_n;
|
|
sigBB_n = sigBH_n * gijBB;
|
|
// pour la déformation cumulée associée,
|
|
Tenseur3HH eps_interHH_n = gijHH_t * save_resul.eps_cumulBB_t * gijHH_t;
|
|
Tenseur3BB epsBB_n = gijBB * eps_interHH_n * gijBB ;
|
|
save_resul.eps_cumulBB = delta_epsBB + epsBB_n;
|
|
break;}
|
|
};
|
|
|
|
bool affichage = (Permet_affichage() > 5);
|
|
#ifdef MISE_AU_POINT
|
|
if (affichage)
|
|
{cout << "\n === donnees d'entree ";
|
|
cout << "\n epsBB_tdt(local)= "; epsBB.Ecriture(cout);
|
|
cout << "\n DepsBB(local)= "; DepsBB.Ecriture(cout);
|
|
cout << "\n delta_epsBB(local)= "; delta_epsBB.Ecriture(cout);
|
|
cout << "\n sigHH_t(local)= "; sigHH_t.Ecriture(cout);
|
|
// en absolue
|
|
Tenseur3BB tiutiu;
|
|
epsBB.BaseAbsolue(tiutiu,*(ex.giH_tdt));
|
|
cout << "\n eps en absolu :";tiutiu.Ecriture(cout);
|
|
DepsBB.BaseAbsolue(tiutiu,*(ex.giH_tdt));
|
|
cout << "\n Deps en absolu :";tiutiu.Ecriture(cout);
|
|
delta_epsBB.BaseAbsolue(tiutiu,*(ex.giH_tdt));
|
|
cout << "\n delta_eps en absolu :";tiutiu.Ecriture(cout);
|
|
Tenseur3HH titi;
|
|
sigHH_t.BaseAbsolue(titi,*(ex.giB_tdt));
|
|
cout << "\n sig_t en absolu :";titi.Ecriture(cout);
|
|
};
|
|
#endif
|
|
|
|
// opération de transmission de la métrique
|
|
const Met_abstraite::Impli* ex_impli = NULL;
|
|
const Met_abstraite::Expli_t_tdt* ex_expli_tdt = &ex;
|
|
const Met_abstraite::Umat_cont* ex_expli = NULL;
|
|
|
|
// cas de la thermo dépendance, on calcul les grandeurs
|
|
if (mu_temperature != NULL)
|
|
{ mu = mu_temperature->Valeur(*temperature);}
|
|
else if (mu_nD != NULL)
|
|
// là il faut calculer la fonction nD
|
|
{ // on utilise la méthode générique de loi abstraite
|
|
list <SaveResul*> list_save; // inter pour l'appel de la fonction
|
|
list_save.push_back(saveResul);
|
|
Tableau <double> & tab_val = Loi_comp_abstraite::Loi_comp_Valeur_FnD_Evoluee
|
|
(mu_nD,1 // une seule valeur attendue en retour
|
|
,ex_impli,ex_expli_tdt,ex_expli
|
|
,NULL
|
|
,NULL
|
|
,&list_save
|
|
);
|
|
|
|
/*// ici on utilise les variables connues aux pti, ou calculées à partir de
|
|
// on commence par récupérer les conteneurs des grandeurs à fournir
|
|
List_io <Ddl_enum_etendu>& li_enu_scal = mu_nD->Li_enu_etendu_scalaire();
|
|
List_io <TypeQuelconque >& li_quelc = mu_nD->Li_equi_Quel_evolue();
|
|
bool absolue = true; // on se place systématiquement en absolu
|
|
// on va utiliser la méhode Valeur_multi_interpoler_ou_calculer
|
|
// pour les grandeurs strictement scalaire
|
|
Tableau <double> val_ddl_enum(Valeur_multi_interpoler_ou_calculer
|
|
(absolue,TEMPS_tdt,li_enu_scal,ex_impli,ex_expli_tdt,ex_expli,NULL)
|
|
);
|
|
// on utilise la méthode Valeurs_Tensorielles_interpoler_ou_calculer
|
|
// pour les Coordonnees et Tenseur
|
|
Valeurs_Tensorielles_interpoler_ou_calculer
|
|
(absolue,TEMPS_tdt,li_quelc,ex_impli,ex_expli_tdt,ex_expli,NULL);
|
|
// calcul de la valeur et retour dans tab_ret
|
|
Tableau <double> & tab_val = mu_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
|
|
#ifdef MISE_AU_POINT
|
|
if (tab_val.Taille() != 1)
|
|
{ cout << "\nErreur : la fonction nD relative a la fonction mu "
|
|
<< " doit calculer un scalaire or le tableau de retour est de taille "
|
|
<< tab_val.Taille() << " ce n'est pas normal !\n";
|
|
cout << " Hypo_hooke3D::Calcul_SigmaHH\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
*/
|
|
// on récupère le premier élément du tableau uniquement
|
|
mu = tab_val(1);
|
|
};
|
|
if (!compress_thermophysique) // sinon kc est mis à jour avec la méthode CalculGrandeurTravail(..)
|
|
{if (Kc_temperature != NULL)
|
|
{Kc = Kc_temperature->Valeur(*temperature);}
|
|
else if (Kc_nD != NULL)
|
|
// là il faut calculer la fonction nD
|
|
{ // on utilise la méthode générique de loi abstraite
|
|
list <SaveResul*> list_save; // inter pour l'appel de la fonction
|
|
list_save.push_back(saveResul);
|
|
Tableau <double> & tab_val = Loi_comp_abstraite::Loi_comp_Valeur_FnD_Evoluee
|
|
(Kc_nD,1 // une seule valeur attendue en retour
|
|
,ex_impli,ex_expli_tdt,ex_expli
|
|
,NULL
|
|
,NULL
|
|
,&list_save
|
|
);
|
|
|
|
/* // ici on utilise les variables connues aux pti, ou calculées à partir de
|
|
// on commence par récupérer les conteneurs des grandeurs à fournir
|
|
List_io <Ddl_enum_etendu>& li_enu_scal = Kc_nD->Li_enu_etendu_scalaire();
|
|
List_io <TypeQuelconque >& li_quelc = Kc_nD->Li_equi_Quel_evolue();
|
|
bool absolue = true; // on se place systématiquement en absolu
|
|
// on va utiliser la méhode Valeur_multi_interpoler_ou_calculer
|
|
// pour les grandeurs strictement scalaire
|
|
Tableau <double> val_ddl_enum(Valeur_multi_interpoler_ou_calculer
|
|
(absolue,TEMPS_tdt,li_enu_scal,ex_impli,ex_expli_tdt,ex_expli,NULL)
|
|
);
|
|
// on utilise la méthode Valeurs_Tensorielles_interpoler_ou_calculer
|
|
// pour les Coordonnees et Tenseur
|
|
Valeurs_Tensorielles_interpoler_ou_calculer
|
|
(absolue,TEMPS_tdt,li_quelc,ex_impli,ex_expli_tdt,ex_expli,NULL);
|
|
// calcul de la valeur et retour dans tab_ret
|
|
Tableau <double> & tab_val = Kc_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
|
|
#ifdef MISE_AU_POINT
|
|
if (tab_val.Taille() != 1)
|
|
{ cout << "\nErreur : la fonction nD relative a la fonction Kc "
|
|
<< " doit calculer un scalaire or le tableau de retour est de taille "
|
|
<< tab_val.Taille() << " ce n'est pas normal !\n";
|
|
cout << " Hypo_hooke3D::Calcul_SigmaHH\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
*/
|
|
// on récupère le premier élément du tableau uniquement
|
|
Kc = tab_val(1);
|
|
};
|
|
};
|
|
|
|
// cas d'une non-linéarité en fonction de la déformation
|
|
double Kc_use=Kc;// pour ne pas changer les valeurs à chaque passage !!
|
|
double mu_use=mu;// "
|
|
if ((Kc_IIeps != NULL)||(mu_IIeps != NULL))
|
|
{ Tenseur3BH epsBH = epsBB * gijHH;double II_eps=epsBH.II();
|
|
if (Kc_IIeps != NULL)
|
|
{ double coef1 = Kc_IIeps->Valeur(II_eps);
|
|
Kc_use *= coef1;
|
|
};
|
|
if (mu_IIeps != NULL)
|
|
{ double coef2 = mu_IIeps->Valeur(II_eps);
|
|
mu_use *= coef2;
|
|
};
|
|
};
|
|
|
|
// sauvegarde des paramètres matériau
|
|
save_resul.Kc = Kc_use;
|
|
save_resul.mu = mu_use;
|
|
|
|
#ifdef MISE_AU_POINT
|
|
if (affichage)
|
|
{cout << "\n giB_tdt" << (*ex.giB_tdt);
|
|
cout << "\n giH_tdt" << (*ex.giH_tdt);
|
|
cout << "\n mu= "<< mu_use << ", K= "<< Kc_use;
|
|
};
|
|
#endif
|
|
// recup de l'incrément de temps
|
|
double deltat=ParaGlob::Variables_de_temps().IncreTempsCourant();
|
|
|
|
double unSurDeltat=0;
|
|
if (unSurDeltat < 0)
|
|
{ cout << "\n le pas de temps est négatif !! "; };
|
|
|
|
static const double untier=1./3.;
|
|
double Isig_n = sigBH_n.Trace();
|
|
|
|
//---- on fait un traitement différent suivant que le pas de temps est petit ou non
|
|
if (Abs(deltat) >= ConstMath::trespetit)
|
|
{ // -- cas normal
|
|
|
|
// cas de la partie sphérique
|
|
Tenseur3BH DepsBH = DepsBB * gijHH;
|
|
// le calcul de la contrainte correspond à l'intégration d'une équation différencielle
|
|
// D_barre=1/mu dS/dt pour la partie déviatoire
|
|
// et pour la partie sphérique
|
|
// I_D = 1/(Kc) dI_Sig/dt
|
|
double IDeps = DepsBH.Trace();
|
|
Tenseur3BH Deps_barre_BH = DepsBH - (untier * IDeps) * IdBH3;
|
|
// cas de la partie sphérique
|
|
double Isigma = Isig_n + deltat * Kc_use * IDeps;
|
|
// cas de la partie déviatorique
|
|
|
|
switch (cas_calcul)
|
|
{ case 0: // calcul normal (tous les termes)
|
|
{ // cas de la partie sphérique déjà calculée
|
|
// cas de la partie déviatorique
|
|
Tenseur3BH SBH_n = sigBH_n - (untier * Isig_n) * IdBH3;
|
|
Tenseur3HH SHH = gijHH * (SBH_n + deltat * mu_use * Deps_barre_BH);
|
|
sigHH = SHH + (untier * Isigma) * gijHH ;
|
|
break;
|
|
}
|
|
case 1: // calcul de la partie déviatorique seule
|
|
{ // cas de la partie déviatorique
|
|
Tenseur3BH SBH_n = sigBH_n - (untier * Isig_n) * IdBH3;
|
|
sigHH = gijHH * (SBH_n + deltat * mu_use * Deps_barre_BH);
|
|
break;
|
|
}
|
|
case 2: // calcul de la partie sphérique seule
|
|
{ // cas de la partie sphérique
|
|
sigHH = (untier * Isigma) * gijHH ; //*IdBH3 ;
|
|
break;
|
|
}
|
|
default:
|
|
{ cout << "\n erreur l'indicateur cas_calcul= " << cas_calcul << " n'a pas une valeur correcte !! "
|
|
<< "\n Hypo_hooke3D::Calcul_SigmaHH (.... ";
|
|
Sortie(1);
|
|
}
|
|
};
|
|
#ifdef MISE_AU_POINT
|
|
if (affichage)
|
|
{cout << "\n pas de temps normal ";
|
|
cout << "\n IDeps= "<< IDeps;
|
|
cout << "\n Deps_barre_BH(local)= "; Deps_barre_BH.Ecriture(cout);
|
|
Tenseur3BH tiutiu;
|
|
Deps_barre_BH.BaseAbsolue(tiutiu,*(ex.giB_tdt),*(ex.giH_tdt));
|
|
cout << "\n Deps_barre_BH en absolu :";tiutiu.Ecriture(cout);
|
|
Tenseur3HH titi;
|
|
sigHH.BaseAbsolue(titi,*(ex.giB_tdt));
|
|
cout << "\n sig_tdt en absolu :";titi.Ecriture(cout);
|
|
}
|
|
#endif
|
|
// traitement des énergies
|
|
// on incrémente l'énergie élastique
|
|
energ.ChangeEnergieElastique(energ_t.EnergieElastique() + 0.5 * deltat * ((sigHH + sigHH_nn) && DepsBB));
|
|
}
|
|
else
|
|
{// --cas d'un deltat très petit, on utilise delta eps à la place de deltat * D
|
|
#ifdef MISE_AU_POINT
|
|
if (affichage)
|
|
cout << "\n pas de temps tres petit, on utilise delta eps a la place de deltat * D ";
|
|
#endif
|
|
|
|
// cas de la partie sphérique
|
|
Tenseur3BH delta_epsBH = delta_epsBB * gijHH;
|
|
double Idelta_eps = delta_epsBH.Trace();
|
|
Tenseur3BH delta_eps_barre_BH = delta_epsBH - (untier * Idelta_eps) * IdBH3;
|
|
|
|
double Isigma = Isig_n + Kc_use * Idelta_eps;
|
|
// cas de la partie déviatorique
|
|
|
|
switch (cas_calcul)
|
|
{ case 0: // calcul normal (tous les termes)
|
|
{ // cas de la partie sphérique déjà calculée
|
|
// cas de la partie déviatorique
|
|
Tenseur3BH SBH_n = sigBH_n - (untier * Isig_n) * IdBH3;
|
|
Tenseur3HH SHH = gijHH * (SBH_n + mu_use * delta_eps_barre_BH);
|
|
sigHH = SHH + (untier * Isigma) * gijHH ;
|
|
break;
|
|
}
|
|
case 1: // calcul de la partie déviatorique seule
|
|
{ // cas de la partie déviatorique
|
|
Tenseur3BH SBH_n = sigBH_n - (untier * Isig_n) * IdBH3;
|
|
sigHH = gijHH * (SBH_n + mu_use * delta_eps_barre_BH);
|
|
break;
|
|
}
|
|
case 2: // calcul de la partie sphérique seule
|
|
{ // cas de la partie sphérique
|
|
sigHH = (untier * Isigma) * gijHH ; //*IdBH3 ;
|
|
break;
|
|
}
|
|
default:
|
|
{ cout << "\n erreur l'indicateur cas_calcul= " << cas_calcul << " n'a pas une valeur correcte !! "
|
|
<< "\n Hypo_hooke3D::Calcul_SigmaHH (.... ";
|
|
Sortie(1);
|
|
}
|
|
};
|
|
// traitement des énergies
|
|
// on incrémente l'énergie élastique
|
|
energ.ChangeEnergieElastique(energ_t.EnergieElastique() + 0.5 * ((sigHH + sigHH_nn) && delta_epsBB));
|
|
|
|
#ifdef MISE_AU_POINT
|
|
if (affichage)
|
|
{cout << "\n pas de temps tres petit, on utilise delta eps a la place de deltat * D ";
|
|
cout << "\n Idelta_eps= "<< Idelta_eps;
|
|
cout << "\n delta_eps_barre_BH(local)= "; delta_eps_barre_BH.Ecriture(cout);
|
|
Tenseur3BH tiutiu;
|
|
delta_eps_barre_BH.BaseAbsolue(tiutiu,*(ex.giB_tdt),*(ex.giH_tdt));
|
|
cout << "\n delta_eps_barre_BH en absolu :";tiutiu.Ecriture(cout);
|
|
Tenseur3HH titi;
|
|
sigHH.BaseAbsolue(titi,*(ex.giB_tdt));
|
|
cout << "\n sig_tdt en absolu :";titi.Ecriture(cout);
|
|
}
|
|
#endif
|
|
|
|
|
|
}
|
|
|
|
// récup de la compressibilité (-p_point = compress * I_D, S_point = cisaille * D_barre)
|
|
module_compressibilite = Kc_use/3.;
|
|
module_cisaillement = 0.5 * mu_use;
|
|
|
|
LibereTenseur();
|
|
};
|
|
|
|
// void Calcul_DsigmaHH_tdt (TenseurHH & sigHH_t,TenseurBB& DepsBB,DdlElement & tab_ddl
|
|
// ,BaseB& giB_t,TenseurBB & gijBB_t,TenseurHH & gijHH_t
|
|
// ,BaseB& giB_tdt,Tableau <BaseB> & d_giB_tdt,BaseH& giH_tdt,Tableau <BaseH> & d_giH_tdt
|
|
// ,TenseurBB & epsBB_tdt,Tableau <TenseurBB *>& d_epsBB
|
|
// ,TenseurBB & delta_epsBB,TenseurBB & gijBB_tdt,TenseurHH & gijHH_tdt
|
|
// ,Tableau <TenseurBB *>& d_gijBB_tdt
|
|
// ,Tableau <TenseurHH *>& d_gijHH_tdt,double& jacobien_0,double& jacobien
|
|
// ,Vecteur& d_jacobien_tdt,TenseurHH& sigHH,Tableau <TenseurHH *>& d_sigHH
|
|
// ,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double& module_cisaillement
|
|
// ,const Met_abstraite::Impli& ex);
|
|
// calcul des contraintes a t+dt et de ses variations
|
|
void Hypo_hooke3D::Calcul_DsigmaHH_tdt (TenseurHH& sigHH_t,TenseurBB& DepsBB_,DdlElement & tab_ddl
|
|
,BaseB& ,TenseurBB & gijBB_t_,TenseurHH & gijHH_t_
|
|
,BaseB& ,Tableau <BaseB> & ,BaseH& ,Tableau <BaseH> &
|
|
,TenseurBB & epsBB_tdt,Tableau <TenseurBB *>& d_epsBB
|
|
,TenseurBB & delta_epsBB_,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 (Permet_affichage() > 3)
|
|
{cout << "\n --- loi de comportement Hypo_hooke3D Calcul_DsigmaHH_tdt --- ";
|
|
Signature_pti_encours(cout);
|
|
};
|
|
if (DepsBB_.Dimension() != 3)
|
|
{ cout << "\nErreur : la dimension devrait etre 3 !\n";
|
|
cout << " Hypo_hooke3D::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 << " Hypo_hooke3D::Calcul_SDsigmaHH_tdt\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
const Tenseur3BB & epsBB = *((Tenseur3BB*) &epsBB_tdt); // passage en dim 3
|
|
const Tenseur3BB & DepsBB = *((Tenseur3BB*) &DepsBB_); // passage en dim 3
|
|
const Tenseur3HH & gijHH = *((Tenseur3HH*) &gijHH_tdt); // " " " "
|
|
const Tenseur3BB & gijBB = *((Tenseur3BB*) &gijBB_tdt); // " " " "
|
|
|
|
const Tenseur3BB & delta_epsBB = *((Tenseur3BB*) &delta_epsBB_); // passage en dim 3
|
|
const Tenseur3HH & gijHH_t = *((Tenseur3HH*) &gijHH_t_); // " " " "
|
|
const Tenseur3BB & gijBB_t = *((Tenseur3BB*) &gijBB_t_); // " " " "
|
|
|
|
|
|
Tenseur3HH & sigHH = *((Tenseur3HH*) &sigHH_tdt); // " " " "
|
|
Tenseur3HH & sigHH_nn = *((Tenseur3HH*) &sigHH_t); // " " " "
|
|
|
|
SaveResulLoi_Hypo3D & save_resul = *((SaveResulLoi_Hypo3D*) saveResul);
|
|
// tenseur intermédiaires utilisées selon les cas (par forcément dans tous les cas !!)
|
|
Tenseur3BH sigBH_n;Tenseur3HH sigHH_n; Tenseur3BB sigBB_n;Tenseur3BB 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;
|
|
// pour la déformation cumulée associée,
|
|
Tenseur3HH eps_interHH_n = gijHH_t * save_resul.eps_cumulBB_t * gijHH_t;
|
|
Tenseur3BB epsBB_n = 0.5*( gijBB * eps_interHH_n * gijBB + save_resul.eps_cumulBB_t);
|
|
save_resul.eps_cumulBB = delta_epsBB + epsBB_n;
|
|
break;
|
|
}
|
|
case 0: //cas d'une dérivée de Lie deux fois covariante
|
|
{sigBB_n = gijBB_t * sigHH_nn * gijBB_t;
|
|
sigBH_n = sigBB_n * gijHH ;
|
|
sigHH_n = gijHH * sigBH_n ;
|
|
// pour la déformation cumulée associée, on sait que cela donne directement la def d'Almansi
|
|
// mais la def passée en paramètre pourrait ne pas être d'Almansi, donc on calcule
|
|
// quand même la def cumulée
|
|
save_resul.eps_cumulBB = save_resul.eps_cumulBB_t + delta_epsBB;
|
|
break;
|
|
}
|
|
case 1: // cas d'une dérivée de Lie deux fois contravariante
|
|
{sigHH_n = sigHH_nn;
|
|
sigBH_n = gijBB * sigHH_n;
|
|
sigBB_n = sigBH_n * gijBB;
|
|
// pour la déformation cumulée associée,
|
|
Tenseur3HH eps_interHH_n = gijHH_t * save_resul.eps_cumulBB_t * gijHH_t;
|
|
Tenseur3BB epsBB_n = gijBB * eps_interHH_n * gijBB ;
|
|
save_resul.eps_cumulBB = delta_epsBB + epsBB_n;
|
|
break;
|
|
}
|
|
};
|
|
|
|
bool affichage = (Permet_affichage() > 5);
|
|
#ifdef MISE_AU_POINT
|
|
if (affichage)
|
|
{cout << "\n === donnees d'entree ";
|
|
cout << "\n epsBB_tdt(local)= "; epsBB.Ecriture(cout);
|
|
cout << "\n DepsBB(local)= "; DepsBB.Ecriture(cout);
|
|
cout << "\n delta_epsBB(local)= "; delta_epsBB.Ecriture(cout);
|
|
cout << "\n sigHH_t(local)= "; sigHH_t.Ecriture(cout);
|
|
// en absolue
|
|
Tenseur3BB tiutiu;
|
|
epsBB.BaseAbsolue(tiutiu,*(ex.giH_tdt));
|
|
cout << "\n eps en absolu :";tiutiu.Ecriture(cout);
|
|
DepsBB.BaseAbsolue(tiutiu,*(ex.giH_tdt));
|
|
cout << "\n Deps en absolu :";tiutiu.Ecriture(cout);
|
|
delta_epsBB.BaseAbsolue(tiutiu,*(ex.giH_tdt));
|
|
cout << "\n delta_eps en absolu :";tiutiu.Ecriture(cout);
|
|
Tenseur3HH titi;
|
|
sigHH_t.BaseAbsolue(titi,*(ex.giB_tdt));
|
|
cout << "\n sig_t en absolu :";titi.Ecriture(cout);
|
|
};
|
|
#endif
|
|
|
|
|
|
// opération de transmission de la métrique
|
|
const Met_abstraite::Impli* ex_impli = &ex;
|
|
const Met_abstraite::Expli_t_tdt* ex_expli_tdt = NULL;
|
|
const Met_abstraite::Umat_cont* ex_expli = NULL;
|
|
|
|
// cas de la thermo dépendance, on calcul les grandeurs
|
|
if (mu_temperature != NULL)
|
|
{ mu = mu_temperature->Valeur(*temperature);}
|
|
else if (mu_nD != NULL)
|
|
// là il faut calculer la fonction nD
|
|
{ // on utilise la méthode générique de loi abstraite
|
|
list <SaveResul*> list_save; // inter pour l'appel de la fonction
|
|
list_save.push_back(saveResul);
|
|
Tableau <double> & tab_val = Loi_comp_abstraite::Loi_comp_Valeur_FnD_Evoluee
|
|
(mu_nD,1 // une seule valeur attendue en retour
|
|
,ex_impli,ex_expli_tdt,ex_expli
|
|
,NULL
|
|
,NULL
|
|
,&list_save
|
|
);
|
|
/*// ici on utilise les variables connues aux pti, ou calculées à partir de
|
|
// on commence par récupérer les conteneurs des grandeurs à fournir
|
|
List_io <Ddl_enum_etendu>& li_enu_scal = mu_nD->Li_enu_etendu_scalaire();
|
|
List_io <TypeQuelconque >& li_quelc = mu_nD->Li_equi_Quel_evolue();
|
|
bool absolue = true; // on se place systématiquement en absolu
|
|
// on va utiliser la méhode Valeur_multi_interpoler_ou_calculer
|
|
// pour les grandeurs strictement scalaire
|
|
Tableau <double> val_ddl_enum(Valeur_multi_interpoler_ou_calculer
|
|
(absolue,TEMPS_tdt,li_enu_scal,ex_impli,ex_expli_tdt,ex_expli,NULL)
|
|
);
|
|
// on utilise la méthode Valeurs_Tensorielles_interpoler_ou_calculer
|
|
// pour les Coordonnees et Tenseur
|
|
Valeurs_Tensorielles_interpoler_ou_calculer
|
|
(absolue,TEMPS_tdt,li_quelc,ex_impli,ex_expli_tdt,ex_expli,NULL);
|
|
// calcul de la valeur et retour dans tab_ret
|
|
Tableau <double> & tab_val = mu_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
|
|
#ifdef MISE_AU_POINT
|
|
if (tab_val.Taille() != 1)
|
|
{ cout << "\nErreur : la fonction nD relative a la fonction mu "
|
|
<< " doit calculer un scalaire or le tableau de retour est de taille "
|
|
<< tab_val.Taille() << " ce n'est pas normal !\n";
|
|
cout << " Hypo_hooke3D::Calcul_SigmaHH\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
*/
|
|
// on récupère le premier élément du tableau uniquement
|
|
mu = tab_val(1);
|
|
};
|
|
if (!compress_thermophysique) // sinon kc est mis à jour avec la méthode CalculGrandeurTravail(..)
|
|
{if (Kc_temperature != NULL)
|
|
{Kc = Kc_temperature->Valeur(*temperature);}
|
|
else if (Kc_nD != NULL)
|
|
// là il faut calculer la fonction nD
|
|
{ // on utilise la méthode générique de loi abstraite
|
|
list <SaveResul*> list_save; // inter pour l'appel de la fonction
|
|
list_save.push_back(saveResul);
|
|
Tableau <double> & tab_val = Loi_comp_abstraite::Loi_comp_Valeur_FnD_Evoluee
|
|
(Kc_nD,1 // une seule valeur attendue en retour
|
|
,ex_impli,ex_expli_tdt,ex_expli
|
|
,NULL
|
|
,NULL
|
|
,&list_save
|
|
);
|
|
|
|
/* // ici on utilise les variables connues aux pti, ou calculées à partir de
|
|
// on commence par récupérer les conteneurs des grandeurs à fournir
|
|
List_io <Ddl_enum_etendu>& li_enu_scal = Kc_nD->Li_enu_etendu_scalaire();
|
|
List_io <TypeQuelconque >& li_quelc = Kc_nD->Li_equi_Quel_evolue();
|
|
bool absolue = true; // on se place systématiquement en absolu
|
|
// on va utiliser la méhode Valeur_multi_interpoler_ou_calculer
|
|
// pour les grandeurs strictement scalaire
|
|
Tableau <double> val_ddl_enum(Valeur_multi_interpoler_ou_calculer
|
|
(absolue,TEMPS_tdt,li_enu_scal,ex_impli,ex_expli_tdt,ex_expli,NULL)
|
|
);
|
|
// on utilise la méthode Valeurs_Tensorielles_interpoler_ou_calculer
|
|
// pour les Coordonnees et Tenseur
|
|
Valeurs_Tensorielles_interpoler_ou_calculer
|
|
(absolue,TEMPS_tdt,li_quelc,ex_impli,ex_expli_tdt,ex_expli,NULL);
|
|
// calcul de la valeur et retour dans tab_ret
|
|
Tableau <double> & tab_val = Kc_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
|
|
#ifdef MISE_AU_POINT
|
|
if (tab_val.Taille() != 1)
|
|
{ cout << "\nErreur : la fonction nD relative a la fonction Kc "
|
|
<< " doit calculer un scalaire or le tableau de retour est de taille "
|
|
<< tab_val.Taille() << " ce n'est pas normal !\n";
|
|
cout << " Hypo_hooke3D::Calcul_SigmaHH\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
*/
|
|
// on récupère le premier élément du tableau uniquement
|
|
Kc = tab_val(1);
|
|
};
|
|
};
|
|
|
|
|
|
// cas d'une non-linéarité en fonction de la déformation
|
|
Tenseur3BH epsBH; Courbe1D::ValDer valder_Kc,valder_mu;
|
|
double Kc_base=Kc;double Kc_use=Kc;// pour ne pas changer les valeurs à chaque passage !!
|
|
double mu_base=mu;double mu_use=mu;// idem
|
|
if ((Kc_IIeps != NULL)||(mu_IIeps != NULL))
|
|
{ epsBH = epsBB * gijHH;double II_eps=epsBH.II();
|
|
if (Kc_IIeps != NULL)
|
|
{ valder_Kc = Kc_IIeps->Valeur_Et_derivee(II_eps);
|
|
Kc_use *= valder_Kc.valeur;
|
|
};
|
|
if (mu_IIeps != NULL)
|
|
{ valder_mu = mu_IIeps->Valeur_Et_derivee(II_eps);
|
|
mu_use *= valder_mu.valeur;
|
|
};
|
|
};
|
|
|
|
// sauvegarde des paramètres matériau
|
|
save_resul.Kc = Kc_use;
|
|
save_resul.mu = mu_use;
|
|
|
|
#ifdef MISE_AU_POINT
|
|
if (affichage)
|
|
{cout << "\n giB_tdt" << (*ex.giB_tdt);
|
|
cout << "\n giH_tdt" << (*ex.giH_tdt);
|
|
cout << "\n mu= "<< mu_use << ", K= "<< Kc_use;
|
|
};
|
|
#endif
|
|
|
|
Tenseur3BH DepsBH = DepsBB * gijHH;
|
|
// recup de l'incrément de temps
|
|
double deltat=ParaGlob::Variables_de_temps().IncreTempsCourant();
|
|
// le calcul de la contrainte correspond à l'intégration d'une équation différencielle
|
|
// D_barre=1/mu dS/dt pour la partie déviatoire
|
|
// et pour la partie sphérique
|
|
// I_D = 1/(Kc) dI_Sig/dt
|
|
double IDeps = DepsBH.Trace();
|
|
static const double untier=1./3.;
|
|
Tenseur3BH Deps_barre_BH = DepsBH - (untier * IDeps) * IdBH3;
|
|
double Isig_n = sigBH_n.Trace();
|
|
Tenseur3BH SBH_n = sigBH_n - (untier * Isig_n) * IdBH3;
|
|
|
|
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
|
|
{ // 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;
|
|
};
|
|
// cas de la partie sphérique
|
|
double Isigma = Isig_n + deltat * Kc_use * IDeps;
|
|
// cas de la partie déviatorique
|
|
|
|
switch (cas_calcul)
|
|
{ case 0: // calcul normal (tous les termes)
|
|
{ // la partie sphérique est déjà calculé, cas de la partie déviatorique
|
|
Tenseur3HH SHH = gijHH * (SBH_n + deltat * mu_use * Deps_barre_BH);
|
|
sigHH = SHH + (untier * Isigma) * gijHH ;
|
|
break;
|
|
}
|
|
case 1: // calcul de la partie déviatorique seule
|
|
{ sigHH = gijHH * (SBH_n + deltat * mu_use * Deps_barre_BH);
|
|
break;
|
|
}
|
|
case 2: // calcul de la partie sphérique seule
|
|
{ sigHH = (untier * Isigma) * gijHH ; // *IdBH3;
|
|
break;
|
|
}
|
|
default:
|
|
{ cout << "\n erreur l'indicateur cas_calcul= " << cas_calcul << " n'a pas une valeur correcte !! "
|
|
<< "\n Hypo_hooke3D::Calcul_DsigmaHH_tdt (.... ";
|
|
Sortie(1);
|
|
}
|
|
};
|
|
#ifdef MISE_AU_POINT
|
|
if (affichage)
|
|
{//cout << "\n pas de temps normal ";
|
|
cout << "\n IDeps= "<< IDeps;
|
|
cout << "\n Deps_barre_BH(local)= "; Deps_barre_BH.Ecriture(cout);
|
|
Tenseur3BH tiutiu;
|
|
Deps_barre_BH.BaseAbsolue(tiutiu,*(ex.giB_tdt),*(ex.giH_tdt));
|
|
cout << "\n Deps_barre_BH en absolu :";tiutiu.Ecriture(cout);
|
|
Tenseur3HH titi;
|
|
sigHH.BaseAbsolue(titi,*(ex.giB_tdt));
|
|
cout << "\n sig_tdt en absolu :";titi.Ecriture(cout);
|
|
}
|
|
#endif
|
|
////--- debug
|
|
//cout << "\n Hypo_hooke3D::Calcul_DsigmaHH_tdt";
|
|
//cout << "\n IDeps= "<<IDeps << " Isig_n= "<<Isig_n << " Isigma= "<<Isigma
|
|
// << " mu_use= "<< mu_use << "\n Deps_barre_BH ";
|
|
//Deps_barre_BH.Ecriture(cout);
|
|
//cout << " sigHH "; sigHH.Ecriture(cout);
|
|
//cout << endl;
|
|
////--- fin debug
|
|
//----------------- debug
|
|
//Tenseur3BB truc =deltat*DepsBB;
|
|
//cout << "\n epsBB="<<epsBB<<" ";
|
|
//cout << "\n unSurDeltat*DepsBB="<<truc<<" ";
|
|
//cout << "\n sighh="<<sigHH<<" ";
|
|
//----------- fin debug
|
|
|
|
// cas de la partie déviatoire puis du tenseur total
|
|
int nbddl = d_gijBB_tdt.Taille();
|
|
Tenseur3BH d_DepsBH,d_Deps_barre_BH,depsBH; // tenseurs de travail
|
|
Tenseur3BH dsigBH_n,d_SBH_n; // tenseurs de travail
|
|
Tenseur_ns3HH d_SHH; // tenseurs de travail
|
|
// en fait dans le cas d'une linéarisation seul le transport de la contrainte à de l'importance
|
|
// 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 ()
|
|
Tenseur3HH & dsigHH = *((Tenseur3HH*) (d_sigHH(i))); // passage en dim 1
|
|
const Tenseur3BB & dgijBB = *((Tenseur3BB*)(d_gijBB_tdt(i))); // passage en dim 1
|
|
const Tenseur3HH & dgijHH = *((Tenseur3HH*)(d_gijHH_tdt(i))) ; // pour simplifier l'ecriture
|
|
const Tenseur3BB & depsBB = *((Tenseur3BB *) (d_epsBB(i))); // "
|
|
// variation de la vitesse de déformation
|
|
d_DepsBH = ( unSurDeltat) * depsBB * gijHH + DepsBB * dgijHH;
|
|
// variation de la trace
|
|
double d_IDeps = d_DepsBH.Trace();
|
|
// variation du déviateur
|
|
d_Deps_barre_BH = d_DepsBH - (d_IDeps/3.) * IdBH3;
|
|
|
|
// 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 du au transport
|
|
double dIsig_n = dsigBH_n.Trace();
|
|
// variation de la trace de sigma actuel
|
|
double dIsigma = dIsig_n + deltat * Kc_use * d_IDeps;
|
|
double dIIepsBH=0.;
|
|
if ((Kc_IIeps != NULL) || (mu_IIeps != NULL))
|
|
{depsBH = epsBB * dgijHH + depsBB * gijHH ;
|
|
dIIepsBH = (depsBH && epsBH) + (epsBH && depsBH);
|
|
};
|
|
if (Kc_IIeps != NULL)
|
|
{ double d_Kc = Kc_base * valder_Kc.derivee * (dIIepsBH);
|
|
dIsigma += deltat * d_Kc * IDeps;
|
|
};
|
|
// variation du déviateur due au transport
|
|
d_SBH_n = dsigBH_n - (untier * dIsig_n) * IdBH3;
|
|
//
|
|
switch (cas_calcul)
|
|
{ case 0: // calcul normal (tous les termes)
|
|
{ // variation du déviateur des contraintes
|
|
d_SHH = dgijHH * (SBH_n + deltat * mu_use * Deps_barre_BH)
|
|
+ gijHH * (d_SBH_n + deltat * mu_use * d_Deps_barre_BH);
|
|
// cas d'une non-linéarité en fonction de la déformation
|
|
if (mu_IIeps != NULL)
|
|
{ depsBH = epsBB * dgijHH + depsBB * gijHH ;
|
|
double d_mu = mu_base * valder_mu.derivee * (dIIepsBH);
|
|
d_SHH += gijHH * ((deltat * d_mu) * Deps_barre_BH);
|
|
};
|
|
dsigHH = d_SHH + (untier * dIsigma) * gijHH
|
|
+ (untier * Isigma) * dgijHH ;
|
|
break;
|
|
}
|
|
case 1: // calcul de la partie déviatorique seule
|
|
{ // variation du déviateur des contraintes
|
|
dsigHH = dgijHH * (SBH_n + deltat * mu_use * Deps_barre_BH)
|
|
+ gijHH * (d_SBH_n + deltat * mu_use * d_Deps_barre_BH);
|
|
// cas d'une non-linéarité en fonction de la déformation
|
|
if (mu_IIeps != NULL)
|
|
{ depsBH = epsBB * dgijHH + depsBB * gijHH ;
|
|
double d_mu = mu_base * valder_mu.derivee * (dIIepsBH);
|
|
dsigHH += gijHH * ((deltat * d_mu) * Deps_barre_BH);
|
|
};
|
|
break;
|
|
}
|
|
case 2: // calcul de la partie sphérique seule
|
|
{ dsigHH = (untier * dIsigma) * gijHH
|
|
+ (untier * Isigma) * dgijHH ;
|
|
break;
|
|
}
|
|
};
|
|
////----------------- debug
|
|
//cout << "\n dsighh("<<i<<")="<<dsigHH<<" ";
|
|
//----------- fin debug
|
|
};
|
|
// traitement des énergies
|
|
// on incrémente l'énergie élastique
|
|
energ.ChangeEnergieElastique(energ_t.EnergieElastique() + 0.5 * deltat * ((sigHH + sigHH_nn) && DepsBB));
|
|
|
|
// récup de la compressibilité (-p_point = compress * I_D, S_point = cisaille * D_barre)
|
|
module_compressibilite = Kc_use/3.;
|
|
module_cisaillement = 0.5 * mu_use;
|
|
////----------------- debug
|
|
//cout << "\n\n\n"<<endl;Sortie(1);
|
|
//----------- fin debug
|
|
|
|
LibereTenseur();
|
|
};
|
|
|
|
//void Calcul_dsigma_deps (bool en_base_orthonormee, TenseurHH & sigHH_t,TenseurBB& DepsBB
|
|
// ,TenseurBB & epsBB_tdt,TenseurBB & delta_epsBB,double& jacobien_0,double& jacobien
|
|
// ,TenseurHH& sigHH,TenseurHHHH& d_sigma_deps
|
|
// ,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double& module_cisaillement
|
|
// ,const Met_abstraite::Umat_cont& ex) ; //= 0;
|
|
// calcul des contraintes et ses variations par rapport aux déformations a t+dt
|
|
// en_base_orthonormee: le tenseur de contrainte en entrée est en orthonormee
|
|
// le tenseur de déformation et son incrémentsont également en orthonormees
|
|
// si = false: les bases transmises sont utilisées
|
|
// ex: contient les éléments de métrique relativement au paramétrage matériel = X_(0)^a
|
|
void Hypo_hooke3D::Calcul_dsigma_deps (bool en_base_orthonormee, TenseurHH & sigHH_t,TenseurBB& DepsBB_
|
|
,TenseurBB & epsBB_tdt,TenseurBB & delta_epsBB_,double& ,double&
|
|
,TenseurHH& sigHH_tdt,TenseurHHHH& d_sigma_deps_
|
|
,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double& module_cisaillement
|
|
,const Met_abstraite::Umat_cont& ex)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if (Permet_affichage() > 3)
|
|
{cout << "\n --- loi de comportement Hypo_hooke3D Calcul_dsigma_deps --- ";
|
|
Signature_pti_encours(cout);
|
|
};
|
|
if (DepsBB_.Dimension() != 3)
|
|
{ cout << "\nErreur : la dimension devrait etre 3 !\n";
|
|
cout << " Hypo_hooke3D::Calcul_DsigmaHH_tdt\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
|
|
const Tenseur3BB & epsBB = *((Tenseur3BB*) &epsBB_tdt); // passage en dim 3
|
|
const Tenseur3BB & DepsBB = *((Tenseur3BB*) &DepsBB_); // passage en dim 3
|
|
Tenseur3HH & sigHH = *((Tenseur3HH*) &sigHH_tdt); // " " " "
|
|
Tenseur3HH & sigHH_nn = *((Tenseur3HH*) &sigHH_t); // " " " "
|
|
const Tenseur3HH & gijHH = *((Tenseur3HH*) ex.gijHH_tdt); // " " " "
|
|
const Tenseur3BB & gijBB = *((Tenseur3BB*) ex.gijBB_tdt); // " " " "
|
|
const Tenseur3HH & gijHH_t = *((Tenseur3HH*) ex.gijHH_t); // " " " "
|
|
const Tenseur3BB & gijBB_t = *((Tenseur3BB*) ex.gijBB_t); // " " " "
|
|
const Tenseur3BB & delta_epsBB = *((Tenseur3BB*) &delta_epsBB_); // passage en dim 3
|
|
|
|
|
|
SaveResulLoi_Hypo3D & save_resul = *((SaveResulLoi_Hypo3D*) saveResul);
|
|
// --- opération de transport du tenseur sigma(t), de t à tdt
|
|
// tenseur intermédiaires utilisées selon les cas (par forcément dans tous les cas !!)
|
|
Tenseur3BH sigBH_n;Tenseur3HH sigHH_n; Tenseur3BB sigBB_n;Tenseur3BB sig_interBB_n;
|
|
if (en_base_orthonormee)
|
|
{// pour l'instant le transport s'effectue dans la base orthonormee!! ce qui est peut-être
|
|
// mauvais dans le cas de grandes transformations !!
|
|
sigBH_n = IdBB3 * sigHH_nn;
|
|
// version peut-être plus rapide
|
|
//Tenseur3BH sigBH_n = sigHH_t.BaissePremierIndice();
|
|
} // deformation en mixte
|
|
else
|
|
{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;
|
|
// pour la déformation cumulée associée,
|
|
Tenseur3HH eps_interHH_n = gijHH_t * save_resul.eps_cumulBB_t * gijHH_t;
|
|
Tenseur3BB epsBB_n = 0.5*( gijBB * eps_interHH_n * gijBB + save_resul.eps_cumulBB_t);
|
|
save_resul.eps_cumulBB = delta_epsBB + epsBB_n;
|
|
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 ;
|
|
// pour la déformation cumulée associée, on sait que cela donne directement la def d'Almansi
|
|
// mais la def passée en paramètre pourrait ne pas être d'Almansi, donc on calcule
|
|
// quand même la def cumulée
|
|
save_resul.eps_cumulBB = save_resul.eps_cumulBB_t + delta_epsBB;
|
|
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;
|
|
// pour la déformation cumulée associée,
|
|
Tenseur3HH eps_interHH_n = gijHH_t * save_resul.eps_cumulBB_t * gijHH_t;
|
|
Tenseur3BB epsBB_n = gijBB * eps_interHH_n * gijBB ;
|
|
save_resul.eps_cumulBB = delta_epsBB + epsBB_n;
|
|
break;}
|
|
};
|
|
};
|
|
|
|
bool affichage = (Permet_affichage() > 5);
|
|
#ifdef MISE_AU_POINT
|
|
if (affichage)
|
|
{cout << "\n === donnees d'entree ";
|
|
if (en_base_orthonormee)
|
|
{cout << "\n calcul en base orthonormee: ";
|
|
cout << "\n epsBB_tdt(absolu)= "; epsBB.Ecriture(cout);
|
|
cout << "\n DepsBB(absolu)= "; DepsBB.Ecriture(cout);
|
|
cout << "\n delta_epsBB(absolu)= "; delta_epsBB.Ecriture(cout);
|
|
cout << "\n sigHH_t(absolu)= "; sigHH_t.Ecriture(cout);
|
|
}
|
|
else
|
|
{cout << "\n calcul en base naturelle: ";
|
|
cout << "\n epsBB_tdt(local)= "; epsBB.Ecriture(cout);
|
|
cout << "\n DepsBB(local)= "; DepsBB.Ecriture(cout);
|
|
cout << "\n delta_epsBB(local)= "; delta_epsBB.Ecriture(cout);
|
|
cout << "\n sigHH_t(local)= "; sigHH_t.Ecriture(cout);
|
|
// en absolue
|
|
Tenseur3BB tiutiu;
|
|
epsBB.BaseAbsolue(tiutiu,*(ex.giH_tdt));
|
|
cout << "\n eps en absolu :";tiutiu.Ecriture(cout);
|
|
DepsBB.BaseAbsolue(tiutiu,*(ex.giH_tdt));
|
|
cout << "\n Deps en absolu :";tiutiu.Ecriture(cout);
|
|
delta_epsBB.BaseAbsolue(tiutiu,*(ex.giH_tdt));
|
|
cout << "\n delta_eps en absolu :";tiutiu.Ecriture(cout);
|
|
Tenseur3HH titi;
|
|
sigHH_t.BaseAbsolue(titi,*(ex.giB_tdt));
|
|
cout << "\n sig_t en absolu :";titi.Ecriture(cout);
|
|
};
|
|
}
|
|
#endif
|
|
|
|
// opération de transmission de la métrique
|
|
const Met_abstraite::Impli* ex_impli = NULL;
|
|
const Met_abstraite::Expli_t_tdt* ex_expli_tdt = NULL;
|
|
const Met_abstraite::Umat_cont* ex_expli = &ex;
|
|
|
|
// cas de la thermo dépendance, on calcul les grandeurs
|
|
if (mu_temperature != NULL)
|
|
{ mu = mu_temperature->Valeur(*temperature);}
|
|
else if (mu_nD != NULL)
|
|
// là il faut calculer la fonction nD
|
|
{ // on utilise la méthode générique de loi abstraite
|
|
list <SaveResul*> list_save; // inter pour l'appel de la fonction
|
|
list_save.push_back(saveResul);
|
|
Tableau <double> & tab_val = Loi_comp_abstraite::Loi_comp_Valeur_FnD_Evoluee
|
|
(mu_nD,1 // une seule valeur attendue en retour
|
|
,ex_impli,ex_expli_tdt,ex_expli
|
|
,NULL
|
|
,NULL
|
|
,&list_save
|
|
);
|
|
/* // ici on utilise les variables connues aux pti, ou calculées à partir de
|
|
// on commence par récupérer les conteneurs des grandeurs à fournir
|
|
List_io <Ddl_enum_etendu>& li_enu_scal = mu_nD->Li_enu_etendu_scalaire();
|
|
List_io <TypeQuelconque >& li_quelc = mu_nD->Li_equi_Quel_evolue();
|
|
bool absolue = true; // on se place systématiquement en absolu
|
|
// on va utiliser la méhode Valeur_multi_interpoler_ou_calculer
|
|
// pour les grandeurs strictement scalaire
|
|
Tableau <double> val_ddl_enum(Valeur_multi_interpoler_ou_calculer
|
|
(absolue,TEMPS_tdt,li_enu_scal,ex_impli,ex_expli_tdt,ex_expli,NULL)
|
|
);
|
|
// on utilise la méthode Valeurs_Tensorielles_interpoler_ou_calculer
|
|
// pour les Coordonnees et Tenseur
|
|
Valeurs_Tensorielles_interpoler_ou_calculer
|
|
(absolue,TEMPS_tdt,li_quelc,ex_impli,ex_expli_tdt,ex_expli,NULL);
|
|
// calcul de la valeur et retour dans tab_ret
|
|
Tableau <double> & tab_val = mu_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
|
|
#ifdef MISE_AU_POINT
|
|
if (tab_val.Taille() != 1)
|
|
{ cout << "\nErreur : la fonction nD relative a la fonction mu "
|
|
<< " doit calculer un scalaire or le tableau de retour est de taille "
|
|
<< tab_val.Taille() << " ce n'est pas normal !\n";
|
|
cout << " Hypo_hooke3D::Calcul_SigmaHH\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
*/
|
|
// on récupère le premier élément du tableau uniquement
|
|
mu = tab_val(1);
|
|
};
|
|
if (!compress_thermophysique) // sinon kc est mis à jour avec la méthode CalculGrandeurTravail(..)
|
|
{if (Kc_temperature != NULL)
|
|
{Kc = Kc_temperature->Valeur(*temperature);}
|
|
else if (Kc_nD != NULL)
|
|
// là il faut calculer la fonction nD
|
|
{ // on utilise la méthode générique de loi abstraite
|
|
list <SaveResul*> list_save; // inter pour l'appel de la fonction
|
|
list_save.push_back(saveResul);
|
|
Tableau <double> & tab_val = Loi_comp_abstraite::Loi_comp_Valeur_FnD_Evoluee
|
|
(Kc_nD,1 // une seule valeur attendue en retour
|
|
,ex_impli,ex_expli_tdt,ex_expli
|
|
,NULL
|
|
,NULL
|
|
,&list_save
|
|
);
|
|
/* // ici on utilise les variables connues aux pti, ou calculées à partir de
|
|
// on commence par récupérer les conteneurs des grandeurs à fournir
|
|
List_io <Ddl_enum_etendu>& li_enu_scal = Kc_nD->Li_enu_etendu_scalaire();
|
|
List_io <TypeQuelconque >& li_quelc = Kc_nD->Li_equi_Quel_evolue();
|
|
bool absolue = true; // on se place systématiquement en absolu
|
|
// on va utiliser la méhode Valeur_multi_interpoler_ou_calculer
|
|
// pour les grandeurs strictement scalaire
|
|
Tableau <double> val_ddl_enum(Valeur_multi_interpoler_ou_calculer
|
|
(absolue,TEMPS_tdt,li_enu_scal,ex_impli,ex_expli_tdt,ex_expli,NULL)
|
|
);
|
|
// on utilise la méthode Valeurs_Tensorielles_interpoler_ou_calculer
|
|
// pour les Coordonnees et Tenseur
|
|
Valeurs_Tensorielles_interpoler_ou_calculer
|
|
(absolue,TEMPS_tdt,li_quelc,ex_impli,ex_expli_tdt,ex_expli,NULL);
|
|
// calcul de la valeur et retour dans tab_ret
|
|
Tableau <double> & tab_val = Kc_nD->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
|
|
#ifdef MISE_AU_POINT
|
|
if (tab_val.Taille() != 1)
|
|
{ cout << "\nErreur : la fonction nD relative a la fonction Kc "
|
|
<< " doit calculer un scalaire or le tableau de retour est de taille "
|
|
<< tab_val.Taille() << " ce n'est pas normal !\n";
|
|
cout << " Hypo_hooke3D::Calcul_SigmaHH\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
*/
|
|
// on récupère le premier élément du tableau uniquement
|
|
Kc = tab_val(1);
|
|
};
|
|
};
|
|
|
|
|
|
// cas d'une non-linéarité en fonction de la déformation
|
|
Tenseur3BH DepsBH; Tenseur3BB Deps_barre_BB;Tenseur3HH Deps_barre_HH; // init
|
|
Tenseur3BH Deps_barre_BH;
|
|
double IDeps=0.; // "
|
|
Tenseur3BH epsBH;
|
|
|
|
Courbe1D::ValDer valder_Kc,valder_mu;
|
|
double Kc_base=Kc;double Kc_use=Kc;// pour ne pas changer les valeurs à chaque passage !!
|
|
double mu_base=mu;double mu_use=mu;// idem
|
|
static const double untier=1./3.;
|
|
|
|
|
|
if (en_base_orthonormee)
|
|
{DepsBH = DepsBB.MonteDernierIndice();
|
|
IDeps=DepsBH.Trace();
|
|
Deps_barre_BH = DepsBH - (untier * IDeps) * IdBH3;
|
|
Deps_barre_BB = Deps_barre_BH * IdBB3;
|
|
Deps_barre_HH = IdHH3 * Deps_barre_BH ;
|
|
epsBH = epsBB.MonteDernierIndice(); // deformation en mixte
|
|
}
|
|
else
|
|
{DepsBH = DepsBB * gijHH;
|
|
IDeps=DepsBH.Trace();
|
|
Deps_barre_BH = DepsBH - (untier * IDeps) * IdBH3;
|
|
Deps_barre_BB = Deps_barre_BH * gijBB;
|
|
Deps_barre_HH = gijHH * Deps_barre_BH ;
|
|
epsBH = epsBB * gijHH; // deformation en mixte
|
|
};
|
|
|
|
if ((Kc_IIeps != NULL)||(mu_IIeps != NULL))
|
|
{
|
|
double Ieps = epsBH.Trace();
|
|
Tenseur3BH eps_barre_BH = epsBH - (untier * Ieps) * IdBH3;
|
|
|
|
|
|
double II_eps=epsBH.II();
|
|
if (Kc_IIeps != NULL)
|
|
{ valder_Kc = Kc_IIeps->Valeur_Et_derivee(II_eps);
|
|
Kc_use *= valder_Kc.valeur;
|
|
};
|
|
if (mu_IIeps != NULL)
|
|
{ valder_mu = mu_IIeps->Valeur_Et_derivee(II_eps);
|
|
mu_use *= valder_mu.valeur;
|
|
};
|
|
};
|
|
|
|
// sauvegarde des paramètres matériau
|
|
save_resul.Kc = Kc_use;
|
|
save_resul.mu = mu_use;
|
|
|
|
#ifdef MISE_AU_POINT
|
|
if (affichage)
|
|
{cout << "\n giB_tdt" << (*ex.giB_tdt);
|
|
cout << "\n giH_tdt" << (*ex.giH_tdt);
|
|
cout << "\n mu= "<< mu_use << ", K= "<< Kc_use;
|
|
};
|
|
#endif
|
|
|
|
// recup de l'incrément de temps
|
|
double deltat=ParaGlob::Variables_de_temps().IncreTempsCourant();
|
|
// le calcul de la contrainte correspond à l'intégration d'une équation différencielle
|
|
// delta_eps_barre=1/mu delta_sigma/dt pour la partie déviatoire
|
|
// et pour la partie sphérique
|
|
// I_D = 1/(Kc) I_Sig_point
|
|
double Isig_n = sigBH_n.Trace();
|
|
Tenseur3BH SBH_n = sigBH_n - (untier * Isig_n) * IdBH3;
|
|
|
|
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
|
|
{ // 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;
|
|
};
|
|
// cas de la partie sphérique scalaire
|
|
double Isigma = Isig_n + deltat * Kc_use * IDeps;
|
|
|
|
// cas de la partie déviatorique
|
|
|
|
if (en_base_orthonormee)
|
|
{ switch (cas_calcul)
|
|
{ case 0: // calcul normal (tous les termes)
|
|
{ // la partie sphérique est déjà calculé, cas de la partie déviatorique
|
|
Tenseur3HH SHH = IdHH3 * (SBH_n + (deltat * mu_use) * Deps_barre_BH);
|
|
sigHH = SHH + (untier * Isigma) * IdHH3;
|
|
break;
|
|
}
|
|
case 1: // calcul de la partie déviatorique seule
|
|
{ sigHH = IdHH3 * (SBH_n + (deltat * mu_use) * Deps_barre_BH);
|
|
break;
|
|
}
|
|
case 2: // calcul de la partie sphérique seule
|
|
{ sigHH = (untier * Isigma) * IdHH3;
|
|
break;
|
|
}
|
|
default:
|
|
{ cout << "\n erreur l'indicateur cas_calcul= " << cas_calcul << " n'a pas une valeur correcte !! "
|
|
<< "\n Hypo_hooke3D::Calcul_dsigma_deps (.... ";
|
|
Sortie(1);
|
|
}
|
|
};
|
|
}
|
|
else
|
|
{ switch (cas_calcul)
|
|
{ case 0: // calcul normal (tous les termes)
|
|
{ // la partie sphérique est déjà calculé, cas de la partie déviatorique
|
|
Tenseur3HH SHH = gijHH * (SBH_n + deltat * mu_use * Deps_barre_BH);
|
|
sigHH = SHH + (untier * Isigma) * gijHH ;
|
|
break;
|
|
}
|
|
case 1: // calcul de la partie déviatorique seule
|
|
{ sigHH = gijHH * (SBH_n + deltat * mu_use * Deps_barre_BH);
|
|
break;
|
|
}
|
|
case 2: // calcul de la partie sphérique seule
|
|
{ sigHH = (untier * Isigma) * gijHH ; // *IdBH3;
|
|
break;
|
|
}
|
|
default:
|
|
{ cout << "\n erreur l'indicateur cas_calcul= " << cas_calcul << " n'a pas une valeur correcte !! "
|
|
<< "\n Hypo_hooke3D::Calcul_dsigma_deps (.... ";
|
|
Sortie(1);
|
|
}
|
|
};
|
|
};
|
|
|
|
#ifdef MISE_AU_POINT
|
|
if (affichage)
|
|
{cout << "\n IDeps= "<< IDeps;
|
|
|
|
if (en_base_orthonormee)
|
|
{cout << "\n Deps_barre_BH(absolu)= "; Deps_barre_BH.Ecriture(cout);
|
|
cout << "\n sig_tdt en absolu :";sigHH.Ecriture(cout);
|
|
}
|
|
else
|
|
{Tenseur3BH tiutiu;
|
|
Deps_barre_BH.BaseAbsolue(tiutiu,*(ex.giB_tdt),*(ex.giH_tdt));
|
|
cout << "\n Deps_barre_BH en absolu :";tiutiu.Ecriture(cout);
|
|
Tenseur3HH titi;
|
|
sigHH.BaseAbsolue(titi,*(ex.giB_tdt));
|
|
cout << "\n sig_tdt en absolu :";titi.Ecriture(cout);
|
|
};
|
|
}
|
|
#endif
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
////--- debug
|
|
//cout << "\n Hypo_hooke3D::Calcul_dsigma_deps";
|
|
//cout << "\n IDeps= "<<IDeps << " Isig_n= "<<Isig_n << " Isigma= "<<Isigma
|
|
// << " mu_use= "<< mu_use << "\n Deps_barre_BH ";
|
|
//Deps_barre_BH.Ecriture(cout);
|
|
//cout << "\n sigHH "; sigHH.Ecriture(cout);
|
|
//cout << "\n DepsBB "; DepsBB.Ecriture(cout);
|
|
//cout << " gijHH "; gijHH.Ecriture(cout);
|
|
//cout << "\n en_base_orthonormee= "<< en_base_orthonormee << " cas_calcul= "<<cas_calcul;
|
|
//// << "\n "
|
|
//cout << endl;
|
|
////--- fin debug
|
|
|
|
// --- cas le la variation du tenseur des contraintes par rapport aux déformations ----
|
|
Tenseur3HHHH & d_sigma_depsHHHH = *((Tenseur3HHHH*) &d_sigma_deps_);
|
|
|
|
|
|
|
|
if (en_base_orthonormee)
|
|
{ // on commence par calculer la variation de l'incrément de déformation barre / à eps
|
|
// (d_delta_eps_ij)barre / d_eps_kl = (delta_i^k * delta_j^l
|
|
// - 1/3 * delta_ij * g^nm * delta_m^k * delta_n^l)
|
|
// ici g^nm = delta^nm, et g^nm * delta_m^k * delta_n^l = id * id = id = delta^kl
|
|
Tenseur3HHHH d_deltat_Deps_barre_HHHH =
|
|
((Tenseur3BBBB*) &(PIdBBBB3 - untier * IdBBBB3))->Monte4Indices();
|
|
|
|
switch (cas_calcul)
|
|
{ case 0: // calcul normal (tous les termes)
|
|
{ d_sigma_depsHHHH = mu_use * d_deltat_Deps_barre_HHHH;
|
|
if (mu_IIeps != NULL)
|
|
d_sigma_depsHHHH += ((Tenseur3BBBB*) &((mu_base * valder_mu.derivee * 2. * deltat)
|
|
* Tenseur3BBBB::Prod_tensoriel((Deps_barre_BH * IdBB3),epsBB)))->Monte4Indices();
|
|
d_sigma_depsHHHH += (untier * Kc) * IdHHHH3;
|
|
if (Kc_IIeps != NULL)
|
|
d_sigma_depsHHHH += ((Tenseur3BBBB*) &((untier * Kc_base * valder_Kc.derivee * 2. )
|
|
* Tenseur3BBBB::Prod_tensoriel(IdBB3, epsBB)))->Monte4Indices();
|
|
break;
|
|
}
|
|
case 1: // calcul de la partie déviatorique seule
|
|
{ d_sigma_depsHHHH = mu_use * d_deltat_Deps_barre_HHHH;
|
|
if (mu_IIeps != NULL)
|
|
d_sigma_depsHHHH += ((Tenseur3BBBB*) &((mu_base * valder_mu.derivee * 2. * deltat)
|
|
* Tenseur3BBBB::Prod_tensoriel((Deps_barre_BH * IdBB3),epsBB)))->Monte4Indices();
|
|
break;
|
|
}
|
|
case 2: // calcul de la partie sphérique seule
|
|
{ d_sigma_depsHHHH = (untier * Kc) * IdHHHH3;
|
|
if (Kc_IIeps != NULL)
|
|
d_sigma_depsHHHH += ((Tenseur3BBBB*) &((untier * Kc_base * valder_Kc.derivee * 2. )
|
|
* Tenseur3BBBB::Prod_tensoriel(IdBB3, epsBB)))->Monte4Indices();
|
|
break;
|
|
}
|
|
default:
|
|
{ cout << "\n erreur l'indicateur cas_calcul= " << cas_calcul << " n'a pas une valeur correcte !! "
|
|
<< "\n Hypo_hooke3D::Calcul_DsigmaHH_tdt (.... ";
|
|
Sortie(1);
|
|
}
|
|
};
|
|
}
|
|
else // sinon cas où les bases sont curvilignes
|
|
{ // calcul de variables intermédiaires
|
|
I_x_I_HHHH=Tenseur3HHHH::Prod_tensoriel(gijHH,gijHH);
|
|
I_xbarre_I_HHHH=Tenseur3HHHH::Prod_tensoriel_barre(gijHH,gijHH);
|
|
Tenseur3HH epsHH(gijHH * epsBH);
|
|
I_x_eps_HHHH=Tenseur3HHHH::Prod_tensoriel(gijHH,epsHH);
|
|
Tenseur3HH Deps_HH(gijHH * DepsBH);
|
|
I_x_D_HHHH=Tenseur3HHHH::Prod_tensoriel(gijHH,Deps_HH);
|
|
I_xbarre_D_HHHH=Tenseur3HHHH::Prod_tensoriel_barre(gijHH,Deps_HH);
|
|
|
|
// variation de sigma_n et de la trace en fonction du transport
|
|
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)
|
|
d_sig_t_HHHH = Tenseur3HHHH::Prod_tensoriel_barre(gijHH,sigHH_n);
|
|
d_spherique_sig_t_HHHH = (1. /6.) *
|
|
(Tenseur3HHHH::Prod_tensoriel(gijHH,sigHH_n)+ Isig_n * I_xbarre_I_HHHH);
|
|
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
|
|
d_sig_t_HHHH = 2.*Tenseur3HHHH::Prod_tensoriel_barre(gijHH,sigHH_n);
|
|
d_spherique_sig_t_HHHH = untier *
|
|
(Tenseur3HHHH::Prod_tensoriel(gijHH,sigHH_n)+ Isig_n * I_xbarre_I_HHHH);
|
|
break;
|
|
}
|
|
case 1: // cas d'une dérivée de Lie deux fois contravariantes
|
|
{// pour info sigBH_n = gijBB * sigHH_n, ici il n'y a aucune conséquence
|
|
// sur sigma(t), par contre il y en a une sur la trace
|
|
d_sig_t_HHHH.Inita(0.);
|
|
d_spherique_sig_t_HHHH = untier *
|
|
(Tenseur3HHHH::Prod_tensoriel(gijHH,sigHH_n)+ Isig_n * I_xbarre_I_HHHH);
|
|
break;
|
|
}
|
|
};
|
|
|
|
// on choisit entre les différents cas
|
|
double e01,e02;e01=e02=0.; // les coefficients pour la partie transportée
|
|
double b01,b02,b03,b04,b05;b01=b02=b03=b04=b05=0.; // les coefficients pour le reste de l'équation
|
|
// l'expression générique est:
|
|
// d_sigma_depsHHHH = b01 * I_x_I_HHHH + b02 * I_x_D_HHHH + b03 * I_xbarre_I_HHHH
|
|
// + b04 * I_xbarre_D_HHHH
|
|
// + e01 * d_sig_t_HHHH + e02 * d_spherique_sig_t_HHHH;
|
|
// en fonction des coefficients nuls on simplifie
|
|
|
|
switch (cas_calcul)
|
|
{ case 0: // calcul normal (tous les termes) // cas complet
|
|
{ b01= (Kc_use - mu_use) * untier;
|
|
b02= -2.* (Kc_use - mu_use) * untier * deltat;
|
|
b03= -2. * (Kc_use - mu_use) * untier * deltat * IDeps + mu_use;
|
|
b04= -4. * mu_use * deltat;
|
|
e01= mu_use;
|
|
e02= untier;
|
|
d_sigma_depsHHHH = b01 * I_x_I_HHHH + b02 * I_x_D_HHHH
|
|
+ b03 * I_xbarre_I_HHHH + b04 * I_xbarre_D_HHHH
|
|
+ e01 * d_sig_t_HHHH + e02 * d_spherique_sig_t_HHHH;
|
|
break;
|
|
}
|
|
case 1: // calcul de la partie déviatorique seule
|
|
{ b01= - mu_use * untier;
|
|
b02= 2.* mu_use * untier * deltat;
|
|
b03= 2. * mu_use * untier * deltat * IDeps + mu_use;
|
|
b04= -4. * mu_use * deltat;
|
|
e01= mu_use;
|
|
e02= untier;
|
|
d_sigma_depsHHHH = b01 * I_x_I_HHHH + b02 * I_x_D_HHHH
|
|
+ b03 * I_xbarre_I_HHHH + b04 * I_xbarre_D_HHHH
|
|
+ e01 * d_sig_t_HHHH + e02 * d_spherique_sig_t_HHHH;
|
|
break;
|
|
}
|
|
case 2: // calcul de la partie sphérique seule
|
|
{ b01= Kc_use * untier;
|
|
b02= -2.*Kc_use * untier * deltat;
|
|
b03= -2.*Kc_use * untier * deltat * IDeps;
|
|
b04= 0.;
|
|
e01= 0.;
|
|
e02= untier;
|
|
d_sigma_depsHHHH = b01 * I_x_I_HHHH + b02 * I_x_D_HHHH
|
|
+ b03 * I_xbarre_I_HHHH
|
|
+ e02 * d_spherique_sig_t_HHHH;
|
|
break;
|
|
}
|
|
default:
|
|
{ cout << "\n erreur l'indicateur cas_calcul= " << cas_calcul << " n'a pas une valeur correcte !! "
|
|
<< "\n Hypo_hooke3D::Calcul_dsigma_deps (.... ";
|
|
Sortie(1);
|
|
}
|
|
};
|
|
};
|
|
|
|
// traitement des énergies
|
|
// on incrémente l'énergie élastique
|
|
energ.ChangeEnergieElastique(energ_t.EnergieElastique() + 0.5 * deltat * ((sigHH + sigHH_nn) && DepsBB));
|
|
|
|
// récup de la compressibilité (-p_point = compress * I_D, S_point = cisaille * D_barre)
|
|
module_compressibilite = Kc_use/3.;
|
|
module_cisaillement = 0.5 * mu_use;
|
|
|
|
LibereTenseur();
|
|
LibereTenseurQ();
|
|
};
|
|
|