343 lines
13 KiB
C++
Executable file
343 lines
13 KiB
C++
Executable file
// 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 "Courbe_relax_expo.h"
|
|
#include "Sortie.h"
|
|
#include "ConstMath.h"
|
|
#include "MathUtil.h"
|
|
#include "ParaGlob.h"
|
|
#include "MotCle.h"
|
|
|
|
// CONSTRUCTEURS :
|
|
Courbe_relax_expo::Courbe_relax_expo(string nom) :
|
|
Courbe1D(nom,COURBE_RELAX_EXPO)
|
|
,xa(-ConstMath::tresgrand),xb(1.),xc(0.)
|
|
,xmin(-ConstMath::tresgrand),xmax(ConstMath::tresgrand)
|
|
// xa négatif -> pb que l'on peut détecter pour savoir si c'est complet
|
|
{};
|
|
|
|
// de copie
|
|
Courbe_relax_expo::Courbe_relax_expo(const Courbe_relax_expo& Co) :
|
|
Courbe1D(Co)
|
|
,xa(Co.xa),xb(Co.xb),xc(Co.xc)
|
|
,xmin(Co.xmin),xmax(Co.xmax)
|
|
{};
|
|
// de copie à partir d'une instance générale
|
|
Courbe_relax_expo::Courbe_relax_expo(const Courbe1D& Coo) :
|
|
Courbe1D(Coo)
|
|
{ if (Coo.Type_courbe() != COURBE_RELAX_EXPO)
|
|
{ cout << "\n erreur dans le constructeur de copie pour une courbe COURBE_RELAX_EXPO "
|
|
<< " à partir d'une instance générale ";
|
|
cout << "\n Courbe_relax_expo::Courbe_relax_expo(const Courbe1D& Co) ";
|
|
Sortie(1);
|
|
};
|
|
// définition des données
|
|
Courbe_relax_expo & Co = (Courbe_relax_expo&) Coo;
|
|
xa = Co.xa; xb = Co.xb;xc = Co.xc;
|
|
xmin = Co.xmin; xmax = Co.xmax;
|
|
};
|
|
|
|
// DESTRUCTEUR :
|
|
Courbe_relax_expo::~Courbe_relax_expo()
|
|
{};
|
|
|
|
// METHODES PUBLIQUES :
|
|
|
|
// --------- virtuelles ---------
|
|
|
|
// affichage de la courbe
|
|
void Courbe_relax_expo::Affiche() const
|
|
{ cout << "\n Courbe_relax_expo: nom_ref= " << nom_ref;
|
|
cout << "\n xa=" << xa << " n= " << xb << " xc= " << xc << " ";
|
|
cout << " min_x= " << xmin << " max_x= " << xmax << " ";
|
|
};
|
|
|
|
// vérification que tout est ok, pres à l'emploi
|
|
// ramène true si ok, false sinon
|
|
bool Courbe_relax_expo::Complet_courbe()const
|
|
{ bool ret = Complet_var(); // on regarde du coté de la classe mère tout d'abord
|
|
// puis les variables propres
|
|
if (xa == -ConstMath::tresgrand) ret = false;
|
|
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 Courbe_relax_expo::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 l'entête de chaque coef et on vérifie
|
|
string nomcoef;
|
|
// lecture de xa
|
|
*(entreePrinc->entree) >> nomcoef >> xa;
|
|
if(nomcoef != "xa=")
|
|
{ cout << "\n erreur en lecture du coefficient xa , on attendait le mot cle: xa="
|
|
<< " et on a lue : " << nomcoef;
|
|
entreePrinc->MessageBuffer("**Courbe_relax_expo::LectureDonneesParticulieres**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
// lecture de xb
|
|
*(entreePrinc->entree) >> nomcoef >> xb;
|
|
if(nomcoef != "xb=")
|
|
{ cout << "\n erreur en lecture du coefficient xb , on attendait le mot cle: xb="
|
|
<< " et on a lue : " << nomcoef;
|
|
entreePrinc->MessageBuffer("**Courbe_relax_expo::LectureDonneesParticulieres**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
// lecture de xc
|
|
*(entreePrinc->entree) >> nomcoef >> xc;
|
|
if(nomcoef != "xc=")
|
|
{ cout << "\n erreur en lecture du coefficient xc , on attendait le mot cle: xc="
|
|
<< " et on a lue : " << nomcoef;
|
|
entreePrinc->MessageBuffer("**Courbe_relax_expo::LectureDonneesParticulieres**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
// --- lecture éventuelle de bornes min max ----
|
|
if(strstr(entreePrinc->tablcar,"avec_bornesMinMax_")!=0)
|
|
{entreePrinc->NouvelleDonnee(); // on se positionne sur un nouvel enreg
|
|
string nom;
|
|
// on lit tant que l'on ne rencontre pas la ligne contenant "fin_bornesMinMax_"
|
|
// ou un nouveau mot clé global auquel cas il y a pb !!
|
|
MotCle motCle; // ref aux mots cle
|
|
while (strstr(entreePrinc->tablcar,"fin_bornesMinMax_")==0)
|
|
{
|
|
// si on a un mot clé global dans la ligne courante c-a-d dans tablcar --> erreur
|
|
if ( motCle.SimotCle(entreePrinc->tablcar))
|
|
{ cout << "\n erreur de lecture des bornes min max d'une courbe Courbe_relax_expo:"
|
|
<< " on n'a pas trouve le mot cle "
|
|
<< " fin_bornesMinMax_ et par contre la ligne courante contient un mot cle global ";
|
|
entreePrinc->MessageBuffer("** erreur de lecture des bornes min max Courbe_relax_expo::LectDonnParticulieres_courbes(**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
|
|
// lecture d'un mot clé
|
|
*(entreePrinc->entree) >> nom;
|
|
|
|
if ((entreePrinc->entree)->rdstate() == 0)
|
|
{} // lecture normale
|
|
#ifdef ENLINUX
|
|
else if ((entreePrinc->entree)->fail())
|
|
// on a atteind la fin de la ligne et on appelle un nouvel enregistrement
|
|
{ entreePrinc->NouvelleDonnee(); // lecture d'un nouvelle enregistrement
|
|
*(entreePrinc->entree) >>nom;
|
|
}
|
|
#else
|
|
else if ((entreePrinc->entree)->eof())
|
|
// la lecture est bonne mais on a atteind la fin de la ligne
|
|
{ if(nom != "fin_bornesMinMax_")
|
|
{entreePrinc->NouvelleDonnee(); *(entreePrinc->entree) >> nom;};
|
|
}
|
|
#endif
|
|
else // cas d'une erreur de lecture
|
|
{ cout << "\n erreur de lecture inconnue ";
|
|
entreePrinc->MessageBuffer("** erreur2 de lecture des bornes min max Courbe_relax_expo::LectDonnParticulieres_courbes(**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
|
|
// cas de xmin
|
|
if(nom == "xmin=")
|
|
{*(entreePrinc->entree) >> xmin;
|
|
}
|
|
// cas de xmax
|
|
else if(nom == "xmax=")
|
|
{*(entreePrinc->entree) >> xmax;
|
|
};
|
|
|
|
}; //-- fin du while
|
|
}; //-- fin de la lecture des paramètres de réglage
|
|
};
|
|
|
|
// def info fichier de commande
|
|
void Courbe_relax_expo::Info_commande_Courbes1D(UtilLecture & entreePrinc)
|
|
{
|
|
ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
|
|
sort << "\n#............................................"
|
|
<< "\n# exemple de definition d'une courbe COURBE_RELAX_EXPO ( f(x) = (a-b)*exp(-c*x) + b ) "
|
|
<< "\n#"
|
|
<< "\n courbe_monte COURBE_RELAX_EXPO # nom de la courbe puis le type de la courbe"
|
|
<< "\n # def des coeff de la courbe COURBE_RELAX_EXPO "
|
|
<< "\n xa= 2. xb= -1. xc= 1.3 "
|
|
<< "\n# il est egalement possible de definir des mini et maxi pour x "
|
|
<< "\n# dans le cas ou x < xmin, x= xmin, x > xmax: x= xmax "
|
|
<< "\n# La syntaxe globale est la suivante: "
|
|
<< "\n xa= 2. xb= -1. xc= 1.3 avec_bornesMinMax_ # mot cle obligatoire "
|
|
<< "\n# xmin= 0. xmax=3. "
|
|
<< "\n# fin_bornesMinMax_ # mot cle obligatoire "
|
|
<< "\n# "
|
|
<< "\n# Toutes ces bornes sont optionnels, elles peuvent etre indiquees dans un ordre "
|
|
<< "\n# quelconque et sur plusieurs lignes si l'on veut "
|
|
<< "\n# NB: en dehors des bornes, les derivees sont nulles !! "
|
|
<< endl;
|
|
};
|
|
|
|
// ramène la valeur
|
|
double Courbe_relax_expo::Valeur(double X)
|
|
{ double x = MaX(X,xmin); x = MiN (x,xmax);
|
|
return ((xa-xb)*exp(-x*xc)+xb);
|
|
};
|
|
|
|
// ramène la valeur et la dérivée en paramètre
|
|
Courbe1D::ValDer Courbe_relax_expo::Valeur_Et_derivee(double X)
|
|
{ ValDer ret; // def de la valeur de retour
|
|
//tout d'abord on regarde s'il est en dehors des bornes
|
|
double x = MaX(X,xmin); x = MiN (x,xmax);
|
|
double xx = (xa-xb)*exp(-x*xc);
|
|
ret.valeur = xx + xb;
|
|
if ((X < xmin) || (X > xmax))
|
|
{ ret.derivee = 0.;}
|
|
else
|
|
{ ret.derivee = -xc * xx;
|
|
};
|
|
return ret;
|
|
};
|
|
|
|
// ramène la dérivée
|
|
double Courbe_relax_expo::Derivee(double X)
|
|
{ if ((X < xmin) || (X > xmax))
|
|
return 0;
|
|
double x = MaX(X,xmin); x = MiN (x,xmax);
|
|
return ( -xc*(xa-xb)*exp(-x*xc));
|
|
};
|
|
|
|
// ramène la valeur et les dérivées première et seconde en paramètre
|
|
Courbe1D::ValDer2 Courbe_relax_expo::Valeur_Et_der12(double X)
|
|
{ ValDer2 ret; // def de la valeur de retour
|
|
double x = MaX(X,xmin); x = MiN (x,xmax);
|
|
double xx = (xa-xb)*exp(-x*xc);
|
|
ret.valeur = xx + xb;
|
|
if ((X < xmin) || (X > xmax))
|
|
{ ret.derivee = 0.;ret.der_sec = 0.;}
|
|
else
|
|
{ ret.derivee = -xc * xx;
|
|
ret.der_sec = xc * xc * xx;
|
|
};
|
|
return ret;
|
|
};
|
|
|
|
// ramène la dérivée seconde
|
|
double Courbe_relax_expo::Der_sec(double X)
|
|
{ if ((X < xmin) || (X > xmax))
|
|
return 0;
|
|
double x = MaX(X,xmin); x = MiN (x,xmax);
|
|
return (xc * xc * (xa-xb)*exp(-x*xc));
|
|
};
|
|
|
|
// 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 Courbe_relax_expo::Valeur_stricte(double X)
|
|
{ Valbool ret; // def de la valeur de retour
|
|
double x = MaX(X,xmin); x = MiN (x,xmax);
|
|
ret.valeur = ((xa-xb)*exp(-x*xc)+xb);
|
|
if ((X < xmin) || (X > xmax)) { ret.dedans = false;}
|
|
else { 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 Courbe_relax_expo::Valeur_Et_derivee_stricte(double X)
|
|
{ ValDerbool ret; // def de la valeur de retour
|
|
double x = MaX(X,xmin); x = MiN (x,xmax);
|
|
double xx = (xa-xb)*exp(-x*xc);
|
|
ret.valeur = xx + xb;
|
|
if ((X < xmin) || (X > xmax))
|
|
{ ret.derivee = 0.;ret.dedans = false;}
|
|
else
|
|
{ ret.derivee = -xc * xx;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 Courbe_relax_expo::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 != "Courbe_relax_expo")
|
|
{ cout << "\n erreur dans la vérification du type de courbe lue ";
|
|
cout << "\n Courbe_relax_expo::Lecture_base_info(... ";
|
|
Sortie(1);
|
|
}
|
|
// lecture des infos
|
|
ent >> nom >> xa >> nom >> xb >> nom >> xc >> nom >> xmin >> nom >> xmax ;
|
|
}
|
|
};
|
|
|
|
// cas donne le niveau de sauvegarde
|
|
// = 1 : on sauvegarde tout
|
|
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
|
|
void Courbe_relax_expo::Ecriture_base_info(ofstream& sort,const int cas)
|
|
{ // on n'a que des grandeurs constantes
|
|
if (cas == 1)
|
|
{ sort << " Courbe_relax_expo ";
|
|
sort << " xa= " << xa << " xb= " << xb <<" xc= " << xc
|
|
<< " xmin= " << xmin << " xmax= " << xmax << " ";
|
|
}
|
|
};
|
|
|
|
// sortie du schemaXML: en fonction de enu
|
|
void Courbe_relax_expo::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;
|
|
}
|
|
};
|
|
};
|
|
|