Herezh_dev/herezh_pp/Util/Courbes/TangenteHyperbolique.cc

268 lines
10 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 "TangenteHyperbolique.h"
#include "Sortie.h"
#include "ConstMath.h"
#include "MathUtil.h"
#include "ParaGlob.h"
// CONSTRUCTEURS :
TangenteHyperbolique::TangenteHyperbolique(string nom) :
Courbe1D(nom,COURBE_TANH)
,ax(0.),bx(1.),cx(0.),dx(1.)
{};
// de copie
TangenteHyperbolique::TangenteHyperbolique(const TangenteHyperbolique& Co) :
Courbe1D(Co)
,ax(Co.ax),bx(Co.bx),cx(Co.cx),dx(Co.dx)
{};
// de copie à partir d'une instance générale
TangenteHyperbolique::TangenteHyperbolique(const Courbe1D& Coo) :
Courbe1D(Coo)
{ if (Coo.Type_courbe() != COURBE_TANH)
{ cout << "\n erreur dans le constructeur de copie pour une courbe COURBE_TANH "
<< " à partir d'une instance générale ";
cout << "\n TangenteHyperbolique::TangenteHyperbolique(const Courbe1D& Co) ";
Sortie(1);
};
// définition des données
TangenteHyperbolique & Co = (TangenteHyperbolique&) Coo;
ax = Co.ax;bx = Co.bx; cx = Co.cx; dx = Co.dx;
};
// DESTRUCTEUR :
TangenteHyperbolique::~TangenteHyperbolique()
{};
// METHODES PUBLIQUES :
// --------- virtuelles ---------
// affichage de la courbe
void TangenteHyperbolique::Affiche() const
{ cout << "\n TangenteHyperbolique: nom_ref= " << nom_ref;
cout << "\n a= " << ax << " b= " << bx << " c= " << cx << " d= " << dx;
};
// vérification que tout est ok, pres à l'emploi
// ramène true si ok, false sinon
bool TangenteHyperbolique::Complet_courbe()const
{ bool ret = Complet_var(); // on regarde du coté de la classe mère tout d'abord
// puis les variables propres
if (!ret && (ParaGlob::NiveauImpression() >0))
{ cout << "\n ***** la courbe n'est pas complete ";
this->Affiche();
};
return ret;
} ;
// Lecture des donnees de la classe sur fichier
// le nom passé en paramètre est le nom de la courbe
// s'il est vide c-a-d = "", la methode commence par lire le nom sinon
// ce nom remplace le nom actuel
void TangenteHyperbolique::LectDonnParticulieres_courbes(const string& nom,UtilLecture * entreePrinc)
{ if (nom == "") { *(entreePrinc->entree) >> nom_ref;}
else {nom_ref=nom;};
entreePrinc->NouvelleDonnee(); // lecture d'une nouvelle ligne
// on lit le premier parametre
string toto;
*(entreePrinc->entree) >> toto >> ax ;
if(toto != "a=")
{ cout << "\n erreur en lecture du coefficient a, on attendait le mot cle a= et on a lue " << toto;
cout << "\n TangenteHyperbolique::LectureDonneesParticulieres "
<< "(UtilLecture * entreePrinc) " << endl ;
entreePrinc->MessageBuffer("**erreur1, TangenteHyperbolique::LectureDonneesParticulieres **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
*(entreePrinc->entree) >> toto >> bx ;
if(toto != "b=")
{ cout << "\n erreur en lecture du coefficient b, on attendait le mot cle b= et on a lue " << toto;
cout << "\n TangenteHyperbolique::LectureDonneesParticulieres "
<< "(UtilLecture * entreePrinc) " << endl ;
entreePrinc->MessageBuffer("**erreur2, TangenteHyperbolique::LectureDonneesParticulieres **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
*(entreePrinc->entree) >> toto >> cx ;
if(toto != "c=")
{ cout << "\n erreur en lecture du coefficient c, on attendait le mot cle c= et on a lue " << toto;
cout << "\n TangenteHyperbolique::LectureDonneesParticulieres "
<< "(UtilLecture * entreePrinc) " << endl ;
entreePrinc->MessageBuffer("**erreur3, TangenteHyperbolique::LectureDonneesParticulieres **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
*(entreePrinc->entree) >> toto >> dx ;
if(toto != "d=")
{ cout << "\n erreur en lecture du coefficient d, on attendait le mot cle d= et on a lue " << toto;
cout << "\n TangenteHyperbolique::LectureDonneesParticulieres "
<< "(UtilLecture * entreePrinc) " << endl ;
entreePrinc->MessageBuffer("**erreur4, TangenteHyperbolique::LectureDonneesParticulieres **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
if (Abs(dx) < ConstMath::trespetit)
{ cout << "\n erreur en lecture du coefficient d lu, il est trop petit donc nul= " << dx << " -> division par zero ";
cout << "\n TangenteHyperbolique::LectureDonneesParticulieres "
<< "(UtilLecture * entreePrinc) " << endl ;
entreePrinc->MessageBuffer("**erreur5, TangenteHyperbolique::LectureDonneesParticulieres **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
};
// def info fichier de commande
void TangenteHyperbolique::Info_commande_Courbes1D(UtilLecture & entreePrinc)
{
ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
sort << "\n#............................................"
<< "\n# exemple de definition d'une courbe COURBE_TANH "
<< " ( f(x) = a + b * tanh( (x-c)/d) "
<< "\n # def des coeff de la courbe COURBE_TANH "
<< "\n a= 100. b= -32. c= 295. d= 22. "
<< endl;
};
// ramène la valeur
double TangenteHyperbolique::Valeur(double x)
{ return ax+bx*tanh((x-cx)/dx);};
// ramène la valeur et la dérivée en paramètre
Courbe1D::ValDer TangenteHyperbolique::Valeur_Et_derivee(double x)
{ ValDer ret;
double X = (x-cx)/dx;
ret.valeur = ax+bx*tanh(X);
ret.derivee = bx / (dx*Sqr(cosh(X)));
return ret;
};
// ramène la dérivée
double TangenteHyperbolique::Derivee(double x)
{ return (bx / (dx*Sqr(cosh((x-cx)/dx))));};
// ramène la valeur et les dérivées première et seconde en paramètre
Courbe1D::ValDer2 TangenteHyperbolique::Valeur_Et_der12(double x)
{ ValDer2 ret;
double X = (x-cx)/dx;
ret.valeur = ax+bx*tanh(X);
ret.derivee = bx / (dx*Sqr(cosh(X)));
ret.der_sec = (-2./dx) * ret.derivee * tanh(X);
return ret;
};
// ramène la dérivée seconde
double TangenteHyperbolique::Der_sec(double x)
{ double X = (x-cx)/dx;
double derivee = bx / (dx*Sqr(cosh(X)));
return (-2./dx) * derivee * tanh(X);
};
// ramène la valeur si dans le domaine strictement de définition
// si c'est inférieur au x mini, ramène la valeur minimale possible de y
// si supérieur au x maxi , ramène le valeur maximale possible de y
Courbe1D::Valbool TangenteHyperbolique::Valeur_stricte(double x)
{ Valbool ret; // def de la valeur de retour
// ici toujours ok
double X = (x-cx)/dx;
ret.valeur = ax+bx*tanh(X);
ret.dedans = true;
return ret;
};
// ramène la valeur et la dérivée si dans le domaine strictement de définition
// si c'est inférieur au x mini, ramène la valeur minimale possible de y et Y' correspondant
// si supérieur au x maxi , ramène le valeur maximale possible de y et Y' correspondant
Courbe1D::ValDerbool TangenteHyperbolique::Valeur_Et_derivee_stricte(double x)
{ ValDerbool ret; // def de la valeur de retour
double X = (x-cx)/dx;
ret.valeur = ax+bx*tanh(X);
ret.derivee = bx / (dx*Sqr(cosh(X)));
// ici toujours ok
ret.dedans = true;
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 TangenteHyperbolique::Lecture_base_info(ifstream& ent,const int cas)
{ // on n'a que des grandeurs constantes
if (cas == 1)
{ string nom;
// lecture et vérification de l'entête
ent >> nom;
if (nom != "TangenteHyperbolique")
{ cout << "\n erreur dans la vérification du type de courbe lue ";
cout << "\n TangenteHyperbolique::Lecture_base_info(... ";
Sortie(1);
}
// lecture des infos
ent >> nom >> ax >> nom >> bx >> nom >> cx >> nom >> dx;
}
};
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void TangenteHyperbolique::Ecriture_base_info(ofstream& sort,const int cas)
{ // on n'a que des grandeurs constantes
if (cas == 1)
{ sort << " TangenteHyperbolique ";
sort << " a= " << ax << " b= " << bx << " c= " << cx << " d= "<< dx << " ";
}
};
// sortie du schemaXML: en fonction de enu
void TangenteHyperbolique::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu)
{
switch (enu)
{ case XML_TYPE_GLOBAUX :
{
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
};
};