// 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) .
//
// 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 .
//
// For more information, please consult: .
/************************************************************************
* 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