// 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 "IsoHyperBulk_gene.h"
#include "ComLoi_comp_abstraite.h"

# include <iostream>
using namespace std;  //introduces namespace std
#include <math.h>
#include <stdlib.h>
#include "Sortie.h"
#include "ConstMath.h"
#include "CharUtil.h"


//================== initialisation des variables static ======================
// indicateur utilisé par Verif_Potentiel_et_var  
int IsoHyperBulk_gene::indic_Verif_PoGrenoble_et_var = 0;
//================== fin d'initialisation des variables static ================

IsoHyperBulk_gene::IsoHyperBulk_gene ()  : // Constructeur par defaut
 Hyper3D(ISOHYPERBULK_GENE,CAT_MECANIQUE,false)
 ,F_w_V(NULL),F_w_T(NULL)
    {};
// Constructeur de copie
IsoHyperBulk_gene::IsoHyperBulk_gene (const IsoHyperBulk_gene& loi) :
  Hyper3D (loi)
  ,F_w_V(loi.F_w_V),F_w_T(loi.F_w_T)
	{
   //--- dependance via des fonctions éventuelles
   if (F_w_V != NULL)
	  	if (F_w_V->NomCourbe() == "_")
	  		F_w_V = Courbe1D::New_Courbe1D(*(loi.F_w_V));
	  if (F_w_T != NULL)
    if (F_w_T->NomCourbe() == "_")
      	  F_w_T = Courbe1D::New_Courbe1D(*(loi.F_w_T));
 };

IsoHyperBulk_gene::~IsoHyperBulk_gene ()
// Destructeur 
{ 
  //--- dependance via des fonctions éventuelles
  if (F_w_V != NULL)
      if (F_w_V->NomCourbe() == "_") delete F_w_V;
  //--- dependance via des fonctions éventuelles
  if (F_w_T != NULL)
      if (F_w_T->NomCourbe() == "_") delete F_w_T;
};


// Lecture des donnees de la classe sur fichier
void IsoHyperBulk_gene::LectureDonneesParticulieres
  (UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D,LesFonctions_nD& lesFonctionsnD)
  { // lecture du module qui  dépend d'une fonction de V
    string nom;
    // lecture de la loi d'évolution du module  en fonction de V
    *(entreePrinc->entree) >>  nom;
    bool avec_passage_nouvelle_donnee = true; // pour l'appel de la classe mère
    if (nom != "omega_V=")
         { cout << "\n erreur en lecture du mot cle omega_V= , on a lu: " << nom <<" !! ";
           entreePrinc->MessageBuffer("**erreur1 IsoHyperBulk_gene::LectureDonneesParticulieres (...**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
         };
    // on lit maintenant le nom ou le type de la courbe
    *(entreePrinc->entree) >>  nom;
    // on regarde si la courbe existe, si oui on récupère la référence
    if (lesCourbes1D.Existe(nom)) 
      { F_w_V = lesCourbes1D.Trouve(nom);
      }
    else
     { // sinon il faut la lire maintenant
       string non_courbe("_");   
       F_w_V = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
       // lecture de la courbe
       F_w_V->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
       entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
       avec_passage_nouvelle_donnee = false; // car on a déjà
     };
    // puis on s'occupe des dépendances à des fonctions éventuelles
    // on regarde si le module  est thermo dépendant
    if(strstr(entreePrinc->tablcar,"omega_thermo_dependant_")!=0)
     { *(entreePrinc->entree) >> nom;
       if (nom != "omega_thermo_dependant_")
         { cout << "\n erreur en lecture de la thermodependance de omega, on aurait du lire le mot cle omega_thermo_dependant_"
                << " suivi du nom d'une courbe de charge ou de la courbe elle meme et on a lue: " << nom;
           entreePrinc->MessageBuffer("**erreur1 IsoHyperBulk_gene::LectureDonneesParticulieres (...**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
         };
       // lecture de la loi d'évolution du module  en fonction de la température
       *(entreePrinc->entree) >>  nom;    
       // on regarde si la courbe existe, si oui on récupère la référence 
       if (lesCourbes1D.Existe(nom)) 
         { F_w_T = lesCourbes1D.Trouve(nom);
           avec_passage_nouvelle_donnee = true;
         }
       else
        { // sinon il faut la lire maintenant
          string non_courbe("_");   
          F_w_T = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
          // lecture de la courbe
          F_w_T->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
          entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
          avec_passage_nouvelle_donnee = false; // car on a déjà
        };
        // on signale que la loi est thermodépendante
        thermo_dependant = true;
     };
   
    // cas avec régularisation (variable stockée dans Hyper3D.h)
    string nom1;
    if (strstr(entreePrinc->tablcar,"avec_regularisation_")!=NULL)
     { *(entreePrinc->entree) >> nom1 ;
       if (nom1 != "avec_regularisation_")
         { cout << "\n erreur en lecture du drapeau de regularisation, on attendait le mot cles "
             << " avec_regularisation_ on a lue: " << nom1 ;
           entreePrinc->MessageBuffer("**9--IsoHyper3DOrgeas1::LectureDonneesParticulieres(.....**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);
         };
       *(entreePrinc->entree) >> fact_regularisation;
       avec_regularisation=true;
     };
    // lecture de l'indication du post traitement
    string nom_class_methode = "IsoHyperBulk_gene";string le_mot_cle = "sortie_post_";
    entreePrinc->Lecture_un_parametre_int(0,nom_class_methode,0,1,le_mot_cle,sortie_post);

    // appel au niveau de la classe mère
    Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire
                 (*entreePrinc,lesFonctionsnD);
    };
// affichage de la loi
void IsoHyperBulk_gene::Affiche() const
  { cout << " \n loi de comportement 3D hyperelastique isotrope generale uniquement volumique : " << Nom_comp(id_comp)
         << " parametres : \n"; 
    cout << " multiplicateur fonction de V "
         << " courbe F_w_V= g(V): " ;
    if ( F_w_V != NULL) { cout << F_w_V->NomCourbe() <<" ";}
    else { cout << " la fonction dependance a V n'est pas encore definie ";};
   
    // dépendance à la température        
    if ( F_w_T != NULL) { cout << " multiplicateur fonction de la temperature "
                                        << " courbe F_w_T=f(T): " << F_w_T->NomCourbe() <<" ";
                         };
    cout << endl;
    // appel de la classe mère
    Loi_comp_abstraite::Affiche_don_classe_abstraite();
  };
            
// affichage et definition interactive des commandes particulières à chaques lois
void IsoHyperBulk_gene::Info_commande_LoisDeComp(UtilLecture& entreePrinc)
 {  ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
	   cout << "\n definition standart (rep o) ou exemples exhaustifs (rep n'importe quoi) ? ";
	   string rep = "_";
    // procédure de lecture avec prise en charge d'un retour chariot
    rep = lect_return_defaut(true,"o");

    sort << "\n# .......  loi de comportement 3D hyperelastique isotrope ISOHYPERBULK_GENE  ........"
         << "\n#------------------------------"
         << "\n#     omega   |  fonction     |"
         << "\n#------------------------------"
         << "\n     omega_V=     courbe2      "
         << "\n#  La fonction omega_V(V) est quelconque, ici il s'agit de la courbe de nom courbe2, qui doit avoir"
         << "\n#  ete definie au prealable (courbe 1D)  "
         << endl;
	   if ((rep != "o") && (rep != "O" ) && (rep != "0") )
      { sort << "\n# il est possible d'avoir un coefficient multiplicatif dependant de la temperature "
             << "\n# dans ce cas la dependance du potentiel a la temperature est omega(T,V) = f(T) * omega_V  "
             << "\n# un exemple de declaration: avec courbe1 le nom d'une courbe 1D : "
             << "\n#------------------------------"
             << "\n#     omega   |  fonction     |"
             << "\n#------------------------------"
             << "\n#     omega_V=     courbe2    omega_thermo_dependant_  courbe1  "
             << "\n#  "
             << "\n#  "
             << "\n# comme pour toutes les lois, la declaration de chaque courbe peut etre effectuee via un nom de courbe"
             << "\n# deja existante ou en declarant directement la courbe, dans ce dernier cas, ne pas oublier de finir "
             << "\n# chaque declaration de courbe avec un retour chariot (return) "
             << "\n#  un exemple de declaration:"
             << "\n#------------------------------"
             << "\n#     omega   |  fonction     |"
             << "\n#------------------------------"
             << "\n#     omega_V=    CPL1D DdlP 0.  0.  1.  1.  FdlP "
             << "\n#            omega_thermo_dependant_  CPL1D DdlP 0.  0.  1.  2.  FdlP  "
             << "\n#------------------------------------------------------------------------------------"
             << "\n#  il est possible d'indiquer un facteur de regularisation qui permet d'eviter "
             << "\n#  de potentiels  problemes de NaN, de type division par 0 par exemple "
             << "\n#  1/a est remplace par 1/(a+fact_regularisation), par defaut fact_regularisation = 1.e-12 "
             << "\n#  pour indiquer un facteur de regulation non nul on indique en dernier parametre "
             << "\n#  le mot cle avec_regularisation_ suivi du facteur voulu "
             << "\n#  ex: "
             << "\n#    avec_regularisation_  1.e-12 "
             << "\n#  ce mot cle doit se situer avant le mot cle sortie_post_ "
             << "\n#------------------------------------------------------------------------------------"
             << "\n#  il est possible de recuperer differentes grandeurs de travail par exemple "
             << "\n#  l'intensite du potentiel, comme ces grandeurs sont calculees au moment de la resolution "
             << "\n#  et ne sont pas stockees, il faut indiquer le mot cle sortie_post_ suivi de 1 (par defaut = 0) "
             << "\n#  ensuite au moment de la constitution du .CVisu on aura acces aux grandeurs de travail "
             << "\n#  ex: "
             << "\n#    sortie_post_  1 "
             << "\n#  ce mot cle est le dernier des parametres specifiques de la loi il doit se situe "
             << "\n#  a la fin de la derniere ligne de donnees "
             << "\n#"
             << "\n#------------------------------------------------------------------------------------"
             << "\n#  "
             ;
      };
    // appel de la classe Hyper3D
    Hyper3D::Info_commande_LoisDeComp_hyper3D(entreePrinc);
    // appel de la classe mère
    Loi_comp_abstraite::Info_commande_don_LoisDeComp(entreePrinc);     
  };  		  	  

// test si la loi est complete
int IsoHyperBulk_gene::TestComplet()
    { int ret = LoiAbstraiteGeneral::TestComplet();
      if (F_w_V == NULL)
       { cout << " \n La fonction omega(V) n'est pas defini pour la loi " << Nom_comp(id_comp)
              << '\n';
         Affiche();     
         ret = 0;
       };
                
       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 IsoHyperBulk_gene::Lecture_base_info_loi(ifstream& ent,const int cas
              ,LesReferences& lesRef,LesCourbes1D& lesCourbe1D,LesFonctions_nD& lesFonctionsnD)
  { string nom;
	   if (cas == 1) 
	    { // dépendance à V
	      bool test; ent >> nom >> test;
	      if (!test)
	       { if (F_w_V != NULL) {if (F_w_V->NomCourbe() == "_") delete F_w_V; F_w_V = NULL;};
        }
	      else
	       { ent >> nom; F_w_V = lesCourbe1D.Lecture_pour_base_info(ent,cas,F_w_V); };
       // dépendance à la température
	      ent >> nom >> test;
	      if (!test)
	       { if (F_w_T != NULL) {if (F_w_T->NomCourbe() == "_") delete F_w_T; F_w_T = NULL;};
        }
	      else
	       { ent >> nom; F_w_T = lesCourbe1D.Lecture_pour_base_info(ent,cas,F_w_T); };
       // gestion du post-traitement
       ent >> nom >> sortie_post ;
     };
	   // appel class mère  
	   Loi_comp_abstraite::Lecture_don_base_info(ent,cas,lesRef,lesCourbe1D,lesFonctionsnD);
  };
    // cas donne le niveau de sauvegarde
    // = 1 : on sauvegarde tout
    // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void IsoHyperBulk_gene::Ecriture_base_info_loi(ofstream& sort,const int cas)
  { if (cas == 1) 
     { if (F_w_V == NULL)
        { sort << " F_w_V " << " 0 ";}
       else 
        { sort << " F_w_V " << " 1 ";
          LesCourbes1D::Ecriture_pour_base_info(sort,cas,F_w_V);
        }; 
       if (F_w_T == NULL)
        { sort << " F_w_T " << " 0 ";}
       else 
        { sort << " F_w_T " << " 1 ";
          LesCourbes1D::Ecriture_pour_base_info(sort,cas,F_w_T);
        }; 
       // gestion du post-traitement
       sort << " sortie_post= "<< sortie_post << " ";
     };
    // appel de la classe mère
    Loi_comp_abstraite::Ecriture_don_base_info(sort,cas);  
   }; 

 // calcul d'un module d'young équivalent à la loi, ceci pour un
 // chargement nul
double IsoHyperBulk_gene::Module_young_equivalent(Enum_dure ,const Deformation & ,SaveResul * )
   { // on ne connait pas le module d'young, on va donc ramener un module avec par défaut un nu équivalent = 0
     double coef_T = 1.;
     if (F_w_T != NULL) coef_T = F_w_T->Valeur(*temperature);
     Courbe1D::ValDer valder_V =F_w_V->Valeur_Et_derivee(ConstMath::unpeupetit);
     double module_compress = (coef_T / log(1.+ConstMath::unpeupetit))
                  * ( ConstMath::unpeupetit * valder_V.derivee + valder_V.valeur);
     // --- cas d'une dépendance à une fonction de V
     double coef_V = 1.;
     if (F_w_V != NULL) coef_V = F_w_V->Valeur(1.);
    
     return (3.* module_compress); // le 3 je n'en suis pas sûr, mais ce n'est pas important
   };

// récupération d'un module de compressibilité équivalent à la loi, ceci pour un chargement nul
// il s'agit ici de la relation -pression = sigma_trace/3. = module de compressibilité * I_eps
double IsoHyperBulk_gene::Module_compressibilite_equivalent(Enum_dure ,const Deformation & ,SaveResul * )
   {
     double coef_T = 1.;
     if (F_w_T != NULL) coef_T = F_w_T->Valeur(*temperature);
     Courbe1D::ValDer valder_V =F_w_V->Valeur_Et_derivee(ConstMath::unpeupetit);
     double module_compress = (coef_T / log(1.+ConstMath::unpeupetit))
                  * ( ConstMath::unpeupetit * valder_V.derivee + valder_V.valeur);
     // --- cas d'une dépendance à une fonction de V
     double coef_V = 1.;
     if (F_w_V != NULL) coef_V = F_w_V->Valeur(1.);
      return module_compress;
   };

// ===========  METHODES Protégées dérivant de virtuelles : ==============

//  METHODES internes spécifiques à l'hyperélasticité isotrope découlant de 
//  méthodes virtuelles de Hyper3D

    // calcul du potentiel tout seul sans la phase car Qeps est  nul
    // ou très proche de 0
double IsoHyperBulk_gene::PoGrenoble
             (const double & ,const Invariant & inv)
   { // --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
     double coef_T = 1.;
     if (F_w_T != NULL) coef_T = F_w_T->Valeur(*temperature);
     // ---  fonction de V
     double coef_V =  F_w_V->Valeur(inv.V);
     // le potentiel et ses dérivées
     double E = coef_T * coef_V ;
     // retour
     return E;
   };

    // calcul du potentiel tout seul avec la phase donc dans le cas où Qeps est non nul
double IsoHyperBulk_gene::PoGrenoble
             (const Invariant0QepsCosphi & ,const Invariant & inv)
   { // --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
     double coef_T = 1.;
     if (F_w_T != NULL) coef_T = F_w_T->Valeur(*temperature);
     // --- cas d'une dépendance à une fonction de V
     double coef_V  = F_w_V->Valeur(inv.V);
     // le potentiel et ses dérivées
     double E = coef_T * coef_V ;
     // retour
     return E;
   };

    // calcul du potentiel tout seul sans la phase car Qeps est  nul
    // ou très proche de 0, et de sa variation suivant V uniquement
Hyper3D::PoGrenoble_V IsoHyperBulk_gene::PoGrenoble_et_V
             (const double & ,const Invariant & inv)
 { PoGrenoble_V ret;
   double logV = log(inv.V);
   // --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
   double coef_T = 1.;
   if (F_w_T != NULL) coef_T = F_w_T->Valeur(*temperature);
   // --- cas d'une dépendance à une fonction de V
   Courbe1D::ValDer valder_V =F_w_V->Valeur_Et_derivee(inv.V);
////// debug
//cout << "\n debug IsoHyperBulk_gene::PoGrenoble_et_V: ** inv.V= " << inv.V << ", valder_V.valeur= " << valder_V.valeur
//     << ", valder_V.derivee= "<< valder_V.derivee << endl;
////// fin debug
   // le potentiel et ses dérivées
   ret.E = coef_T * valder_V.valeur ;
   ret.EV = coef_T * valder_V.derivee;
   if (logV > ConstMath::unpeupetit)
     {ret.Ks = (coef_T / logV) * ( inv.V * valder_V.derivee + valder_V.valeur);}
   else // si la variation de volume est trop faible on utilise le module sécant pour la valeur unpeupetite
     { valder_V = F_w_V->Valeur_Et_derivee(1.+ConstMath::unpeupetit);
       ret.Ks = (coef_T / log(1.+ConstMath::unpeupetit)) * ( ConstMath::unpeupetit * valder_V.derivee + valder_V.valeur);
     };
   // retour
   return ret;
   };

    // calcul du potentiel et de sa variation suivant V uniquement
Hyper3D::PoGrenoble_V IsoHyperBulk_gene::PoGrenoble_et_V
             (const Invariant0QepsCosphi & ,const Invariant & inv)
 { Hyper3D::PoGrenoble_V ret;
   double logV = log(inv.V);
   // le potentiel et ses dérivées
   // --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
   double coef_T = 1.;
   if (F_w_T != NULL) coef_T = F_w_T->Valeur(*temperature);
   // --- cas d'une dépendance à une fonction de V
   Courbe1D::ValDer valder_V = F_w_V->Valeur_Et_derivee(inv.V);

   ret.E = coef_T * valder_V.valeur ;
   ret.EV = coef_T * valder_V.derivee;
  
   if (logV > ConstMath::unpeupetit)
     {ret.Ks = (coef_T / logV) * ( inv.V * valder_V.derivee + valder_V.valeur);}
   else // si la variation de volume est trop faible on utilise le module sécant pour la valeur unpeupetite
     { valder_V = F_w_V->Valeur_Et_derivee(1.+ConstMath::unpeupetit);
       ret.Ks = (coef_T / log(1.+ConstMath::unpeupetit)) * ( ConstMath::unpeupetit * valder_V.derivee + valder_V.valeur);
     };
   // retour
   return ret;
   };

    // calcul du potentiel tout seul sans la phase car Qeps est  nul
    // ou très proche de 0, et de ses variations première et seconde suivant V uniquement
Hyper3D::PoGrenoble_VV IsoHyperBulk_gene::PoGrenoble_et_VV
             (const double & ,const Invariant & inv)
 { PoGrenoble_VV ret;
   double logV = log(inv.V);
   // --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
   double coef_T = 1.;
   if (F_w_T != NULL) coef_T = F_w_T->Valeur(*temperature);
   // --- cas d'une dépendance à une fonction de V
   Courbe1D::ValDer2 valder_V = F_w_V->Valeur_Et_der12(inv.V);
////// debug
//cout << "\n debug IsoHyperBulk_gene::PoGrenoble_et_VV: inv.V= " << inv.V << ", valder_V.valeur= " << valder_V.valeur
//     << ", valder_V.derivee= "<< valder_V.derivee << endl;
////// fin debug
  
   // le potentiel et ses dérivées premières
   ret.E = coef_T * valder_V.valeur ;
   ret.EV = coef_T * valder_V.derivee;
   // dérivées secondes
   ret.EVV  =  coef_T * valder_V.der_sec ;
   // le module sécant
   if (logV > ConstMath::unpeupetit)
     {ret.Ks = (coef_T / logV) * ( inv.V * valder_V.derivee + valder_V.valeur);}
   else // si la variation de volume est trop faible on utilise le module sécant pour la valeur unpeupetite
     { valder_V = F_w_V->Valeur_Et_der12(1.+ConstMath::unpeupetit);
       ret.Ks = (coef_T / log(1.+ConstMath::unpeupetit)) * ( ConstMath::unpeupetit * valder_V.derivee + valder_V.valeur);
     };
   // retour
   return ret;
   };

    // calcul du potentiel et de sa variation première et seconde suivant V uniquement
Hyper3D::PoGrenoble_VV IsoHyperBulk_gene::PoGrenoble_et_VV
             (const Invariant0QepsCosphi & ,const Invariant & inv)
 { Hyper3D::PoGrenoble_VV ret;
   double logV = log(inv.V);
   // --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
   double coef_T = 1.;
   if (F_w_T != NULL) coef_T = F_w_T->Valeur(*temperature);
   // --- cas d'une dépendance à une fonction de V
   Courbe1D::ValDer2  valder_V = F_w_V->Valeur_Et_der12(inv.V);
   // le potentiel et ses dérivées premières
   ret.E = coef_T * valder_V.valeur ;
   ret.EV = coef_T * valder_V.derivee;
   // dérivées secondes
   ret.EVV  = coef_T * valder_V.der_sec ;
   // le module sécant
   if (logV > ConstMath::unpeupetit)
     {ret.Ks = (coef_T / logV) * ( inv.V * valder_V.derivee + valder_V.valeur);}
   else // si la variation de volume est trop faible on utilise le module sécant pour la valeur unpeupetite
     { valder_V = F_w_V->Valeur_Et_der12(1.+ConstMath::unpeupetit);
       ret.Ks = (coef_T / log(1.+ConstMath::unpeupetit)) * ( ConstMath::unpeupetit * valder_V.derivee + valder_V.valeur);
     };
   // retour
   return ret;
 };

 // calcul du potentiel et de ses dérivées non compris la phase
Hyper3D::PoGrenobleSansPhaseSansVar IsoHyperBulk_gene::PoGrenoble
            (const InvariantQeps & ,const Invariant & inv)
 { PoGrenobleSansPhaseSansVar ret;
   double logV = log(inv.V);
   // le potentiel et ses dérivées
   // --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
   double coef_T = 1.;
   if (F_w_T != NULL) coef_T = F_w_T->Valeur(*temperature);
   // --- cas d'une dépendance à une fonction de V
   Courbe1D::ValDer valder_V = F_w_V->Valeur_Et_derivee(inv.V);
   ret.E = coef_T * valder_V.valeur ;
   ret.EV = coef_T * valder_V.derivee;
  
   if (logV > ConstMath::unpeupetit)
     {ret.Ks = (coef_T / logV) * ( inv.V * valder_V.derivee + valder_V.valeur);}
   else // si la variation de volume est trop faible on utilise le module sécant pour la valeur unpeupetite
     { valder_V = F_w_V->Valeur_Et_derivee(1.+ConstMath::unpeupetit);
       ret.Ks = (coef_T / log(1.+ConstMath::unpeupetit)) * ( ConstMath::unpeupetit * valder_V.derivee + valder_V.valeur);
     };
   // retour
   return ret;
 };
   
   // calcul du potentiel et de ses dérivées avec la phase
Hyper3D::PoGrenobleAvecPhaseSansVar IsoHyperBulk_gene::PoGrenoblePhase
             (const InvariantQepsCosphi& ,const Invariant & inv) 
 { PoGrenobleAvecPhaseSansVar ret;
   double logV = log(inv.V);
   // le potentiel et ses dérivées
   // --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
   double coef_T = 1.;
   if (F_w_T != NULL) coef_T = F_w_T->Valeur(*temperature);
   // --- cas d'une dépendance à une fonction de V
   Courbe1D::ValDer valder_V = F_w_V->Valeur_Et_derivee(inv.V);
   ret.E = coef_T * valder_V.valeur ;
   ret.EV = coef_T * valder_V.derivee;
  
   if (logV > ConstMath::unpeupetit)
     {ret.Ks = (coef_T / logV) * ( inv.V * valder_V.derivee + valder_V.valeur);}
   else // si la variation de volume est trop faible on utilise le module sécant pour la valeur unpeupetite
     { valder_V = F_w_V->Valeur_Et_derivee(1.+ConstMath::unpeupetit);
       ret.Ks = (coef_T / log(1.+ConstMath::unpeupetit)) * ( ConstMath::unpeupetit * valder_V.derivee + valder_V.valeur);
     };
   // retour
   return ret;
 };
      

// calcul  du potentiel sans phase et dérivées avec  ses variations par rapport aux invariants
Hyper3D::PoGrenobleSansPhaseAvecVar IsoHyperBulk_gene::PoGrenoble_et_var
             (const Invariant2Qeps& ,const Invariant & inv)
 { PoGrenobleSansPhaseAvecVar ret;
   double logV = log(inv.V);
   // --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
   double coef_T = 1.;
   if (F_w_T != NULL) coef_T = F_w_T->Valeur(*temperature);
   // --- cas d'une dépendance à une fonction de V
   Courbe1D::ValDer2 valder_V = F_w_V->Valeur_Et_der12(inv.V);
   // le potentiel et ses dérivées premières
   ret.E = coef_T * valder_V.valeur ;
   ret.EV = coef_T * valder_V.derivee;
   // dérivées secondes
   ret.EVV  = coef_T * valder_V.der_sec ;
   // le module sécant
   if (logV > ConstMath::unpeupetit)
     {ret.Ks = (coef_T / logV) * ( inv.V * valder_V.derivee + valder_V.valeur);}
   else // si la variation de volume est trop faible on utilise le module sécant pour la valeur unpeupetite
     { valder_V = F_w_V->Valeur_Et_der12(1.+ConstMath::unpeupetit);
       ret.Ks = (coef_T / log(1.+ConstMath::unpeupetit)) * ( ConstMath::unpeupetit * valder_V.derivee + valder_V.valeur);
     };
   ret.EQV = 0.;
   // retour
   return ret;
 };
    
    // calcul  du potentiel avec phase et dérivées avec  ses variations par rapport aux invariants
Hyper3D::PoGrenobleAvecPhaseAvecVar IsoHyperBulk_gene::PoGrenoblePhase_et_var
             (const Invariant2QepsCosphi& ,const Invariant & inv)
 { Hyper3D::PoGrenobleAvecPhaseAvecVar ret;
   double logV = log(inv.V);
   // --- cas de la thermo dépendance, on calcul les grandeurs matérielles -----
   double coef_T = 1.;
   if (F_w_T != NULL) coef_T = F_w_T->Valeur(*temperature);
   // --- cas d'une dépendance à une fonction de V
   Courbe1D::ValDer2 valder_V = F_w_V->Valeur_Et_der12(inv.V);
   // le potentiel et ses dérivées premières
   ret.E = coef_T * valder_V.valeur ;
   ret.EV = coef_T * valder_V.derivee;
   // dérivées secondes
   ret.EVV  = coef_T * valder_V.der_sec ;
   // le module sécant
   if (logV > ConstMath::unpeupetit)
     {ret.Ks = (coef_T / logV) * ( inv.V * valder_V.derivee + valder_V.valeur);}
   else // si la variation de volume est trop faible on utilise le module sécant pour la valeur unpeupetite
     { valder_V = F_w_V->Valeur_Et_der12(1.+ConstMath::unpeupetit);
       ret.Ks = (coef_T / log(1.+ConstMath::unpeupetit)) * ( ConstMath::unpeupetit * valder_V.derivee + valder_V.valeur);
     };
   ret.EQV = 0.;
   // retour
   return ret;
 };