158 lines
6.3 KiB
C++
158 lines
6.3 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/>.
|
|
|
|
#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.) ;
|
|
};
|
|
|
|
|