// 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_sin.h"
#include "Sortie.h"
#include "ConstMath.h"
#include "MathUtil.h"
#include "ParaGlob.h"

    // CONSTRUCTEURS :
Courbe_sin::Courbe_sin(string nom) :
 Courbe1D(nom,COURBE_SIN)
 ,ax(-ConstMath::tresgrand),bx(ConstMath::tresgrand)
 ,ampli(1.),alph(1.),bet(0.),en_degre(false)
  {};
    
    // de copie
Courbe_sin::Courbe_sin(const Courbe_sin& Co) :
 Courbe1D(Co),ax(Co.ax),bx(Co.bx)
 ,ampli(Co.ampli),alph(Co.alph),bet(Co.bet),en_degre(Co.en_degre)
  {};
    // de copie à partir d'une instance générale
Courbe_sin::Courbe_sin(const Courbe1D& Coo) :
 Courbe1D(Coo)
  { if (Coo.Type_courbe() != COURBE_SIN)
      { cout << "\n erreur dans le constructeur de copie pour une courbe Courbe_sin "
             << " à partir d'une instance générale ";
        cout << "\n Courbe_sin::Courbe_sin(const Courbe1D& Co) ";
           Sortie(1);          
          };
    // définition des données
    Courbe_sin & Co = (Courbe_sin&) Coo;
    ax = Co.ax; bx = Co.bx;
    ampli=Co.ampli;alph=Co.alph;bet=Co.bet;en_degre=Co.en_degre;
  };

    // DESTRUCTEUR :
Courbe_sin::~Courbe_sin() 
  {};
    
    // METHODES PUBLIQUES :
    
    // --------- virtuelles ---------
    
    // affichage de la courbe
void Courbe_sin::Affiche() const 
  { cout << "\n Courbe_sin: nom_ref= " << nom_ref << " ";
    cout << "\n a=" << ax << " b= " << bx << " " ;
    cout << " ampli= " << ampli << " alph= " << alph << " bet= " << bet ;
    if (!en_degre) {cout << " en_radian ";}
    else {cout << " en_degre ";};
   };

    // vérification que tout est ok, pres à l'emploi
    // ramène true si ok, false sinon
bool Courbe_sin::Complet_courbe()const
 { bool ret = Complet_var(); // on regarde du coté de la classe mère tout d'abord
   // puis les variables propres
   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_sin::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 titi;
     // on lit l'entête
     if(strstr(entreePrinc->tablcar,"a=")!=0)
      { *(entreePrinc->entree) >> titi >> ax;
        if(titi != "a=")
         { cout << "\n erreur en lecture du coefficient a , on attendait le mot cle: a="
                << " et on a lue : " << titi;
           entreePrinc->MessageBuffer("**Courbe_sin::LectureDonneesParticulieres**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);          
          };
        };
     if(strstr(entreePrinc->tablcar,"b=")!=0)
      { *(entreePrinc->entree) >> titi >> bx;
        if(titi != "b=")
         { cout << "\n erreur en lecture du coefficient b , on attendait le mot cle: b="
                << " et on a lue : " << titi;
           entreePrinc->MessageBuffer("**Courbe_sin::LectureDonneesParticulieres**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);          
          };
      };

     if(strstr(entreePrinc->tablcar,"ampli=")!=0)
      { *(entreePrinc->entree) >> titi >> ampli;
        if(titi != "ampli=")
         { cout << "\n erreur en lecture du coefficient ampli , on attendait le mot cle: ampli="
                << " et on a lue : " << titi;
           entreePrinc->MessageBuffer("**Courbe_sin::LectureDonneesParticulieres**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);          
          };
      };
     if(strstr(entreePrinc->tablcar,"alph=")!=0)
      { *(entreePrinc->entree) >> titi >> alph;
        if(titi != "alph=")
         { cout << "\n erreur en lecture du coefficient alph , on attendait le mot cle: alph="
                << " et on a lue : " << titi;
           entreePrinc->MessageBuffer("**Courbe_sin::LectureDonneesParticulieres**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);          
          };
      };
     if(strstr(entreePrinc->tablcar,"bet=")!=0)
      { *(entreePrinc->entree) >> titi >> bet;
        if(titi != "bet=")
         { cout << "\n erreur en lecture du coefficient bet , on attendait le mot cle: bet="
                << " et on a lue : " << titi;
           entreePrinc->MessageBuffer("**Courbe_sin::LectureDonneesParticulieres**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);          
          };
      };
     if(strstr(entreePrinc->tablcar,"en_degre_")!=0)
      { *(entreePrinc->entree) >> titi ;
        if(titi != "en_degre_")
         { cout << "\n erreur en lecture du coefficient en_degre_ , on attendait le mot cle: en_degre_"
                << " et on a lue : " << titi;
           entreePrinc->MessageBuffer("**Courbe_sin::LectureDonneesParticulieres**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);          
          };
        en_degre=true;  
      };
     // on fait le changement degré radian si nécessaire:
     if (en_degre) 
      {alph *= ConstMath::Pi / 180.;
       bet *= ConstMath::Pi / 180.;
      };
   };
    
// def info fichier de commande
void Courbe_sin::Info_commande_Courbes1D(UtilLecture & entreePrinc) 
  {  
     ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
     sort << "\n#............................................"
          << "\n# exemple de definition d'une courbe Courbe_sin ( f(x) = ampli*sin(alph*x+beta)   |" 
          << "\n#    les parametres (tous optionnels) de la courbe sont (ordre a respecter) :  "
          << "\n#     . une limite inferieur pour x, ex: a= -1 , par defaut= -l'infini "
          << "\n#     . une limite superieur pour x, ex: b= 4  , par defaut= +l'infini "
          << "\n#     . le coeff ampli, ex: ampli= 2.  , par defaut= 1.  "
          << "\n#     . le coeff alph, ex: alph= 3., par defaut= 1.  "
          << "\n#     . le coeff beta, ex: bet= 0.5, par defaut= 0.  "
          << "\n#     . x en radian (valeur par defaut) ou en degre (presence d'un mot cle) "
          << "\n#                                          ex: en_degre_ "
          << "\n#      exemple complet "
          << "\n courbe_monte   COURBE_SIN  # nom de la courbe puis le type de la courbe "
          << "\n      # def des coeff de la courbe= mini et maxi de x "
          << "\n      # pour x < a => f=f(a), pour x>b => f=f(b)"
          << "\n      # a et b sont facultatif, par defaut = -l'infini et + l'infini "
          << "\n      a= 0. b= 1. ampli= 2. alph= 3. bet= 0.5 en_degre_ "
          << endl;
   };
        
    // ramène la valeur 
double Courbe_sin::Valeur(double x)    
  { double ret=0.;
    if (x < ax) {ret = ampli*sin(alph*ax+bet);}
    else if (x > bx)  {ret = ampli*sin(alph*bx+bet);}
    else {ret = ampli*sin(alph*x+bet);};
    return ret;
  };

    // ramène la valeur et la dérivée en paramètre
Courbe1D::ValDer Courbe_sin::Valeur_Et_derivee(double x)  
  {  ValDer ret; // def de la valeur de retour
    if (x < ax) {ret.valeur = ampli*sin(alph*ax+bet);
                 ret.derivee = ampli*alph*cos(alph*ax+bet); }
    else if (x > bx)  {ret.valeur = ampli*sin(alph*bx+bet);
                 ret.derivee = ampli*alph*cos(alph*bx+bet);}
    else {ret.valeur = ampli*sin(alph*x+bet);
                 ret.derivee = ampli*alph*cos(alph*x+bet);};
    return ret;
  };
    
    // ramène la dérivée 
double Courbe_sin::Derivee(double x)  
  { double ret=0.; // def de la valeur de retour
    if (x < ax) {ret = ampli*alph*cos(alph*ax+bet); }
    else if (x > bx)  {ret = ampli*alph*cos(alph*bx+bet);}
    else {ret = ampli*alph*cos(alph*x+bet);};
    return ret;
  };
        
    // ramène la valeur et les dérivées première et seconde en paramètre
Courbe1D::ValDer2 Courbe_sin::Valeur_Et_der12(double x)
  { ValDer2 ret; // def de la valeur de retour
    if (x < ax) {ret.valeur = ampli*sin(alph*ax+bet);
                 ret.derivee = ampli*alph*cos(alph*ax+bet); }
    else if (x > bx)  {ret.valeur = ampli*sin(alph*bx+bet);
                 ret.derivee = ampli*alph*cos(alph*bx+bet);}
    else {ret.valeur = ampli*sin(alph*x+bet);
                 ret.derivee = ampli*alph*cos(alph*x+bet);};
    ret.der_sec = -alph*alph*ret.valeur;             
    return ret;
  };
        
    // ramène la dérivée seconde
double Courbe_sin::Der_sec(double x)
  { double ret=0.;
    if (x < ax) {ret = -alph*alph*ampli*sin(alph*ax+bet);}
    else if (x > bx)  {ret = -alph*alph*ampli*sin(alph*bx+bet);}
    else {ret = -alph*alph*ampli*sin(alph*x+bet);};
    return ret;
  };
    
    // 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_sin::Valeur_stricte(double x)  
  { Valbool ret; // def de la valeur de retour
    if (x < ax) {ret.valeur = ampli*sin(alph*ax+bet);
                 ret.dedans = false; }
    else if (x > bx)  {ret.valeur = ampli*sin(alph*bx+bet);
                 ret.dedans = false;}
    else {ret.valeur = ampli*sin(alph*x+bet);
                 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_sin::Valeur_Et_derivee_stricte(double x)  
  { ValDerbool ret; // def de la valeur de retour
    if (x < ax) {ret.valeur = ampli*sin(alph*ax+bet);
                 ret.derivee = ampli*alph*cos(alph*ax+bet); 
                 ret.dedans = false;}
    else if (x > bx)  {ret.valeur = ampli*sin(alph*bx+bet);
                 ret.derivee = ampli*alph*cos(alph*bx+bet);
                 ret.dedans = false;}
    else {ret.valeur = ampli*sin(alph*x+bet);
                 ret.derivee = ampli*alph*cos(alph*x+bet);
                 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_sin::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_sin")
         { cout << "\n erreur dans la vérification du type de courbe lue ";    
           cout << "\n Courbe_sin::Lecture_base_info(... ";
           Sortie(1); 
           } 
        // lecture des infos
        ent >> nom >> ax >> nom >> bx >> nom >> en_degre >> nom >> ampli 
            >> nom >> alph >> nom >> bet  ;
       }
   };

    // cas donne le niveau de sauvegarde
    // = 1 : on sauvegarde tout
    // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Courbe_sin::Ecriture_base_info(ofstream& sort,const int cas)
  { // on n'a que des grandeurs constantes
    if (cas == 1)
      { sort << " Courbe_sin ";
        sort << "  a= " << ax  << " b= " << bx 
             << " en_degre= " << en_degre << " ampli= " << ampli 
             << " alph= " << alph << " bet= " << bet <<" ";
       }
   };
         
// sortie du schemaXML: en fonction de enu 
void Courbe_sin::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;
		}
	};		
  };
     
