Herezh_dev/Enumeration/EnumTypeCalcul.h
2023-05-03 17:23:49 +02:00

172 lines
8.6 KiB
C++

/*! \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