

// 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/>.

/************************************************************************
 *     DATE:        04/03/2008                                          *
 *                                                                $     *
 *     AUTEUR:      G RIO   (mailto:gerardrio56@free.fr)                *
 *                                                                $     *
 *     PROJET:      Herezh++                                            *
 *                                                                $     *
 ************************************************************************
 *     BUT:  Interface pour les types de calcul de cristalinité.        *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/
// FICHIER : CristaliniteAbstraite.h
// CLASSE : CristaliniteAbstraite

/// pour les calculs de cristalinité


#ifndef CRISTALINITEABSTRAITE_H
#define CRISTALINITEABSTRAITE_H


#include "Enum_crista.h"
#include "Tableau_T.h"
#include "LesCourbes1D.h"
#include "Enum_dure.h"
#include "LesFonctions_nD.h"

/// @addtogroup Les_lois_concernant_thermique
///  @{
///


class CristaliniteAbstraite 
{

	public :

	// CONSTRUCTEURS :
	
	// Constructeur par defaut
	CristaliniteAbstraite (): id_crista(CRISTA_PAS_DEFINI),saveCrista(NULL) {};
	
	// Constructeur utile si l'identificateur du nom est connus
	CristaliniteAbstraite (Enum_crista id_crita) : id_crista(id_crita),saveCrista(NULL) {};
	
	// Constructeur utile si le nom est connus	
	CristaliniteAbstraite (char* nom) : id_crista(Id_nom_Enum_crista(nom)),saveCrista(NULL) {};
	
	// Constructeur de copie
	CristaliniteAbstraite (const CristaliniteAbstraite & a ) 
	   : id_crista(a.id_crista),saveCrista(a.saveCrista->Nevez_SaveCrista()) {};
	 
	// DESTRUCTEUR VIRTUEL :
	
	virtual ~CristaliniteAbstraite () {};
		
		
// 2) METHODES VIRTUELLES  public:
		
//   --------- données spécifiques éventuelles de la loi --------------
		// initialise les donnees particulieres a l'elements
		// de matiere traite ( c-a-dire au pt calcule)
		// Il y a creation d'une instance de SaveCrista particuliere
		// a la loi concernee
		// la SaveCrista classe est remplie par les instances heritantes
		// le pointeur de SaveCrista est sauvegarde au niveau de l'element
		// c'a-d que les info particulieres au point considere sont stocke
		// au niveau de l'element et non de la loi.
		class SaveCrista 
		 { public :
		    // destructeur virtuelle
		    virtual ~SaveCrista() {};
		    // définition d'une nouvelle instance identique
		    // appelle du constructeur via new 
		    virtual SaveCrista * Nevez_SaveCrista() const =0;		    
	     //============= 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)
	     virtual void Lecture_base_info (ifstream& ent,const int cas)  = 0;
         // cas donne le niveau de sauvegarde
         // = 1 : on sauvegarde tout
         // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
	     virtual void Ecriture_base_info(ofstream& sort,const int cas) = 0;
	     
	     // mise à jour des informations transitoires en définitif s'il y a convergence 
	     // par exemple (pour la plasticité par exemple)
	     virtual void TdtversT()=0;
	     virtual void TversTdt()=0;
	     // affichage des infos
	     virtual void Affiche() = 0;
	     // idem sur ofstream
	     virtual void Affiche(ofstream& sort)=0;
	     // Surcharge de l'operateur =
		    virtual SaveCrista& operator= (const SaveCrista& a) = 0;
	        	        
   };
        // création d'une instance du même type
		virtual SaveCrista * New_et_Initialise() { return NULL;};
		// création d'une instance identique
		virtual SaveCrista * New_et_Initialise(const SaveCrista& ) { return NULL;};
		
		// affichage des donnees particulieres a l'elements
		// de matiere traite ( c-a-dire au pt calcule)
		virtual void AfficheDataSpecif(ofstream& ,SaveCrista * ) const {};
		
//   --------- fin données spécifiques éventuelles de la loi --------------

    // affichage de la loi
    virtual void Affiche() const = 0; 
    
    // Lecture des donnees de la classe sur fichier
    virtual void LectureDonneesLoiCrista(UtilLecture * entreePrinc,LesCourbes1D& ,LesFonctions_nD& ) = 0;
    
    // affichage et definition interactive des paramètres 
    virtual void Info_commande_LoisCrista(UtilLecture& entreePrinc) = 0;

    // calcul de la fonction K(T,P)
    virtual double  fct_KT(const double& P, const double& T ) const = 0;
    
    // calcul du taux de cristalinité à tdt à partir de sa valeur à t
    // P_t, P : pression à t et, t+deltat (= actuelle)
    // T_t, T : température à t et, t+deltat (=actuelle)
    virtual double  Cristalinite
         (const double& P_t, const double& T_t,CristaliniteAbstraite::SaveCrista * saveTP
         ,const double& P, const double& T,Enum_dure temps) = 0 ;

    // calcul du taux de cristalinité à tdt à partir des grandeurs à tdt
    // P : pression à  t+deltat (= actuelle)
    // T : température à  t+deltat (=actuelle)
    virtual double  Cristalinite
         (CristaliniteAbstraite::SaveCrista * saveTP,const double& P, const double& T) = 0 ;

	//----- lecture écriture de restart spécifique aux données de la classe -----
	// 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)
	virtual void Lecture_don_base_info(ifstream& ,const int  ,LesCourbes1D& ,LesFonctions_nD& ) = 0;
    // cas donne le niveau de sauvegarde
    // = 1 : on sauvegarde tout
    // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
	virtual void Ecriture_don_base_info(ofstream& ,const int ) const = 0;	
	
	//------- non virtuelle -------
	// le type
	Enum_crista Type_Crista() const {return id_crista;};		  	
    // pointeur de travail utilise par les classes derivantes		
    SaveCrista * saveCrista; 

    // ---------- static ---------
    
    // ramène un pointeur  correspondant au type de crista passé en paramètre
    // IMPORTANT : il y a création d'une instance (utilisation d'un new)
    static CristaliniteAbstraite* New_Cristalinite(Enum_crista typeCrista);
    // ramène un pointeur sur une instance copie de celle passée en paramètre
    // IMPORTANT : il y a création d'une instance (utilisation d'un new)
    static CristaliniteAbstraite* New_Cristalinite(const CristaliniteAbstraite& Co);
		
// VARIABLES PROTEGEES :

    protected:
    // l'identificateur de la classe calculant la cristalinité  
    Enum_crista id_crista;
};
/// @}  // end of group


#endif
