Herezh_dev/Util/Courbes/TripodeCos3phi.cc

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

    // CONSTRUCTEURS :
TripodeCos3phi::TripodeCos3phi(string nom) :
 Courbe1D(nom,COURBE_TRIPODECOS3PHI)
 ,xn(1.),gamma(0.),val_absolu(false) 
  {};
    
    // de copie
TripodeCos3phi::TripodeCos3phi(const TripodeCos3phi& Co) :
 Courbe1D(Co)
 ,xn(Co.xn),gamma(Co.gamma),val_absolu(Co.val_absolu)
  {};
    // de copie à partir d'une instance générale
TripodeCos3phi::TripodeCos3phi(const Courbe1D& Coo) :
 Courbe1D(Coo)
  { if (Coo.Type_courbe() != COURBE_TRIPODECOS3PHI)
      { cout << "\n erreur dans le constructeur de copie pour une courbe COURBE_TRIPODECOS3PHI "
             << " à partir d'une instance générale ";
        cout << "\n TripodeCos3phi::TripodeCos3phi(const Courbe1D& Co) ";
           Sortie(1);          
          };
    // définition des données
    TripodeCos3phi & Co = (TripodeCos3phi&) Coo;
    xn = Co.xn;gamma = Co.gamma;
    val_absolu = Co.val_absolu;       
  };

    // DESTRUCTEUR :
TripodeCos3phi::~TripodeCos3phi() 
  {};
    
    // METHODES PUBLIQUES :
    
    // --------- virtuelles ---------
    
    // affichage de la courbe
void TripodeCos3phi::Affiche() const 
  { cout << "\n TripodeCos3phi: nom_ref= " << nom_ref;
    cout << "\n  n= " << xn << " gamma= " << gamma;
    if (val_absolu) 
    	{cout << " f(x) = 1./(1.+gamma*|cos(3*x)|)^n ";}
    else
    	{cout << " f(x) = 1./(1.+gamma*cos(3*x))^n ";}
   };

    // vérification que tout est ok, pres à l'emploi
    // ramène true si ok, false sinon
bool TripodeCos3phi::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 TripodeCos3phi::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
     if(strstr(entreePrinc->tablcar,"n=")==0)
         { cout << "\n erreur en lecture du coefficient n ";
           cout << "\n TripodeCos3phi::LectureDonneesParticulieres "
                << "(UtilLecture * entreePrinc) " << endl ;
           entreePrinc->MessageBuffer("**erreur1, TripodeCos3phi::LectureDonneesParticulieres **");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);          
          }
     if(strstr(entreePrinc->tablcar,"gamma=")==0)
         { cout << "\n erreur en lecture du coefficient gamma ";
           cout << "\n TripodeCos3phi::LectureDonneesParticulieres "
                << "(UtilLecture * entreePrinc) " << endl ;
           entreePrinc->MessageBuffer("**erreur2, TripodeCos3phi::LectureDonneesParticulieres **");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);          
          }
     // lecture des coeffs
     string toto;
     *(entreePrinc->entree) >> toto >> gamma >> toto >> xn ; 
     //on regarde si c'est la valeur absolue ou la valeur de x que l'on utilise
     if(strstr(entreePrinc->tablcar,"val_absolu_cos(3x)_")!=0)
        {val_absolu=true;}
     else
        {val_absolu=false;}
         
   };
    
// def info fichier de commande
void TripodeCos3phi::Info_commande_Courbes1D(UtilLecture & entreePrinc) 
  {  
     ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
     sort << "\n#............................................"
          << "\n# exemple de definition d'une courbe COURBE_TRIPODECOS3PHI "
          << " ( f(x) = 1./(1.+gamma*cos(3*x))^n = (1.+gamma*cos(3*x))^(-n) "
          << "\n      # def des coeff de la courbe COURBE_TRIPODECOS3PHI "
          << "\n      gamma= 0.9  n= 0.1 "
          << "\n# il est possible de n'utiliser que la valeur absolue de cos(3*x) "
          << "\n# dans ce cas:  f(x) = 1./(1.+gamma*|cos(3*x)|)^n "
          << "\n# exemple de syntaxe  "
          << "\n      gamma= 0.9  n= 0.1 val_absolu_cos(3x)_ "
          << endl;
   };
        
    // ramène la valeur 
double TripodeCos3phi::Valeur(double x)  
  { if (val_absolu)
       { return pow((1.+gamma*Abs(cos(3*x))),-xn);}
    else   
       { return pow((1.+gamma*cos(3*x)),-xn);};
  };

    // ramène la valeur et la dérivée en paramètre
Courbe1D::ValDer TripodeCos3phi::Valeur_Et_derivee(double x)  
  { ValDer ret;
    if (val_absolu)
       { double X = 1.+gamma*Abs(cos(3*x));
         ret.valeur = pow(X,-xn);
         ret.derivee =  (3.*xn*gamma*sin(3.*x)/X) * ret.valeur * Signe(cos(3*x));
         return ret;
        }
    else   
       { double X = 1.+gamma*cos(3*x);
         ret.valeur = pow(X,-xn);
         ret.derivee =  (3.*xn*gamma*sin(3.*x)/X) * ret.valeur;
         return ret;
        };
  };
    
    // ramène la dérivée 
double TripodeCos3phi::Derivee(double x)  
  { if (val_absolu)
       { double X = 1.+gamma*Abs(cos(3*x));
         return ( (3.*xn*gamma*sin(3.*x)/X) * pow(X,-xn)) * Signe(cos(3*x));
        }
    else   
       { double X = 1.+gamma*cos(3*x);
         return ( (3.*xn*gamma*sin(3.*x)/X) * pow(X,-xn));
        };
  };
        
    // ramène la valeur et les dérivées première et seconde en paramètre
Courbe1D::ValDer2 TripodeCos3phi::Valeur_Et_der12(double x)
  { ValDer2 ret;
    if (val_absolu)
       { double X = 1.+gamma*Abs(cos(3*x));
         ret.valeur = pow(X,-xn);
         double signe = Signe(cos(3*x));
         ret.derivee =  (3.*xn*gamma*sin(3.*x)/X) * ret.valeur * signe;
         ret.der_sec =  9. * xn * ret.valeur * ( 
                              (xn-1.)*Sqr(gamma*sin(3.*x)) / (X*X) 
                              - gamma * signe * cos(3.*x)  / X
                                  ); 
         return ret;
        }
    else   
       { double X = 1.+gamma*cos(3*x);
         ret.valeur = pow(X,-xn);
         ret.derivee =  (3.*xn*gamma*sin(3.*x)/X) * ret.valeur;
         ret.der_sec =  9. * xn * ret.valeur * ( 
                              (xn-1.)*Sqr(gamma*sin(3.*x)) / (X*X) 
                              - gamma  * cos(3.*x)  / X
                                  ); 
         return ret;
        };
  };
        
    // ramène la dérivée seconde
double TripodeCos3phi::Der_sec(double x)
  { if (val_absolu)
       { double X = 1.+gamma*Abs(cos(3*x));
         double valeur = pow(X,-xn);
         double signe = Signe(cos(3*x));
         return   9. * xn * valeur * ( 
                              (xn-1.)*Sqr(gamma*sin(3.*x)) / (X*X) 
                              - gamma * signe * cos(3.*x)  / X
                                  ); 
        }
    else   
       { double X = 1.+gamma*cos(3*x);
         double valeur = pow(X,-xn);
         return  9. * xn * valeur * ( 
                              (xn-1.)*Sqr(gamma*sin(3.*x)) / (X*X) 
                              - gamma  * cos(3.*x)  / 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  TripodeCos3phi::Valeur_stricte(double x)  
  { Valbool ret; // def de la valeur de retour
    // ici toujours ok
    if (val_absolu)
       { ret.valeur = pow((1.+gamma*Abs(cos(3*x))),-xn);}
    else   
       { ret.valeur = pow((1.+gamma*cos(3*x)),-xn);};
    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  TripodeCos3phi::Valeur_Et_derivee_stricte(double x)  
  { ValDerbool ret; // def de la valeur de retour
    if (val_absolu)
       { double X = 1.+gamma*Abs(cos(3*x));
         ret.valeur = pow(X,-xn);
         ret.derivee =  (3.*xn*gamma*sin(3.*x)/X) * ret.valeur * Signe(cos(3*x));
        }
    else   
       { double X = 1.+gamma*cos(3*x);
         ret.valeur = pow(X,-xn);
         ret.derivee =  (3.*xn*gamma*sin(3.*x)/X) * ret.valeur;
        };
    // 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 TripodeCos3phi::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 != "TripodeCos3phi")
         { cout << "\n erreur dans la vérification du type de courbe lue ";    
           cout << "\n TripodeCos3phi::Lecture_base_info(... ";
           Sortie(1); 
           } 
        // lecture des infos
        ent >> nom >> gamma >> nom >> xn >> nom >> val_absolu;
       }
   };

    // cas donne le niveau de sauvegarde
    // = 1 : on sauvegarde tout
    // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void TripodeCos3phi::Ecriture_base_info(ofstream& sort,const int cas)
  { // on n'a que des grandeurs constantes
    if (cas == 1)
      { sort << " TripodeCos3phi ";
        sort << "  gamma= " << gamma  << "  n= " << xn << " abs= " << val_absolu << " ";
       }
   };
         
// sortie du schemaXML: en fonction de enu 
void TripodeCos3phi::SchemaXML_Courbes1D(ofstream& sort,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;
		}
  default: sort << "\n SchemaXML: cas non pris en compte " ;
	};
  };