// FICHIER : Loi_de_Tait.cp
// CLASSE : Loi_de_Tait


// 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 "Debug.h"

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


#include "Loi_de_Tait.h"

//==================== cas de la class de sauvegarde SaveResul ===================

// constructeur  par défaut à ne pas utiliser
Loi_de_Tait::SaveResul_Loi_de_Tait::SaveResul_Loi_de_Tait() :
	stockParaInt(NULL), saveCrista(NULL)
  { }; 

// le constructeur courant
// sCrista s'il est NULL, on en tient pas compte
// s'il est non NULL, on cré l'instances saveCrista par défaut
Loi_de_Tait::SaveResul_Loi_de_Tait::SaveResul_Loi_de_Tait
                        (CompThermoPhysiqueAbstraite::StockParaInt* stock
                         ,CristaliniteAbstraite::SaveCrista* sCrista):
	stockParaInt(NULL),saveCrista(NULL) 
  {if (sCrista != NULL) 
  	saveCrista = sCrista->Nevez_SaveCrista();	
   if (stock != NULL)
   	{ stockParaInt = new CompThermoPhysiqueAbstraite::StockParaInt(*stock);
   	};
  }; 

// constructeur de copie 
Loi_de_Tait::SaveResul_Loi_de_Tait::SaveResul_Loi_de_Tait
                                         (const Loi_de_Tait::SaveResul_Loi_de_Tait& sav ):
	stockParaInt(NULL),saveCrista(NULL) 
  {if (sav.saveCrista != NULL) 
  	saveCrista = sav.saveCrista->Nevez_SaveCrista();
   if (sav.stockParaInt != NULL)
   	{ stockParaInt = new CompThermoPhysiqueAbstraite::StockParaInt(*(sav.stockParaInt));
   	};
  }; 

// destructeur
Loi_de_Tait::SaveResul_Loi_de_Tait::~SaveResul_Loi_de_Tait() 
  {if (saveCrista != NULL) delete saveCrista;
   if (stockParaInt != NULL) delete stockParaInt; 
  };
  
// affectation
CompThermoPhysiqueAbstraite::SaveResul &
   Loi_de_Tait::SaveResul_Loi_de_Tait::operator = ( const CompThermoPhysiqueAbstraite::SaveResul & a)
  { Loi_de_Tait::SaveResul_Loi_de_Tait& sav = *((Loi_de_Tait::SaveResul_Loi_de_Tait*) &a);
    if (sav.saveCrista != NULL)
     { if (saveCrista == NULL)
         saveCrista = sav.saveCrista->Nevez_SaveCrista();
       else
         (*saveCrista) = *(sav.saveCrista);
     }
    else
     delete saveCrista;
    if (sav.stockParaInt != NULL)
     { if (stockParaInt == NULL)
         stockParaInt  = new CompThermoPhysiqueAbstraite::StockParaInt(*(sav.stockParaInt));
       else
         (*stockParaInt) = *(sav.stockParaInt);
     }
    else
     delete stockParaInt;
    return *this;
  };

     //============= lecture écriture dans base info ==========
     
// 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 Loi_de_Tait::SaveResul_Loi_de_Tait::Lecture_base_info 
                                                 (istream& ent,const int cas)
  {  // ici toutes les données sont toujours a priori variables
     // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas
     string toto; ent >> toto;
     #ifdef MISE_AU_POINT	 	 
      if (toto != "S_R_LoiTait")
          { cout << "\n erreur en lecture du conteneur pour la loi thermo physique de Tait"
                 << " \n Loi_de_Tait::SaveResul_Loi_de_Tait::Lecture_base_info(..";
            Sortie(1);     
          }
     #endif
     bool test=false;ent >> test;
     if (test)
       {// on regarde si les pointeurs existent sinon erreur
        if (stockParaInt == NULL) 
          { cout << "\n erreur en lecture du conteneur pour la loi thermo physique de Tait"
                 << " on a detecte qu'il faut lire un conteneur de StockParaInt, mais "
                 << " le conteneur resultat n'a pas ete aloue !! "
                 << " \n Loi_de_Tait::SaveResul_Loi_de_Tait::Lecture_base_info(..";
            Sortie(1);     
          }
        else // sinon on peut lire
          { ent >>  stockParaInt->pression >> stockParaInt->temperature ;};
     	};
     test=false; ent >> test;
     if (test)
       {// on regarde si les pointeurs existent sinon erreur
        if (saveCrista == NULL) 
          { cout << "\n erreur en lecture du conteneur pour la loi thermo physique de Tait"
                 << " on a detecte qu'il faut lire un conteneur de cristalinite, mais "
                 << " le conteneur resultat n'a pas ete aloue !! "
                 << " \n Loi_de_Tait::SaveResul_Loi_de_Tait::Lecture_base_info(..";
            Sortie(1);     
          }
        else // sinon on peut lire
         { saveCrista->Lecture_base_info (ent,cas);}; 
     	};
    }; 

// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Loi_de_Tait::SaveResul_Loi_de_Tait::Ecriture_base_info
                                                 (ostream& sort,const int cas)
   { // ici toutes les données sont toujours a priori variables
     // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas
     sort << "\n S_R_LoiTait  ";
     if (stockParaInt == NULL)
     	{sort << " 0  ";} // on sort un indicateur disant qu'il n'y a pas de pointeur
     else
     	{sort << " 1  " << stockParaInt->pression<< " "<< " " << stockParaInt->temperature<< " ";
     	};
     if (saveCrista == NULL)
     	{sort << " 0  ";} // on sort un indicateur disant qu'il n'y a pas de pointeur
     else
     	{sort << " 1  "; saveCrista->Ecriture_base_info(sort,cas);};	
	 }; 
	        
// affichage des infos
void Loi_de_Tait::SaveResul_Loi_de_Tait::Affiche()	
   { cout << "\n S_R_LoiTait ";
     if (stockParaInt != NULL)
     	{ cout << " pression= " << stockParaInt->pression
     	       << " temperature= " << stockParaInt->temperature << " ";
     	};
     if (saveCrista != NULL)
     	{ cout << " cristalinite : "; saveCrista->Affiche();};	
	 }; 
// idem sur un ofstream
void Loi_de_Tait::SaveResul_Loi_de_Tait::Affiche(ostream& sort)			        
   { sort << "\n S_R_LoiTait ";
     if (stockParaInt != NULL)
     	{ sort << " pression= " << stockParaInt->pression
     	       << " temperature= " << stockParaInt->temperature << " ";
     	};
     if (saveCrista != NULL)
     	{ sort << " cristalinite : "; saveCrista->Affiche(sort);};	
	 }; 	        

// mise à jour des informations transitoires en définitif s'il y a convergence 
// par exemple (pour la plasticité par exemple)
void Loi_de_Tait::SaveResul_Loi_de_Tait::TdtversT() 
 { if (saveCrista != NULL)
 	 saveCrista->TdtversT();
 };

void Loi_de_Tait::SaveResul_Loi_de_Tait::TversTdt() 
 { if (saveCrista != NULL)
 	  saveCrista->TversTdt();
 };

      
// def d'une instance de données spécifiques, et initialisation
Loi_de_Tait::SaveResul * Loi_de_Tait::New_et_Initialise() 
 { Loi_de_Tait::SaveResul * cont=NULL; // conteneur de retour
   if (sortie_post || (crista != NULL)) 
     // cas où il faut un conteneur
     {if (sortie_post && (crista == NULL))
        // cas sans cristalinité
        { // il faut quand même dimensionner stock, car ensuite on peut vouloir la pression
          double  pres=0; double  temper=0.;
          CompThermoPhysiqueAbstraite::StockParaInt* stock =
                      new CompThermoPhysiqueAbstraite::StockParaInt(pres,temper);
          cont = new Loi_de_Tait::SaveResul_Loi_de_Tait(stock ,NULL );
          delete stock;
        }
      else // sinon c'est soit  (sortie_post && (crista != NULL))
           // ou (!sortie_post && (crista != NULL)) 
        { CristaliniteAbstraite::SaveCrista* interr =  crista->New_et_Initialise();
          double  pres=0; double  temper=0.;
          CompThermoPhysiqueAbstraite::StockParaInt* stock =
                      new CompThermoPhysiqueAbstraite::StockParaInt(pres,temper);
          cont = new Loi_de_Tait::SaveResul_Loi_de_Tait(stock , interr);
          delete interr;
          delete stock;
         };
     };
   return cont;
 };

//==================== fin du cas de la class de sauvegarde SaveResul ============

Loi_de_Tait::Loi_de_Tait () :  // Constructeur par defaut
  CompThermoPhysiqueAbstraite(LOI_DE_TAIT,CAT_THERMO_PHYSIQUE,4),alphaT(0.)
  ,compressibilite(0.),lambda(0.),lambda_temperature(NULL),cp(0.),cp_temperature(NULL)
  ,b1s(0.),b2s(0.),b3s(0.),b4s(0.),b1m(0.),b2m(0.),b3m(0.),b4m(0.),b5(0.),b6(0.),b7(0.),b8(0.),b9(0.)
  ,sortie_post(false),type_de_calcul(0),crista(NULL)
   { };
	

// Constructeur de copie
Loi_de_Tait::Loi_de_Tait (const Loi_de_Tait& loi) :
	CompThermoPhysiqueAbstraite(loi),alphaT(loi.alphaT)
  ,compressibilite(loi.compressibilite)
  ,lambda(loi.lambda),lambda_temperature(loi.lambda_temperature)
  ,cp(loi.cp),cp_temperature(loi.cp_temperature)
  ,b1s(loi.b1s),b2s(loi.b2s),b3s(loi.b3s),b4s(loi.b4s),b1m(loi.b1m),b2m(loi.b2m),b3m(loi.b3m)
  ,b4m(loi.b4m),b5(loi.b5),b6(loi.b6),b7(loi.b7),b8(loi.b8),b9(loi.b9)
  ,sortie_post(loi.sortie_post),type_de_calcul(loi.type_de_calcul),crista(loi.crista)
    {
	  if (lambda_temperature != NULL)	
         if (lambda_temperature->NomCourbe() == "_") 
      	  lambda_temperature = Courbe1D::New_Courbe1D(*(loi.lambda_temperature));
      if (cp_temperature != NULL)	
         if (cp_temperature->NomCourbe() == "_") 
            cp_temperature = Courbe1D::New_Courbe1D(*(loi.cp_temperature));
      if (crista != NULL)
        crista = CristaliniteAbstraite::New_Cristalinite(*(loi.crista));   
    };

Loi_de_Tait::~Loi_de_Tait ()
// Destructeur 
{ if (lambda_temperature != NULL)
      if (lambda_temperature->NomCourbe() == "_") delete lambda_temperature;
  if (cp_temperature != NULL)
      if (cp_temperature->NomCourbe() == "_") delete cp_temperature;
  if (crista != NULL)
        delete crista;   
  };

// Lecture des donnees de la classe sur fichier
void Loi_de_Tait::LectureDonneesParticulieres
   (UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD)
  { // ------------    lecture du coefficient de dilatation
    string nom; *(entreePrinc->entree) >>  nom; 
    if (nom != "coefficients_bi")
      { cout << "\n erreur en lecture des coefficients bi, on attendait le mot cle coefficients_bi"
             << " et on a lue " << nom;
        entreePrinc->MessageBuffer("**erreur1** Loi_de_Tait::LectureDonneesParticulieres (... ");
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);     
       };
    // lecture des coefficients bis
    string nom_b1,nom_b2,nom_b3,nom_b4;
    entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
    *(entreePrinc->entree) >> nom_b1 >> b1s >> nom_b2 >> b2s >> nom_b3 >> b3s >> nom_b4 >> b4s; 
    if ((nom_b1 != "b1s=") || (nom_b2 != "b2s=") || (nom_b3 != "b3s=") || (nom_b4 != "b4s=") ) 
      { cout << "\n erreur en lecture des coefficients bis,  un des labels de coefficients n'est pas correcte,"
             << "  on a lue " << nom_b1 << " " << b1s << " " << nom_b2 << " " << b2s << " "<< " " 
             << nom_b3 << " " << b3s << " "<< " " << nom_b4 << " " << b4s << " "<< " ";
        entreePrinc->MessageBuffer("**erreur2** Loi_de_Tait::LectureDonneesParticulieres (... ");
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);     
       };
    // lecture des coefficients bim
    entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
    *(entreePrinc->entree) >> nom_b1 >> b1m >> nom_b2 >> b2m >> nom_b3 >> b3m >> nom_b4 >> b4m; 
    if ((nom_b1 != "b1m=") || (nom_b2 != "b2m=") || (nom_b3 != "b3m=") || (nom_b4 != "b4m=") ) 
      { cout << "\n erreur en lecture des coefficients bim,  un des labels de coefficients n'est pas correcte,"
             << "  on a lue " << nom_b1 << " " << b1m << " " << nom_b2 << " " << b2m << " " 
             << nom_b3 << " " << b3m << " "<<   nom_b4 << " " << b4m << " ";
        entreePrinc->MessageBuffer("**erreur3** Loi_de_Tait::LectureDonneesParticulieres (... ");
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);     
       };
    // lecture des coefficients bi
    string nom_b9;
    entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
    *(entreePrinc->entree) >> nom_b1 >> b5 >> nom_b2 >> b6 >> nom_b3 >> b7 >> nom_b4 >> b8
                           >> nom_b9 >> b9 ;; 
    if ((nom_b1 != "b5=") || (nom_b2 != "b6=") || (nom_b3 != "b7=") || (nom_b4 != "b8=") || (nom_b9 != "b9=")) 
      { cout << "\n erreur2 en lecture des coefficients bi,  un des labels de coefficients n'est pas correcte,"
             << "  on a lue " << nom_b1 << " " << b5 << " " << nom_b2 << " " << b6 << " " 
             << nom_b3 << " " << b7 << " "<< nom_b4 << " " << b8 << " "<< nom_b9 << " " << b9 << " ";
        entreePrinc->MessageBuffer("**erreur4** Loi_de_Tait::LectureDonneesParticulieres (... ");
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);     
       };
    //   ----------  lecture de la conductivité
    entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
    *(entreePrinc->entree) >>  nom; 
    if (nom != "lambda=")
      { cout << "\n erreur en lecture de la conductivite, on attendait le mot cle lambda=";
        entreePrinc->MessageBuffer("**erreur5** Loi_de_Tait::LectureDonneesParticulieres (... ");
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);     
       }
    // on regarde si le coeff est thermo dépendant 
    if(strstr(entreePrinc->tablcar,"lambda_thermo_dependant_")!=0)
     { thermo_dependant=true;
       *(entreePrinc->entree) >> nom;
       if (nom != "lambda_thermo_dependant_")
         { cout << "\n erreur en lecture de la thermodependance, on aurait du lire le mot cle lambda_thermo_dependant_"
                << " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
           entreePrinc->MessageBuffer("**erreur6** Loi_de_Tait::LectureDonneesParticulieres (... ");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
          }
       // lecture de la loi d'évolution du coefficient  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)) 
         { lambda_temperature = lesCourbes1D.Trouve(nom);
          }
       else
        { // sinon il faut la lire maintenant
          string non_courbe("_");   
          lambda_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
          // lecture de la courbe
          lambda_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
         } 
       entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
      }
    else
     { // lecture du coefficient 
       *(entreePrinc->entree) >> lambda ;
      };
    //   ----------  lecture de la capacité calorifique
    *(entreePrinc->entree) >>  nom; 
    if (nom != "cp=")
      { cout << "\n erreur en lecture de la capacite calorifique, on attendait le mot cle cp=";
        entreePrinc->MessageBuffer("**erreur7** Loi_de_Tait::LectureDonneesParticulieres (... ");
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);     
       }
    // on regarde si le coeff est thermo dépendant 
    if(strstr(entreePrinc->tablcar,"cp_thermo_dependant_")!=0)
     { thermo_dependant=true;
       *(entreePrinc->entree) >> nom;
       if (nom != "cp_thermo_dependant_")
         { cout << "\n erreur en lecture de la thermodependance, on aurait du lire le mot cle cp_thermo_dependant_"
                << " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
           entreePrinc->MessageBuffer("**erreur8** Loi_de_Tait::LectureDonneesParticulieres (... ");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
          }
       // lecture de la loi d'évolution du coefficient  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)) 
         { cp_temperature = lesCourbes1D.Trouve(nom);
          }
       else
        { // sinon il faut la lire maintenant
          string non_courbe("_");   
          cp_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
          // lecture de la courbe
          cp_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
         } 
       entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
      }
    else
     { // lecture du coefficient 
       *(entreePrinc->entree) >> cp ;
      };
    // lecture éventuelle du paramètre   sortie_post
    if(strstr(entreePrinc->tablcar,"prepa_sortie_post=")!=0)
      {*(entreePrinc->entree) >>  nom >> sortie_post;
       entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
       }
    else
      {entreePrinc->NouvelleDonnee(); }; // prepa du flot de lecture 
      
    // lecture éventuelle de la cristalinité  
    if(strstr(entreePrinc->tablcar,"type_de_calcul_=")!=0)
      {*(entreePrinc->entree) >>  nom >> type_de_calcul;
       if (type_de_calcul != 0)
       	{ // lecture de loi de cristalinité
       	  string non_crista;
       	  *(entreePrinc->entree) >>  nom >> non_crista;
       	  // on crée la loi
       	  crista = CristaliniteAbstraite::New_Cristalinite(Id_nom_Enum_crista(non_crista.c_str()));
       	  // on lit les données spécifiques à la loi    
          entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
          crista->LectureDonneesLoiCrista(entreePrinc,lesCourbes1D,lesFonctionsnD);
       	}
       else 
         while (strstr(entreePrinc->tablcar,"fin_loi_tait")==0)
            entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
      };
        
    // prepa du flot de lecture
    if(strstr(entreePrinc->tablcar,"fin_loi_tait")!=0) 
      {entreePrinc->NouvelleDonnee(); }
    else
     { cout << "\n erreur on ne trouve pas le mot cle fin_loi_tait, verifiez les donnes de la loi !";
       entreePrinc->MessageBuffer("**erreur9** Loi_de_Tait::LectureDonneesParticulieres (... ");
       throw (UtilLecture::ErrNouvelleDonnee(-1));
       Sortie(1);
       };     
    };

// affichage de la loi
void Loi_de_Tait::Affiche() const 
  { cout << " \n loi de comportement thermique isotrope avec le comportement d'etat de Tait ";
    cout << "\n b1s= " << b1s << " b2s= " << b2s << " b3s= " << b3s << " b4s= " << b4s << " "
         << "\n b1m= " << b1m << " b2m= " << b2m << " b3m= " << b3m << " b4m= " << b4m << " "
         << "\n b5= " << b5 << " b6= " << b6 << " b7= " << b7 << " b8= " << b8 << " b9= " << b9 << " \n"; 
    if ( lambda_temperature != NULL) { cout << " conductivite thermo dependante " 
                                            << " courbe lambda=f(T): " << lambda_temperature->NomCourbe() <<" ";}
    else                             { cout << " conductivite lambda= " << lambda ;} 
    if ( cp_temperature != NULL) { cout << " capacite calorifique thermo dependante " 
                                        << " courbe cp=f(T): " << cp_temperature->NomCourbe() <<" ";}
    else                         { cout << " capacite calorifique cp= " << cp ;}
    cout << " \n prepa_sortie_post=" << sortie_post << " ";
    if (type_de_calcul != 0)
      { cout << "\n calcul avec cristalinite: type_de_calcul= " << type_de_calcul;
        crista->Affiche();
      };
    cout << endl;
  };
            
// affichage et definition interactive des commandes particulières à chaques lois
void Loi_de_Tait::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");
    if (lambda == 0.) { lambda = 10.;}; // on initialise à une valeur arbitraire
    if (cp == 0.) { cp = 1.;}; // on initialise à une valeur arbitraire
      
    sort << "\n#-------- debut cas d'une loi thermo physique  --------"

         << "\n \n poly_therm2       LOI_DE_TAIT  "; 

    sort << "\n# ----- loi de comportement thermique isotrope avec le comportement d'etat de Tait ---------"
         << "\n# |   la loi necessite 13 coefficients  qui permettent le calcul du volume specifique Vspe |"
         << "\n# |   Vspe = V0(T)*(1.-C*log(1.+P/B(T))) + Vt(T,P)     avec les relations                  |"
         << "\n# |   C = 0.0894, Ttrans = b5 + b6 * P                                                     |"
         << "\n# |   si T < Ttrans: V0(T) = b1s+b2s*(T-b5), B(T) = b3s*exp(-b4s*(T-b5))                   |"
         << "\n# |   si T >= Ttrans: V0(T) = b1m+b2m*(T-b5), B(T) = b3m*exp(-b4m*(T-b5))                  |"
         << "\n# |   Vt(T,P) = b7*exp(-b8(T-b5)-b9*P)                                                     |"
         << "\n# |   En fonction du volume specifique on obtient la masse volumique ro=1./ Vspe           |"
         << "\n# |   le coefficient de dilatation lineaire : alpha = 1./(3*ro) * d ro / d T               |"
         << "\n# |   et le coefficient de compressibilite: ksi = -1./ro * d ro / d p                      |"
         << "\n# ------------------------------------------------------------------------------------------";
         
    sort << "\n#  definition des coefficients "
         << "\n coefficients_bi "
         << "\n b1s= " << b1s << " b2s= " << b2s << " b3s= " << b3s << " b4s= " << b4s << " "
         << "\n b1m= " << b1m << " b2m= " << b2m << " b3m= " << b3m << " b4m= " << b4m << " "
         << "\n b5= " << b5 << " b6= " << b6 << " b7= " << b7 << " b8= " << b8 << " b9= " << b9 << " " 
         << "\n # puis on definit la conductivite et la capacite calorifique \n";
    sort << "\n# ......................................................."
         << "\n# |   conductivite         |  capacite calorifique      | "
         << "\n# |                        |                            | "
         << "\n# |        lambda          |       cp                   | "
         << "\n#........................................................"
         << "\n     lambda=  " << setprecision(8) << lambda << "   cp=  " << setprecision(8) << cp << " ";
	   if ((rep != "o") && (rep != "O" ) && (rep != "0") )
      { sort << "\n# \n# chaque parametre peut etre remplace par une fonction dependante de la temperature " 
         << "\n# pour ce faire on utilise un mot cle puis une nom de courbe ou la courbe directement comme avec "
         << "\n# les autre loi de comportement "
         << "\n# exemple pour la conductivite:                  mlambda=   lambda_thermo_dependant_   courbe2  "
         << "\n# exemple pour la capacite calorifique:          cp=        cp_thermo_dependant_       courbe3  "
         << "\n# IMPORTANT: a chaque fois qu'il y a une thermodependence, il faut passer une ligne apres la description"
         << "\n# de la grandeur thermodependante, mais pas de passage a la ligne si se n'est pas thermo dependant "
         << "\n#"
         << "\n# ensuite une variable booleenne qui indique si oui ou non on sauvegarde des donnees intermediaires"
         << "\n# pour le post-traitement, pour ensuite pouvoir afficher : temperature de transition, volume specifique"
         << "\n# pression, dilatation, conditivité, capacite calorifique, coeff de compressibilite"
         << "   prepa_sortie_post=   0 # valeur par defaut -> pas de sauvegarde "
         << "\n#"
         << "\n#---- prise en compte de la cristalinite ---------"
         << "\n# il est possible de tenir compte d'un tau de cristalinite de la maniere suivante: "
         << "\n# tout d'abord un indicateur (faculatatif) indiquant le type de calcul voulu, par defaut = 0"
         << "\n#   type_de_calcul : =1 -> calcul du taux de cristalinite, mais pas de dependance des variables " 
         << "\n#                        de  ThermoDonnee(alpha, lambda, compressibilite) avec la cristalinite "
         << "\n#                  : =2 -> calcul du taux de cristalinité, avec dépendance des variables de ThermoDonnee "
         << "\n#  Dans le cas ou le type_de_calcul n'est pas nul, il faut ensuite definir la methode de calcul de la cristalinite"
         << "\n#  ex: pour la loi d'hoffman1  "
         << "\n type_de_calcul_=  2 Cristalinite_= HOFFMAN1 "
         << "\n#";
       };
    // appel de la cristalinité
    crista->Info_commande_LoisCrista(entreePrinc);     
    // appel de la classe mère
    CompThermoPhysiqueAbstraite::Info_commande_don_LoisDeComp(entreePrinc); 
    sort << "\n         fin_loi_tait        \n "; 
	   if ((rep != "o") && (rep != "O" ) && (rep != "0") )
      { sort << "\n#   la derniere ligne doit contenir uniquement le mot cle:     fin_loi_tait ";};
    sort << endl;
  };  		  	  

// test si la loi est complete
int Loi_de_Tait::TestComplet()
    { int ret = LoiAbstraiteGeneral::TestComplet();
       return ret; 
    }; 
   
// récupération des grandeurs particulière (hors ddl )
// correspondant à liTQ
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
void Loi_de_Tait::Grandeur_particuliere
              (bool absolue, List_io<TypeQuelconque>& liTQ,CompThermoPhysiqueAbstraite::SaveResul * saveDon,list<int>& )
 {// on passe en revue la liste
  List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end();
  // on accède aux grandeurs que si sortie_post=true 
  if(sortie_post)
   for (itq=liTQ.begin();itq!=itqfin;itq++)
    {TypeQuelconque& tipParticu = (*itq); // pour simplifier
     if (tipParticu.EnuTypeQuelconque().Nom_vide()) // veut dire que c'est un enum pur
     { EnumTypeQuelconque enuTQ = tipParticu.EnuTypeQuelconque().EnumTQ();

       // 1) -----cas des contraintes individuelles à chaque loi à t et courantes
       if (enuTQ == TEMPERATURE_LOI_THERMO_PHYSIQUE)
        { SaveResul_Loi_de_Tait & save_resul = *((SaveResul_Loi_de_Tait*) saveDon);
          Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
          tyTQ=save_resul.stockParaInt->temperature;
         }
       else if (enuTQ == PRESSION_LOI_THERMO_PHYSIQUE)
        { SaveResul_Loi_de_Tait & save_resul = *((SaveResul_Loi_de_Tait*) saveDon);
          Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
          tyTQ=save_resul.stockParaInt->pression;
         }
       else if ( (enuTQ == TEMPERATURE_TRANSITION)
                || (enuTQ == VOLUME_SPECIFIQUE)
                || (enuTQ == COEFF_DILATATION_LINEAIRE)
                || (enuTQ == CONDUCTIVITE)
                || (enuTQ == CAPACITE_CALORIFIQUE)
                || (enuTQ == COEFF_COMPRESSIBILITE)
                || (enuTQ == CRISTALINITE))
        { // dans ce cas il faut recalculer les grandeurs
          SaveResul_Loi_de_Tait & save_resul = *((SaveResul_Loi_de_Tait*) saveDon);
          Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
          // appel fonction interne
          double& P=save_resul.stockParaInt->pression;          // récup des valeurs sauvegardées
          temperature = save_resul.stockParaInt->temperature;  //       "
          double temp_trans;double  vol_spec;  // def des valeurs de sorties
          // !! a priori on sort les valeurs pour tdt, car sinon ça ne fonctionne pas pour l'instant
          Calcul_diff_valeurs(P,temp_trans,vol_spec);
          // choix pour les retours
          if (enuTQ == TEMPERATURE_TRANSITION) {tyTQ=temp_trans;}
          else if (enuTQ == VOLUME_SPECIFIQUE) {tyTQ=vol_spec;}
          else if (enuTQ == COEFF_DILATATION_LINEAIRE) {tyTQ=alphaT;}
          else if (enuTQ == CONDUCTIVITE) {tyTQ=lambda;}
          else if (enuTQ == CAPACITE_CALORIFIQUE) {tyTQ=cp;}
          else if (enuTQ == COEFF_COMPRESSIBILITE) {tyTQ=compressibilite;}
          else if ((enuTQ == CRISTALINITE)
                   || (crista != NULL))  {tyTQ=tyTQ = crista->Cristalinite(save_resul.saveCrista,P,temperature);}
//          cout << "\n " << temp_trans <<" " << vol_spec << " " <<alphaT << " ";
         };
      };
    };
  };

// récupération et création de la liste de tous les grandeurs particulières
// ces grandeurs sont ajoutées à la liste passées en paramètres
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
void Loi_de_Tait::ListeGrandeurs_particulieres(bool absolue,List_io<TypeQuelconque>& liTQ)
 {Grandeur_scalaire_double grand_courant; // def d'une grandeur courante 
  // def d'un type quelconque représentatif à chaque grandeur
  // a priori ces grandeurs sont défini aux points d'intégration identique à la contrainte par exemple
  // enu_ddl_type_pt est définit dans la loi Abtraite générale
  // on n'ajoute que si sortie_post est vraie, sinon aucune grandeur n'est sauvegardé, donc on ne peut
  // plus y accèder
  if(sortie_post)
  {// a) $$$ cas de TEMPERATURE_LOI_THERMO_PHYSIQUE
   {TypeQuelconque typQ1(TEMPERATURE_LOI_THERMO_PHYSIQUE,enu_ddl_type_pt,grand_courant);
    liTQ.push_back(typQ1);
    };
   // b) $$$ cas de PRESSION_LOI_THERMO_PHYSIQUE
   {TypeQuelconque typQ2(PRESSION_LOI_THERMO_PHYSIQUE,enu_ddl_type_pt,grand_courant);
    liTQ.push_back(typQ2);
    };
   // c) $$$ cas de TEMPERATURE_TRANSITION
   {TypeQuelconque typQ3(TEMPERATURE_TRANSITION,enu_ddl_type_pt,grand_courant);
    liTQ.push_back(typQ3);
    };
   // d) $$$ cas de VOLUME_SPECIFIQUE
   {TypeQuelconque typQ4(VOLUME_SPECIFIQUE,enu_ddl_type_pt,grand_courant);
    liTQ.push_back(typQ4);
    };
   // e) $$$ cas de COEFF_DILATATION_LINEAIRE
   {TypeQuelconque typQ5(COEFF_DILATATION_LINEAIRE,enu_ddl_type_pt,grand_courant);
    liTQ.push_back(typQ5);
    };
   // f) $$$ cas de CONDUCTIVITE
   {TypeQuelconque typQ6(CONDUCTIVITE,enu_ddl_type_pt,grand_courant);
    liTQ.push_back(typQ6);
    };
   // g) $$$ cas de CAPACITE_CALORIFIQUE
   {TypeQuelconque typQ7(CAPACITE_CALORIFIQUE,enu_ddl_type_pt,grand_courant);
    liTQ.push_back(typQ7);
    };
   // h) $$$ cas de COEFF_COMPRESSIBILITE
   {TypeQuelconque typQ8(COEFF_COMPRESSIBILITE,enu_ddl_type_pt,grand_courant);
    liTQ.push_back(typQ8);
    };
   // i) $$$ cas de CRISTALINITE
   if (crista != NULL)
   {TypeQuelconque typQ8(CRISTALINITE,enu_ddl_type_pt,grand_courant);
    liTQ.push_back(typQ8);
    };
   }; //-- fin du cas sortie_post=true
  };

	   //----- 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 Loi_de_Tait::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
                                             ,LesFonctions_nD& lesFonctionsnD)
  { string nom; bool test;
	if (cas == 1)
	  { ent >> nom; 
	    if (nom != "LOI_DE_TAIT")
	     { cout << "\n erreur en lecture de la loi : LOI_DE_TAIT, on attendait le mot cle : LOI_DE_TAIT "
	            << "\n Loi_de_Tait::Lecture_base_info_loi(...";
	       Sortie(1);
	      };
        // lecture des coefficients bi
        ent >> nom >> b1s >> nom >> b2s >> nom >> b3s >> nom >> b4s; 
        ent >> nom >> b1m >> nom >> b2m >> nom >> b3m >> nom >> b4m; 
        ent >> nom >> b5 >> nom >> b6 >> nom >> b7 >> nom >> b8 >> nom >> b9 ; 
	    // lambda
	    ent >> nom >> test;
	    if (!test)
	     { ent >> lambda;
	       if (lambda_temperature != NULL) 
	          {if (lambda_temperature->NomCourbe() == "_") delete lambda_temperature; lambda_temperature = NULL;};
	      }
	    else
	     { ent >> nom; lambda_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,lambda_temperature); };
	    // cp
	    ent >> nom >> test;
	    if (!test)
	     { ent >> cp;
	       if (cp_temperature != NULL) 
	          {if (cp_temperature->NomCourbe() == "_") delete cp_temperature; cp_temperature = NULL;};
	      }
	    else
	     { ent >> nom; cp_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,cp_temperature); };
        // cas du post-traitement
        ent >> nom >> sortie_post ; 
        // cas de la cristalinité
        ent >> nom >> type_de_calcul;
        if (type_de_calcul != 0)
     	{ Enum_crista enuCrista;
     	  ent >> nom >> enuCrista;
     	  // création s'il le faut de l'instance de calcul de la cristalinité
     	  if (crista != NULL)
     	  	{ // cas où une instance existe déjà
     	  	  if (crista->Type_Crista() != enuCrista)
     	  	  	{ // cas où l'instance n'est pas a doc
     	  	  	  delete crista; 
       	          // on crée une  loi conforme
       	          crista = CristaliniteAbstraite::New_Cristalinite(enuCrista);
     	  	  	};
     	  	}
     	  else // sinon l'instance n'existe pas, il faut donc la créer	
       	     { crista = CristaliniteAbstraite::New_Cristalinite(enuCrista);
     	  	  };
       	  // on lit les données spécifiques à la loi    
          crista->Lecture_don_base_info(ent,cas,lesCourbes1D,lesFonctionsnD);
     	};
	   } 
	 CompThermoPhysiqueAbstraite::Lecture_don_base_info(ent,cas,lesRef,lesCourbes1D,lesFonctionsnD); 
   };
       // cas donne le niveau de sauvegarde
       // = 1 : on sauvegarde tout
       // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Loi_de_Tait::Ecriture_base_info_loi(ostream& sort,const int cas)
{ if (cas == 1)
   { sort << " LOI_DE_TAIT " ;
     sort << "\n b1s= " << b1s << " b2s= " << b2s << " b3s= " << b3s << " b4s= " << b4s << " "
          << "\n b1m= " << b1m << " b2m= " << b2m << " b3m= " << b3m << " b4m= " << b4m << " "
          << "\n b5= " << b5 << " b6= " << b6 << " b7= " << b7 << " b8= " << b8 << " b9= " << b9 << " \n"; 
	 sort << "\n  lambda= ";             
     if (lambda_temperature == NULL)
      { sort << false << " " << lambda << " ";}
     else 
      { sort << true << " fonction_lambda_temperature ";
        LesCourbes1D::Ecriture_pour_base_info(sort,cas,lambda_temperature);
       }; 
	 sort << "\n  cp= ";             
     if (cp_temperature == NULL)
      { sort << false << " " << cp << " ";}
     else 
      { sort << true << " fonction_cp_temperature ";
        LesCourbes1D::Ecriture_pour_base_info(sort,cas,cp_temperature);
       }; 
     // cas du post-traitement
     sort << "\n prepa_sortie_post= " << sortie_post << " "; 
     // cas de la cristalinité
     sort << "\n type_de_calcul= " << type_de_calcul;
     if (type_de_calcul != 0)
     	{ sort << " id_crista= " << crista->Type_Crista() << " ";
     	  crista->Ecriture_don_base_info(sort,cas);
     	};
     }  
  // appel de la classe mère
  CompThermoPhysiqueAbstraite::Ecriture_don_base_info(sort,cas);
  };


 // ========== codage des METHODES VIRTUELLES :================
// ramène les données thermiques défnies au point
// P: la pression à l'énuméré temps, et P_t la pression au temps t
// taux_cris n'est calculé que si crista est non NULL
void Loi_de_Tait::Cal_donnees_thermiques(const double& P_t,CompThermoPhysiqueAbstraite::SaveResul * saveDon 
                       ,const Deformation & def,const double& P_e,Enum_dure temps, ThermoDonnee& donneeThermique)
  {  saveResul = saveDon; // association pour les méthodes dérivées
     // calcul de la température
    temperature = def.DonneeInterpoleeScalaire(TEMP,temps);
    double temperature_t = NULL; // par défaut
    if (crista != NULL)
       {if (temps == TEMPS_tdt)
          { // dans ce cas on doit disposer des températures et pression à t
            temperature_t = def.DonneeInterpoleeScalaire(TEMP,TEMPS_t);
        	}
        else // on prend la température déjà calculée (car c'est o ou t)
          {	temperature_t = temperature;}
       };
    
    // 1) récup de la pression
    double P = P_e;
    // l'idée est que les lois de tait ne sont plausibles que pour des pressions positives.
    // or pendant des itérations de Newton, au niveau de l'équilibre global, on peut avoir l'apparition 
    // de condition non physique qui conduisent à des pressions (relatives) négatives, dans ce cas 
    // on met la pression à 0 (on limite la pression)
    if (P < 0.) P = 0.;
    // appel fonction interne
    double temp_trans;double  vol_spec;
    double taux_cris = 0.;
    Calcul_diff_valeurs(P,temp_trans,vol_spec);
    // la cristalinité indépendante si nécessaire
    if (crista != NULL)
      { Loi_de_Tait::SaveResul_Loi_de_Tait* saveRes = ((Loi_de_Tait::SaveResul_Loi_de_Tait*) saveResul);
        taux_cris = crista->Cristalinite(P_t,temperature_t,saveRes->saveCrista,P,temperature,temps);
      };
    // retour des données thermiques
    donneeThermique.ChangeAlphaTLambdaCp(alphaT,lambda,cp); 
    donneeThermique.ChangeCompressibilite(compressibilite); 
    // la cristalinité si nécessaire
    if (crista != NULL) 
       donneeThermique.ChangeTauxCrista(taux_cris);
    // les données particulière a enregistrer si nécessaire
    if(sortie_post)
     { SaveResul_Loi_de_Tait & save_resul = *((SaveResul_Loi_de_Tait*) saveDon);
       save_resul.stockParaInt->pression=P;
       save_resul.stockParaInt->temperature=temperature;
      };
   };

// remontée aux différentes variables
// taux_cris n'est calculé que si crista est non NULL
void Loi_de_Tait::Calcul_diff_valeurs(const double& P, double& temp_trans, double & vol_spec)
  { double T=temperature; // pour simplifier les notations pour la suite
    // maintenant on s'occupe du calcul du volume spécifique
    // 1) calcul de la température de transition
    const double C=0.0894;double v0T,bT,der_v0T_T,der_bT_T;
    temp_trans=b5+b6*P; 
    // init à 0, correspond au cas où l'on est haut dessus de la température
    // de transition
    double vT=0.; double der_vT_T = 0.; double der_vT_P = 0.;               
    if (temperature < temp_trans)
      {v0T = b1s+b2s*(T-b5); 
       der_v0T_T = b2s;
       bT  = b3s*exp(-b4s*(T-b5));
       der_bT_T = -b4s*b3s*exp(-b4s*(T-b5));
       // ici les termes suivants sont non nuls
       vT=b7*exp(-b8*(T-b5)-b9*P);
       der_vT_T = -b8*b7*exp(-b8*(T-b5)-b9*P);
       der_vT_P = -b9*b7*exp(-b8*(T-b5)-b9*P);
       }
    else
      {v0T = b1m+b2m*(T-b5); 
       der_v0T_T = b2m;
       bT  = b3m*exp(-b4m*(T-b5));
       der_bT_T = -b4s*b3s*exp(-b4s*(T-b5));
       };
       
    // si l'on voulait limiter les pressions négatives on pourrait par exemple prendre une fonction du type
    // ((tanh(P+beta)+1)/2)*P :  tend vers P lorsque P>-beta
           
       
    #ifdef MISE_AU_POINT
      if ( Abs(bT) <= ConstMath::trespetit)
        { cout << "\n erreur le coef B(T) de la loi de Tait est egal a zero " << bT
               << " il y aura des divisions par zero donc arret ! ";
          Sortie(1);
         }
    #endif
    // 3) le volume spécifique  (l'inverse de la masse volumique)
    double unPlusPsurbT = 1.+P/bT;     
    #ifdef MISE_AU_POINT
      if ( unPlusPsurbT <= 0.)
        { cout << "\n erreur dans la loi de Tait 1.+P/bT est <= a zero " << unPlusPsurbT
               << " on ne peut pas calculer son log donc arret ! " << " P= " << P << ", bT= " << bT;
          Sortie(1);
         }
    #endif
    #ifdef MISE_AU_POINT
      if ( Abs(unPlusPsurbT) <= ConstMath::trespetit)
        { cout << "\n erreur dans la loi de Tait 1.+P/bT est nulle  " << unPlusPsurbT
               << " il y aura des divisions par zero donc arret ! ";
          Sortie(1);
         }
    #endif
    vol_spec = v0T*(1.- C*log(unPlusPsurbT)) + vT; 
    #ifdef MISE_AU_POINT
      if ( Abs(vol_spec) <= ConstMath::trespetit)
        { cout << "\n erreur dans la loi de Tait le volume specifique est nulle  " << vol_spec
               << " il y aura des divisions par zero donc arret ! ";
          Sortie(1);
         }
    #endif
    // 2) la variation par rapport à T
    double der_vol_spec_T = der_v0T_T*(1.- C*log(unPlusPsurbT)) + der_vT_T
                            + v0T * (C*(1./unPlusPsurbT)*(- der_bT_T)/(bT*bT));
    // 3) la variation de la masse volumique
    double der_ro_T = - der_vol_spec_T/(vol_spec*vol_spec);
    // 4) calcul du coefficient de dilatation linéaire
    alphaT = (- der_ro_T * vol_spec)/3.; // divisé par 3 pour avoir le coefficient de dilatation linéaire
                                         // et non volumique
    // calcul des deux autres coefficients                        
    if (lambda_temperature != NULL) {lambda= lambda_temperature->Valeur(temperature);}
    if (cp_temperature != NULL) {cp= cp_temperature->Valeur(temperature);}
    // 5) calcul de la compressibilité
    //  5-1) variation par rapport à P
    double der_vol_spec_P = v0T * (-C/(P+bT))+der_vT_P;
    //  5-2) compressibilité
    compressibilite = -  der_vol_spec_P/v0T;  
   };

  // calcul du flux et ses variations  par rapport aux ddl a t+dt: stockage dans ptIntegThermi et dans d_flux
  // calcul également des paramètres thermiques dTP ainsi que des énergies mises en jeux
  // calcul des énergies thermiques
  // en entrée: température, gradient de temp, et grandeurs associées, métrique
void Loi_de_Tait::Calcul_DfluxH_tdt
    (const double & P_t,PtIntegThermiInterne& ptIntegThermi, const double & P,DdlElement & tab_ddl
     ,const Deformation & def  // prévue pour servir pour l'interpolation
		  	, Tableau <CoordonneeB >& d_gradTB,Tableau <CoordonneeH >& d_flux,ThermoDonnee& dTP
		  	,EnergieThermi & energ,const EnergieThermi & energ_t,const Met_abstraite::Impli& ex)
      { cout << "\n *** erreur, methode non implantee actuellement: "
             << "\n Loi_de_Tait::Calcul_DfluxH_tdt(.. "<<endl;
        Sortie(1);
      };












