301 lines
10 KiB
C++
Executable file
301 lines
10 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 "CourbePolynomiale.h"
|
|
#include "Sortie.h"
|
|
#include "ConstMath.h"
|
|
#include "MathUtil.h"
|
|
#include "CharUtil.h"
|
|
#include "ParaGlob.h"
|
|
|
|
|
|
// CONSTRUCTEURS :
|
|
CourbePolynomiale::CourbePolynomiale(string nom) :
|
|
Courbe1D(nom,COURBEPOLYNOMIALE),coef()
|
|
{};
|
|
|
|
// de copie
|
|
CourbePolynomiale::CourbePolynomiale(const CourbePolynomiale& Co) :
|
|
Courbe1D(Co),coef(Co.coef)
|
|
{};
|
|
// de copie à partir d'une instance générale
|
|
CourbePolynomiale::CourbePolynomiale(const Courbe1D& Coo) :
|
|
Courbe1D(Coo)
|
|
{ if (Coo.Type_courbe() != COURBEPOLYNOMIALE)
|
|
{ cout << "\n erreur dans le constructeur de copie pour une courbe COURBEPOLYNOMIALE "
|
|
<< " à partir d'une instance générale ";
|
|
cout << "\n CourbePolynomiale::CourbePolynomiale(const Courbe1D& Co) ";
|
|
Sortie(1);
|
|
};
|
|
// définition des données
|
|
CourbePolynomiale & Co = (CourbePolynomiale&) Coo;
|
|
coef = Co.coef;
|
|
};
|
|
|
|
// DESTRUCTEUR :
|
|
CourbePolynomiale::~CourbePolynomiale()
|
|
{};
|
|
|
|
// METHODES PUBLIQUES :
|
|
|
|
// --------- virtuelles ---------
|
|
|
|
// affichage de la courbe
|
|
void CourbePolynomiale::Affiche() const
|
|
{ cout << "\n CourbePolynomiale : nom_ref= " << nom_ref;
|
|
cout << "\n coef=" << coef << " ";
|
|
};
|
|
|
|
// vérification que tout est ok, pres à l'emploi
|
|
// ramène true si ok, false sinon
|
|
bool CourbePolynomiale::Complet_courbe()const
|
|
{ bool ret = Complet_var(); // on regarde du coté de la classe mère tout d'abord
|
|
// puis les variables propres
|
|
if (coef.Taille() == 0) 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 CourbePolynomiale::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
|
|
string ncoe;
|
|
// tout d'abord on passe le mot clé
|
|
*(entreePrinc->entree) >> ncoe;
|
|
// if(strstr(entreePrinc->tablcar,"debut_coef=")==0)
|
|
if(ncoe != "debut_coef=")
|
|
{ cout << "\n erreur en lecture de l'entete des coefficients "
|
|
<< " on attendait la chaine: debut_coef= et on a lue "<< ncoe;
|
|
entreePrinc->MessageBuffer("**erreur1 CourbePolynomiale::LectureDonneesParticulieres**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
// lecture des coeffs
|
|
list <double> list_coef; // pour la lecture
|
|
try
|
|
{ *(entreePrinc->entree) >> ncoe;
|
|
while (ncoe != "fin_coef")
|
|
{ double co = ChangeReel(ncoe);
|
|
list_coef.push_back(co);
|
|
*(entreePrinc->entree) >> ncoe;
|
|
}
|
|
}
|
|
catch (ErrSortieFinale)
|
|
// cas d'une direction voulue vers la sortie
|
|
// on relance l'interuption pour le niveau supérieur
|
|
{ ErrSortieFinale toto;
|
|
throw (toto);
|
|
}
|
|
catch (...)
|
|
{ cout << "\n erreur en lecture des coefficients du polynome "
|
|
<< " a la suite du mot cle debut_coef= on attendait n coefficient suivi du mot cle"
|
|
<< " fin_coef et on lue "<< ncoe;
|
|
entreePrinc->MessageBuffer("**erreur1 CourbePolynomiale::LectureDonneesParticulieres**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
// définition du tableau
|
|
int taille = list_coef.size();
|
|
coef.Change_taille(taille);
|
|
list <double>::iterator il = list_coef.begin();
|
|
for (int i=1;i<= taille;i++,il++)
|
|
coef(i)=(*il);
|
|
};
|
|
|
|
// def info fichier de commande
|
|
void CourbePolynomiale::Info_commande_Courbes1D(UtilLecture & entreePrinc)
|
|
{
|
|
ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
|
|
sort << "\n#............................................"
|
|
<< "\n# exemple de definition d'une courbe COURBEPOLYNOMIALE"
|
|
<< "\n#"
|
|
<< "\n courbe_exemple COURBEPOLYNOMIALE # nom de la courbe puis le type de la courbe"
|
|
<< "\n # def des coefficients d'un polynome du troisieme degre 1+3x+6x^2+8x^3"
|
|
<< "\n debut_coef= 1. 3. 6. 8. fin_coef "
|
|
<< endl;
|
|
};
|
|
|
|
// ramène la valeur
|
|
double CourbePolynomiale::Valeur(double x)
|
|
{ double taille = coef.Taille();
|
|
double vale = coef(taille);
|
|
for (int i=taille-1;i> 0;i--)
|
|
{ vale = vale*x + coef(i);};
|
|
return vale;
|
|
};
|
|
|
|
// ramène la valeur et la dérivée en paramètre
|
|
Courbe1D::ValDer CourbePolynomiale::Valeur_Et_derivee(double x)
|
|
{ ValDer ret; // def de la valeur de retour
|
|
double taille = coef.Taille();
|
|
// valeur
|
|
ret.valeur = coef(taille);
|
|
for (int i=taille-1;i> 0;i--)
|
|
{ ret.valeur = ret.valeur*x + coef(i);};
|
|
// dérivée
|
|
ret.derivee = coef(taille) * (taille-1.);
|
|
for (int i=taille-1;i> 1;i--)
|
|
{ ret.derivee = ret.derivee*x + coef(i) * (i-1.);};
|
|
return ret;
|
|
};
|
|
|
|
// ramène la dérivée
|
|
double CourbePolynomiale::Derivee(double x)
|
|
{ double taille = coef.Taille();
|
|
double der = coef(taille) * (taille-1.);
|
|
for (int i=taille-1;i> 1;i--)
|
|
{ der = der*x + coef(i) * (i-1.);};
|
|
return der;
|
|
};
|
|
|
|
// ramène la valeur et les dérivées première et seconde en paramètre
|
|
Courbe1D::ValDer2 CourbePolynomiale::Valeur_Et_der12(double x)
|
|
{ ValDer2 ret; // def de la valeur de retour
|
|
double taille = coef.Taille();
|
|
// valeur
|
|
ret.valeur = coef(taille);
|
|
for (int i=taille-1;i> 0;i--)
|
|
{ ret.valeur = ret.valeur*x + coef(i);};
|
|
// dérivée
|
|
ret.derivee = coef(taille) * (taille-1.);
|
|
for (int i=taille-1;i> 1;i--)
|
|
{ ret.derivee = ret.derivee*x + coef(i) * (i-1.);};
|
|
// dérivée seconde
|
|
ret.der_sec = coef(taille) * (taille-1.) * (taille-2.);
|
|
for (int i=taille-1;i> 2;i--)
|
|
{ ret.der_sec = ret.der_sec*x + coef(i) * (i-1.) * (i-2.);
|
|
};
|
|
return ret;
|
|
};
|
|
|
|
// ramène la dérivée seconde
|
|
double CourbePolynomiale::Der_sec(double x)
|
|
{ double taille = coef.Taille();
|
|
double der2 = coef(taille) * (taille-1.) * (taille-2.);
|
|
for (int i=taille-1;i> 2;i--)
|
|
{ der2 = der2*x + coef(i) * (i-1.) * (i-2.);};
|
|
return der2;
|
|
};
|
|
|
|
// 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 CourbePolynomiale::Valeur_stricte(double x)
|
|
{ Valbool ret; // def de la valeur de retour
|
|
double taille = coef.Taille();
|
|
// valeur
|
|
ret.valeur = coef(taille);
|
|
for (int i=taille-1;i> 0;i--)
|
|
{ ret.valeur = ret.valeur*x + coef(i);};
|
|
// intervale de définition R
|
|
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 CourbePolynomiale::Valeur_Et_derivee_stricte(double x)
|
|
{ ValDerbool ret; // def de la valeur de retour
|
|
double taille = coef.Taille();
|
|
// valeur
|
|
ret.valeur = coef(taille);
|
|
for (int i=taille-1;i> 0;i--)
|
|
{ ret.valeur = ret.valeur*x + coef(i);};
|
|
// dérivée
|
|
ret.derivee = coef(taille) * (taille-1.);
|
|
for (int i=taille-1;i> 1;i--)
|
|
{ ret.derivee = ret.derivee*x + coef(i) * (i-1.);};
|
|
// intervale de définition R
|
|
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 CourbePolynomiale::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 != "COURBEPOLYNOMIALE")
|
|
{ cout << "\n erreur dans la vérification du type de courbe lue ";
|
|
cout << "\n CourbePolynomiale::Lecture_base_info(... ";
|
|
Sortie(1);
|
|
}
|
|
// lecture des infos
|
|
coef.Entree(ent);
|
|
}
|
|
};
|
|
|
|
// cas donne le niveau de sauvegarde
|
|
// = 1 : on sauvegarde tout
|
|
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
|
|
void CourbePolynomiale::Ecriture_base_info(ofstream& sort,const int cas)
|
|
{ // on n'a que des grandeurs constantes
|
|
if (cas == 1)
|
|
{ sort << " COURBEPOLYNOMIALE ";
|
|
coef.Sortir(sort);
|
|
}
|
|
};
|
|
|
|
// sortie du schemaXML: en fonction de enu
|
|
void CourbePolynomiale::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;
|
|
}
|
|
};
|
|
};
|
|
|