// 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;
		}
	};		
  };
     
