Herezh_dev/herezh_pp/comportement/Hyper_elastique/TreloarN.cc

158 lines
6.3 KiB
C++
Raw Normal View History

// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "TreloarN.h"
#include "MathUtil.h"
#include "ComLoi_comp_abstraite.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <math.h>
#include <stdlib.h>
#include "Sortie.h"
TreloarN::TreloarN () : // Constructeur par defaut
Hyper3DN(TRELOAR,CAT_MECANIQUE), K(0.), C(0.)
{};
// Constructeur de copie
TreloarN::TreloarN (const TreloarN& loi) :
Hyper3DN (loi), K(loi.K), C(loi.C)
{};
// Lecture des donnees de la classe sur fichier
void TreloarN::LectureDonneesParticulieres (UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D
,LesFonctions_nD& lesFonctionsnD)
{ // lecture des quatres coefficients de la loi
*(entreePrinc->entree) >> K >> C ;
// appel au niveau de la classe mère
Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire
(*entreePrinc,lesFonctionsnD);
};
// affichage de la loi
void TreloarN::Affiche() const
{ cout << " \n loi de comportement 3D hyperélastique isotrope de Treloar : " << Nom_comp(id_comp)
<< " paramètres : \n";
cout << " K= " << K << " ; C = " << C ;
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 TreloarN::Info_commande_LoisDeComp(UtilLecture& entreePrinc)
{ ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
sort << "\n# ....... loi de comportement 3D hyperélastique isotrope de Treloar ........"
<< "\n#-------------------------"
<< "\n# K | C |"
<< "\n#-------------------------"
<< "\n 160000 150 "
<< endl;
// appel de la classe mère
Loi_comp_abstraite::Info_commande_don_LoisDeComp(entreePrinc);
};
// test si la loi est complete
int TreloarN::TestComplet()
{ int ret = LoiAbstraiteGeneral::TestComplet();
if ((K == 0.) && (C == 0.) )
{ cout << " \n Les paramètres ne sont pas défini pour la loi " << Nom_comp(id_comp)
<< '\n';
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 TreloarN::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
,LesFonctions_nD& lesFonctionsnD)
{ string toto;
if (cas == 1) {ent >> toto >> K >> toto >> C;};
// appel class mère
Loi_comp_abstraite::Lecture_don_base_info(ent,cas,lesRef,lesCourbes1D,lesFonctionsnD);
};
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void TreloarN::Ecriture_base_info_loi(ofstream& sort,const int cas)
{ if (cas == 1)
{sort << "TRELOAR" << " compressibilite " << K << " coef Treloar " << C ;}
// appel de la classe mère
Loi_comp_abstraite::Ecriture_don_base_info(sort,cas);
};
// =========== METHODES Protégées dérivant de virtuelles : ==============
// calcul du potentiel et de ses dérivées premières
void TreloarN::Potentiel( double& jacobien_0,double& Ieps,double& V,double& bIIb,
double& E,double& EV,double& EbIIb,double& EIeps)
{
double V43 = pow(V,4./3);
double logV = log(V); double log2V = logV * logV ; double untiers = 1. / 3. ;
// le potentiel
E = jacobien_0 * (C *( V43 * (3.-4.* Ieps + 4.* untiers * Ieps * Ieps - 4. * bIIb) - 3)
+ V * log2V * K * 0.5) ;
// les variations premières
EIeps = jacobien_0 * C * V43 *(-4. + 8.* untiers * Ieps);
EbIIb = -4. * jacobien_0 * C * V43;
EV = 4. * untiers * jacobien_0 * C * pow(V,untiers) + 0.5 * K * log2V + K * logV;
};
// calcul du potentiel et de ses dérivées premières et secondes
void TreloarN::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 )
{
double V43 = pow(V,4./3);
double logV = log(V); double log2V = logV * logV ; double untiers = 1. / 3. ;
double V13 = pow(V,untiers);
// le potentiel
E = jacobien_0 * (C *( V43 * (3.-4.* Ieps + 4.* untiers * Ieps * Ieps - 4. * bIIb) - 3)
+ V * log2V * K * 0.5) ;
// les variations premières
EIeps = jacobien_0 * C * V43 *(-4. + 8.* untiers * Ieps);
EbIIb = -4. * jacobien_0 * C * V43;
EV = 4. * untiers * jacobien_0 * C * V13 + 0.5 * K * log2V + K * logV;
// les variations secondes
EIeps2 = 8. * jacobien_0 * C * V43 * Ieps * untiers ;
EbIIbIeps = 0.;
EVIeps = 4. * jacobien_0 * C * V13 *(-4. + 8. * untiers * Ieps )* untiers ;
EbIIb2 = 0.;
EVbIIb = -16. * jacobien_0 * C * V13 * untiers ;
EVV = 4. * jacobien_0 * C * untiers * untiers /(V13 *V13) + K/V * (logV + 1.) ;
};