// 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) .
//
// 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 .
//
// For more information, please consult: .
/************************************************************************
* DATE: 19/6/2005 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: La classe Hyper_W_gene_3D permet de calculer *
* les grandeurs générales nécessaires pour exploiter une *
* loi hyper-élastique utilisant un potentiel W défini *
* a partir des élongations. *
* Il s'agit d'une classe de travail. *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef HYPER_W_GENE_3D_H
#define HYPER_W_GENE_3D_H
#include "LesReferences.h"
#include "LesCourbes1D.h"
#include "Tenseur.h"
#include "Tenseur3.h"
#include "TenseurQ-3.h"
#include "TenseurQ3gene.h"
#include "Loi_comp_abstraite.h"
/// @addtogroup Les_lois_hyperelastiques
/// @{
///
class Hyper_W_gene_3D : public Loi_comp_abstraite
{
public :
// CONSTRUCTEURS :
// Constructeur par defaut
Hyper_W_gene_3D ();
// Constructeur utile si l'identificateur du nom de la loi
// de comportement et la dimension sont connus
// vit_def indique si oui ou non la loi utilise la vitesse de déformation
Hyper_W_gene_3D (Enum_comp id_compor,Enum_categorie_loi_comp categorie_comp
,int dimension,bool vit_def = false);
// Constructeur de copie
Hyper_W_gene_3D (const Hyper_W_gene_3D& loi) ;
// DESTRUCTEUR :
virtual ~Hyper_W_gene_3D ();
// classe permettant le stockage de grandeurs de post-traitement
class Invariantpost3D
{ public :
Invariantpost3D() : potentiel(0.) {}; // constructeur par défaut
Invariantpost3D(const double& potent)
: potentiel(potent) {};
Invariantpost3D(const Invariantpost3D & a)
: potentiel(a.potentiel) {};
// Surcharge de l'operateur = : realise l'affectation
Invariantpost3D& operator= (const Invariantpost3D& a)
{potentiel=a.potentiel; return *this;};
// surcharge de l'operator de lecture
friend istream & operator >> (istream & ent, Invariantpost3D & a)
{ string toto;
ent >> toto >> a.potentiel; return ent;
};
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream & sort , const Invariantpost3D & a)
{ sort << " potent= "<< a.potentiel << " "; return sort;
};
// data
double potentiel;
};
class SaveResulHyper_W_gene_3D: public Loi_comp_abstraite::SaveResul
{ public :
// constructeur
SaveResulHyper_W_gene_3D(); // par défaut
// avec_para : le nombre indique si on sauvegarde des paramètres matériaux qui varient
// et également des invariants.
// si == 0 : pas de stockage (joue en fait le role de sortie_post)
SaveResulHyper_W_gene_3D(int avec_para); // avec init ou pas
SaveResulHyper_W_gene_3D(const SaveResulHyper_W_gene_3D& sav); // de copie
virtual ~SaveResulHyper_W_gene_3D(); // destructeur
// définition d'une nouvelle instance identique
// appelle du constructeur via new
SaveResul * Nevez_SaveResul() const {return (new SaveResulHyper_W_gene_3D(*this));};
// affectation
virtual SaveResul & operator = ( const SaveResul & a);
//============= lecture écriture dans base info ==========
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
virtual void Lecture_base_info (ifstream& ,const int ) ;
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
virtual void Ecriture_base_info(ofstream& ,const int ) ;
// mise à jour des informations transitoires
void TdtversT() ;
void TversTdt() ;
// affichage à l'écran des infos
void Affiche() const ;
//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
// ici il ne s'agit que de grandeurs scalaires donc rien n'a faire
// gpH(i) = gamma(i,j) * gH(j)
virtual void ChBase_des_grandeurs(const Mat_pleine& beta,const Mat_pleine& gamma){};
// procedure permettant de completer éventuellement les données particulières
// de la loi stockées
// au niveau du point d'intégration par exemple: exemple: un repère d'anisotropie
// completer est appelé apres sa creation avec les donnees du bloc transmis
// peut etre appeler plusieurs fois
SaveResul* Complete_SaveResul(const BlocGen & bloc, const Tableau & tab_coor
,const Loi_comp_abstraite* loi){return NULL;};
// --- gestion d'une map de grandeurs quelconques éventuelles ---
// une map de grandeurs quelconques particulière qui peut servir aux classes appelantes
// il s'agit ici d'une map interne qui a priori ne doit servir qu'aux class loi de comportement
// un exemple d'utilisation est une loi combinée qui a besoin de grandeurs spéciales définies
// -> n'est pas sauvegardé, car a priori il s'agit de grandeurs redondantes
map < EnumTypeQuelconque , TypeQuelconque, std::less < EnumTypeQuelconque> > map_type_quelconque;
// récupération des type quelconque sous forme d'un arbre pour faciliter la recherche
const map < EnumTypeQuelconque , TypeQuelconque, std::less < EnumTypeQuelconque> >* Map_type_quelconque()
const {return &map_type_quelconque;};
//-------------------------------------------------------------------
// données optionnelles : les paramètres matériaux réellement utilisés
//-------------------------------------------------------------------
// si on le demande: dans le cas où les paramètres matériaux sont des fonctions nD
// on stocke les paramètres matériaux
Vecteur *para_loi, *para_loi_t;
// également des grandeurs qui sont éventuellement créées si on le demande
Hyper_W_gene_3D::Invariantpost3D * invP, * invP_t;
protected:
virtual void Mise_a_jour_map_type_quelconque();
// ---- fin gestion d'une liste de grandeurs quelconques éventuelles ---
};
virtual SaveResul * New_et_Initialise() = 0;
friend class SaveResulHyper_W_gene_3D;
// 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
virtual void Grandeur_particuliere
(bool absolue,List_io& liTQ,Loi_comp_abstraite::SaveResul * saveDon,list& decal) const;
// récupération 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
virtual void ListeGrandeurs_particulieres(bool absolue,List_io& liTQ) const;
// calcul des invariants et de leurs variations premières
void Invariants_et_var1(const TenseurBB & gijBB_0,const TenseurHH & gijHH_0
,const TenseurBB & gijBB_tdt,const TenseurHH & gijHH_tdt
,const double& jacobien_0,const double& jacobien)
{InvariantsEtVar1(gijBB_0,gijHH_0,gijBB_tdt,gijHH_tdt,jacobien_0,jacobien);
// vérification numérique de la dérivée
// Calcul_derivee_numerique(gijBB_0,gijHH_0,gijBB_tdt,gijHH_tdt,jacobien_0,jacobien);
};
// calcul des invariants et de leurs variations premières et secondes
void Invariants_et_var2(const TenseurBB & gijBB_0,const TenseurHH & gijHH_0
,const TenseurBB & gijBB_tdt,const TenseurHH & gijHH_tdt
,const double& jacobien_0,const double& jacobien)
{InvariantsEtVar2(gijBB_0,gijHH_0,gijBB_tdt,gijHH_tdt,jacobien_0,jacobien);
// Calcul_derivee_numerique2(gijBB_0,gijHH_0,gijBB_tdt,gijHH_tdt,jacobien_0,jacobien);
};
// --- acces en lectures aux différentes grandeurs calculées
// par Invariants_et_var1 et Invariants_et_var2
const double& I__B() const {return I_B;};
const double& I__BB() const {return I_BB;};
// const double& I__BBB() const {return I_BBB;};
const double& II__B() const {return II_B;};
const Vecteur& JJ_r() const {return J_r;};
// const Tenseur3HH& D_I_B_epsBB_HH() const {return d_I_B_epsBB_HH;};
// const Tenseur3HH& D_II_B_epsBB_HH() const {return d_II_B_epsBB_HH;};
// const Tenseur3HH& D_III_B_epsBB_HH() const {return d_III_B_epsBB_HH;};
const Tableau & D_J_r_epsBB_HH() const {return d_J_r_epsBB_HH;};
// --- acces en lectures aux différentes grandeurs calculées
// uniquemenent par Invariants_et_var2
// const Tenseur3HHHH& D_I_B_eps2BB_HHHH () const {return d_I_B_eps2BB_HHHH;};
// const Tenseur3HHHH& D_II_B_eps2BB_HHHH () const {return d_II_B_eps2BB_HHHH;};
// const Tenseur3HHHH& D_III_B_eps2BB_HHHH () const {return d_III_B_eps2BB_HHHH;};
const Tenseur3HHHH& D_J_1_eps2BB_HHHH () const {return d_J_1_eps2BB_HHHH;};
const Tenseur3HHHH& D_J_2_eps2BB_HHHH () const {return d_J_2_eps2BB_HHHH;};
const Tenseur3HHHH& D_J_3_eps2BB_HHHH () const {return d_J_3_eps2BB_HHHH;};
// activation du stockage de grandeurs quelconques qui pourront ensuite être récupéré
// via le conteneur SaveResul, si la grandeur n'existe pas ici, aucune action
virtual void Activation_stockage_grandeurs_quelconques(list & listEnuQuelc);
// insertion des conteneurs ad hoc concernant le stockage de grandeurs quelconques
// passée en paramètre, dans le save result: ces conteneurs doivent être valides
// c-a-d faire partie de listdeTouslesQuelc_dispo_localement
virtual void Insertion_conteneur_dans_save_result(SaveResul * saveResul);
protected :
// données
int sortie_post; // permet de stocker et ensuite d'accéder en post-traitement à certaines données
// = 0 par défaut,
// = 1 : on stocke toutes les grandeurs et elles sont disponibles en sortie
// lecture dans les classes dérivées !!
int nb_para_loi; // nombre de paramètre de la loi: doit être défini par les classes dérivée
// est utilisé par ListeGrandeurs_particulieres
double I_B,I_BB;//,I_BBB; // les 3 invariants primaires de B c'est-à-dire les trois traces
// I_B, I_{B.B}, I_{B.B.B}, en fait on ne se sert pas de I_BBB
double II_B,III_B; // les 3 invariants en I de B: I_1=I_B, I_2=II_B,I_3=III_B
Vecteur J_r ; // les 3 invariants en J
// variation des I II III par rapport aux composantes covariantes de la déformation
Tenseur3HH d_I_B_epsBB_HH,d_II_B_epsBB_HH,d_III_B_epsBB_HH;
// variation des J_r par rapport aux composantes covariantes de la déformation
Tableau d_J_r_epsBB_HH;
// variation seconde des I_r par rapport aux composantes covariantes de la déformation
// Tenseur3HHHH d_I_B_eps2BB_HHHH,d_II_B_eps2BB_HHHH,d_III_B_eps2BB_HHHH;
// variation seconde des J_r par rapport aux composantes covariantes de la déformation
Tenseur3HHHH d_J_1_eps2BB_HHHH,d_J_2_eps2BB_HHHH,d_J_3_eps2BB_HHHH;
// autres variables utiles pour la loi de comportement
double V; // variation relative de volume
Tenseur3HH BB_HH; // B . B
Tenseur3HB B_HB; // B en mixte
Tenseur3HB BB_HB; // B . B en mixte
// variables tensorielles du second ordre intermédiaires
Tenseur3HHHH IxI_HHHH,IxbarreI_HHHH,IxB_HHHH,BxI_HHHH;
// grandeurs de travail
double J3_puiss_untiers // J3 puissance 1/3
,unSurJ3_puissuntiers // 1/(J3^{1/3})
,unSurJ3_puissuntiers2 // (1/(J3^{1/3})^2
,unSurJ3_puissuntiers4; // (1/(J3^{1/3})^4
// --------méthodes internes
// affichage et definition interactive des commandes particulières ici = une partie générique
// pour les lois, utilisée par les classes dérivées
void Info_commande_LoisDeComp_hyper3D(UtilLecture& lec);
// calcul des invariants et de leurs variations premières
void InvariantsEtVar1(const TenseurBB & gijBB_0,const TenseurHH & gijHH_0
,const TenseurBB & gijBB_tdt,const TenseurHH & gijHH_tdt
,const double& jacobien_0,const double& jacobien);
// calcul des invariants et de leurs variations premières et secondes
void InvariantsEtVar2(const TenseurBB & gijBB_0,const TenseurHH & gijHH_0
,const TenseurBB & gijBB_tdt,const TenseurHH & gijHH_tdt
,const double& jacobien_0,const double& jacobien);
// vérification de la dérivée avec une dérivée numérique
// calcul des dérivées numériques premières
void Calcul_derivee_numerique(const TenseurBB & gijBB_0,const TenseurHH & gijHH_0
,const TenseurBB & gijBB_tdt,const TenseurHH & gijHH_tdt
,const double& jacobien_0,const double& jacobien);
// calcul des dérivées numériques premières et secondes
void Calcul_derivee_numerique2(const TenseurBB & gijBB_0,const TenseurHH & gijHH_0
,const TenseurBB & gijBB_tdt,const TenseurHH & gijHH_tdt
,const double& jacobien_0,const double& jacobien);
// --- pour le débug ----
// calcul des invariants et de leurs variations premières en numérique
void Invariants_et_var1_deb(const TenseurBB & gijBB_0,const TenseurHH & gijHH_0
,const TenseurBB & gijBB_tdt,const TenseurHH & gijHH_tdt
,const double& jacobien_0,const double& jacobien)
{InvariantsEtVar1(gijBB_0,gijHH_0,gijBB_tdt,gijHH_tdt,jacobien_0,jacobien);
// vérification numérique de la dérivée
Calcul_derivee_numerique(gijBB_0,gijHH_0,gijBB_tdt,gijHH_tdt,jacobien_0,jacobien);
};
// calcul des invariants et de leurs variations premières et secondes
void Invariants_et_var2_deb(const TenseurBB & gijBB_0,const TenseurHH & gijHH_0
,const TenseurBB & gijBB_tdt,const TenseurHH & gijHH_tdt
,const double& jacobien_0,const double& jacobien)
{InvariantsEtVar2(gijBB_0,gijHH_0,gijBB_tdt,gijHH_tdt,jacobien_0,jacobien);
Calcul_derivee_numerique2(gijBB_0,gijHH_0,gijBB_tdt,gijHH_tdt,jacobien_0,jacobien);
};
};
/// @} // end of group
#endif