// FICHIER : Loi_iso_thermo.cp
// CLASSE : Loi_iso_thermo


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

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

// constructeur  par défaut à ne pas utiliser
Loi_iso_thermo::SaveResul_Loi_iso_thermo::SaveResul_Loi_iso_thermo() :
	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_iso_thermo::SaveResul_Loi_iso_thermo::SaveResul_Loi_iso_thermo
                        (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_iso_thermo::SaveResul_Loi_iso_thermo::SaveResul_Loi_iso_thermo
                                         (const Loi_iso_thermo::SaveResul_Loi_iso_thermo& 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_iso_thermo::SaveResul_Loi_iso_thermo::~SaveResul_Loi_iso_thermo() 
  {if (saveCrista != NULL) delete saveCrista;
   if (stockParaInt != NULL) delete stockParaInt; 
  };
  
// affectation
CompThermoPhysiqueAbstraite::SaveResul &
   Loi_iso_thermo::SaveResul_Loi_iso_thermo::operator = ( const CompThermoPhysiqueAbstraite::SaveResul & a)
  { Loi_iso_thermo::SaveResul_Loi_iso_thermo& sav = *((Loi_iso_thermo::SaveResul_Loi_iso_thermo*) &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_iso_thermo::SaveResul_Loi_iso_thermo::Lecture_base_info 
                                                 (ifstream& 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_LoiIso_thermo")
          { cout << "\n erreur en lecture du conteneur pour la loi thermo physique de Loi_iso_thermo"
                 << " \n Loi_iso_thermo::SaveResul_Loi_iso_thermo::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 Loi_iso_thermo"
                 << " on a detecte qu'il faut lire un conteneur de StockParaInt, mais "
                 << " le conteneur resultat n'a pas ete aloue !! "
                 << " \n Loi_iso_thermo::SaveResul_Loi_iso_thermo::Lecture_base_info(..";
            Sortie(1);     
          }
        else // sinon on peut lire
          { ent  >> stockParaInt->pression  >> stockParaInt->temperature ;};
     	};
     test=false; ent >> test;
// --- pour le débug
//     test=true; ent >> toto; cout << "\n toto= " << toto << endl;
//-- fin débug     
     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 Loi_iso_thermo"
                 << " on a detecte qu'il faut lire un conteneur de cristalinite, mais "
                 << " le conteneur resultat n'a pas ete aloue !! "
                 << " \n Loi_iso_thermo::SaveResul_Loi_iso_thermo::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_iso_thermo::SaveResul_Loi_iso_thermo::Ecriture_base_info
                                                 (ofstream& 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_LoiIso_thermo  ";
     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_iso_thermo::SaveResul_Loi_iso_thermo::Affiche()	
   { cout << "\n S_R_LoiIso_thermo ";
     if (stockParaInt != NULL)
     	{ cout << " pression= " << stockParaInt->pression
     	       << " temperature= " << stockParaInt->temperature << " ";
     	};
     if (saveCrista != NULL)
     	{ cout << " cristalinite a tdt: "; saveCrista->Affiche();};	
	 }; 
// idem sur un ofstream
void Loi_iso_thermo::SaveResul_Loi_iso_thermo::Affiche(ofstream& sort)			        
   { sort << "\n S_R_LoiIso_thermo ";
     if (stockParaInt != NULL)
     	{ sort << " pression= " << stockParaInt->pression
     	       << " temperature= " << stockParaInt->temperature << " ";
     	};
     if (saveCrista != NULL)
     	{ sort << " cristalinite a tdt: "; 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_iso_thermo::SaveResul_Loi_iso_thermo::TdtversT() 
 { if (saveCrista != NULL)
 	 saveCrista->TdtversT();
 };

void Loi_iso_thermo::SaveResul_Loi_iso_thermo::TversTdt() 
 { if (saveCrista != NULL)
 	  saveCrista->TversTdt();
 };

      
// def d'une instance de données spécifiques, et initialisation
Loi_iso_thermo::SaveResul * Loi_iso_thermo::New_et_Initialise() 
 { Loi_iso_thermo::SaveResul * cont=NULL; // conteneur de retour
   if (sortie_post || (crista != NULL)) 
     // cas où il faut un conteneur spécifique
     {if (sortie_post && (crista == NULL))
        // cas sans cristalinité
        { cont = new Loi_iso_thermo::SaveResul_Loi_iso_thermo(); }
      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();
          cont = new Loi_iso_thermo::SaveResul_Loi_iso_thermo(stock , interr);
          delete interr;
          delete stock;
         };
     }
   else // sinon on ne garde que le conteneur basique hérité
     { cont = new SaveResul_Loi_iso_thermo(NULL,NULL);
     };
   return cont;
 };

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

Loi_iso_thermo::Loi_iso_thermo () :  // Constructeur par defaut
  CompThermoPhysiqueAbstraite(LOI_ISO_THERMO,CAT_THERMO_PHYSIQUE,4),alphaT(0.),alphaT_temperature(NULL)
  ,compressibilite(ConstMath::trespetit),compressibilite_temperature(NULL)
  ,lambda(0.),lambda_temperature(NULL),cp(0.),cp_temperature(NULL)
  ,sortie_post(false),type_de_calcul(0),crista(NULL)
   { };
	

// Constructeur de copie
Loi_iso_thermo::Loi_iso_thermo (const Loi_iso_thermo& loi) :
	CompThermoPhysiqueAbstraite(loi),alphaT(loi.alphaT),alphaT_temperature(loi.alphaT_temperature)
  ,compressibilite(loi.compressibilite),compressibilite_temperature(loi.compressibilite_temperature)
  ,lambda(loi.lambda),lambda_temperature(loi.lambda_temperature)
  ,cp(loi.cp),cp_temperature(loi.cp_temperature)
  ,sortie_post(loi.sortie_post),type_de_calcul(loi.type_de_calcul),crista(loi.crista)
	 {// on regarde s'il s'agit de courbes locales ou de courbes globales
	  if (alphaT_temperature != NULL)
	   if (alphaT_temperature->NomCourbe() == "_")
        {// comme il s'agit d'une courbe locale on la redéfinie (sinon pb lors du destructeur de loi)
         string non_courbe("_");   
         alphaT_temperature = Courbe1D::New_Courbe1D(*loi.alphaT_temperature);
        };
	  if (lambda_temperature != NULL)
	   if (lambda_temperature->NomCourbe() == "_")
        {// comme il s'agit d'une courbe locale on la redéfinie (sinon pb lors du destructeur de loi)
         string non_courbe("_");   
         lambda_temperature = Courbe1D::New_Courbe1D(*loi.lambda_temperature);
        };
	  if (cp_temperature != NULL)
	   if (cp_temperature->NomCourbe() == "_")
        {// comme il s'agit d'une courbe locale on la redéfinie (sinon pb lors du destructeur de loi)
         string non_courbe("_");   
         cp_temperature = Courbe1D::New_Courbe1D(*loi.cp_temperature);
        };
	  if (compressibilite_temperature != NULL)
	   if (compressibilite_temperature->NomCourbe() == "_")
        {// comme il s'agit d'une courbe locale on la redéfinie (sinon pb lors du destructeur de loi)
         string non_courbe("_");   
         compressibilite_temperature = Courbe1D::New_Courbe1D(non_courbe,loi.compressibilite_temperature->Type_courbe());
        };
	  };

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

// Lecture des donnees de la classe sur fichier
void Loi_iso_thermo::LectureDonneesParticulieres (UtilLecture * entreePrinc
                   ,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD)
  { // ------------    lecture du coefficient de dilatation
    string nom; *(entreePrinc->entree) >>  nom; 
    if (nom != "alphaT=")
      { cout << "\n erreur en lecture du coefficient de dilatation, on attendait le mot cle alphaT=";
        entreePrinc->MessageBuffer("**erreur1** Loi_iso_thermo::LectureDonneesParticulieres (... ");
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);     
       }
    // on regarde si le coeff est thermo dépendant 
    if(strstr(entreePrinc->tablcar,"alphaT_thermo_dependant_")!=0)
     { thermo_dependant=true;
       *(entreePrinc->entree) >> nom;
       if (nom != "alphaT_thermo_dependant_")
         { cout << "\n erreur en lecture de la thermodependance, on aurait du lire le mot cle alphaT_thermo_dependant_"
                << " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
           entreePrinc->MessageBuffer("**erreur2** Loi_iso_thermo::LectureDonneesParticulieres (... ");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
          }
       // lecture de la loi d'évolution du coefficient de dilatation 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)) 
         { alphaT_temperature = lesCourbes1D.Trouve(nom);
          }
       else
        { // sinon il faut la lire maintenant
          string non_courbe("_");   
          alphaT_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
          // lecture de la courbe
          alphaT_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
         } 
       entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
      }
    else
     { // lecture du coefficient 
       *(entreePrinc->entree) >> alphaT ;
      };
    //   ----------  lecture de la conductivité
    *(entreePrinc->entree) >>  nom; 
    if (nom != "lambda=")
      { cout << "\n erreur en lecture de la conductivite, on attendait le mot cle lambda=";
        entreePrinc->MessageBuffer("**erreur3** Loi_iso_thermo::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("**erreur4** Loi_iso_thermo::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("**erreur5** Loi_iso_thermo::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("**erreur6** Loi_iso_thermo::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 de la compressibilite
    if(strstr(entreePrinc->tablcar,"compressibilite=")!=0)
    {*(entreePrinc->entree) >>  nom; 
     if (nom != "compressibilite=")
      { cout << "\n erreur en lecture de la compressibilite, on attendait le mot cle compressibilite=";
        entreePrinc->MessageBuffer("**erreur7** Loi_iso_thermo::LectureDonneesParticulieres (... ");
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);     
       }
     // on regarde si le coeff est thermo dépendant 
     if(strstr(entreePrinc->tablcar,"compressibilite_thermo_dependant_")!=0)
     { thermo_dependant=true;
       *(entreePrinc->entree) >> nom;
       if (nom != "compressibilite_thermo_dependant_")
         { cout << "\n erreur en lecture de la thermodependance, on aurait du lire le mot cle compressibilite_thermo_dependant_"
                << " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
           entreePrinc->MessageBuffer("**erreur8** Loi_iso_thermo::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)) 
         { compressibilite_temperature = lesCourbes1D.Trouve(nom);
          }
       else
        { // sinon il faut la lire maintenant
          string non_courbe("_");   
          compressibilite_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
          // lecture de la courbe
          compressibilite_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
         } 
       entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
      }
     else
     { // lecture du coefficient 
       *(entreePrinc->entree) >> compressibilite ;
      };
    }
    else 
     {compressibilite=ConstMath::trespetit;}; // valeur par défaut indiquant qu'il n'y  pas de compressibilité 
    //   ----------  fin de la lecture éventuelle de la compressibilite
    // si on n'est pas arrivé à la fin de la lecture on passe à la ligne suivante
    // sinon pour l'instant on y reste
    if (strstr(entreePrinc->tablcar,"fin_thermique_isotrope")==0)
      entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
//    entreePrinc->NouvelleDonnee();  // prepa du flot de lecture 
      
    // 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
       };
      
    // 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_thermique_isotrope")==0)
            entreePrinc->NouvelleDonnee(); // prepa du flot de lecture
      };
      
    // prepa du flot de lecture
    if (strstr(entreePrinc->tablcar,"fin_thermique_isotrope")==0)
      entreePrinc->NouvelleDonnee();
    // on passe les lignes éventuelles jusqu'au mot clé de fin de lecture de la loi
    bool entete_message_info_en_trop = true; 
    while (strstr(entreePrinc->tablcar,"fin_thermique_isotrope")==0)
    	{ // il y a des lignes qui ne veulent rien dire pour la loi ??
    	  if (entete_message_info_en_trop)
    	     cout << "\n **** warning, loi iso thermo "
    	          << "\n il y a des infos non utiles ! bizarre et est-ce normal "
    	          << ", lire la doc et les supprimer si elles ne servent pas " ;
    	  cout << "\n " <<  entreePrinc->tablcar;        
    	  entete_message_info_en_trop = false;
    	  entreePrinc->NouvelleDonnee();	
    	};
//    // donc maintenant la prochaine ligne doit-être valide, mais on laisse le test (a virer par la suite) 
//    if(strstr(entreePrinc->tablcar,"fin_thermique_isotrope")==0) entreePrinc->NouvelleDonnee(); 
    entreePrinc->NouvelleDonnee();
    };

// affichage de la loi
void Loi_iso_thermo::Affiche() const 
  { cout << " \n loi de comportement thermique isotrope";
    if ( alphaT_temperature != NULL) { cout << " coefficient de dilatation thermo dependant " 
                                            << " courbe alphaT=f(T): " << alphaT_temperature->NomCourbe() <<" ";}
     else                            { cout << " coefficient de dilatation  alphaT = " << alphaT ;} 
    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 << " conductivite lambda= " << lambda ;} 
    if ( compressibilite_temperature != NULL) { cout << " compressibilite thermo dependante " 
                                        << " courbe compressibilite=f(T): " << compressibilite_temperature->NomCourbe() <<" ";}
    else                         { cout << " compressibilite= " << compressibilite ;} 
    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_iso_thermo::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 (alphaT == 0.) { alphaT = 100.;}; // on initialise à une valeur arbitraire
    if (lambda == 0.) { lambda = 10.;}; // on initialise à une valeur arbitraire
    if (cp == 0.) { cp = 1.;}; // on initialise à une valeur arbitraire
    if (compressibilite == 0.) { compressibilite = 0.002;}; // on initialise à une valeur arbitraire
      
 //   sort << "\n# .......  loi de comportement thermique isotrope ........"
 //        << "\n#    coefficient de dilatation :"
 //        << "\n "<< setprecision(6) << alphaT << endl;
         
    sort << "\n# ..........................  loi de comportement thermique isotrope ......................"
         << "\n# |  coefficient de     |   conductivite  |  capacite       |      compressibilite         "
         << "\n# |                     |                 |   calorifique   |       (facultatif)           "
         << "\n# | dilatation  alphaT  |        lambda   |       cp        |      compressibilite         "
         << "\n#.........................................................................................."
         << "\n    alphaT= "<< setprecision(8) << alphaT << "    lambda=  " << setprecision(8) << lambda
         << "    cp=  " << setprecision(8) << cp << "  compressibilite= " << setprecision(8) << compressibilite
         << "\n                       fin_thermique_isotrope      ";
    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 le coefficient de dilatation:     alphaT=    alphaT_thermo_dependant_   courbe1  "
         << "\n# exemple pour la conductivite:                  mlambda=   lambda_thermo_dependant_   courbe2  "
         << "\n# exemple pour la capacite calorifique:          cp=        cp_thermo_dependant_       courbe3  "
         << "\n# exemple pour la compressibilite:  compressibilite=        compressibilite_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 à 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"
         << "\n#   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#  "
         << "\n# on se reportera a la documentation pour plus d'info sur l'introduction de la cristalinite "
         << "\n#";
       };
    // appel de la cristalinité a priori ici le pointeur est nul, mais on laisse pour le futur où l'on pourrait peut-être
    // accéder à des infos sur la critalinité en interactif
    if (crista != NULL)
     	{ crista->Info_commande_LoisCrista(entreePrinc);};
    // appel de la classe mère
    CompThermoPhysiqueAbstraite::Info_commande_don_LoisDeComp(entreePrinc); 
    sort << "\n#   la derniere ligne doit contenir uniquement le mot cle:     fin_thermique_isotrope "
         << endl;     
  };  		  	  

// test si la loi est complete
int Loi_iso_thermo::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_iso_thermo::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();

       if (enuTQ == TEMPERATURE_LOI_THERMO_PHYSIQUE)
        { SaveResul_Loi_iso_thermo & save_resul = *((SaveResul_Loi_iso_thermo*) 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_iso_thermo & save_resul = *((SaveResul_Loi_iso_thermo*) saveDon);
          Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*) (*itq).Grandeur_pointee()); // pour simplifier
          tyTQ=save_resul.stockParaInt->pression;
         }
       else if ( (enuTQ == COEFF_DILATATION_LINEAIRE)
                || (enuTQ == CONDUCTIVITE)
                || (enuTQ == CAPACITE_CALORIFIQUE)
                || (enuTQ == COEFF_COMPRESSIBILITE)
                || (enuTQ == CRISTALINITE))
        { // dans ce cas il faut recalculer les grandeurs
          SaveResul_Loi_iso_thermo & save_resul = *((SaveResul_Loi_iso_thermo*) 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;  //       "
          // calcul des grandeurs en fonction de la température si nécessaire
          if (alphaT_temperature != NULL) {alphaT= alphaT_temperature->Valeur(temperature);}
          if (lambda_temperature != NULL) {lambda= lambda_temperature->Valeur(temperature);}
          if (cp_temperature != NULL) {cp= cp_temperature->Valeur(temperature);}
          if (compressibilite_temperature != NULL) {compressibilite= compressibilite_temperature->Valeur(temperature);}
          
          // choix pour les retours
          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))  
            {// !! a priori on sort les valeurs pour tdt, car sinon ça ne fonctionne pas pour l'instant
             // on considère que l'intervale = 0 
             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_iso_thermo::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);
    };
   // 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_iso_thermo::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
                                             ,LesFonctions_nD& lesFonctionsnD)
  { string nom; 
	if (cas == 1)
	  { ent >> nom; 
	    if (nom != "LOI_ISO_THERMO")
	     { cout << "\n erreur en lecture de la loi : LOI_ISO_THERMO, on attendait le mot cle : LOI_ISO_THERMO "
	            << "\n LOI_ISO_THERMO::Lecture_base_info_loi(...";
	       Sortie(1);
	      }
	    // ensuite normalement il n'y a pas de pb de lecture puisque c'est écrit automatiquement (sauf en debug)        
	    ent >> nom; // alphaT
	    bool test; ent >> test;
	    if (!test)
	     { ent >> alphaT;
	       if (alphaT_temperature != NULL) 
	           {if (alphaT_temperature->NomCourbe() == "_") delete alphaT_temperature; alphaT_temperature = NULL;};
	      }
	    else
	     { ent >> nom; alphaT_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,alphaT_temperature); };
	    // 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); };
	    // compressibilite
	    ent >> nom >> test;
	    if (!test)
	     { ent >> compressibilite;
	       if (compressibilite_temperature != NULL) 
	          {if (compressibilite_temperature->NomCourbe() == "_") delete compressibilite_temperature; compressibilite_temperature = NULL;};
	      }
	    else
	     { ent >> nom; compressibilite_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,compressibilite_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_iso_thermo::Ecriture_base_info_loi(ofstream& sort,const int cas)
{ if (cas == 1)
   { sort << " LOI_ISO_THERMO " ;
	 sort << "\n  alphaT= ";             
     if (alphaT_temperature == NULL)
      { sort << false << " " << alphaT << " ";}
     else 
      { sort << true << " fonction_alphaT_temperature ";
        LesCourbes1D::Ecriture_pour_base_info(sort,cas,alphaT_temperature);
       }; 
	 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);
       }; 
	 sort << "\n  compressibilite= ";             
     if (compressibilite_temperature == NULL)
      { sort << false << " " << compressibilite << " ";}
     else 
      { sort << true << " fonction_compressibilite_temperature ";
        LesCourbes1D::Ecriture_pour_base_info(sort,cas,compressibilite_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
void Loi_iso_thermo::Cal_donnees_thermiques
          (const double& P_t,CompThermoPhysiqueAbstraite::SaveResul * saveDon,const Deformation & def,const double& P
		  	                               ,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);
    // calcul de alphaT
    if (alphaT_temperature != NULL) {alphaT= alphaT_temperature->Valeur(temperature);}
    if (lambda_temperature != NULL) {lambda= lambda_temperature->Valeur(temperature);}
    if (cp_temperature != NULL) {cp= cp_temperature->Valeur(temperature);}
    if (compressibilite_temperature != NULL) {compressibilite= compressibilite_temperature->Valeur(temperature);}
    // retour des données thermiques
    donneeThermique.ChangeAlphaTLambdaCp(alphaT,lambda,cp);  
    donneeThermique.ChangeCompressibilite(compressibilite);  
    // la cristalinité si nécessaire
    double taux_cris = 0;
    double temperature_t=0; 
    if (crista != NULL)
      { Loi_iso_thermo::SaveResul_Loi_iso_thermo* saveRes 
                = ((Loi_iso_thermo::SaveResul_Loi_iso_thermo*) saveResul);
        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;}
        taux_cris = crista->Cristalinite
                     (P_t,temperature_t,saveRes->saveCrista,P,temperature,temps);
        donneeThermique.ChangeTauxCrista(taux_cris);
        
      };
    // les données particulière a enregistrer si nécessaire
    if(sortie_post)
     { SaveResul_Loi_iso_thermo & save_resul = *((SaveResul_Loi_iso_thermo*) saveDon);
       save_resul.stockParaInt->pression=P;
       save_resul.stockParaInt->temperature=temperature;
      };
   };

// calcul du flux et ses variations  par rapport aux ddl a t+dt: stockage dans ptIntegThermi et dans d_flux
// calcul des énergies thermiques
// en entrée: température, gradient de temp, et grandeurs associées, métrique
void Loi_iso_thermo::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)
   {
     // on commence par calculer les paramètres de la loi thermique
     Cal_donnees_thermiques(P_t,saveResul,def,P,TEMPS_tdt,dTP);
     // calcul du flux en isotrope
     CoordonneeB fluxB = dTP.Conductivite() * ptIntegThermi.GradTB();
     // on le passe en coordonnées contravariantes
     ptIntegThermi.FluxH() = (*ex.gijHH_tdt) * fluxB;
     // calcul de la variation du flux par rapport aux ddl thermique
     int nb_ddl = d_gradTB.Taille();
     d_flux.Change_taille(nb_ddl); // mise à jour de la taille au cas ou
     if (lambda_temperature == NULL)
       // cas le plus simple où seule le gradient dépend de la température
       { for (int iddl=1;iddl<=nb_ddl;iddl++)
           d_flux(iddl) = (*ex.gijHH_tdt) * (lambda*d_gradTB(iddl));
       }
     else
       // cas où la conductivité dépend de la température
       { double der_lambda= lambda_temperature->Derivee(temperature);
         for (int iddl=1;iddl<=nb_ddl;iddl++)
           d_flux(iddl) = (*ex.gijHH_tdt)* (lambda*d_gradTB(iddl) + der_lambda * fluxB);
       };
     // pour les énergies je ne sais pas trop quoi faire actuellement
   };