Herezh_dev/Enumeration/EnumTypeCalcul.h

/*! \file EnumTypeCalcul.h
    \brief def Enumeration concernant les différents types de calcul globaux
* \date      23/01/97
*/


// 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:        23/01/97                                            *
 *                                                                $     *
 *     AUTEUR:      G RIO   (mailto:gerardrio56@free.fr)                *
 *                                                                $     *
 *     PROJET:      Herezh++                                            *
 *                                                                $     *
 ************************************************************************
 *     BUT:  Enumeration des differents type de calcul possible.        *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     * 
 *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/
#ifndef ENUMTYPECALCUL_H
#define ENUMTYPECALCUL_H

#include <iostream>
using namespace std;
#include "UtilLecture.h"
#include <list>

/// @addtogroup Group_types_enumeres
///  @{

/// identificateur principal du type de Calcul
enum EnumTypeCalcul { DYNA_IMP = 1, DYNA_EXP,DYNA_EXP_TCHAMWA,DYNA_EXP_CHUNG_LEE,DYNA_EXP_ZHAI,
                      DYNA_RUNGE_KUTTA,NON_DYNA, NON_DYNA_CONT, 
                      FLAMB_LINEAIRE,INFORMATIONS,UTILITAIRES,DEF_SCHEMA_XML,RIEN_TYPECALCUL,
                      UMAT_ABAQUS, DYNA_EXP_BONELLI , RELAX_DYNA, STAT_DYNA_EXP ,
                      COMBINER
                    };
/// @}  // end of group

/// @addtogroup Group_types_enumeres
///  @{

/// identificateur secondaire optionnel du type de Calcul renseigne par exemple
/// sur le fait de calculer l'erreur,  une relocation, un raffinement, etc ..
enum EnumSousTypeCalcul { aucun_soustypedecalcul =1, avec_remonte , avec_remonte_erreur,
          avec_remonte_erreur_relocation, avec_remonte_erreur_raffinement_relocation,
          remonte,remonte_erreur,remonte_erreur_relocation,remonte_erreur_raffinement_relocation,
          frontieres,visualisation,LinVersQuad,QuadIncVersQuadComp,relocPtMilieuQuad,sauveCommandesVisu,
          lectureCommandesVisu,commandeInteractive,sauveMaillagesEnCours,extrusion2D3D,creation_reference,
          prevision_visu_sigma,prevision_visu_epsilon,prevision_visu_erreur,
          modif_orientation_element,creationMaillageSFE,suppression_noeud_non_references,renumerotation_des_noeuds,
          fusion_de_noeuds,fusion_elements,fusion_maillages,cree_sous_maillage,calcul_geometrique
          };
/// @}  // end of group

// identificateur pour décrire si le calcul est statique, transitoire, dynamique et autre ...
enum Enum_evolution_temporelle{STATIQUE=1,TRANSITOIRE,DYNAMIQUE,AUCUNE_EVOLUTION}; 


// Retourne le nom d'un type de calcul a partir de son identificateur de
// type enumere id_TypeCalcul correspondant
string  Nom_TypeCalcul (const EnumTypeCalcul id_TypeCalcul);
// Retourne le nom du sous type de calcul a partir de son identificateur de
// type enumere id_SousTypeCalcul correspondant, si il existe sinon retourne : aucun_soustypedecalcul
string Nom_SousTypeCalcul (const EnumSousTypeCalcul id_SousTypeCalcul);
// retourne le type d'évolution temporelle du calcul
Enum_evolution_temporelle Evolution_temporelle_du_calcul(const EnumTypeCalcul id_TypeCalcul);

// Retourne l'identificateur de type enumere associe au nom du type de calcul
EnumTypeCalcul Id_nom_TypeCalcul (const string& nom_TypeCalcul);
// Retourne l'identificateur de type enumere associe au nom du sous type de calcul
EnumSousTypeCalcul Id_nom_SousTypeCalcul (const string& nom_SousTypeCalcul);

// indique si le calcul est de type dynamique explicite ou non
bool DynamiqueExplicite(const EnumTypeCalcul id_TypeCalcul);

// indique si le calcul est de type implicite ou non
bool Implicite(const EnumTypeCalcul id_TypeCalcul);

//lecture du type de calcul et d'une liste de  sous-type eventuel
// la lecture se fait via UtilLecture.
// Le booléen indique si le type_calcul ou le sous_type_calcul est actif ou pas
// au niveau de syntaxe on a : 
// - tout d'abord le type de calcul suivi ou non de la chaine "avec" 
//   dans le premier cas le booleen avec_Calcul est mis a true sinon false
// - puis une liste de sous type qui chacun sont précèdé ou non de la chaine "plus" 
//   dans le premier cas  le booleen avec_sousCalcul correspondant est true sinon false
//   les sous_types sont stocké par ordre d'arrivé
void LectureTypeCalcul(UtilLecture& lec,EnumTypeCalcul& typeCalcul,bool& avec_Calcul
                      ,list<EnumSousTypeCalcul> & sousTypeCalcul
                      ,list<bool>& avec_sousCalcul);
// affichage des différents type de calcul et choix du type et éventuellement
//  de sous type
void Info_commande_type_calcul(UtilLecture& lec,EnumTypeCalcul& typeCalcul,bool& avec_Calcul
                      ,list<EnumSousTypeCalcul> & sousTypeCalcul
                      ,list<bool>& avec_sousCalcul);                     

// indique s'il y a un sous-type ou pas -> retour vrai s'il y a un sous type
bool SousType(const EnumSousTypeCalcul sousTypeCalcul);

// indique s'il y a remonte ou pas dans le sous-type
bool Remonte_in(const EnumSousTypeCalcul sousTypeCalcul);

// indique s'il y a "avec" ou pas dans le sous-type
bool Avec_in(const EnumSousTypeCalcul sousTypeCalcul);

// indique s'il y a erreur dans le sous-type
bool Erreur_in(const EnumSousTypeCalcul sousTypeCalcul);

// surcharge de l'operator de lecture
istream & operator >> (istream & entree, EnumTypeCalcul& a);  
// surcharge de l'operator d'ecriture
ostream & operator << (ostream & sort, const EnumTypeCalcul& a);

// surcharge de l'operator de lecture
istream & operator >> (istream & entree, EnumSousTypeCalcul& a);  
// surcharge de l'operator d'ecriture
ostream & operator << (ostream & sort, const EnumSousTypeCalcul& a);

//--------------------- cas de Enum_evolution_temporelle---------------

// Retourne le nom d'un type de Enum_evolution_temporelle a partir de son identificateur de
// type enumere id_Enum_evolution_temporelle correspondant
string Nom_evolution_temporelle (const Enum_evolution_temporelle id_evolution_temporelle);
// Retourne l'identificateur de type enumere associe au nom du type de Enum_evolution_temporelle
Enum_evolution_temporelle Id_nom_evolution_temporelle (const string& nom_evolution_temporelle);
// surcharge de l'operator de lecture
istream & operator >> (istream & entree, Enum_evolution_temporelle& a);  
// surcharge de l'operator d'ecriture
ostream & operator << (ostream & sort, const Enum_evolution_temporelle& a);


#endif