242 lines
12 KiB
C++
242 lines
12 KiB
C++
|
|
|
|
// This file is part of the Herezh++ application.
|
|
//
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
// of mechanics for large transformations of solid structures.
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
//
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
//
|
|
// Copyright (C) 1997-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/>.
|
|
|
|
/************************************************************************
|
|
* DATE: 1/10/98 *
|
|
* $ *
|
|
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
|
|
* $ *
|
|
* PROJET: Herezh++ *
|
|
* $ *
|
|
************************************************************************
|
|
* BUT: Classe générale des potentiels hyperélastiques isotropes, *
|
|
* définis à partir des invariants : *
|
|
* - V : variation relative de volume, *
|
|
* - Ieps : trace du tenseur de déformation d'Almansi, *
|
|
* - bIIb : deuxième invariant barre, du déviateur des *
|
|
* déformations. *
|
|
* $ *
|
|
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
|
|
* VERIFICATION: *
|
|
* *
|
|
* ! date ! auteur ! but ! *
|
|
* ------------------------------------------------------------ *
|
|
* ! ! ! ! *
|
|
* $ *
|
|
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
|
|
* MODIFICATIONS: *
|
|
* ! date ! auteur ! but ! *
|
|
* ------------------------------------------------------------ *
|
|
* $ *
|
|
************************************************************************/
|
|
#ifndef HYPERDN_H
|
|
#define HYPERDN_H
|
|
|
|
#include "Loi_comp_abstraite.h"
|
|
|
|
|
|
|
|
/// @addtogroup Les_lois_hyperelastiques
|
|
/// @{
|
|
///
|
|
|
|
template <class TensHH,class TensBB,class TensBH,class TensHB,
|
|
class Tens_nHH,class Tens_nBB>
|
|
class HyperDN : public Loi_comp_abstraite
|
|
{
|
|
public :
|
|
// CONSTRUCTEURS :
|
|
|
|
HyperDN (); // Constructeur par defaut
|
|
// Constructeur utile si l'identificateur du nom de la loi
|
|
// de comportement et la dimension sont connus
|
|
HyperDN (Enum_comp id_compor,Enum_categorie_loi_comp categorie_comp,int dimension) ;
|
|
// Constructeur utile si l'identificateur du nom de la loi
|
|
// de comportement et la dimension sont connus
|
|
HyperDN (char* nom,Enum_categorie_loi_comp categorie_comp,int dimension) ;
|
|
// DESTRUCTEUR :
|
|
~HyperDN ();
|
|
// constructeur de copie
|
|
HyperDN (const HyperDN & a) ;
|
|
|
|
// 1) definition d'une classe dérivée de SaveResul pour stocker le
|
|
// jacobien initial
|
|
|
|
class SaveResulHyperDN : public Loi_comp_abstraite::SaveResul
|
|
{ public :
|
|
// constructeur
|
|
SaveResulHyperDN(const double & jacob) : jacobien_0(jacob) {};
|
|
// destructeur
|
|
~SaveResulHyperDN() {};
|
|
|
|
// définition d'une nouvelle instance identique
|
|
// appelle du constructeur via new
|
|
SaveResul * Nevez_SaveResul() const {return (new SaveResulHyperDN(*this));};
|
|
// affectation
|
|
virtual SaveResul & operator = ( const SaveResul & a)
|
|
{ SaveResulHyperDN& sav = *((SaveResulHyperDN*) &a);
|
|
jacobien_0=sav.jacobien_0;
|
|
return *this;
|
|
};
|
|
//============= lecture écriture dans base info ==========
|
|
// cas donne le niveau de la récupération
|
|
// = 1 : on récupère tout
|
|
// = 2 : on récupère uniquement les données variables (supposées comme telles)
|
|
virtual void Lecture_base_info (ifstream& ent,const int cas) {};
|
|
// 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& sort,const int cas) {};
|
|
|
|
// affichage à l'écran des infos
|
|
void Affiche() const { cout << "\n SaveResulHyperDN: jacobien_0= " << jacobien_0 << " ";};
|
|
|
|
//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 <Coordonnee>& tab_coor
|
|
,const Loi_comp_abstraite* loi) {return NULL;};
|
|
|
|
|
|
double jacobien_0;
|
|
};
|
|
|
|
SaveResul * New_et_Initialise() { return (new SaveResulHyperDN(0.));};
|
|
|
|
// 2) METHODES public découlant de méthodes virtuelles :
|
|
|
|
// affichage des donnees particulieres a l'elements
|
|
// de matiere traite ( c-a-dire au pt calcule)
|
|
void AfficheDataSpecif(ofstream& ,SaveResul * ) const {};
|
|
|
|
|
|
protected :
|
|
|
|
// 3) METHODES protegees découlant de virtuelles pures:
|
|
// calcul des contraintes a t+dt
|
|
// calcul des contraintes
|
|
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);
|
|
|
|
// calcul des contraintes et de ses variations a t+dt
|
|
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);
|
|
|
|
|
|
// fonction surchargée dans les classes dérivée si besoin est
|
|
virtual void CalculGrandeurTravail
|
|
(const PtIntegMecaInterne& ,const Deformation &
|
|
,Enum_dure,const ThermoDonnee&
|
|
,const Met_abstraite::Impli* ex_impli
|
|
,const Met_abstraite::Expli_t_tdt* ex_expli_tdt
|
|
,const Met_abstraite::Umat_cont* ex_umat
|
|
,const List_io<Ddl_etendu>* exclure_dd_etend
|
|
,const List_io<const TypeQuelconque *>* exclure_Q
|
|
) {};
|
|
|
|
// 4) METHODES internes spécifiques à l'hyperélasticité isotrope
|
|
|
|
// par exemple, regarder dans hyper10N pour le calcul des invariants
|
|
|
|
// Calcul des trois invariants ,de epsBH,
|
|
// retour de IdGBH qui pointe sur le bon tenseur
|
|
virtual TensBH * Invariants (TenseurBB& epsBB_t,TenseurBB& gijBB_t,
|
|
TenseurHH & gijHH_t, double& jacobien_0,double& jacobien_t,
|
|
double & Ieps,double & V,double& bIIb,TensBH & epsBH) = 0;
|
|
// calcul des trois invariants et de leurs variations, de epsBH,
|
|
// et de sa variation, puis retour de IdGBH qui pointe sur le bon tenseur
|
|
virtual TensBH * Invariants_et_var
|
|
(TenseurBB& epsBB_tdt,
|
|
TenseurBB& gijBB_tdt,Tableau <TenseurBB *>& d_gijBB_tdt,
|
|
TenseurHH & gijHH_tdt,Tableau <TenseurHH *>& d_gijHH_tdt,
|
|
double& jacobien_0,double& jacobien_tdt,Vecteur& d_jacobien_tdt,
|
|
double & Ieps,Tableau<double> & dIeps,
|
|
double & V,Tableau<double> & dV,double& bIIb,Tableau<double> & dbIIb,
|
|
TensBH & epsBH,Tableau<TensBH> & depsBH) = 0;
|
|
|
|
// calcul du potentiel et de ses dérivées premières
|
|
virtual void Potentiel(double& jacobien_0, double& Ieps,double& V,double& bIIb,
|
|
double& E,double& EV,double& EbIIb,double& EIeps) = 0;
|
|
// calcul du potentiel et de ses dérivées premières et secondes
|
|
virtual void Potentiel_et_var(double& jacobien_0,double& Ieps,double& V,double& bIIb,
|
|
double& E,double& EV,double& EbIIb,double& EIeps ,
|
|
double& EVV,double& EbIIb2,double& EIeps2,
|
|
double& EVbIIb,double& EVIeps,double& EbIIbIeps ) = 0;
|
|
|
|
protected :
|
|
// VARIABLES PROTEGEES :
|
|
|
|
// METHODES PROTEGEES :
|
|
// calcul des coefficients alpha
|
|
inline void Alpha (double& E,double& EV,double& EbIIb,double& EIeps,
|
|
double& jacobien_0,double& Ieps,double& V,double& bIIb,
|
|
double& alpha_0,double& alpha_1,double& alpha_2);
|
|
|
|
|
|
// calcul des coefficients alpha et de leurs variations par rapport aux degrés de libertés
|
|
inline void Alpha_var (double& E,double& EV,double& EbIIb,double& EIeps,
|
|
double& EVV,double& EbIIb2,double& EIeps2,
|
|
double& EVbIIb,double& EVIeps,double& EbIIbIeps,
|
|
double& jacobien_0,double& Ieps,Tableau<double> & dIeps,double& V,Tableau<double> & dV,
|
|
double& bIIb,Tableau<double> & dbIIb,
|
|
double& alpha_0,Tableau<double> & dalpha_0,
|
|
double& alpha_1,Tableau<double> & dalpha_1,
|
|
double& alpha_2,Tableau<double> & dalpha_2);
|
|
|
|
};
|
|
/// @} // end of group
|
|
|
|
#include "HyperDN.cc"
|
|
|
|
|
|
#endif
|