From 6021f832faf20a3cf262df8c5059546e3e686815 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?G=C3=A9rard=20Rio?= Date: Wed, 15 Sep 2021 12:00:56 +0200 Subject: [PATCH] =?UTF-8?q?introduction=20des=20fichiers=20relatifs=20aux?= =?UTF-8?q?=20=C3=A9num=C3=A9rations=20globales?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Enumeration/EnuTypeCL.cc | 130 ++ Enumeration/EnuTypeCL.h | 115 ++ Enumeration/EnuTypeQuelParticulier.cc | 183 ++ Enumeration/EnuTypeQuelParticulier.h | 110 ++ Enumeration/EnumCourbe1D.cc | 203 ++ Enumeration/EnumCourbe1D.h | 103 + Enumeration/EnumElemTypeProblem.cc | 180 ++ Enumeration/EnumElemTypeProblem.h | 84 + Enumeration/EnumFonction_nD.cc | 125 ++ Enumeration/EnumFonction_nD.h | 98 + Enumeration/EnumLangue.cc | 112 ++ Enumeration/EnumLangue.h | 93 + Enumeration/EnumTypeCalcul.cc | 851 ++++++++ Enumeration/EnumTypeCalcul.h | 172 ++ Enumeration/EnumTypeGradient.cc | 119 ++ Enumeration/EnumTypeGradient.h | 106 + Enumeration/EnumTypeGrandeur.cc | 247 +++ Enumeration/EnumTypeGrandeur.h | 111 ++ Enumeration/EnumTypePilotage.cc | 121 ++ Enumeration/EnumTypePilotage.h | 69 + Enumeration/EnumTypeViteRotat.cc | 105 + Enumeration/EnumTypeViteRotat.h | 71 + Enumeration/EnumTypeVitesseDefor.cc | 109 ++ Enumeration/EnumTypeVitesseDefor.h | 72 + Enumeration/Enum_Critere_loi.cc | 138 ++ Enumeration/Enum_Critere_loi.h | 96 + Enumeration/Enum_GrandeurGlobale.cc | 300 +++ Enumeration/Enum_GrandeurGlobale.h | 94 + Enumeration/Enum_IO_XML.cc | 136 ++ Enumeration/Enum_IO_XML.h | 95 + Enumeration/Enum_PiPoCo.cc | 155 ++ Enumeration/Enum_PiPoCo.h | 101 + Enumeration/Enum_StabHourglass.cc | 128 ++ Enumeration/Enum_StabHourglass.h | 96 + Enumeration/Enum_StabMembrane.cc | 223 +++ Enumeration/Enum_StabMembrane.h | 111 ++ Enumeration/Enum_Suite.cc | 123 ++ Enumeration/Enum_TypeQuelconque.cc | 1731 +++++++++++++++++ Enumeration/Enum_TypeQuelconque.h | 193 ++ Enumeration/Enum_boolddl.cc | 169 ++ Enumeration/Enum_boolddl.h | 82 + Enumeration/Enum_calcul_masse.cc | 115 ++ Enumeration/Enum_calcul_masse.h | 91 + Enumeration/Enum_categorie_loi_comp.cc | 155 ++ Enumeration/Enum_categorie_loi_comp.h | 94 + Enumeration/Enum_chargement.cc | 133 ++ Enumeration/Enum_chargement.h | 74 + Enumeration/Enum_comp.cc | 395 ++++ Enumeration/Enum_comp.h | 125 ++ Enumeration/Enum_contrainte_mathematique.cc | 110 ++ Enumeration/Enum_contrainte_mathematique.h | 74 + Enumeration/Enum_crista.cc | 115 ++ Enumeration/Enum_crista.h | 94 + .../Enum_ddl (copy: conflict on 2017-11-21).h | 199 ++ Enumeration/Enum_ddl.cc | 1397 +++++++++++++ Enumeration/Enum_ddl.h | 272 +++ Enumeration/Enum_ddl_var_static.cc | 65 + Enumeration/Enum_dure.cc | 151 ++ Enumeration/Enum_dure.h | 103 + Enumeration/Enum_geom.cc | 172 ++ Enumeration/Enum_geom.h | 80 + Enumeration/Enum_interpol.cc | 166 ++ Enumeration/Enum_interpol.h | 76 + Enumeration/Enum_liaison_noeud.cc | 104 + Enumeration/Enum_liaison_noeud.h | 95 + Enumeration/Enum_mat.cc | 117 ++ Enumeration/Enum_mat.h | 70 + Enumeration/Enum_matrice.cc | 227 +++ Enumeration/Enum_matrice.h | 102 + Enumeration/Enum_proj_aniso.cc | 120 ++ Enumeration/Enum_proj_aniso.h | 95 + Enumeration/Enum_suite.h | 96 + Enumeration/Enum_type_deformation.cc | 128 ++ Enumeration/Enum_type_deformation.h | 100 + Enumeration/Enum_type_geom.cc | 108 + Enumeration/Enum_type_geom.h | 69 + Enumeration/Enum_type_pt_integ.cc | 106 + Enumeration/Enum_type_pt_integ.h | 71 + Enumeration/Enum_type_resolution_matri.cc | 287 +++ Enumeration/Enum_type_resolution_matri.h | 131 ++ Enumeration/Enum_type_stocke_deformation.cc | 129 ++ Enumeration/Enum_type_stocke_deformation.h | 100 + Enumeration/Enum_variable_metrique.cc | 281 +++ Enumeration/Enum_variable_metrique.h | 107 + Enumeration/MotCle.cc | 116 ++ Enumeration/MotCle.h | 99 + 86 files changed, 14774 insertions(+) create mode 100644 Enumeration/EnuTypeCL.cc create mode 100644 Enumeration/EnuTypeCL.h create mode 100644 Enumeration/EnuTypeQuelParticulier.cc create mode 100644 Enumeration/EnuTypeQuelParticulier.h create mode 100644 Enumeration/EnumCourbe1D.cc create mode 100644 Enumeration/EnumCourbe1D.h create mode 100644 Enumeration/EnumElemTypeProblem.cc create mode 100644 Enumeration/EnumElemTypeProblem.h create mode 100755 Enumeration/EnumFonction_nD.cc create mode 100755 Enumeration/EnumFonction_nD.h create mode 100644 Enumeration/EnumLangue.cc create mode 100644 Enumeration/EnumLangue.h create mode 100644 Enumeration/EnumTypeCalcul.cc create mode 100644 Enumeration/EnumTypeCalcul.h create mode 100644 Enumeration/EnumTypeGradient.cc create mode 100644 Enumeration/EnumTypeGradient.h create mode 100644 Enumeration/EnumTypeGrandeur.cc create mode 100644 Enumeration/EnumTypeGrandeur.h create mode 100644 Enumeration/EnumTypePilotage.cc create mode 100644 Enumeration/EnumTypePilotage.h create mode 100644 Enumeration/EnumTypeViteRotat.cc create mode 100644 Enumeration/EnumTypeViteRotat.h create mode 100644 Enumeration/EnumTypeVitesseDefor.cc create mode 100644 Enumeration/EnumTypeVitesseDefor.h create mode 100755 Enumeration/Enum_Critere_loi.cc create mode 100755 Enumeration/Enum_Critere_loi.h create mode 100755 Enumeration/Enum_GrandeurGlobale.cc create mode 100755 Enumeration/Enum_GrandeurGlobale.h create mode 100644 Enumeration/Enum_IO_XML.cc create mode 100644 Enumeration/Enum_IO_XML.h create mode 100644 Enumeration/Enum_PiPoCo.cc create mode 100644 Enumeration/Enum_PiPoCo.h create mode 100644 Enumeration/Enum_StabHourglass.cc create mode 100644 Enumeration/Enum_StabHourglass.h create mode 100755 Enumeration/Enum_StabMembrane.cc create mode 100755 Enumeration/Enum_StabMembrane.h create mode 100644 Enumeration/Enum_Suite.cc create mode 100644 Enumeration/Enum_TypeQuelconque.cc create mode 100644 Enumeration/Enum_TypeQuelconque.h create mode 100644 Enumeration/Enum_boolddl.cc create mode 100644 Enumeration/Enum_boolddl.h create mode 100755 Enumeration/Enum_calcul_masse.cc create mode 100644 Enumeration/Enum_calcul_masse.h create mode 100644 Enumeration/Enum_categorie_loi_comp.cc create mode 100644 Enumeration/Enum_categorie_loi_comp.h create mode 100755 Enumeration/Enum_chargement.cc create mode 100755 Enumeration/Enum_chargement.h create mode 100644 Enumeration/Enum_comp.cc create mode 100644 Enumeration/Enum_comp.h create mode 100755 Enumeration/Enum_contrainte_mathematique.cc create mode 100755 Enumeration/Enum_contrainte_mathematique.h create mode 100644 Enumeration/Enum_crista.cc create mode 100644 Enumeration/Enum_crista.h create mode 100644 Enumeration/Enum_ddl (copy: conflict on 2017-11-21).h create mode 100644 Enumeration/Enum_ddl.cc create mode 100644 Enumeration/Enum_ddl.h create mode 100644 Enumeration/Enum_ddl_var_static.cc create mode 100644 Enumeration/Enum_dure.cc create mode 100644 Enumeration/Enum_dure.h create mode 100644 Enumeration/Enum_geom.cc create mode 100644 Enumeration/Enum_geom.h create mode 100644 Enumeration/Enum_interpol.cc create mode 100644 Enumeration/Enum_interpol.h create mode 100755 Enumeration/Enum_liaison_noeud.cc create mode 100755 Enumeration/Enum_liaison_noeud.h create mode 100644 Enumeration/Enum_mat.cc create mode 100644 Enumeration/Enum_mat.h create mode 100755 Enumeration/Enum_matrice.cc create mode 100644 Enumeration/Enum_matrice.h create mode 100755 Enumeration/Enum_proj_aniso.cc create mode 100755 Enumeration/Enum_proj_aniso.h create mode 100644 Enumeration/Enum_suite.h create mode 100644 Enumeration/Enum_type_deformation.cc create mode 100644 Enumeration/Enum_type_deformation.h create mode 100644 Enumeration/Enum_type_geom.cc create mode 100644 Enumeration/Enum_type_geom.h create mode 100644 Enumeration/Enum_type_pt_integ.cc create mode 100644 Enumeration/Enum_type_pt_integ.h create mode 100755 Enumeration/Enum_type_resolution_matri.cc create mode 100644 Enumeration/Enum_type_resolution_matri.h create mode 100644 Enumeration/Enum_type_stocke_deformation.cc create mode 100644 Enumeration/Enum_type_stocke_deformation.h create mode 100644 Enumeration/Enum_variable_metrique.cc create mode 100644 Enumeration/Enum_variable_metrique.h create mode 100644 Enumeration/MotCle.cc create mode 100644 Enumeration/MotCle.h diff --git a/Enumeration/EnuTypeCL.cc b/Enumeration/EnuTypeCL.cc new file mode 100644 index 0000000..8a57e5c --- /dev/null +++ b/Enumeration/EnuTypeCL.cc @@ -0,0 +1,130 @@ +// FICHIER : EnuTypeCL.cc + + +// 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-2021 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: . + + +#include "EnuTypeCL.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + +// tout d'abord on définit la map qui permet de relier les chaines et les types énumérés + // 1) def de la map + map < string, EnuTypeCL , std::less < string> > + ClassPourEnuTypeCL::map_EnuTypeCL; + + // 2) def de la grandeur statique qui permet de remplir la map + ClassPourEnuTypeCL ClassPourEnuTypeCL::remplir_map; + // le constructeur qui rempli effectivement la map + ClassPourEnuTypeCL::ClassPourEnuTypeCL() + { // remplissage de la map + map_EnuTypeCL["TANGENTE_CL"]=TANGENTE_CL; + map_EnuTypeCL["RIEN_TYPE_CL"]=RIEN_TYPE_CL; + }; + +char* NomTypeCL(EnuTypeCL id_TypeCL) +// Retourne le nom du type de grandeur correspondant a l'identificateur +// de type enumere id_TypeCL +{ char* result; + switch (id_TypeCL) + { case TANGENTE_CL : result="TANGENTE_CL"; break; + case RIEN_TYPE_CL : result="RIEN_TYPE_CL"; break; + default : + cout << "\nErreur : valeur incorrecte du type EnuTypeCL !\n"; + cout << "NomTypeCL(EnuTypeCL ) \n"; + Sortie(1); + }; + return result; +}; + +EnuTypeCL Id_nomTypeCL (char* nom_TypeCL) +// Retourne la variable de type enumere associe au nom nom_TypeCL +{ // on vérifie si la variable de type enumere existe + map < string, EnuTypeCL , std::less < string> >& maa=ClassPourEnuTypeCL::map_EnuTypeCL; + map < string, EnuTypeCL , std::less < string> >::iterator il,ilfin= maa.end(); + il = maa.find(nom_TypeCL); + if (il == maa.end()) + {// on vérifie si la variable de type enumere existe + cout << "\nErreur : nom du type de grandeur '" < >& maa=ClassPourEnuTypeCL::map_EnuTypeCL; + map < string, EnuTypeCL , std::less < string> >::iterator il,ilfin= maa.end(); + il = maa.find(nom_TypeCL); + if (il == maa.end()) + {// on vérifie si la variable de type enumere existe + cout << "\nErreur : nom du type de grandeur '" <> (istream & entree, EnuTypeCL & result) + { char nom_TypeCL[80]; + entree >> nom_TypeCL; + result = Id_nomTypeCL ( nom_TypeCL); + return entree; + }; + +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnuTypeCL& a) + { // on ecrit la forme caractère + sort << NomTypeCL(a) << " "; + return sort; + }; + diff --git a/Enumeration/EnuTypeCL.h b/Enumeration/EnuTypeCL.h new file mode 100644 index 0000000..8c313c9 --- /dev/null +++ b/Enumeration/EnuTypeCL.h @@ -0,0 +1,115 @@ +/*! \file EnuTypeCL.h + \brief Type énuméré pour définir les différentes sous-classes de conditions limites. +* \date 04/10/2007 +*/ + + +// 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-2021 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/10/2007 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Type énuméré pour définir les différentes sous-classes * + * de conditions limites. * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + + +// Afin de realiser un gain en place memoire, les noms des types de grandeurs sont +// stockes a l'aide d'un type enumere. + + +#ifndef ENUTYPECL_H +#define ENUTYPECL_H +#include +using namespace std; +#include +#include "ParaGlob.h" +#include "EnumTypeGrandeur.h" +#include "Enum_dure.h" +#include "Tableau_T.h" + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Type énuméré pour définir les différentes sous-classes de conditions limites. +enum EnuTypeCL { TANGENTE_CL, RIEN_TYPE_CL}; +/// @} // end of group + +/// @addtogroup Group_types_enumeres +/// @{ + +/// def de la map qui fait la liaison entre les string et les énumérés + +class ClassPourEnuTypeCL +{ public: + /// def de la map qui fait la liaison entre les string et les énumérés + static map < string, EnuTypeCL , std::less < string> > map_EnuTypeCL; + // def de la grandeur statique qui permet de remplir la map + static ClassPourEnuTypeCL remplir_map; + // le constructeur qui rempli effectivement la map + ClassPourEnuTypeCL(); + }; +/// @} // end of group + +// Retourne le nom du type de grandeur a partir de son identificateur de +// type enumere id_TypeCL correspondant +char* NomTypeCL (EnuTypeCL id_TypeCL); + +// indique si le string correspond à un type CL reconnu ou non +bool Existe_typeCL(string& nom); + +// Retourne l'identificateur de type enumere associe au nom du type de grandeur +// nom_TypeCL +EnuTypeCL Id_nomTypeCL (char* nom_TypeCL); +EnuTypeCL Id_nomTypeCL (string& nom_TypeCL); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, EnuTypeCL& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnuTypeCL& a); + +#endif diff --git a/Enumeration/EnuTypeQuelParticulier.cc b/Enumeration/EnuTypeQuelParticulier.cc new file mode 100644 index 0000000..f8ab0bf --- /dev/null +++ b/Enumeration/EnuTypeQuelParticulier.cc @@ -0,0 +1,183 @@ +// FICHIER : EnuTypeQuelParticulier.cc + + +// 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-2021 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: . + + +#include "EnuTypeQuelParticulier.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + +// tout d'abord on définit la map qui permet de relier les chaines et les types énumérés + // 1) def de la map + map < string, EnuTypeQuelParticulier , std::less < string> > + ClassPourEnuTypeQuelParticulier::map_EnuTypeQuelParticulier; + + // 2) def de la grandeur statique qui permet de remplir la map + ClassPourEnuTypeQuelParticulier ClassPourEnuTypeQuelParticulier::remplir_map; + // le constructeur qui rempli effectivement la map + ClassPourEnuTypeQuelParticulier::ClassPourEnuTypeQuelParticulier() + { // remplissage de la map + map_EnuTypeQuelParticulier["RIEN_TYPE_QUELCONQUE_PARTICULIER"]=RIEN_TYPE_QUELCONQUE_PARTICULIER; + map_EnuTypeQuelParticulier["PARTICULIER_TENSEURHH"]=PARTICULIER_TENSEURHH; + map_EnuTypeQuelParticulier["PARTICULIER_TENSEURBB"]=PARTICULIER_TENSEURBB; + map_EnuTypeQuelParticulier["PARTICULIER_COORDONNEE"]=PARTICULIER_COORDONNEE; + map_EnuTypeQuelParticulier["PARTICULIER_TABLEAU_TENSEURHH"]=PARTICULIER_TABLEAU_TENSEURHH; + map_EnuTypeQuelParticulier["PARTICULIER_TABLEAU2_TENSEURHH"]=PARTICULIER_TABLEAU2_TENSEURHH; + map_EnuTypeQuelParticulier["PARTICULIER_TENSEURBH"]=PARTICULIER_TENSEURBH; + map_EnuTypeQuelParticulier["PARTICULIER_SCALAIRE_DOUBLE"]=PARTICULIER_SCALAIRE_DOUBLE; + map_EnuTypeQuelParticulier["PARTICULIER_TABLEAU_SCALAIRE_DOUBLE"]=PARTICULIER_TABLEAU_SCALAIRE_DOUBLE; + map_EnuTypeQuelParticulier["PARTICULIER_SCALAIRE_ENTIER"]=PARTICULIER_SCALAIRE_ENTIER; + map_EnuTypeQuelParticulier["PARTICULIER_TABLEAU_SCALAIRE_ENTIER"]=PARTICULIER_TABLEAU_SCALAIRE_ENTIER; + map_EnuTypeQuelParticulier["PARTICULIER_TABLEAU_QUELCONQUE"]=PARTICULIER_TABLEAU_QUELCONQUE; + map_EnuTypeQuelParticulier["PARTICULIER_TABLEAU_COORDONNEE"]=PARTICULIER_TABLEAU_COORDONNEE; + map_EnuTypeQuelParticulier["PARTICULIER_VECTEUR"]=PARTICULIER_VECTEUR; + map_EnuTypeQuelParticulier["PARTICULIER_TABLEAU_VECTEUR"]=PARTICULIER_TABLEAU_VECTEUR; + map_EnuTypeQuelParticulier["PARTICULIER_BASE_H"]=PARTICULIER_BASE_H; + map_EnuTypeQuelParticulier["PARTICULIER_BASE_B"]=PARTICULIER_BASE_B; + map_EnuTypeQuelParticulier["PARTICULIER_TABLEAU_BASE_H"]=PARTICULIER_TABLEAU_BASE_H; + map_EnuTypeQuelParticulier["PARTICULIER_TABLEAU_BASE_B"]=PARTICULIER_TABLEAU_BASE_B; + map_EnuTypeQuelParticulier["PARTICULIER_TABLEAU_TENSEURBH"]=PARTICULIER_TABLEAU_TENSEURBH; + map_EnuTypeQuelParticulier["PARTICULIER_TABLEAU_TENSEURBB"]=PARTICULIER_TABLEAU_TENSEURBB; + map_EnuTypeQuelParticulier["PARTICULIER_TENSEURHB"]=PARTICULIER_TENSEURHB; + map_EnuTypeQuelParticulier["PARTICULIER_TABLEAU_TENSEURHB"]=PARTICULIER_TABLEAU_TENSEURHB; + map_EnuTypeQuelParticulier["PARTICULIER_DDL_ETENDU"]=PARTICULIER_DDL_ETENDU; + map_EnuTypeQuelParticulier["PARTICULIER_TABLEAU_DDL_ETENDU"]=PARTICULIER_TABLEAU_DDL_ETENDU; + map_EnuTypeQuelParticulier["PARTICULIER_VECTEUR_NOMMER"]=PARTICULIER_VECTEUR_NOMMER; + map_EnuTypeQuelParticulier["PARTICULIER_TABLEAU_VECTEUR_NOMMER"]=PARTICULIER_TABLEAU_VECTEUR_NOMMER; + map_EnuTypeQuelParticulier["PARTICULIER_TABLEAU_VECTEUR_NOMMER"]=PARTICULIER_TABLEAU_VECTEUR_NOMMER; + map_EnuTypeQuelParticulier["PARTICULIER_SCALAIRE_DOUBLE_NOMMER_INDICER"]=PARTICULIER_SCALAIRE_DOUBLE_NOMMER_INDICER; + }; + +string NomTypeQuelParticulier(EnuTypeQuelParticulier id_TypeQuelParticulier) +// Retourne le nom du type de grandeur correspondant a l'identificateur +// de type enumere id_TypeQuelParticulier +{ string result; + switch (id_TypeQuelParticulier) + { case RIEN_TYPE_QUELCONQUE_PARTICULIER : result="RIEN_TYPE_QUELCONQUE_PARTICULIER"; break; + case PARTICULIER_TENSEURHH : result="PARTICULIER_TENSEURHH"; break; + case PARTICULIER_TENSEURBB : result="PARTICULIER_TENSEURBB"; break; + case PARTICULIER_COORDONNEE : result="PARTICULIER_COORDONNEE"; break; + case PARTICULIER_TABLEAU_TENSEURHH : result="PARTICULIER_TABLEAU_TENSEURHH"; break; + case PARTICULIER_TABLEAU2_TENSEURHH : result="PARTICULIER_TABLEAU2_TENSEURHH"; break; + case PARTICULIER_TENSEURBH : result="PARTICULIER_TENSEURBH"; break; + case PARTICULIER_SCALAIRE_DOUBLE : result="PARTICULIER_SCALAIRE_DOUBLE"; break; + case PARTICULIER_TABLEAU_SCALAIRE_DOUBLE : result="PARTICULIER_TABLEAU_SCALAIRE_DOUBLE"; break; + case PARTICULIER_SCALAIRE_ENTIER : result="PARTICULIER_SCALAIRE_ENTIER"; break; + case PARTICULIER_TABLEAU_SCALAIRE_ENTIER : result="PARTICULIER_TABLEAU_SCALAIRE_ENTIER"; break; + case PARTICULIER_TABLEAU_QUELCONQUE : result="PARTICULIER_TABLEAU_QUELCONQUE"; break; + case PARTICULIER_TABLEAU_COORDONNEE : result="PARTICULIER_TABLEAU_COORDONNEE"; break; + case PARTICULIER_VECTEUR : result="PARTICULIER_VECTEUR"; break; + case PARTICULIER_TABLEAU_VECTEUR : result="PARTICULIER_TABLEAU_VECTEUR"; break; + case PARTICULIER_BASE_H : result="PARTICULIER_BASE_H"; break; + case PARTICULIER_BASE_B : result="PARTICULIER_BASE_B"; break; + case PARTICULIER_TABLEAU_BASE_H : result="PARTICULIER_TABLEAU_BASE_H"; break; + case PARTICULIER_TABLEAU_BASE_B : result="PARTICULIER_TABLEAU_BASE_B"; break; + case PARTICULIER_TABLEAU_TENSEURBH : result="PARTICULIER_TABLEAU_TENSEURBH"; break; + case PARTICULIER_TABLEAU_TENSEURBB : result="PARTICULIER_TABLEAU_TENSEURBB"; break; + case PARTICULIER_TENSEURHB : result="PARTICULIER_TENSEURHB"; break; + case PARTICULIER_TABLEAU_TENSEURHB : result="PARTICULIER_TABLEAU_TENSEURHB"; break; + case PARTICULIER_DDL_ETENDU : result="PARTICULIER_DDL_ETENDU"; break; + case PARTICULIER_TABLEAU_DDL_ETENDU : result="PARTICULIER_TABLEAU_DDL_ETENDU"; break; + case PARTICULIER_VECTEUR_NOMMER : result="PARTICULIER_VECTEUR_NOMMER"; break; + case PARTICULIER_TABLEAU_VECTEUR_NOMMER : result="PARTICULIER_TABLEAU_VECTEUR_NOMMER"; break; + case PARTICULIER_SCALAIRE_DOUBLE_NOMMER_INDICER : result="PARTICULIER_SCALAIRE_DOUBLE_NOMMER_INDICER"; break; + default : + cout << "\nErreur : valeur incorrecte du type EnuTypeQuelParticulier !\n"; + cout << "NomTypeQuelParticulier(EnuTypeQuelParticulier ) \n"; + Sortie(1); + }; + return result; +}; + +EnuTypeQuelParticulier Id_nomTypeQuelParticulier (char* nom_TypeQuelParticulier) +// Retourne la variable de type enumere associe au nom nom_TypeQuelParticulier +{ // on vérifie si la variable de type enumere existe + map < string, EnuTypeQuelParticulier , std::less < string> >& maa=ClassPourEnuTypeQuelParticulier::map_EnuTypeQuelParticulier; + map < string, EnuTypeQuelParticulier , std::less < string> >::iterator il,ilfin= maa.end(); + il = maa.find(nom_TypeQuelParticulier); + if (il == ilfin) + {// on vérifie si la variable de type enumere existe + cout << "\nErreur : nom du type de grandeur '" < >& maa=ClassPourEnuTypeQuelParticulier::map_EnuTypeQuelParticulier; + map < string, EnuTypeQuelParticulier , std::less < string> >::iterator il,ilfin= maa.end(); + il = maa.find(nom_TypeQuelParticulier); + if (il == ilfin) + {// on vérifie si la variable de type enumere existe + cout << "\nErreur : nom du type de grandeur '" <> (istream & entree, EnuTypeQuelParticulier & result) + { char nom_TypeQuelParticulier[80]; + entree >> nom_TypeQuelParticulier; + result = Id_nomTypeQuelParticulier ( nom_TypeQuelParticulier); + return entree; + }; + +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnuTypeQuelParticulier& a) + { // on ecrit la forme caractère + sort << NomTypeQuelParticulier(a) << " "; + return sort; + }; + diff --git a/Enumeration/EnuTypeQuelParticulier.h b/Enumeration/EnuTypeQuelParticulier.h new file mode 100644 index 0000000..7d51339 --- /dev/null +++ b/Enumeration/EnuTypeQuelParticulier.h @@ -0,0 +1,110 @@ +/*! \file EnuTypeQuelParticulier.h + \brief def de l'enuméré concernant les types quelconques particuliers. +*/ +// FICHIER : EnuTypeQuelParticulier.h + +// 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-2021 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: . + + +// Afin de realiser un gain en place memoire, les noms des types de grandeurs sont +// stockes a l'aide d'un type enumere. Les fonctions NomTypeQuelParticulier et Id_nomTypeQuelParticulier rendent +// possible le lien entre les noms des geometries et les identificateurs +// de type enumere correspondants. + + +#ifndef ENUTYPEQUELPARTICULIER_H +#define ENUTYPEQUELPARTICULIER_H +#include +using namespace std; +#include +#include "ParaGlob.h" +#include "EnumTypeGrandeur.h" +#include "Enum_dure.h" +#include "Tableau_T.h" + + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré concernant les types quelconques particuliers. + +enum EnuTypeQuelParticulier { RIEN_TYPE_QUELCONQUE_PARTICULIER = 1,PARTICULIER_TENSEURHH + ,PARTICULIER_TENSEURBB,PARTICULIER_COORDONNEE + ,PARTICULIER_TABLEAU_COORDONNEE + ,PARTICULIER_VECTEUR,PARTICULIER_TABLEAU_VECTEUR + ,PARTICULIER_BASE_H,PARTICULIER_BASE_B + ,PARTICULIER_TABLEAU_BASE_H,PARTICULIER_TABLEAU_BASE_B + ,PARTICULIER_TABLEAU_TENSEURHH,PARTICULIER_TABLEAU2_TENSEURHH + ,PARTICULIER_TENSEURBH,PARTICULIER_SCALAIRE_DOUBLE + ,PARTICULIER_TABLEAU_SCALAIRE_DOUBLE + ,PARTICULIER_SCALAIRE_ENTIER,PARTICULIER_TABLEAU_SCALAIRE_ENTIER + ,PARTICULIER_TABLEAU_QUELCONQUE + ,PARTICULIER_TABLEAU_TENSEURBH,PARTICULIER_TABLEAU_TENSEURBB + ,PARTICULIER_TENSEURHB,PARTICULIER_TABLEAU_TENSEURHB + ,PARTICULIER_DDL_ETENDU,PARTICULIER_TABLEAU_DDL_ETENDU + ,PARTICULIER_VECTEUR_NOMMER,PARTICULIER_TABLEAU_VECTEUR_NOMMER + ,PARTICULIER_SCALAIRE_DOUBLE_NOMMER_INDICER + }; +/// @} // end of group + + +/// @addtogroup Group_types_enumeres +/// @{ + +/// def de la map qui fait la liaison entre les string et les énumérés + +class ClassPourEnuTypeQuelParticulier +{ public: + /// def de la map qui fait la liaison entre les string et les énumérés + static map < string, EnuTypeQuelParticulier , std::less < string> > map_EnuTypeQuelParticulier; + // def de la grandeur statique qui permet de remplir la map + static ClassPourEnuTypeQuelParticulier remplir_map; + // le constructeur qui rempli effectivement la map + ClassPourEnuTypeQuelParticulier(); + }; +/// @} // end of group + +// Retourne le nom du type de grandeur a partir de son identificateur de +// type enumere id_TypeQuelParticulier correspondant +string NomTypeQuelParticulier (EnuTypeQuelParticulier id_TypeQuelParticulier); + +// indique si le string correspond à un type quelParticulier reconnu ou non +bool Existe_typeQuelParticulier(string& nom); + +// Retourne l'identificateur de type enumere associe au nom du type de grandeur +// nom_TypeQuelParticulier +EnuTypeQuelParticulier Id_nomTypeQuelParticulier (char* nom_TypeQuelParticulier); +EnuTypeQuelParticulier Id_nomTypeQuelParticulier (string& nom_TypeQuelParticulier); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, EnuTypeQuelParticulier& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnuTypeQuelParticulier& a); + +#endif diff --git a/Enumeration/EnumCourbe1D.cc b/Enumeration/EnumCourbe1D.cc new file mode 100644 index 0000000..19fe150 --- /dev/null +++ b/Enumeration/EnumCourbe1D.cc @@ -0,0 +1,203 @@ +// FICHIER : EnumCourbe1D.cp + + +// 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-2021 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: . + + +#include "EnumCourbe1D.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +string Nom_Courbe1D (EnumCourbe1D id_Courbe1D) +// Retourne le nom de la Courbe1 correspondant a l'identificateur +// de type enumere id_Courbe1D +{ + + string result; + switch (id_Courbe1D) + { + case COURBEPOLYLINEAIRE_1_D :result="COURBEPOLYLINEAIRE_1_D";break; + case COURBEPOLYHERMITE_1_D :result="COURBEPOLYHERMITE_1_D";break; + case COURBE_EXPOAFF :result="COURBE_EXPOAFF";break; + case COURBE_UN_MOINS_COS :result="COURBE_UN_MOINS_COS";break; + case CPL1D :result="CPL1D";break; + case COURBEPOLYNOMIALE :result="COURBEPOLYNOMIALE";break; + case F1_ROND_F2 :result="F1_ROND_F2";break; + case F1_PLUS_F2 :result="F1_PLUS_F2";break; + case F_CYCLIQUE :result="F_CYCLIQUE";break; + case F_CYCLE_ADD :result="F_CYCLE_ADD";break; + case F_UNION_1D :result="F_UNION_1D";break; + case COURBE_TRIPODECOS3PHI :result="COURBE_TRIPODECOS3PHI";break; + case COURBE_SIXPODECOS3PHI :result="COURBE_SIXPODECOS3PHI";break; + case COURBE_POLY_LAGRANGE :result="COURBE_POLY_LAGRANGE";break; + case COURBE_EXPO_N :result="COURBE_EXPO_N";break; + case COURBE_EXPO2_N :result="COURBE_EXPO2_N";break; + case COURBE_RELAX_EXPO :result="COURBE_RELAX_EXPO";break; + case COURBE_COS :result="COURBE_COS";break; + case COURBE_SIN :result="COURBE_SIN";break; + case COURBE_TANH :result="COURBE_TANH";break; + case COURBE_LN_COSH :result="COURBE_LN_COSH";break; + case COURBE_EXPRESSION_LITTERALE_1D :result="COURBE_EXPRESSION_LITTERALE_1D";break; + case COURBE_EXPRESSION_LITTERALE_AVEC_DERIVEE_1D :result="COURBE_EXPRESSION_LITTERALE_AVEC_DERIVEE_1D";break; + case AUCUNE_COURBE1D :result="AUCUNE_COURBE1D";break; + default : + cout << "\nErreur : valeur incorrecte du type EnumCourbe1D !\n"; + cout << "Nom_Courbe1D(EnumCourbe1D ) \n"; + Sortie(1); + }; + return result; + +}; + +EnumCourbe1D Id_Nom_Courbe1D (const string& nom_Courbe1D) +// Retourne la variable de type enumere associee au nom de la Courbe1D +{ + + EnumCourbe1D result; + if ( nom_Courbe1D == "COURBEPOLYLINEAIRE_1_D" ) + result=COURBEPOLYLINEAIRE_1_D; + else if ( nom_Courbe1D == "COURBEPOLYHERMITE_1_D" ) + result=COURBEPOLYHERMITE_1_D; + else if ( nom_Courbe1D == "COURBE_EXPOAFF" ) + result=COURBE_EXPOAFF; + else if ( nom_Courbe1D == "COURBE_UN_MOINS_COS" ) + result=COURBE_UN_MOINS_COS; + else if ( nom_Courbe1D == "CPL1D" ) + result=CPL1D; + else if ( nom_Courbe1D == "COURBEPOLYNOMIALE" ) + result=COURBEPOLYNOMIALE; + else if ( nom_Courbe1D == "F1_ROND_F2" ) + result=F1_ROND_F2; + else if ( nom_Courbe1D == "F1_PLUS_F2" ) + result=F1_PLUS_F2; + else if ( nom_Courbe1D == "F_CYCLIQUE" ) + result=F_CYCLIQUE; + else if ( nom_Courbe1D == "F_CYCLE_ADD" ) + result=F_CYCLE_ADD; + else if ( nom_Courbe1D == "F_UNION_1D" ) + result=F_UNION_1D; + else if ( nom_Courbe1D == "COURBE_TRIPODECOS3PHI" ) + result=COURBE_TRIPODECOS3PHI; + else if ( nom_Courbe1D == "COURBE_SIXPODECOS3PHI" ) + result=COURBE_SIXPODECOS3PHI; + else if ( nom_Courbe1D == "COURBE_POLY_LAGRANGE" ) + result=COURBE_POLY_LAGRANGE; + else if ( nom_Courbe1D == "COURBE_EXPO_N" ) + result=COURBE_EXPO_N; + else if ( nom_Courbe1D == "COURBE_EXPO2_N" ) + result=COURBE_EXPO2_N; + else if ( nom_Courbe1D == "COURBE_RELAX_EXPO" ) + result=COURBE_RELAX_EXPO; + else if ( nom_Courbe1D == "COURBE_COS" ) + result=COURBE_COS; + else if ( nom_Courbe1D == "COURBE_SIN" ) + result=COURBE_SIN; + else if ( nom_Courbe1D == "COURBE_TANH" ) + result=COURBE_TANH; + else if ( nom_Courbe1D == "COURBE_LN_COSH" ) + result=COURBE_LN_COSH; + else if ( nom_Courbe1D == "COURBE_EXPRESSION_LITTERALE_1D" ) + result=COURBE_EXPRESSION_LITTERALE_1D; + else if ( nom_Courbe1D == "COURBE_EXPRESSION_LITTERALE_AVEC_DERIVEE_1D" ) + result=COURBE_EXPRESSION_LITTERALE_AVEC_DERIVEE_1D; + else if ( nom_Courbe1D == "AUCUNE_COURBE1D" ) + result=AUCUNE_COURBE1D; + else + { + cout << "\nErreur : nom de la Courbe1D inconnu !: " << nom_Courbe1D << "\n"; + cout << "Id_Nom_Courbe1D (... \n"; + Sortie(1); + }; + return result; + +}; + +// Retourne vrai si le nom passé en argument représente un type de courbe reconnu +// sinon false +bool Type_EnumCourbe1D_existe(const string& nom) +{ bool result; + if ( nom == "COURBEPOLYLINEAIRE_1_D") result=true; + else if ( nom == "COURBEPOLYHERMITE_1_D") result=true; + else if ( nom == "COURBE_EXPOAFF") result=true; + else if ( nom == "COURBE_UN_MOINS_COS") result=true; + else if ( nom == "CPL1D") result=true; + else if ( nom == "COURBEPOLYNOMIALE") result=true; + else if ( nom == "F1_ROND_F2") result=true; + else if ( nom == "F1_PLUS_F2") result=true; + else if ( nom == "F_CYCLIQUE") result=true; + else if ( nom == "F_CYCLE_ADD") result=true; + else if ( nom == "F_UNION_1D") result=true; + else if ( nom == "COURBE_TRIPODECOS3PHI") result=true; + else if ( nom == "COURBE_SIXPODECOS3PHI") result=true; + else if ( nom == "COURBE_POLY_LAGRANGE") result=true; + else if ( nom == "COURBE_EXPO_N") result=true; + else if ( nom == "COURBE_EXPO2_N") result=true; + else if ( nom == "COURBE_RELAX_EXPO") result=true; + else if ( nom == "COURBE_COS") result=true; + else if ( nom == "COURBE_SIN") result=true; + else if ( nom == "COURBE_TANH") result=true; + else if ( nom == "COURBE_LN_COSH") result=true; + else if ( nom == "COURBE_EXPRESSION_LITTERALE_1D") result=true; + else if ( nom == "COURBE_EXPRESSION_LITTERALE_AVEC_DERIVEE_1D") result=true; + else if ( nom == "AUCUNE_COURBE1D") result=true; + else result = false; + return result; +}; + + // surcharge de l'operator de lecture +istream & operator >> (istream & entree, EnumCourbe1D& a) + { string nom_EnumCourbe1D; + entree >> nom_EnumCourbe1D; + a = Id_Nom_Courbe1D ( nom_EnumCourbe1D); + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnumCourbe1D& a) + { // on ecrit la forme caractère + sort << Nom_Courbe1D(a) << " "; + return sort; + }; + + diff --git a/Enumeration/EnumCourbe1D.h b/Enumeration/EnumCourbe1D.h new file mode 100644 index 0000000..4e2b188 --- /dev/null +++ b/Enumeration/EnumCourbe1D.h @@ -0,0 +1,103 @@ +/*! \file EnumCourbe1D.h + \brief Enumeration des différentes courbes 1D existantes +* \date 19/01/2001 +*/ + +// FICHIER : EnumCourbe1D.h + +// 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-2021 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: 19/01/2001 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Enumeration des différentes courbes 1D existantes * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + + +#ifndef ENUMCOURBE_1_D_H +#define ENUMCOURBE_1_D_H +#include +using namespace std; +#include +#include +#include + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Enumeration des différentes courbes 1D existantes + +enum EnumCourbe1D { COURBEPOLYLINEAIRE_1_D=1, COURBE_EXPOAFF, COURBE_UN_MOINS_COS + ,CPL1D,COURBEPOLYNOMIALE, F1_ROND_F2, F1_PLUS_F2 + , F_CYCLIQUE, F_CYCLE_ADD, F_UNION_1D + ,COURBE_TRIPODECOS3PHI,COURBE_SIXPODECOS3PHI + ,COURBE_POLY_LAGRANGE, COURBE_EXPO_N, COURBE_EXPO2_N + ,COURBE_RELAX_EXPO, COURBE_COS, COURBE_SIN, COURBE_TANH + ,COURBEPOLYHERMITE_1_D, COURBE_LN_COSH + ,COURBE_EXPRESSION_LITTERALE_1D,COURBE_EXPRESSION_LITTERALE_AVEC_DERIVEE_1D + , AUCUNE_COURBE1D}; +/// @} // end of group + + + +// Retourne le nom d'une courbe1D a partir de son identificateur de +// type enumere id_Courbe1D correspondant +string Nom_Courbe1D (EnumCourbe1D id_Courbe1D); + +// Retourne l'identificateur de type enumere associe au nom d'une courbe1D +EnumCourbe1D Id_Nom_Courbe1D (const string& nom_Courbe1D) ; + +// Retourne vrai si le nom passé en argument représente un type de courbe reconnu +// sinon false +bool Type_EnumCourbe1D_existe(const std::string& nom); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, EnumCourbe1D& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnumCourbe1D& a); + +#endif diff --git a/Enumeration/EnumElemTypeProblem.cc b/Enumeration/EnumElemTypeProblem.cc new file mode 100644 index 0000000..59cf272 --- /dev/null +++ b/Enumeration/EnumElemTypeProblem.cc @@ -0,0 +1,180 @@ +// FICHIER EnumElemTypeProblem.cp + + +// 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-2021 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: . + + +#include "EnumElemTypeProblem.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + +#ifndef EnumElemTypeProblem_deja_inclus + + +#ifndef MISE_AU_POINT + inline +#endif +int Nombre_de_EnumElemTypeProblem() { return 5;}; // nombre maxi d'enum + + +#ifndef MISE_AU_POINT + inline +#endif +string NomElemTypeProblem (const EnumElemTypeProblem id_ElemTypeProblem) +// Retourne le nom a partir de son identificateur de +// type enumere id_ElemTypeProbleme correspondant +{ + + string result=""; + switch (id_ElemTypeProblem) + { + case MECA_SOLIDE_DEFORMABLE : + result="MECA_SOLIDE_DEFORMABLE"; + break; + case MECA_SOLIDE_INDEFORMABLE : + result="MECA_SOLIDE_INDEFORMABLE"; + break; + case MECA_FLUIDE : + result="MECA_FLUIDE"; + break; + case THERMIQUE : + result="THERMIQUE"; + break; + case ELECTROMAGNETIQUE : + result="ELECTROMAGNETIQUE"; + break; + case RIEN_PROBLEM : + result="RIEN_PROBLEM"; + break; + default : + cout << "\nErreur : valeur incorrecte du type EnumElemTypeProblem !\n"; + cout << "NomElemTypeProblem (EnumElemTypeProblem id_ElemTypeProblem) \n"; + Sortie(1); + }; + return result; + +}; + +#ifndef MISE_AU_POINT + inline +#endif +EnumElemTypeProblem Id_nom_ElemTypeProblem (const string& nom) +// Retourne l'identificateur de type enumere associe au nom +{ + + EnumElemTypeProblem result=RIEN_PROBLEM; + if ( nom == "MECA_SOLIDE_DEFORMABLE" ) + result=MECA_SOLIDE_DEFORMABLE; + else if ( nom == "MECA_SOLIDE_INDEFORMABLE" ) + result=MECA_SOLIDE_INDEFORMABLE; + else if ( nom == "MECA_FLUIDE" ) + result=MECA_FLUIDE; + else if ( nom == "THERMIQUE" ) + result=THERMIQUE; + else if ( nom == "ELECTROMAGNETIQUE" ) + result=ELECTROMAGNETIQUE; + else if ( nom == "RIEN_PROBLEM" ) + result=RIEN_PROBLEM; + else + { + cout << "\nErreur : nom:\"" << nom << "\" du degre de liberte inconnu !\n"; + cout << "Id_nom_ElemTypeProblem (string nom) \n"; + Sortie(1); + }; + return result; + +}; + +// retourne true si l'identificateur existe, false sinon +#ifndef MISE_AU_POINT + inline +#endif +bool ExisteEnum_ElemTypeProblem(const string& nom) + { bool res; + if ( nom == "MECA_SOLIDE_DEFORMABLE" ) + res=true; + else if ( nom == "MECA_SOLIDE_INDEFORMABLE" ) + res=true; + else if ( nom == "MECA_FLUIDE" ) + res=true; + else if ( nom == "THERMIQUE" ) + res=true; + else if ( nom == "ELECTROMAGNETIQUE" ) + res=true; + else if ( nom == "RIEN_PROBLEM" ) + res=true; + else + res = false; + return res; + +}; + +#ifndef MISE_AU_POINT + inline +#endif +// retourne le nombre maxi de Type de problème apréhendé +int NbEnum_ElemTypeProblem() + { return 6;}; + + // surcharge de l'operator de lecture +#ifndef MISE_AU_POINT + inline +#endif +istream & operator >> (istream & entree, EnumElemTypeProblem& a) + { string nom_EnumElemTypeProblem; + entree >> nom_EnumElemTypeProblem; + a = Id_nom_ElemTypeProblem ( nom_EnumElemTypeProblem); + return entree; + }; + + // surcharge de l'operator d'ecriture +#ifndef MISE_AU_POINT + inline +#endif +ostream & operator << (ostream & sort, const EnumElemTypeProblem& a) + { // on ecrit la forme caractère + sort << NomElemTypeProblem(a) << " "; + return sort; + }; + +#endif diff --git a/Enumeration/EnumElemTypeProblem.h b/Enumeration/EnumElemTypeProblem.h new file mode 100644 index 0000000..070a2b2 --- /dev/null +++ b/Enumeration/EnumElemTypeProblem.h @@ -0,0 +1,84 @@ +/*! \file EnumElemTypeProblem.h + \brief def de l'enuméré concernant les types de problème +*/ +// FICHIER : EnumElemTypeProblem.h + +// 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-2021 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: . + + +// liste des différentes types de problème que l'on peut trouver au niveau d'un élément +// fini + + +#ifndef ENUMELEMTYPEPROBLEM_H +#define ENUMELEMTYPEPROBLEM_H + +//#include "Debug.h" +// #include +#include +using namespace std; + + + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré concernant les types de problème + +enum EnumElemTypeProblem { MECA_SOLIDE_DEFORMABLE = 1, MECA_SOLIDE_INDEFORMABLE, + MECA_FLUIDE, THERMIQUE, ELECTROMAGNETIQUE , RIEN_PROBLEM}; +/// @} // end of group + + +int Nombre_de_EnumElemTypeProblem() ; // nombre maxi d'enum +// Retourne le nom a partir de son identificateur de +// type enumere id_ElemTypeProbleme correspondant +string NomElemTypeProblem (const EnumElemTypeProblem id_ElemTypeProblem); + +// Retourne l'identificateur de type enumere associe au nom +EnumElemTypeProblem Id_nom_ElemTypeProblem (const string& nom_ElemTypeProblem); + +// retourne true si l'identificateur existe, false sinon +bool ExisteEnum_ElemTypeProblem(const string& nom_ElemTypeProblem); + +// retourne le nombre maxi de Type de problème apréhendé +int NbEnum_ElemTypeProblem(); +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, EnumElemTypeProblem& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnumElemTypeProblem& a); + +// pour faire de l'inline +#ifndef MISE_AU_POINT + #include "EnumElemTypeProblem.cc" + #define EnumElemTypeProblem_deja_inclus +#endif + + +#endif diff --git a/Enumeration/EnumFonction_nD.cc b/Enumeration/EnumFonction_nD.cc new file mode 100755 index 0000000..3d615df --- /dev/null +++ b/Enumeration/EnumFonction_nD.cc @@ -0,0 +1,125 @@ +// FICHIER : EnumFonction_nD.cp + + +// 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-2021 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: . + + +#include "EnumFonction_nD.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" + +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +string Nom_Fonction_nD (EnumFonction_nD id_Fonction_nD) +// Retourne le nom de la Fonction_nD correspondant a l'identificateur +// de type enumere id_Fonction_nD +{ + + string result; + switch (id_Fonction_nD) + { + case FONCTION_EXPRESSION_LITTERALE_nD :result="FONCTION_EXPRESSION_LITTERALE_nD";break; + case FONCTION_COURBE1D :result="FONCTION_COURBE1D";break; + case FONC_SCAL_COMBINEES_ND : result="FONC_SCAL_COMBINEES_ND";break; + case FONCTION_EXTERNE_ND : result="FONCTION_EXTERNE_ND";break; + case AUCUNE_FONCTION_nD :result="AUCUNE_FONCTION_nD";break; + default : + cout << "\nErreur : valeur incorrecte du type EnumFonction_nD !\n"; + cout << "Nom_Fonction_nD(EnumFonction_nD ) \n"; + Sortie(1); + }; + return result; + +}; + +EnumFonction_nD Id_Nom_Fonction_nD (const string& nom_Fonction_nD) +// Retourne la variable de type enumere associee au nom de la Fonction_nD +{ + + EnumFonction_nD result; + if ( nom_Fonction_nD == "FONCTION_EXPRESSION_LITTERALE_nD" ) + result=FONCTION_EXPRESSION_LITTERALE_nD; + else if ( nom_Fonction_nD == "FONCTION_COURBE1D" ) + result=FONCTION_COURBE1D; + else if ( nom_Fonction_nD == "FONC_SCAL_COMBINEES_ND") + result = FONC_SCAL_COMBINEES_ND; + else if ( nom_Fonction_nD == "FONCTION_EXTERNE_ND") + result = FONCTION_EXTERNE_ND; + else if ( nom_Fonction_nD == "AUCUNE_FONCTION_nD" ) + result=AUCUNE_FONCTION_nD; + else + { + cout << "\nErreur : nom de la Fonction_nD inconnu !: " << nom_Fonction_nD << "\n"; + cout << "Id_Nom_Fonction_nD (string nom_Fonction_nD) \n"; + Sortie(1); + }; + return result; + +}; + +// Retourne vrai si le nom passé en argument représente un type de Fonction_nD reconnu +// sinon false +bool Type_EnumFonction_nD_existe(const string& nom) +{ bool result; + if ( nom == "FONCTION_EXPRESSION_LITTERALE_nD") result=true; + else if ( nom == "FONCTION_COURBE1D") result=true; + else if ( nom == "FONC_SCAL_COMBINEES_ND") result = true; + else if ( nom == "FONCTION_EXTERNE_ND") result = true; + else if ( nom == "AUCUNE_FONCTION_nD") result=true; + else result = false; + return result; +}; + + // surcharge de l'operator de lecture +istream & operator >> (istream & entree, EnumFonction_nD& a) + { string nom_EnumFonction_nD; + entree >> nom_EnumFonction_nD; + a = Id_Nom_Fonction_nD ( nom_EnumFonction_nD); + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnumFonction_nD& a) + { // on ecrit la forme caractère + sort << Nom_Fonction_nD(a) << " "; + return sort; + }; + + diff --git a/Enumeration/EnumFonction_nD.h b/Enumeration/EnumFonction_nD.h new file mode 100755 index 0000000..ee89c85 --- /dev/null +++ b/Enumeration/EnumFonction_nD.h @@ -0,0 +1,98 @@ +/*! \file EnumFonction_nD.h + \brief Enumeration des différentes fonctions nD existantes +* \date 06/03/2023 +*/ + + +// 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-2021 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: 06/03/2023 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Enumeration des différentes fonctions nD existantes * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + + +#ifndef ENUMFONCTION_ND_H +#define ENUMFONCTION_ND_H +#include +using namespace std; +#include +#include +#include + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Enumeration des différentes fonctions nD existantes + +enum EnumFonction_nD { FONCTION_EXPRESSION_LITTERALE_nD=1 + ,FONCTION_COURBE1D,FONC_SCAL_COMBINEES_ND + ,FONCTION_EXTERNE_ND + ,AUCUNE_FONCTION_nD}; +/// @} // end of group + + + +// Retourne le nom d'une Fonction_nD a partir de son identificateur de +// type enumere id_Fonction_nD correspondant +string Nom_Fonction_nD (EnumFonction_nD id_Fonction_nD); + +// Retourne l'identificateur de type enumere associe au nom d'une Fonction_nD +EnumFonction_nD Id_Nom_Fonction_nD (const string& nom_Fonction_nD) ; + +// Retourne vrai si le nom passé en argument représente un type de courbe reconnu +// sinon false +bool Type_EnumFonction_nD_existe(const std::string& nom); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, EnumFonction_nD& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnumFonction_nD& a); + +#endif diff --git a/Enumeration/EnumLangue.cc b/Enumeration/EnumLangue.cc new file mode 100644 index 0000000..067a8f3 --- /dev/null +++ b/Enumeration/EnumLangue.cc @@ -0,0 +1,112 @@ +// FICHIER : EnumLangue.cp + + +// 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-2021 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: . + + +#include "EnumLangue.h" + + +# include +#include +using namespace std; //introduces namespace std + +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include +#include + + + +char* Nom_EnumLangue (EnumLangue id_EnumLangue) +// Retourne le nom du type de EnumLangue correspondant a l'identificateur +// de type enumere id_EnumLangue +{ + + char* result; + switch (id_EnumLangue) + { + case FRANCAIS : + result="FRANCAIS"; + break; + case ENGLISH : + result="ENGLISH"; + break; + default : + cout << "\nErreur : valeur incorrecte du type EnumLangue !\n"; + cout << "Nom_EnumLangue(EnumLangue ) \n"; + Sortie(1); + }; + return result; + +}; + +EnumLangue Id_nom_EnumLangue (char* nom_EnumLangue) +// Retourne la variable de type enumere associe au nom +// de EnumLangue nom_EnumLangue +{ + + EnumLangue result; + if ( strcmp(nom_EnumLangue,"FRANCAIS")==0 ) + result=FRANCAIS; + else if ( strcmp(nom_EnumLangue,"ENGLISH")==0 ) + result=ENGLISH; + else + { + cout << "\nErreur : nom " << nom_EnumLangue << " de EnumLangue inconnu !\n"; + cout << "\n Id_nom_EnumLangue(char* ) \n"; + Sortie(1); + }; + return result; + +}; + +// surcharge de la lecture +istream & operator >> (istream & entree, EnumLangue & result) + { char nom_EnumLangue[45]; + entree >> nom_EnumLangue; + result = Id_nom_EnumLangue ( nom_EnumLangue); + return entree; + }; + + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnumLangue& a) + { // on ecrit la forme caractère + sort << Nom_EnumLangue(a) << " "; + return sort; + }; + diff --git a/Enumeration/EnumLangue.h b/Enumeration/EnumLangue.h new file mode 100644 index 0000000..e75a67c --- /dev/null +++ b/Enumeration/EnumLangue.h @@ -0,0 +1,93 @@ +/*! \file EnumLangue.h + \brief def Enumeration des différents languages +* \date 30/05/2009 +*/ + +// FICHIER : EnumLangue.h + +// 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-2021 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: 30/05/2009 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Enumération des différents languages * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + +#ifndef ENUM_LANGAGE_H +#define ENUM_LANGAGE_H + +#include +using namespace std; + + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Enumération des différents languages + +enum EnumLangue { FRANCAIS = 1, ENGLISH }; +/// @} // end of group + +const int nombre_maxi_de_type_de_EnumLangue = 2; + +// Retourne un nom de type de EnumLangue a partir de son identificateur de +// type enumere id_EnumLangue correspondant +char* Nom_EnumLangue (EnumLangue id_EnumLangue); + +// Retourne l'identificateur de type enumere associe au nom du type +// de EnumLangue nom_EnumLangue +EnumLangue Id_nom_EnumLangue (char* nom_EnumLangue); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, EnumLangue& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnumLangue& a); + + +#endif + + diff --git a/Enumeration/EnumTypeCalcul.cc b/Enumeration/EnumTypeCalcul.cc new file mode 100644 index 0000000..927b1eb --- /dev/null +++ b/Enumeration/EnumTypeCalcul.cc @@ -0,0 +1,851 @@ + +// 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-2021 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: . + +#include "EnumTypeCalcul.h" +#include +#include "Sortie.h" +#include "CharUtil.h" + +// 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) +{ + string result; + switch (id_TypeCalcul) + {case RIEN_TYPECALCUL : result="aucun_TYPE_de_CALCUL"; break; + case DYNA_IMP : result="dynamique_implicite"; break; + case DYNA_EXP : result="dynamique_explicite"; break; + case DYNA_EXP_TCHAMWA : result="dynamique_explicite_tchamwa"; break; + case DYNA_EXP_CHUNG_LEE: result="dynamique_explicite_chung_lee"; break; + case DYNA_EXP_ZHAI : result="dynamique_explicite_zhai"; break; + case DYNA_RUNGE_KUTTA : result="dynamique_Runge_Kutta"; break; + case NON_DYNA : result="non_dynamique"; break; + case NON_DYNA_CONT : result="non_dynamique_avec_contact"; break; + case FLAMB_LINEAIRE : result="flambement_lineaire_en_implicite_non_dynamique"; break; + case INFORMATIONS : result="informations"; break; + case UTILITAIRES : result="utilitaires"; break; + case DEF_SCHEMA_XML : result="def_schema_xml"; break; + case UMAT_ABAQUS : result="umat_abaqus"; break; + case DYNA_EXP_BONELLI : result="dynamique_explicite_bonelli"; break; + case RELAX_DYNA : result="dynamique_relaxation_dynam"; break; + case STAT_DYNA_EXP : result="mixte_statique_dynamique_explicite"; break; + case COMBINER : result="combiner"; break; + default : + cout << "\nErreur : valeur incorrecte du type EnumTypeCalcul !\n"; + cout << "string Nom_TypeCalcul (EnumTypeCalcul id_TypeCalcul)" << endl; + Sortie(1); + }; + return result; + +}; + +// 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) +{ + string result; + switch (id_SousTypeCalcul) + {case aucun_soustypedecalcul : result="aucun_sous_TYPE_de_CALCUL"; break; + case avec_remonte : result="avec_remontee_aux_valeurs_aux_noeuds"; break; + case avec_remonte_erreur : result="avec_remontee_et_calcul_d'erreur"; break; + case avec_remonte_erreur_relocation : result="avec_remonte_erreur_et_relocalion"; break; + case avec_remonte_erreur_raffinement_relocation : result="avec_remontee_erreur_raffinement_et_relocation"; break; + case remonte : result="uniquement_remontee"; break; + case remonte_erreur : result="remontee_et_erreur"; break; + case remonte_erreur_relocation : result="remontee_erreur_et_relocation"; break; + case remonte_erreur_raffinement_relocation : result="remontee_erreur_raffinement_et_relocation"; break; + case frontieres : result="frontieres"; break; + case visualisation : result="visualisation"; break; + case LinVersQuad : result="LinVersQuad"; break; + case QuadIncVersQuadComp : result="QuadIncVersQuadComp"; break; + case relocPtMilieuQuad : result="relocPtMilieuQuad"; break; + case sauveCommandesVisu : result="sauveCommandesVisu"; break; + case lectureCommandesVisu : result="lectureCommandesVisu"; break; + case commandeInteractive : result="commandeInteractive"; break; + case sauveMaillagesEnCours : result="sauveMaillagesEnCours"; break; + case extrusion2D3D : result="extrusion2D3D"; break; + case creation_reference : result="creation_reference"; break; + case prevision_visu_sigma : result="prevision_visu_sigma"; break; + case prevision_visu_epsilon : result="prevision_visu_epsilon"; break; + case prevision_visu_erreur : result="prevision_visu_erreur"; break; + case modif_orientation_element : result="modif_orientation_element"; break; + case creationMaillageSFE : result="creationMaillageSFE"; break; + case suppression_noeud_non_references : result="suppression_noeud_non_references"; break; + case renumerotation_des_noeuds : result="renumerotation_des_noeuds"; break; + case fusion_de_noeuds : result="fusion_de_noeuds"; break; + case fusion_elements : result="fusion_elements"; break; + case fusion_maillages : result="fusion_maillages"; break; + case cree_sous_maillage : result="cree_sous_maillage"; break; + case calcul_geometrique : result="calcul_geometrique"; break; + default : + cout << "\nErreur : valeur incorrecte du type EnumSousTypeCalcul !\n"; + cout << "string Nom_SousTypeCalcul (EnumSousTypeCalcul id_SousTypeCalcul)" << endl; + Sortie(1); + }; + return result; + +}; + +// retourne le type d'évolution temporelle du calcul +Enum_evolution_temporelle Evolution_temporelle_du_calcul(const EnumTypeCalcul id_TypeCalcul) +{Enum_evolution_temporelle result;; + switch (id_TypeCalcul) + { case RIEN_TYPECALCUL : result=AUCUNE_EVOLUTION; break; + case DYNA_IMP : result=DYNAMIQUE; break; + case DYNA_EXP : result=DYNAMIQUE; break; + case DYNA_EXP_TCHAMWA : result=DYNAMIQUE; break; + case DYNA_EXP_CHUNG_LEE: result=DYNAMIQUE; break; + case DYNA_EXP_ZHAI : result=DYNAMIQUE; break; + case DYNA_RUNGE_KUTTA : result=DYNAMIQUE; break; + case NON_DYNA : result=STATIQUE; break; + case NON_DYNA_CONT : result=STATIQUE; break; + case FLAMB_LINEAIRE : result=STATIQUE; break; + case INFORMATIONS : result=AUCUNE_EVOLUTION; break; + case UTILITAIRES : result=AUCUNE_EVOLUTION; break; + case DEF_SCHEMA_XML : result=AUCUNE_EVOLUTION; break; + case UMAT_ABAQUS : result=AUCUNE_EVOLUTION; break; + case DYNA_EXP_BONELLI : result=DYNAMIQUE; break; + case RELAX_DYNA : result=DYNAMIQUE; break; + case STAT_DYNA_EXP : result=DYNAMIQUE; break; + case COMBINER : result=DYNAMIQUE; break; + default : + cout << "\nErreur : valeur incorrecte du type EnumTypeCalcul !\n"; + cout << "Enum_evolution_temporelle Evolution_temporelle_du_calcul(const EnumTypeCalcul id_TypeCalcul)" + << endl; + Sortie(1); + }; + return result; +}; + +// Retourne l'identificateur de type enumere associe au nom du type de calcul +EnumTypeCalcul Id_nom_TypeCalcul (const string& nom_TypeCalcul) +{ + + EnumTypeCalcul result; + if (( nom_TypeCalcul == "RIEN_TYPECALCUL" ) + ||( nom_TypeCalcul == "aucun_TYPE_de_CALCUL" )) + result=RIEN_TYPECALCUL; + else if (( nom_TypeCalcul == "DYNA_IMP" ) + ||( nom_TypeCalcul == "dynamique_implicite" )) + result=DYNA_IMP; + else if (( nom_TypeCalcul == "DYNA_EXP" ) + ||( nom_TypeCalcul == "dynamique_explicite" )) + result=DYNA_EXP; + else if (( nom_TypeCalcul == "DYNA_EXP_TCHAMWA" ) + ||( nom_TypeCalcul == "dynamique_explicite_tchamwa" )) + result=DYNA_EXP_TCHAMWA; + else if (( nom_TypeCalcul == "DYNA_EXP_CHUNG_LEE" ) + ||( nom_TypeCalcul == "dynamique_explicite_chung_lee" )) + result=DYNA_EXP_CHUNG_LEE; + else if (( nom_TypeCalcul == "DYNA_EXP_ZHAI" ) + ||( nom_TypeCalcul == "dynamique_explicite_zhai" )) + result=DYNA_EXP_ZHAI; + else if (( nom_TypeCalcul == "DYNA_RUNGE_KUTTA" ) + ||( nom_TypeCalcul == "dynamique_Runge_Kutta" )) + result=DYNA_RUNGE_KUTTA; + else if (( nom_TypeCalcul == "NON_DYNA" ) + ||( nom_TypeCalcul == "non_dynamique" )) + result=NON_DYNA; + else if (( nom_TypeCalcul == "NON_DYNA_CONT" ) + ||( nom_TypeCalcul == "non_dynamique_avec_contact" )) + result=NON_DYNA_CONT; + else if (( nom_TypeCalcul == "FLAMB_LINEAIRE" ) + ||( nom_TypeCalcul == "flambement_lineaire_en_implicite_non_dynamique" )) + result=FLAMB_LINEAIRE; + else if (( nom_TypeCalcul == "INFORMATIONS" ) + ||( nom_TypeCalcul == "calcul_d'information_relatives_aux_maillages_d'entrees" )) + result=INFORMATIONS; + else if (( nom_TypeCalcul == "UTILITAIRES" ) + ||( nom_TypeCalcul == "utilitaires" )) + result=UTILITAIRES; + else if (( nom_TypeCalcul == "DEF_SCHEMA_XML" ) + ||( nom_TypeCalcul == "def_schema_xml" )) + result=DEF_SCHEMA_XML; + else if (( nom_TypeCalcul == "UMAT_ABAQUS" ) + ||( nom_TypeCalcul == "umat_abaqus" )) + result=UMAT_ABAQUS; + else if (( nom_TypeCalcul == "DYNA_EXP_BONELLI" ) + ||( nom_TypeCalcul == "dynamique_explicite_bonelli" )) + result=DYNA_EXP_BONELLI; + else if (( nom_TypeCalcul == "RELAX_DYNA" ) + ||( nom_TypeCalcul == "dynamique_relaxation_dynam" )) + result=RELAX_DYNA; + else if (( nom_TypeCalcul == "STAT_DYNA_EXP" ) + ||( nom_TypeCalcul == "mixte_statique_dynamique_explicite" )) + result=STAT_DYNA_EXP; + else if (( nom_TypeCalcul == "COMBINER" ) + ||( nom_TypeCalcul == "combiner" )) + result=COMBINER; + else + { + cout << "\nErreur : nom de type de calcul inconnu !\n"; + cout << " nom_TypeCalcul = " << nom_TypeCalcul << '\n'; + cout << "Id_nom_TypeCalcul (string& nom_TypeCalcul) " << endl; + Sortie(1); + }; + return result; + +}; + +// Retourne l'identificateur de type enumere associe au nom du sous type de calcul +EnumSousTypeCalcul Id_nom_SousTypeCalcul (const string& nom_SousTypeCalcul) +{ + + EnumSousTypeCalcul result; + if ( nom_SousTypeCalcul == "aucun_sous_TYPE_de_CALCUL" ) result=aucun_soustypedecalcul; + else if ( nom_SousTypeCalcul == "avec_remontee_aux_valeurs_aux_noeuds" ) result=avec_remonte; + else if ( nom_SousTypeCalcul == "avec_remontee_et_calcul_d'erreur" ) result=avec_remonte_erreur; + else if ( nom_SousTypeCalcul == "avec_remonte_erreur_et_relocalion" ) result=avec_remonte_erreur_relocation; + else if ( nom_SousTypeCalcul == "avec_remontee_erreur_raffinement_et_relocation" ) + result=avec_remonte_erreur_raffinement_relocation; + else if ( nom_SousTypeCalcul == "uniquement_remontee" ) result=remonte; + else if ( nom_SousTypeCalcul == "remontee_et_erreur" )result=remonte_erreur; + else if ( nom_SousTypeCalcul == "remontee_erreur_et_relocation" ) result=remonte_erreur_relocation; + else if ( nom_SousTypeCalcul == "remontee_erreur_raffinement_et_relocation" ) + result=remonte_erreur_raffinement_relocation; + else if ( nom_SousTypeCalcul == "frontieres" ) result=frontieres; + else if ( nom_SousTypeCalcul == "visualisation" ) result=visualisation; + else if ( nom_SousTypeCalcul == "LinVersQuad" )result=LinVersQuad; + else if ( nom_SousTypeCalcul == "QuadIncVersQuadComp" )result=QuadIncVersQuadComp; + else if ( nom_SousTypeCalcul == "relocPtMilieuQuad" ) result=relocPtMilieuQuad; + else if ( nom_SousTypeCalcul == "sauveCommandesVisu" ) result=sauveCommandesVisu; + else if ( nom_SousTypeCalcul == "lectureCommandesVisu" ) result=lectureCommandesVisu; + else if ( nom_SousTypeCalcul == "commandeInteractive" ) result=commandeInteractive; + else if ( nom_SousTypeCalcul == "sauveMaillagesEnCours" ) result=sauveMaillagesEnCours; + else if ( nom_SousTypeCalcul == "extrusion2D3D" ) result=extrusion2D3D; + else if ( nom_SousTypeCalcul == "creation_reference" ) result=creation_reference; + else if ( nom_SousTypeCalcul == "prevision_visu_sigma" ) result=prevision_visu_sigma; + else if ( nom_SousTypeCalcul == "prevision_visu_epsilon" ) result=prevision_visu_epsilon; + else if ( nom_SousTypeCalcul == "prevision_visu_erreur" ) result=prevision_visu_erreur; + else if ( nom_SousTypeCalcul == "modif_orientation_element" ) result=modif_orientation_element; + else if ( nom_SousTypeCalcul == "creationMaillageSFE" ) result=creationMaillageSFE; + else if ( nom_SousTypeCalcul == "suppression_noeud_non_references" ) result=suppression_noeud_non_references; + else if ( nom_SousTypeCalcul == "renumerotation_des_noeuds" ) result=renumerotation_des_noeuds; + else if ( nom_SousTypeCalcul == "fusion_de_noeuds" ) result=fusion_de_noeuds; + else if ( nom_SousTypeCalcul == "fusion_elements" ) result=fusion_elements; + else if ( nom_SousTypeCalcul == "fusion_maillages" ) result=fusion_maillages; + else if ( nom_SousTypeCalcul == "cree_sous_maillage" ) result=cree_sous_maillage; + else if ( nom_SousTypeCalcul == "calcul_geometrique" ) result=calcul_geometrique; + else + { + cout << "\nErreur : nom de sous type de calcul inconnu !\n"; + cout << " nom_SousTypeCalcul = " << nom_SousTypeCalcul << '\n'; + cout << "Id_nom_SousTypeCalcul (string& nom_SousTypeCalcul)" << endl; + Sortie(1); + }; + return result; + +}; + + +// indique si le calcul est de type dynamique explicite ou non +bool DynamiqueExplicite(const EnumTypeCalcul id_TypeCalcul) +{ bool result=false; + switch (id_TypeCalcul) + { case DYNA_EXP : result=true; break; + case DYNA_EXP_TCHAMWA : result=true; break; + case DYNA_EXP_CHUNG_LEE: result=true; break; + case DYNA_EXP_ZHAI : result=true; break; + case DYNA_RUNGE_KUTTA : result=true; break; + case DYNA_EXP_BONELLI : result=true; break; + case RELAX_DYNA : result=true; break; + case STAT_DYNA_EXP : result=true; break; + case COMBINER : result=true; break; + default : + cout << "\nErreur : valeur incorrecte du type EnumTypeCalcul ! = " << id_TypeCalcul << "\n"; + cout << "DynamiqueExplicite(const EnumTypeCalcul id_TypeCalcul)" + << endl; + Sortie(1); + }; + return result; +}; + + +// indique si le calcul est de type implicite ou non +bool Implicite(const EnumTypeCalcul id_TypeCalcul) +{ bool result=false; + switch (id_TypeCalcul) + {case RIEN_TYPECALCUL : result=false; break; + case DYNA_IMP : result=true; break; + case DYNA_EXP : result=false; break; + case DYNA_EXP_TCHAMWA : result=false; break; + case DYNA_EXP_CHUNG_LEE: result=false; break; + case DYNA_EXP_ZHAI : result=false; break; + case DYNA_RUNGE_KUTTA : result=false; break; + case NON_DYNA : result=true; break; + case NON_DYNA_CONT : result=true; break; + case FLAMB_LINEAIRE : result=true; break; + case INFORMATIONS : result=false; break; + case UTILITAIRES : result=false; break; + case DEF_SCHEMA_XML : result=false; break; + case UMAT_ABAQUS : result=true; break; + case DYNA_EXP_BONELLI : result=false; break; + case RELAX_DYNA : result=false; break; + case STAT_DYNA_EXP : result=false; break; + case COMBINER : result=false; break; + default : + cout << "\nErreur : valeur incorrecte du type EnumTypeCalcul ! = " << id_TypeCalcul << "\n"; + cout << " Implicite(..." + << endl; + Sortie(1); + }; + return result; +}; + + +//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& entreePrinc,EnumTypeCalcul& typeCalcul,bool& avec_Calcul + ,list & sousTypeCalcul + ,list& avec_sousCalcul) + { // tout d'abord le type de calcul + int nbmot; // nb de mot du type principal + if ((strstr(entreePrinc.tablcar,"dynamique")!=NULL) && + (strstr(entreePrinc.tablcar,"implicite")!=NULL)) + { typeCalcul=DYNA_IMP; nbmot = 1; } + else if ((strstr(entreePrinc.tablcar,"dynamique")!=NULL) && + (strstr(entreePrinc.tablcar,"explicite")!=NULL) && + (strstr(entreePrinc.tablcar,"zhai")!=NULL)) + { typeCalcul=DYNA_EXP_ZHAI; nbmot = 1; } + else if ((strstr(entreePrinc.tablcar,"dynamique")!=NULL) && + (strstr(entreePrinc.tablcar,"Runge_Kutta")!=NULL)) + { typeCalcul=DYNA_RUNGE_KUTTA; nbmot = 1; } + else if ((strstr(entreePrinc.tablcar,"dynamique")!=NULL) && + (strstr(entreePrinc.tablcar,"explicite")!=NULL) && + (strstr(entreePrinc.tablcar,"chung_lee")!=NULL)) + { typeCalcul=DYNA_EXP_CHUNG_LEE; nbmot = 1; } + else if ((strstr(entreePrinc.tablcar,"dynamique")!=NULL) && + (strstr(entreePrinc.tablcar,"explicite")!=NULL) && + (strstr(entreePrinc.tablcar,"tchamwa")!=NULL)) + { typeCalcul=DYNA_EXP_TCHAMWA; nbmot = 1; } + else if ((strstr(entreePrinc.tablcar,"dynamique")!=NULL) && + (strstr(entreePrinc.tablcar,"explicite")!=NULL) && + (strstr(entreePrinc.tablcar,"bonelli")!=NULL)) + { typeCalcul=DYNA_EXP_BONELLI; nbmot = 1; } + else if ((strstr(entreePrinc.tablcar,"dynamique")!=NULL) && + (strstr(entreePrinc.tablcar,"relaxation")!=NULL) && + (strstr(entreePrinc.tablcar,"_dynam")!=NULL)) + { typeCalcul=RELAX_DYNA; nbmot = 1; } + else if (strstr(entreePrinc.tablcar,"mixte_statique_dynamique_explicite")!=NULL) + { typeCalcul=STAT_DYNA_EXP; nbmot = 1; } + else if (strstr(entreePrinc.tablcar,"combiner")!=NULL) + { typeCalcul=COMBINER; nbmot = 1; } + +// !!! attention !!! +// il faut que le cas dynamique_explicite soit le dernier, car sinon il est pris par défaut + else if ((strstr(entreePrinc.tablcar,"dynamique")!=NULL) && + (strstr(entreePrinc.tablcar,"explicite")!=NULL)) + { typeCalcul=DYNA_EXP; nbmot = 1; } + else if (strstr(entreePrinc.tablcar,"non_dynamique")!=NULL) + { typeCalcul=NON_DYNA; nbmot = 1; } + else if (strstr(entreePrinc.tablcar,"non_dyna_contact")!=NULL) + { typeCalcul=NON_DYNA_CONT; nbmot = 1; } + else if (strstr(entreePrinc.tablcar,"flamb_lineaire")!=NULL) + { typeCalcul=FLAMB_LINEAIRE; nbmot = 1; } + else if (strstr(entreePrinc.tablcar,"informations")!=NULL) + { typeCalcul=INFORMATIONS; nbmot = 1; } + else if (strstr(entreePrinc.tablcar,"utilitaires")!=NULL) + { typeCalcul=UTILITAIRES; nbmot = 1; } + else if (strstr(entreePrinc.tablcar,"def_schema_xml")!=NULL) + { typeCalcul=DEF_SCHEMA_XML; nbmot = 1; } + else if (strstr(entreePrinc.tablcar,"umat_abaqus")!=NULL) + { typeCalcul=UMAT_ABAQUS; nbmot = 1; } + else + { cout << "\nErreur : nom de type de calcul : " << entreePrinc.tablcar + << ", inconnu !\n"; + cout << "LectureTypeCalcul(UtilLecture& lec);" << endl; + Sortie(1); + }; + // décalage dans la lecture + string sous_type; + for (int i=1;i<= nbmot;i++) (*entreePrinc.entree) >> sous_type; + // on regarde si le prochain mot est "avec" si oui on valide le type principal + (*entreePrinc.entree) >> sous_type; sous_type = Minuscules (sous_type); + if ((sous_type.length() == 0)|| (entreePrinc.entree->rdstate())) +// #ifndef ENLINUX +// ( (entreePrinc.entree->rdstate() & ios_base::badbit) == ios_base::badbit)) +// #else +// ( (entreePrinc.entree->rdstate() & ios::badbit) == ios::badbit)) +// #endif + // cas ou le type est seul alors la validation est par défaut + avec_Calcul = true; + else // cas où il y a des sous types + {if (sous_type == "avec") + { avec_Calcul = true;} + else + { avec_Calcul=false;}; + // puis on lit les sous types avec leur validation éventuelle + // puis les sous-types eventuels + bool valide = true; + // dans le cas où on a lue "avec" il faut tout de suite lire le premier sous type + if (avec_Calcul) + (*entreePrinc.entree) >> sous_type; + EnumSousTypeCalcul enum_sous_type; + bool fin_lecture=false; // fin due à un manque d'info + while ((!entreePrinc.entree->rdstate())&&(!fin_lecture)) + { if (sous_type.length() != 0) + { if (sous_type == "plus") + {valide = true; + (*entreePrinc.entree) >> sous_type; + if (sous_type.length() == 0) + {cout << " \n *** erreur dans la lecture des sous_types de calcul," + << " présence du nom : plus, mais pas de sous_type qui suit !!" + << "\n LectureTypeCalcul(UtilLecture& entreePrinc,...) \n"; + Sortie(1); + }; + enum_sous_type=Id_nom_SousTypeCalcul(sous_type.c_str()); + // on sauvegarde dans la liste + sousTypeCalcul.push_back(enum_sous_type); + avec_sousCalcul.push_back(valide); + } + else + {valide = false; + (*entreePrinc.entree) >> sous_type; + if (sous_type.length() == 0) + {// cas où il n'y a pas de sous_type, normalement on devrait + // l'avoir détecté avant mais dans le cas ou il y aurait un "avec" + // et rien d'autre après + fin_lecture = true; + } + enum_sous_type=Id_nom_SousTypeCalcul(sous_type.c_str()); + // on sauvegarde dans la liste + sousTypeCalcul.push_back(enum_sous_type); + avec_sousCalcul.push_back(valide); + }; + } + else + {fin_lecture = true;}; + // arrivée ici on retente une lecture d'un autre sous type + (*entreePrinc.entree) >> sous_type; + + }; + }; + // on remet le flot de lecture dans sa position originale + entreePrinc.FlotDebutDonnee(); + + }; + +// 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 & sousTypeCalcul + ,list& avec_sousCalcul) + { int num; + int nbmot; // nb de mot du type principal + //cout << "\n "; + string rep; bool choix_valide=false; + cout << "\n ==>Type principal de calcul (defaut 7) : ? "; + while (!choix_valide) + { + try + { + cout + << "\n (1) dynamique_implicite (2) dynamique_explicite_zhai " + << "\n (3) dynamique_explicite_chung_lee (4) dynamique_explicite_tchamwa " + << "\n (5) dynamique_explicite (6) dynamique_Runge_Kutta " + << "\n (7) non_dynamique (8) non_dyna_contact" + << "\n (9) flamb_lineaire (10) informations " + << "\n (11) utilitaires (12) umat_abaqus " + << "\n (13) dynamique_explicite_bonelli (14) dynamique_relaxation_dynam " + << "\n (15) combiner " + << " "<< endl; + rep = "_"; + int c = std::cin.peek(); // peek character (sans changer le flux !!) + if (( c == EOF )||(c=='\n')) + {rep = "7"; + cout << "--> valeur par defaut : 7 "< valeur par defaut : 7 "<= 1)&&(num<=15)) + { choix_valide=true;} + else { cout << "\n Erreur on attendait un entier entre 1 et 15 !!, " + << "\n redonnez une bonne valeur" + << "\n ou taper fin_prog pour arreter le programme"; + choix_valide=false; + }; + switch (num) + { case 1: //"dynamique_implicite") + { typeCalcul=DYNA_IMP; nbmot = 1; break;} + case 2: // "dynamique_explicite_zhai") + { typeCalcul=DYNA_EXP_ZHAI; nbmot = 1; break;} + case 3: // "dynamique_explicite_chung_lee") + { typeCalcul=DYNA_EXP_CHUNG_LEE; nbmot = 1; break;} + case 4: // "dynamique_explicite_tchamwa") + { typeCalcul=DYNA_EXP_TCHAMWA; nbmot = 1; break;} + case 5: // "dynamique_explicite") + { typeCalcul=DYNA_EXP; nbmot = 1; break;} + case 6: // "dynamique_Runge_Kutta") + { typeCalcul=DYNA_RUNGE_KUTTA; nbmot = 1; break;} + case 7: // "non_dynamique") + { typeCalcul=NON_DYNA; nbmot = 1; break;} + case 8: // "non_dyna_contact") + { typeCalcul=NON_DYNA_CONT; nbmot = 1; break;} + case 9: // "flamb_lineaire") + { typeCalcul=FLAMB_LINEAIRE; nbmot = 1; break;} + case 10: // "informations") + { typeCalcul=INFORMATIONS; nbmot = 1; break;} + case 11: // "utilitaires") + { typeCalcul=UTILITAIRES; nbmot = 1; break;} + case 12: // "umat abaqus") + { typeCalcul=UMAT_ABAQUS; nbmot = 1; break;} + case 13: // "dynamique_explicite_bonelli") + { typeCalcul=DYNA_EXP_BONELLI; nbmot = 1; break;} + case 14: // "dynamique_relaxation_dynam") + { typeCalcul=RELAX_DYNA; nbmot = 1; break;} +// case 15: // "mixte_statique_dynamique_explicite") +// { typeCalcul=STAT_DYNA_EXP; nbmot = 1; break;} + case 15: // "combiné") + { typeCalcul=COMBINER; nbmot = 1; break;} + } + } + catch (ErrSortieFinale) + // cas d'une direction voulue vers la sortie + // on relance l'interuption pour le niveau supérieur + { ErrSortieFinale toto; + throw (toto); + } + catch (...)//(UtilLecture::ErrNouvelleDonnee erreur) + { cout << "\n Erreur on attendait un des mots clés proposés !!, " + << "\n redonnez une bonne valeur" + << "\n ou taper fin_prog pour arreter le programme"; + choix_valide=false; + }; + }; //-- fin du while + cout << "--> choix: " << Nom_TypeCalcul(typeCalcul) << endl; + + // cas du sous type de calcul + cout << "\n ==> Sous type de calcul souhaite (defaut 5) : ? "; + EnumSousTypeCalcul enum_sous_type;choix_valide=false; + rep = " "; + string chaine_a_ecrire=" "; + int indic_avec_Calcul = 0; // on initialise une variable entière car pb avec les booléens + cout + << "\n (0) (pas de sous type) (f) fin " + << "\n (1) avec_remonte (2) remonte " + << "\n (3) avec_remonte_erreur (4) remonte_erreur" + << "\n (5) avec plus visualisation (6) visualisation" + << "\n (7) frontieres (8) lineaire -> quadra incomplet" + << "\n (9) quadra incomplet -> quadra complet" + << "\n (10) reloc pt milieu Quadra (11) sauveCommandesVisu" + << "\n (12) lectureCommandesVisu (13) prevision_visu_sigma " + << "\n (14) prevision_visu_epsilon (15) prevision_visu_erreur" + << "\n (16) commandeInteractive (17) sauveMaillagesEnCours " + << "\n (18) extrusion2D3D (19) creation_de_references " + << "\n (20) modif_orientation_element (21) creationMaillageSFE " + << "\n (22) suppression_noeud_non_references (23) renumerotation_des_noeuds " + << "\n (24) fusion_de_noeuds (25) fusion_elements " + << "\n (26) fusion_maillages (27) cree_sous_maillage " + << "\n (28) calcul_geometrique \n " + << endl; + bool non_choix_defaut=false; // pour controller une sortie d'un choix par défaut + while ((!choix_valide) || (!((rep == "f")||(rep == "0"))) // (!(choix_valide || (rep != "f")||(rep != "0"))) + && !non_choix_defaut + ) + { + try + { + rep = "_"; + int c = std::cin.peek(); // peek character (sans changer le flux !!) + if (( c == EOF )||(c=='\n')) + {rep = "5"; + cout << "--> valeur par defaut : 5 "< valeur par defaut : 5 "<= -1)&&(num<=28)) + { choix_valide=true; } + else { cout << "\n Erreur on attendait un entier entre 0 et 26 !!, " + << "\n redonnez une bonne valeur" + << "\n ou taper fin_prog pour arreter le programme"; + choix_valide=false; + } + switch (num) + { case -1: //pas de sous type + { indic_avec_Calcul +=0;enum_sous_type= aucun_soustypedecalcul; break;} + case 0: //pas de sous type + { indic_avec_Calcul +=1;enum_sous_type= aucun_soustypedecalcul; break;} + case 1: // avec_remonte + { indic_avec_Calcul +=1;enum_sous_type= avec_remonte; break;} + case 2: // remonte + { indic_avec_Calcul += 0 ;enum_sous_type= remonte; break;} + case 3: // avec_remonte_erreur + { indic_avec_Calcul +=1;enum_sous_type= avec_remonte_erreur; break;} + case 4: // remonte_erreur + { indic_avec_Calcul += 0;enum_sous_type= remonte_erreur; break;} + case 5: // avec plus visualisation + { indic_avec_Calcul +=1;enum_sous_type= visualisation; break;} + case 6: // visualisation + { indic_avec_Calcul += 0;enum_sous_type= visualisation; break;} + case 7: // frontieres + { indic_avec_Calcul += 0;enum_sous_type= frontieres; break;} + case 8: // transformation lineaire en quadratique incomplet + { indic_avec_Calcul += 0;enum_sous_type= LinVersQuad; break;} + case 9: // transformation quadratique incomplet en quadratique complet + { indic_avec_Calcul += 0;enum_sous_type= QuadIncVersQuadComp; break;} + case 10: // transformation quadratique incomplet en quadratique complet + { indic_avec_Calcul += 0;enum_sous_type= relocPtMilieuQuad; break;} + case 11: // sauvegarde des commandes de visualisation + { indic_avec_Calcul += 0;enum_sous_type= sauveCommandesVisu; break;} + case 12: // lecture des commandes de visualisation + { indic_avec_Calcul += 0;enum_sous_type= lectureCommandesVisu; break;} + case 13: // visualisation automatique par fichier de commande + { indic_avec_Calcul += 0;enum_sous_type= prevision_visu_sigma; break;} + case 14: // visualisation automatique par fichier de commande + { indic_avec_Calcul += 0;enum_sous_type= prevision_visu_epsilon; break;} + case 15: // visualisation automatique par fichier de commande + { indic_avec_Calcul += 0;enum_sous_type= prevision_visu_erreur; break;} + case 16: // prise en compte interactive de commande + { indic_avec_Calcul += 0;enum_sous_type= commandeInteractive; break;} + case 17: // prise en compte interactive de commande + { indic_avec_Calcul += 0;enum_sous_type= sauveMaillagesEnCours; break;} + case 18: // prise en compte interactive de commande + { indic_avec_Calcul += 0;enum_sous_type= extrusion2D3D; break;} + case 19: // création de références + { indic_avec_Calcul += 0;enum_sous_type= creation_reference; break;} + case 20: // modification de l'orientation des éléments + { indic_avec_Calcul += 0;enum_sous_type= modif_orientation_element; break;} + case 21: // création de maillages SFE + { indic_avec_Calcul += 0;enum_sous_type= creationMaillageSFE; break;} + case 22: // suppression des noeuds non referencés + { indic_avec_Calcul += 0;enum_sous_type= suppression_noeud_non_references; break;} + case 23: // renumerotation des noeuds + { indic_avec_Calcul += 0;enum_sous_type= renumerotation_des_noeuds; break;} + case 24: // fusion de noeuds + { indic_avec_Calcul += 0;enum_sous_type= fusion_de_noeuds; break;} + case 25: // fusion d'éléments + { indic_avec_Calcul += 0;enum_sous_type= fusion_elements; break;} + case 26: // fusion de maillages + { indic_avec_Calcul += 0;enum_sous_type= fusion_maillages; break;} + case 27: // création d'un sous maillage + { indic_avec_Calcul += 0;enum_sous_type= cree_sous_maillage; break;} + case 28: // calculs géométriques + { indic_avec_Calcul += 0;enum_sous_type= calcul_geometrique; break;} + } + if (choix_valide) + {// comme il ne s'agit pas de faire un calcul (pour l'instant) on met systématiquement + // avec_Calcul true pour que dans projet il y ait effectivement création de l'algo + // peut-être par la suite il faudra modifier, donc on laisse les cas dans les case précédents + if (enum_sous_type != aucun_soustypedecalcul) + chaine_a_ecrire += " plus " + Nom_SousTypeCalcul(enum_sous_type); + // on sauvegarde dans la liste + sousTypeCalcul.push_back(enum_sous_type); + avec_sousCalcul.push_back(true); + if (chaine_a_ecrire != " ") + cout << "--> choix: " << chaine_a_ecrire << endl; + else + cout << "--> choix: aucun sous type " << endl; + }; + if ((rep == "f")||(rep == "0")) + // on veut l'arrêt + choix_valide=true; + } + catch (ErrSortieFinale) + // cas d'une direction voulue vers la sortie + // on relance l'interuption pour le niveau supérieur + { ErrSortieFinale toto; + throw (toto); + } + catch (...)//(UtilLecture::ErrNouvelleDonnee erreur) + { cout << "\n Erreur on attendait un des mots clés proposés !!, " + << "\n redonnez une bonne valeur" + << "\n ou taper fin_prog pour arreter le programme"; + choix_valide=false; + }; + }; //-- fin du while + if ((indic_avec_Calcul)&&(chaine_a_ecrire != " ")) // on indique si on veut ou non un calcul + chaine_a_ecrire = " avec " + chaine_a_ecrire; + if(chaine_a_ecrire != " ") cout << "\n choix global: " << chaine_a_ecrire << endl; + // écriture dans le fichier de commande + ofstream & sort = *(lec.Commande_pointInfo()); // pour simplifier + sort << "\n#-------------------------------" + << "\n# definition du type de calcul |" + << "\n#-------------------------------" + << "\n TYPE_DE_CALCUL" + << "\n \n"<< Nom_TypeCalcul(typeCalcul) ; + if(chaine_a_ecrire != " ") + sort << chaine_a_ecrire; + sort << endl; + // mise à jour du booléen de calcul, ici par défaut = 1, pour que l'algo continue + avec_Calcul = true; + +} ; + +// indique s'il y a remonte ou pas dans le sous-type +bool Remonte_in(const EnumSousTypeCalcul sousTypeCalcul) + { //if (Nom_SousTypeCalcul(sousTypeCalcul) == "remonte") + if ( Nom_SousTypeCalcul(sousTypeCalcul).find("remonte") != -1) + return true; + return false; + }; + + +// indique s'il y a "avec" ou pas dans le sous-type +bool Avec_in(const EnumSousTypeCalcul sousTypeCalcul) + { //if (Nom_SousTypeCalcul (sousTypeCalcul) == "avec") + if ( Nom_SousTypeCalcul(sousTypeCalcul).find("avec") != -1) + return true; + return false ; + }; + + +// indique s'il y a erreur dans le sous-type +bool Erreur_in(const EnumSousTypeCalcul sousTypeCalcul) + { //if (Nom_SousTypeCalcul (sousTypeCalcul) == "erreur") + if ( Nom_SousTypeCalcul(sousTypeCalcul).find("erreur") != -1) + return true; + return false ; + }; + +// indique s'il y a un sous-type ou pas -> retour vrai s'il y a un sous type +bool SousType(const EnumSousTypeCalcul sousTypeCalcul) + { bool retour = true; + if (sousTypeCalcul==aucun_soustypedecalcul) + retour = false; + return retour; + }; + + // surcharge de l'operator de lecture +istream & operator >> (istream & entree, EnumTypeCalcul& a) + { char nom_EnumTypeCalcul[150]; + entree >> nom_EnumTypeCalcul; + a = Id_nom_TypeCalcul ( nom_EnumTypeCalcul); + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnumTypeCalcul& a) + { // on ecrit la forme caractère + sort << Nom_TypeCalcul(a) << " "; + return sort; + }; + + // surcharge de l'operator de lecture +istream & operator >> (istream & entree, EnumSousTypeCalcul& a) + { char nom_EnumSousTypeCalcul[150]; + entree >> nom_EnumSousTypeCalcul; + a = Id_nom_SousTypeCalcul ( nom_EnumSousTypeCalcul); + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnumSousTypeCalcul& a) + { // on ecrit la forme caractère + sort << Nom_SousTypeCalcul(a) << " "; + return sort; + }; +//--------------------- 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) +{string result; + switch (id_evolution_temporelle) + { case STATIQUE : result="STATIQUE"; break; + case TRANSITOIRE : result="TRANSITOIRE"; break; + case DYNAMIQUE : result="DYNAMIQUE"; break; + case AUCUNE_EVOLUTION : result="AUCUNE_EVOLUTION"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_evolution_temporelle !\n"; + cout << "string Nom_evolution_temporelle (const Enum_evolution_temporelle id_evolution_temporelle)" + << id_evolution_temporelle << endl; + Sortie(1); + }; + return result; +}; + +// 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) +{Enum_evolution_temporelle result; + if ( nom_evolution_temporelle == "STATIQUE" ) + {result=STATIQUE;} + else if ( nom_evolution_temporelle == "TRANSITOIRE" ) + {result=TRANSITOIRE;} + else if ( nom_evolution_temporelle == "DYNAMIQUE" ) + {result=DYNAMIQUE;} + else if ( nom_evolution_temporelle == "AUCUNE_EVOLUTION" ) + {result=AUCUNE_EVOLUTION;} + else + { + cout << "\nErreur : nom de type d'evolution temporelle inconnu !\n"; + cout << " nom_evolution_temporelle = " << nom_evolution_temporelle << '\n'; + cout << "Id_nom_evolution_temporelle (const string& nom_evolution_temporelle) " << endl; + Sortie(1); + }; + // retour + return result; +}; + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_evolution_temporelle& a) + { char nom_evolution_temporelle[150]; + entree >> nom_evolution_temporelle; + a = Id_nom_evolution_temporelle( nom_evolution_temporelle); + return entree; + }; + +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_evolution_temporelle& a) + { // on ecrit la forme caractère + sort << Nom_evolution_temporelle(a) << " "; + return sort; + }; + diff --git a/Enumeration/EnumTypeCalcul.h b/Enumeration/EnumTypeCalcul.h new file mode 100644 index 0000000..b198f55 --- /dev/null +++ b/Enumeration/EnumTypeCalcul.h @@ -0,0 +1,172 @@ +/*! \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) . +// +// Herezh++ is distributed under GPL 3 license ou ultérieure. +// +// Copyright (C) 1997-2021 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: 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 +using namespace std; +#include "UtilLecture.h" +#include + +/// @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 & sousTypeCalcul + ,list& 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 & sousTypeCalcul + ,list& 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 diff --git a/Enumeration/EnumTypeGradient.cc b/Enumeration/EnumTypeGradient.cc new file mode 100644 index 0000000..0743f12 --- /dev/null +++ b/Enumeration/EnumTypeGradient.cc @@ -0,0 +1,119 @@ +// FICHIER EnumTypeGradient.cc + + +// 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-2021 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: . + + +#include "EnumTypeGradient.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + +#ifndef Enum_type_gradient_deja_inclus + +#ifndef MISE_AU_POINT + inline +#endif +char* Nom_type_gradient (Enum_type_gradient id_nom) +// Retourne le nom du type de gradient associe +// a l'identificateur de type enumere id_nom +{ char* result=""; + switch (id_nom) + { case GRADVITESSE_V_TDT : result=" GRADVITESSE_V_TDT"; break; + case GRADVITESSE_VCONST : result="GRADVITESSE_VCONST"; break; + case GRADVITESSE_VT_VTDT : result="GRADVITESSE_VT_VTDT"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_type_gradient !\n"; + cout << "Nom_type_gradient(Enum_type_gradient ) \n"; + Sortie(1); + }; + return result; +}; + +#ifndef MISE_AU_POINT + inline +#endif +Enum_type_gradient Id_nom_type_gradient (char* nom) +// Retourne la variable de type enumere associee au nom du type de gradient +{ Enum_type_gradient result; + if ( strcmp(nom,"GRADVITESSE_V_TDT")==0 ) + result=GRADVITESSE_V_TDT; + else if ( strcmp(nom,"GRADVITESSE_VCONST")==0 ) + result=GRADVITESSE_VCONST; + else if ( strcmp(nom,"GRADVITESSE_VT_VTDT")==0 ) + result=GRADVITESSE_VT_VTDT; + else + { cout << "\nErreur : nom du degre de liberte inconnu !\n"; + cout << "Id_nom_type_gradient (char* nom) \n"; + Sortie(1); + }; + return result; +}; + + + // surcharge de l'operator de lecture +#ifndef MISE_AU_POINT + inline +#endif +istream & operator >> (istream & entree, Enum_type_gradient& a) + { char nom_Enum_type_gradient[50]; + entree >> nom_Enum_type_gradient; + a = Id_nom_type_gradient ( nom_Enum_type_gradient); + return entree; + }; + + // surcharge de l'operator d'ecriture +#ifndef MISE_AU_POINT + inline +#endif +ostream & operator << (ostream & sort, const Enum_type_gradient& a) + { // on ecrit la forme caractère + sort << Nom_type_gradient(a) << " "; + return sort; + }; + +#endif + + + + + diff --git a/Enumeration/EnumTypeGradient.h b/Enumeration/EnumTypeGradient.h new file mode 100644 index 0000000..d037e69 --- /dev/null +++ b/Enumeration/EnumTypeGradient.h @@ -0,0 +1,106 @@ +/*! \file EnumTypeGradient.h + \brief def du gradient de vitesse pour différentes conditions +* \date 28/03/2003 +*/ + +// FICHIER : EnumTypeGradient.h + +// 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-2021 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: 28/03/2003 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Défini une énumération des différents types de calcul du * + * gradient de vitesse. * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ +// Afin de realiser un gain en place memoire, et une vérification de type plus aisé qu' avec +// les entiers + + +#ifndef ENUM_TYPE_GRADIENT_V_H +#define ENUM_TYPE_GRADIENT_V_H + +//#include "Debug.h" +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + + +// ---------- info -------------------------- +/// def du gradient de vitesse pour différentes conditions +// +// GRADVITESSE_V_TDT : le gradient est déterminé à partir de ddl de vitesse à t+dt +// GRADVITESSE_VCONST : calcul en considérant V constant =delta X/delta t dans la config à t+(delta t)/2 +// GRADVITESSE_VT_VTDT : calcul à partir des ddl de vitesse : moyenne de t et t+dt, dans la config +// à t+(delta t)/2 + + +enum Enum_type_gradient { GRADVITESSE_V_TDT=1, GRADVITESSE_VCONST, GRADVITESSE_VT_VTDT}; +/// @} // end of group + +// Retourne le nom du type de gradient a partir de son identificateur de +// type enumere id_ddl correspondant +char* Nom_type_gradient ( Enum_type_gradient id_ddl); + +// Retourne l'identificateur de type enumere associe au nom du type de gradient + Enum_type_gradient Id_nom_type_gradient (char* nom_ddl); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_type_gradient& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_type_gradient& a); + +// pour faire de l'inline +#ifndef MISE_AU_POINT + #include "EnumTypeGradient.cc" + #define Enum_type_gradient_deja_inclus +#endif + +#endif diff --git a/Enumeration/EnumTypeGrandeur.cc b/Enumeration/EnumTypeGrandeur.cc new file mode 100644 index 0000000..2aea685 --- /dev/null +++ b/Enumeration/EnumTypeGrandeur.cc @@ -0,0 +1,247 @@ +// FICHIER : EnumTypeGrandeur.cp + +// 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-2021 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: . + + + +#include "EnumTypeGrandeur.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include +#include "ParaGlob.h" + +// tout d'abord on définit la map qui permet de relier les chaines et les types énumérés + // 1) def de la map + map < string, EnumTypeGrandeur , std::less < string> > + ClassPourEnumTypeGrandeur::map_EnumTypeGrandeur; + map < string, EnumType2Niveau , std::less < string> > + ClassPourEnumTypeGrandeur::map_EnumType2Niveau; + // 2) def de la grandeur statique qui permet de remplir la map + ClassPourEnumTypeGrandeur ClassPourEnumTypeGrandeur::remplir_map; + // le constructeur qui rempli effectivement la map + ClassPourEnumTypeGrandeur::ClassPourEnumTypeGrandeur() + { // pour les types de base + map_EnumTypeGrandeur["RIEN_TYPEGRANDEUR"]=RIEN_TYPEGRANDEUR; + map_EnumTypeGrandeur["SCALAIRE"]=SCALAIRE; + map_EnumTypeGrandeur["VECTEUR"]=VECTEUR; + map_EnumTypeGrandeur["TENSEUR"]=TENSEUR; + map_EnumTypeGrandeur["TENSEUR_NON_SYM"]=TENSEUR_NON_SYM; + map_EnumTypeGrandeur["SCALAIRE_ENTIER"]=SCALAIRE_ENTIER; + map_EnumTypeGrandeur["SCALAIRE_DOUBLE"]=SCALAIRE_DOUBLE; + map_EnumTypeGrandeur["TENSEURBB"]=TENSEURBB; + map_EnumTypeGrandeur["TENSEURHH"]=TENSEURHH; + map_EnumTypeGrandeur["TENSEURBH"]=TENSEURBH; + map_EnumTypeGrandeur["TENSEURHB"]=TENSEURHB; + map_EnumTypeGrandeur["TENSEUR_NON_SYM_BB"]=TENSEUR_NON_SYM_BB; + map_EnumTypeGrandeur["TENSEUR_NON_SYM_HH"]=TENSEUR_NON_SYM_HH; + map_EnumTypeGrandeur["COORDONNEE"]=COORDONNEE; + map_EnumTypeGrandeur["COORDONNEEB"]=COORDONNEEB; + map_EnumTypeGrandeur["COORDONNEEH"]=COORDONNEEH; + map_EnumTypeGrandeur["BASE__H"]=BASE__H; + map_EnumTypeGrandeur["BASE__B"]=BASE__B; + map_EnumTypeGrandeur["CHAINE_CAR"]=CHAINE_CAR; + map_EnumTypeGrandeur["GRANDEUR_QUELCONQUE"]=GRANDEUR_QUELCONQUE; + // pour les structures secondaires + map_EnumType2Niveau["TYPE_SIMPLE"]=TYPE_SIMPLE; + map_EnumType2Niveau["TABLEAU_T"]=TABLEAU_T; + map_EnumType2Niveau["TABLEAU2_T"]=TABLEAU2_T; + map_EnumType2Niveau["LISTE_T"]=LISTE_T; + map_EnumType2Niveau["LISTE_IO_T"]=LISTE_IO_T; + map_EnumType2Niveau["MAP_T"]=MAP_T; + map_EnumType2Niveau["VECTOR_T"]=VECTOR_T; + }; + +string NomTypeGrandeur(EnumTypeGrandeur id_typeGrandeur) +// Retourne le nom du type de grandeur correspondant a l'identificateur +// de type enumere id_typeGrandeur + {string result; + switch (id_typeGrandeur) + {case RIEN_TYPEGRANDEUR : result="RIEN_TYPEGRANDEUR"; break; + case SCALAIRE : result="SCALAIRE"; break; + case VECTEUR : result="VECTEUR"; break; + case TENSEUR : result="TENSEUR"; break; + case TENSEUR_NON_SYM : result="TENSEUR_NON_SYM"; break; + case SCALAIRE_ENTIER : result="SCALAIRE_ENTIER"; break; + case SCALAIRE_DOUBLE : result="SCALAIRE_DOUBLE"; break; + case TENSEURBB : result="TENSEURBB"; break; + case TENSEURHH : result="TENSEURHH"; break; + case TENSEURBH : result="TENSEURBH"; break; + case TENSEURHB : result="TENSEURHB"; break; + case TENSEUR_NON_SYM_BB : result="TENSEUR_NON_SYM_BB"; break; + case TENSEUR_NON_SYM_HH : result="TENSEUR_NON_SYM_HH"; break; + case COORDONNEE : result="COORDONNEE"; break; + case COORDONNEEB : result="COORDONNEEB"; break; + case COORDONNEEH : result="COORDONNEEH"; break; + case BASE__H : result="BASE__H"; break; + case BASE__B : result="BASE__B"; break; + case CHAINE_CAR : result="CHAINE_CAR"; break; + case GRANDEUR_QUELCONQUE : result="GRANDEUR_QUELCONQUE"; break; + default : + cout << "\nErreur : valeur incorrecte du type EnumTypeGrandeur !\n"; + cout << "NomTypeGrandeur(EnumTypeGrandeur ) \n"; + Sortie(1); + }; + return result; + }; + +string NomType2Niveau(EnumType2Niveau id_Type2Niveau) +// Retourne le nom du type de grandeur correspondant a l'identificateur +// de type enumere id_Type2Niveau +{ string result; + switch (id_Type2Niveau) + { case TYPE_SIMPLE : result="TYPE_SIMPLE"; break; + case TABLEAU_T : result="TABLEAU_T"; break; + case TABLEAU2_T : result="TABLEAU2_T"; break; + case LISTE_T : result="LISTE_T"; break; + case LISTE_IO_T : result="LISTE_IO_T"; break; + case MAP_T : result="MAP_T"; break; + case VECTOR_T : result="VECTOR_T"; break; + default : + cout << "\nErreur : valeur incorrecte du type EnumType2Niveau !\n"; + cout << "NomTypeGrandeur(EnumTypeGrandeur ) \n"; + Sortie(1); + }; + return result; +}; + +EnumTypeGrandeur Id_nomTypeGrandeur (string nom_typeGrandeur) +// Retourne la variable de type enumere associe au nom nom_typeGrandeur +{ // on vérifie si la variable de type enumere existe + map < string, EnumTypeGrandeur , std::less < string> >& maa=ClassPourEnumTypeGrandeur::map_EnumTypeGrandeur; + map < string, EnumTypeGrandeur , std::less < string> >::iterator il,ilfin= maa.end(); + string toto; + il = maa.find(nom_typeGrandeur); + if (il == maa.end()) + {// on vérifie si la variable de type enumere existe + cout << "\nErreur : nom du type de grandeur '" < >& maa=ClassPourEnumTypeGrandeur::map_EnumType2Niveau; + map < string, EnumType2Niveau , std::less < string> >::iterator il,ilfin= maa.end(); + string toto; + il = maa.find(nom_Type2Niveau); + if (il == maa.end()) + {// on vérifie si la variable de type enumere existe + cout << "\nErreur : nom du type de grandeur '" <> (istream & entree, EnumTypeGrandeur & result) + { string nom_typeGrandeur; + entree >> nom_typeGrandeur; + result = Id_nomTypeGrandeur ( nom_typeGrandeur); + return entree; + }; + + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnumTypeGrandeur& a) + { // on ecrit la forme caractère + sort << NomTypeGrandeur(a) << " "; + return sort; + }; + diff --git a/Enumeration/EnumTypeGrandeur.h b/Enumeration/EnumTypeGrandeur.h new file mode 100644 index 0000000..93dbc08 --- /dev/null +++ b/Enumeration/EnumTypeGrandeur.h @@ -0,0 +1,111 @@ +/*! \file EnumTypeGrandeur.h + \brief def de l'enuméré concernant les types de structures de grandeurs +*/ +// FICHIER : EnumTypeGrandeur.h + +// 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-2021 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: . + + +// Afin de realiser un gain en place memoire, les noms des types de grandeurs sont +// stockes a l'aide d'un type enumere. Les fonctions NomTypeGrandeur et Id_nomTypeGrandeur rendent +// possible le lien entre des noms grandeur et les identificateurs +// de type enumere correspondants. + + +#ifndef ENUMTYPEGRANDEUR_H +#define ENUMTYPEGRANDEUR_H +#include +using namespace std; +#include + +/// @addtogroup Group_types_enumeres +/// @{ + +/// un énuméré pour les types de base +enum EnumTypeGrandeur { RIEN_TYPEGRANDEUR = 0, SCALAIRE, VECTEUR, TENSEUR, TENSEUR_NON_SYM + ,SCALAIRE_ENTIER,SCALAIRE_DOUBLE,TENSEURBB,TENSEURHH,TENSEURBH,TENSEURHB + ,TENSEUR_NON_SYM_BB,TENSEUR_NON_SYM_HH + ,COORDONNEE,COORDONNEEB,COORDONNEEH + ,BASE__H, BASE__B + ,CHAINE_CAR,GRANDEUR_QUELCONQUE}; +/// @} // end of group + +/// @addtogroup Group_types_enumeres +/// @{ + +/// un énuméré pour les types de structure +enum EnumType2Niveau { TYPE_SIMPLE = 0, TABLEAU_T, TABLEAU2_T, LISTE_T, LISTE_IO_T, MAP_T, VECTOR_T }; +/// @} // end of group + +/// @addtogroup Group_types_enumeres +/// @{ + +/// def de map qui fait la liaison entre les string et les énumérés + +class ClassPourEnumTypeGrandeur +{ public: + /// def de map qui fait la liaison entre les string et les énumérés + static map < string, EnumTypeGrandeur , std::less < string> > map_EnumTypeGrandeur; + static map < string, EnumType2Niveau , std::less < string> > map_EnumType2Niveau; + // def de la grandeur statique qui permet de remplir les map + static ClassPourEnumTypeGrandeur remplir_map; + // le constructeur qui rempli effectivement la map + ClassPourEnumTypeGrandeur(); + }; +/// @} // end of group + +// Retourne le nom du type de grandeur a partir de son identificateur de +// type enumere id_typeGrandeur correspondant +string NomTypeGrandeur (EnumTypeGrandeur id_typeGrandeur); +// idem pour le type secondaire +string NomType2Niveau (EnumType2Niveau id_Type2Niveau ); + +// Retourne l'identificateur de type enumere associe au nom du type de grandeur +// nom_typeGrandeur +EnumTypeGrandeur Id_nomTypeGrandeur (string nom_typeGrandeur); +// item pour le type secondaire +EnumType2Niveau Id_nomType2Niveau (string nom_Type2Niveau ); + +// Retourne le nombre d'éléments de la grandeur en fonction de la dimension +// exemple en dimension 3, pour un scalaire retourne 1, pour un vecteur 3 +// pour un tenseur (a priori symétrique) 6 +// pour un tenseur non symétrique 9 +// RIEN_TYPEGRANDEUR 0 +// pour le cas particulier GRANDEUR_QUELCONQUE : retourne -1 +int NombreElementFoncDim(EnumTypeGrandeur id_typeGrandeur); + +// indique si c'est un type numérique ou non +bool Type_grandeur_numerique(EnumTypeGrandeur id_typeGrandeur); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, EnumTypeGrandeur& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnumTypeGrandeur& a); + +#endif diff --git a/Enumeration/EnumTypePilotage.cc b/Enumeration/EnumTypePilotage.cc new file mode 100644 index 0000000..7309233 --- /dev/null +++ b/Enumeration/EnumTypePilotage.cc @@ -0,0 +1,121 @@ +// FICHIER : EnumTypePilotage.cc + +// 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-2021 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: . + + + +#include "EnumTypePilotage.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + +#include "UtilLecture.h" + +char* Nom_TypePilotage (const EnumTypePilotage id_TypePilotage) +// Retourne le nom de la loi de TypePilotage correspondant a l'identificateur +// de type enumere id_TypePilotage +{ + + char* result; + switch (id_TypePilotage) + { + case PILOTAGE_BASIQUE : result="PILOTAGE_BASIQUE"; break; + case PILOT_GRADIENT : result="PILOT_GRADIENT"; break; + case AUCUN_PILOTAGE : result="AUCUN_PILOTAGE"; break; + default : + cout << "\nErreur : valeur incorrecte du type EnumTypePilotage !\n"; + cout << "Nom_TypePilotage(const EnumTypePilotage id_TypePilotage) \n"; + Sortie(1); + }; + return result; + +}; + +EnumTypePilotage Id_nom_TypePilotage (const char* nom_TypePilotage) +// Retourne la variable de type enumere associee au nom +// de TypePilotage nom_TypePilotage +{ + EnumTypePilotage result; + if ( strcmp(nom_TypePilotage,"PILOTAGE_BASIQUE")==0 ) result=PILOTAGE_BASIQUE; + else if ( strcmp(nom_TypePilotage,"PILOT_GRADIENT")==0 ) result=PILOT_GRADIENT; + else if ( strcmp(nom_TypePilotage,"AUCUN_PILOTAGE")==0 ) result=AUCUN_PILOTAGE; + else + { + cout << "\nErreur : nom du type de pilotage: " << nom_TypePilotage << " inconnu !\n"; + cout << "Id_nom_TypePilotage(char* ) \n"; + Sortie(1); + }; + return result; + +}; + +// retourne si la chaine de caractère existe ou pas en tant que EnumTypePilotage +bool Existe_dans_TypePilotage(const char* nom_TypePilotage) +{ bool retour; + if ( strcmp(nom_TypePilotage,"PILOTAGE_BASIQUE")==0 ) {retour=true;} + else if ( strcmp(nom_TypePilotage,"PILOT_GRADIENT")==0 ) {retour=true;} + else if ( strcmp(nom_TypePilotage,"AUCUN_PILOTAGE")==0 ) {retour=true;} + else {retour = false;}; + return retour; +}; + + // surcharge de l'operator de lecture +istream & operator >> (istream & entree, EnumTypePilotage& a) + { char nom_EnumTypePilotage[50]; + entree >> nom_EnumTypePilotage; + if (Existe_dans_TypePilotage(nom_EnumTypePilotage)) + {a = Id_nom_TypePilotage ( nom_EnumTypePilotage);} + else + { cout << "\n erreur en lecture d'un type de pilotage, chaine lue: " << nom_EnumTypePilotage; + throw (UtilLecture::ErrNouvelleDonnee(-1)); + Sortie(1); + }; + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnumTypePilotage& a) + { // on ecrit la forme caractère + sort << Nom_TypePilotage(a) << " "; + return sort; + }; + + diff --git a/Enumeration/EnumTypePilotage.h b/Enumeration/EnumTypePilotage.h new file mode 100644 index 0000000..38352b0 --- /dev/null +++ b/Enumeration/EnumTypePilotage.h @@ -0,0 +1,69 @@ +/*! \file EnumTypePilotage.h + \brief def de l'enuméré concernant les types de pilotage +*/ +// FICHIER : EnumTypePilotage.h + +// 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-2021 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: . + + +// Afin de realiser un gain en place memoire, les noms des types de pilotage sont +// stockes a l'aide d'un type enumere. Les fonctions Nom_TypePilotage et Id_nom_TypePilotage +// facilitent la liaison entre type énuméré et string + + +#ifndef ENUM_TYPEPILOTAGE_H +#define ENUM_TYPEPILOTAGE_H +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré concernant les types de pilotage + +enum EnumTypePilotage { PILOTAGE_BASIQUE=1,PILOT_GRADIENT,AUCUN_PILOTAGE}; +/// @} // end of group + + +// Retourne le nom du type de pilotage a partir de son identificateur de +// type enumere id_TypePilotage correspondant +char* Nom_TypePilotage (const EnumTypePilotage id_TypePilotage); + +// Retourne l'identificateur de type enumere associe au nom du type de pilotage +EnumTypePilotage Id_nom_TypePilotage (const char* nom_TypePilotage); + +// retourne si la chaine de caractère existe ou pas en tant que EnumTypePilotage +bool Existe_dans_TypePilotage(const char* nom_TypePilotage); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, EnumTypePilotage& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnumTypePilotage& a); + +#endif diff --git a/Enumeration/EnumTypeViteRotat.cc b/Enumeration/EnumTypeViteRotat.cc new file mode 100644 index 0000000..100d6b1 --- /dev/null +++ b/Enumeration/EnumTypeViteRotat.cc @@ -0,0 +1,105 @@ +// FICHIER : EnumTypeViteRotat.cp + + +// 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-2021 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: . + + +#include "EnumTypeViteRotat.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +char* Nom_TypeViteRotat (const EnumTypeViteRotat id_TypeViteRotat) +// Retourne le nom du type de vitesse de rotation correspondant a l'identificateur +// de type enumere id_TypeViteRotat +{ + char* result; + switch (id_TypeViteRotat) + { + case R_CORROTATIONNEL : result="R_CORROTATIONNEL"; break; + case R_REF_ROT_PROPRE : result="R_REF_ROT_PROPRE"; break; + case R_ROT_LOGARITHMIQUE : + result="R_ROT_LOGARITHMIQUE"; break; + default : + cout << "\nErreur : valeur incorrecte du type EnumTypeViteRotat !\n"; + cout << "Nom_TypeViteRotat(EnumTypeViteRotat ) \n"; + Sortie(1); + }; + return result; +}; + +EnumTypeViteRotat Id_nom_TypeViteRotat (const char* nom_TypeViteRotat) +// Retourne la variable de type enumere associe au nom +// de type de vitesse de rotation nom_TypeViteRotat +{ + EnumTypeViteRotat result; + if ( strcmp(nom_TypeViteRotat,"R_CORROTATIONNEL")==0 ) + result=R_CORROTATIONNEL; + else if ( strcmp(nom_TypeViteRotat,"R_REF_ROT_PROPRE")==0 ) + result=R_REF_ROT_PROPRE; + else if ( strcmp(nom_TypeViteRotat,"R_ROT_LOGARITHMIQUE")==0 ) + result=R_ROT_LOGARITHMIQUE; + else + { + cout << "\nErreur : nom de type de vitesse de deformation inconnu !\n"; + cout << "Id_nom_TypeViteRotat(char* ) \n"; + Sortie(1); + }; + return result; +}; + +// surcharge de la lecture +istream & operator >> (istream & entree, EnumTypeViteRotat & result) + { char nom_TypeViteRotat[35]; + entree >> nom_TypeViteRotat; + result = Id_nom_TypeViteRotat ( nom_TypeViteRotat); + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnumTypeViteRotat& a) + { // on ecrit la forme caractère + sort << Nom_TypeViteRotat(a) << " "; + return sort; + }; + diff --git a/Enumeration/EnumTypeViteRotat.h b/Enumeration/EnumTypeViteRotat.h new file mode 100644 index 0000000..814efa9 --- /dev/null +++ b/Enumeration/EnumTypeViteRotat.h @@ -0,0 +1,71 @@ +/*! \file EnumTypeViteRotat.h + \brief def de l'enuméré concernant les type de vitesse de rotation +*/ +// FICHIER : EnumTypeViteRotat.h + +// 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-2021 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: . + + +// Afin de realiser un gain en place memoire, les noms des différents type de calcul de vitesse +// de rotation sont stockes a l'aide d'un type enumere. Les fonctions Nom_TypeViteRotat et +// Id_nom_TypeViteRotat rendent possible le lien entre les noms des types de vitesse de rotation +// et les identificateurs de type enumere correspondants. + + +#ifndef ENUMTYPEVITEROTAT_H +#define ENUMTYPEVITEROTAT_H +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré concernant les type de vitesse de rotation + +enum EnumTypeViteRotat { R_CORROTATIONNEL = 1,R_REF_ROT_PROPRE,R_ROT_LOGARITHMIQUE}; +/// @} // end of group + + +// Retourne un nom de type de vitesse de rotation a partir de son identificateur de +// type enumere id_TypeViteRotat correspondant +char* Nom_TypeViteRotat (const EnumTypeViteRotat id_TypeViteRotat) ; + +// Retourne l'identificateur de type enumere associe au nom du type +// de vitesse de rotation nom_TypeViteRotat +EnumTypeViteRotat Id_nom_TypeViteRotat (const char* nom_TypeViteRotat); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, EnumTypeViteRotat& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnumTypeViteRotat& a); + + +#endif + + diff --git a/Enumeration/EnumTypeVitesseDefor.cc b/Enumeration/EnumTypeVitesseDefor.cc new file mode 100644 index 0000000..2dd3f24 --- /dev/null +++ b/Enumeration/EnumTypeVitesseDefor.cc @@ -0,0 +1,109 @@ +// FICHIER : Enum_TypeVitDef.cp + + +// 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-2021 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: . + + +#include "EnumTypeVitesseDefor.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +char* Nom_TypeVitDef (const Enum_TypeVitDef id_TypeVitDef) +// Retourne le nom du type de vitesse de déformation correspondant a l'identificateur +// de type enumere id_TypeVitDef +{ + char* result; + switch (id_TypeVitDef) + { + case D_MOY_EPS_SUR_DT : result="D_MOY_EPS_SUR_DT"; break; + case D_AVEC_V_A_T_PLUS_DT : result="D_AVEC_V_A_T_PLUS_DT"; break; + case D_AVEC_DX_SUR_DT_A_T_PLUS_DT_SUR2 : + result="D_AVEC_DX_SUR_DT_A_T_PLUS_DT_SUR2"; break; + case D_AVEC_V_MOY_A_T_PLUS_DT_SUR2 : + result="D_AVEC_V_MOY_A_T_PLUS_DT_SUR2"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_TypeVitDef !\n"; + cout << "Nom_TypeVitDef(Enum_TypeVitDef ) \n"; + Sortie(1); + }; + return result; +}; + +Enum_TypeVitDef Id_nom_TypeVitDef (const char* nom_TypeVitDef) +// Retourne la variable de type enumere associe au nom +// de type de vitesse de déformation nom_TypeVitDef +{ + Enum_TypeVitDef result; + if ( strcmp(nom_TypeVitDef,"D_MOY_EPS_SUR_DT")==0 ) + result=D_MOY_EPS_SUR_DT; + else if ( strcmp(nom_TypeVitDef,"D_AVEC_V_A_T_PLUS_DT")==0 ) + result=D_AVEC_V_A_T_PLUS_DT; + else if ( strcmp(nom_TypeVitDef,"D_AVEC_DX_SUR_DT_A_T_PLUS_DT_SUR2")==0 ) + result=D_AVEC_DX_SUR_DT_A_T_PLUS_DT_SUR2; + else if ( strcmp(nom_TypeVitDef,"D_AVEC_V_MOY_A_T_PLUS_DT_SUR2")==0 ) + result=D_AVEC_V_MOY_A_T_PLUS_DT_SUR2; + else + { + cout << "\nErreur : nom de type de vitesse de deformation inconnu !\n"; + cout << "Id_nom_TypeVitDef(char* ) \n"; + Sortie(1); + }; + return result; +}; + +// surcharge de la lecture +istream & operator >> (istream & entree, Enum_TypeVitDef & result) + { char nom_TypeVitDef[35]; + entree >> nom_TypeVitDef; + result = Id_nom_TypeVitDef ( nom_TypeVitDef); + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_TypeVitDef& a) + { // on ecrit la forme caractère + sort << Nom_TypeVitDef(a) << " "; + return sort; + }; + diff --git a/Enumeration/EnumTypeVitesseDefor.h b/Enumeration/EnumTypeVitesseDefor.h new file mode 100644 index 0000000..4d51c55 --- /dev/null +++ b/Enumeration/EnumTypeVitesseDefor.h @@ -0,0 +1,72 @@ +/*! \file EnumTypeVitesseDefor.h + \brief Définition de l'enuméré concernant les types de vitesse de déformation +*/ +// FICHIER : EnumTypeVitesseDefor.h + +// 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-2021 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: . + + +// Afin de realiser un gain en place memoire, les noms des différents type de calcul de vitesse +// de déformation sont stockes a l'aide d'un type enumere. Les fonctions Nom_TypeVitDef et +// Id_nom_TypeVitDef rendent possible le lien entre les noms des types de vitesse de déformation +// et les identificateurs de type enumere correspondants. + + +#ifndef ENUM_TYPEVITESSEDEFOR_H +#define ENUM_TYPEVITESSEDEFOR_H +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré concernant les types de vitesse de déformation + +enum Enum_TypeVitDef { D_MOY_EPS_SUR_DT = 1,D_AVEC_V_A_T_PLUS_DT, + D_AVEC_DX_SUR_DT_A_T_PLUS_DT_SUR2, D_AVEC_V_MOY_A_T_PLUS_DT_SUR2}; +/// @} // end of group + + +// Retourne un nom de type de vitesse de déformation a partir de son identificateur de +// type enumere id_TypeVitDef correspondant +char* Nom_TypeVitDef (const Enum_TypeVitDef id_TypeVitDef) ; + +// Retourne l'identificateur de type enumere associe au nom du type +// de vitesse de déformation nom_TypeVitDef +Enum_TypeVitDef Id_nom_TypeVitDef (const char* nom_TypeVitDef); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_TypeVitDef& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_TypeVitDef& a); + + +#endif + + diff --git a/Enumeration/Enum_Critere_loi.cc b/Enumeration/Enum_Critere_loi.cc new file mode 100755 index 0000000..ca0b8cf --- /dev/null +++ b/Enumeration/Enum_Critere_loi.cc @@ -0,0 +1,138 @@ +// FICHIER Enum_Critere_Loi.cc + + +// 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-2021 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: . + + +#include "Enum_Critere_Loi.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + +// Retourne le nom a partir de son identificateur de type enumere +string Nom_Critere_Loi (Enum_Critere_Loi id_nom) +{string result=""; + switch (id_nom) + { + case AUCUN_CRITERE : + result="AUCUN_CRITERE"; + break; + case PLISSEMENT_MEMBRANE : + result="PLISSEMENT_MEMBRANE"; + break; + case PLISSEMENT_BIEL : + result="PLISSEMENT_BIEL"; + break; + case RUPTURE_SIGMA_PRINC : + result="RUPTURE_SIGMA_PRINC"; + break; + case RUPTURE_EPS_PRINC : + result="RUPTURE_EPS_PRINC"; + break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_Critere_Loi !\n"; + cout << "Nom_Critere_Loi(Enum_Critere_Loi ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_Critere_Loi Id_Nom_Critere_Loi (const string& nom_Critere_Loi) +// Retourne la variable de type enumere associee au nom +{ + + Enum_Critere_Loi result; + if ( nom_Critere_Loi == "AUCUN_CRITERE" ) + result=AUCUN_CRITERE; + else if ( nom_Critere_Loi == "PLISSEMENT_MEMBRANE") + result=PLISSEMENT_MEMBRANE; + else if ( nom_Critere_Loi == "PLISSEMENT_BIEL") + result=PLISSEMENT_BIEL; + else if ( nom_Critere_Loi == "RUPTURE_SIGMA_PRINC" ) + result=RUPTURE_SIGMA_PRINC; + else if ( nom_Critere_Loi == "RUPTURE_EPS_PRINC" ) + result=RUPTURE_EPS_PRINC; + else + { + cout << "\nErreur : nom " << nom_Critere_Loi << " type de critere de loi inconnue !\n"; + cout << "Id_Nom_Critere_Loi (const string& nom_Critere_Loi) \n"; + Sortie(1); + }; + return result; + +}; + + +// Retourne vrai si le nom passé en argument représente un type reconnu +// sinon false +bool Type_Enum_Critere_Loi_existe(const string& nom) +{ bool result; + if ( nom == "PLISSEMENT_MEMBRANE") {result=true;} + else if ( nom == "PLISSEMENT_BIEL") {result=true;} + else if ( nom == "RUPTURE_SIGMA_PRINC") {result=true;} + else if ( nom == "RUPTURE_EPS_PRINC") {result=true;} + else if ( nom == "AUCUN_CRITERE") {result=true;} + else {result = false;} + return result; +}; + + // surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_Critere_Loi& a) + { string nom_Enum_Critere_Loi; + entree >> nom_Enum_Critere_Loi; + a = Id_Nom_Critere_Loi ( nom_Enum_Critere_Loi); + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_Critere_Loi& a) + { // on ecrit la forme caractère + sort << Nom_Critere_Loi(a) << " "; + return sort; + }; + + + + + + diff --git a/Enumeration/Enum_Critere_loi.h b/Enumeration/Enum_Critere_loi.h new file mode 100755 index 0000000..39f0feb --- /dev/null +++ b/Enumeration/Enum_Critere_loi.h @@ -0,0 +1,96 @@ +/*! \file Enum_Critere_loi.h + \brief Enumeration des différentes méthodes permettant d'utiliser des critères sur les lois de comportement +* \date 11/06/2014 +*/ + +// FICHIER : Enum_Critere_loi.h + +// 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-2021 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: 11/06/2014 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + * BUT: Enumeration des différentes méthodes permettant * + * d'utiliser des critères sur les lois de comportement * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + + +#ifndef ENUM_CRITERE_LOI_H +#define ENUM_CRITERE_LOI_H +#include +#include +#include +using namespace std; //introduces namespace std +#include + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Enumeration des différentes méthodes permettant d'utiliser des critères sur les lois de comportement + +enum Enum_Critere_Loi { AUCUN_CRITERE = 0, PLISSEMENT_MEMBRANE,PLISSEMENT_BIEL + ,RUPTURE_SIGMA_PRINC, RUPTURE_EPS_PRINC }; +/// @} // end of group + + + +// Retourne le nom a partir de son identificateur de type enumere +string Nom_Critere_Loi(Enum_Critere_Loi id_Critere_Loi); + +// Retourne l'identificateur de type enumere associe au nom d'un Critere_Loi +Enum_Critere_Loi Id_Nom_Critere_Loi(const string& nom_Critere_Loi) ; + +// Retourne vrai si le nom passé en argument représente un type de Critere_Loi reconnu +// sinon false +bool Type_Enum_Critere_Loi_existe(const string& nom); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_Critere_Loi& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_Critere_Loi& a); + +#endif diff --git a/Enumeration/Enum_GrandeurGlobale.cc b/Enumeration/Enum_GrandeurGlobale.cc new file mode 100755 index 0000000..bdbc120 --- /dev/null +++ b/Enumeration/Enum_GrandeurGlobale.cc @@ -0,0 +1,300 @@ +// FICHIER : Enum_GrandeurGlobale.cp + +// 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-2021 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: . + + + +#include "Enum_GrandeurGlobale.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +string Nom_GrandeurGlobale(const Enum_GrandeurGlobale id_GrandeurGlobale) +// Retourne le nom du type correspondant a l'identificateur +// de type enumere id_GrandeurGlobale +{ + + string result; + switch (id_GrandeurGlobale) + { + + case ENERGIE_CINETIQUE : result="energie_cinetique"; break; + case ENERGIE_INTERNE : result="energie_interne"; break; + case ENERGIE_EXTERNE : result="energie_externe"; break; + case ENERGIE_BILAN : result="energie_bilan"; break; + case QUANTITE_MOUVEMENT : result="quantite_mouvement"; break; + case PUISSANCE_ACCELERATION : result="puissance_acceleration"; break; + case PUISSANCE_INTERNE : result="puissance_interne"; break; + case PUISSANCE_EXTERNE : result="puissance_externe"; break; + case PUISSANCE_BILAN : result="puissance_bilan"; break; + case ENERGIE_ELASTIQUE : result="energie_elastique"; break; + case ENERGIE_PLASTIQUE : result="energie_plastique"; break; + case ENERGIE_VISQUEUSE : result="energie_visqueuse"; break; + case ENERGIE_HOURGLASS_ : result="energie_hourglass"; break; + case ENERGIE_PENALISATION : result="energie_penalisation"; break; + case ENERGIE_FROT_ELAST: result="energie_frot_elast"; break; + case ENERGIE_FROT_PLAST : result="energie_frot_plast"; break; + case ENERGIE_FROT_VISQ : result="energie_frot_visq"; break; + case ENERGIE_VISCO_NUMERIQUE : result="energie_visco_numerique"; break; + case ENERGIE_BULK_VISCOSITY : result="energie_bulk_viscosity"; break; + case PUISSANCE_BULK_VISCOSITY : result="puissance_bulk_viscosity"; break; + case VOLUME_TOTAL_MATIERE : result="volume_total_matiere"; break; + case ENERGIE_STABILISATION_MEMB_BIEL : result="energie_stabilisation_membrane_biel"; break; + case VOL_TOTAL2D_AVEC_PLAN_YZ : result="vol_total2D_avec_plan_yz"; break; + case VOL_TOTAL2D_AVEC_PLAN_XZ : result="vol_total2D_avec_plan_xz"; break; + case VOL_TOTAL2D_AVEC_PLAN_XY : result="vol_total2D_avec_plan_xy"; break; + case NORME_CONVERGENCE : result="norme_de_convergence"; break; + case COMPTEUR_ITERATION_ALGO_GLOBAL : result="compteur_iteration_algo_global"; break; + case MAXPUISSEXT : result="maxpuissext"; break; + case MAXPUISSINT : result="maxpuissint"; break; + case MAXREACTION : result="maxreaction"; break; + case MAXRESIDUGLOBAL : result="maxresiduglobal"; break; + case MAXdeltaX : result="maxdeltax"; break; + case MAXvarDeltaX : result="maxvardeltax"; break; + case MAXvarDdl : result="maxvarddl"; break; + case COMPTEUR_INCREMENT_CHARGE_ALGO_GLOBAL : result="compteur_increment_charge_algo_global"; break; + case AMOR_CINET_VISQUEUX : result="amor_cinet_visqueux"; break; + case TEMPS_COURANT : result="temps_courant"; break; + case ALGO_GLOBAL_ACTUEL : result="algo_global_actuel"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_GrandeurGlobale !\n"; + cout << "Nom_GrandeurGlobale(Enum_GrandeurGlobale ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_GrandeurGlobale Id_nom_GrandeurGlobale (const string& nom_GrandeurGlobale) +// Retourne la variable de type enumere associe au nom +// nom_GrandeurGlobale +{ + + Enum_GrandeurGlobale result; + if ( nom_GrandeurGlobale == "energie_cinetique" ) + result=ENERGIE_CINETIQUE; + else if ( nom_GrandeurGlobale == "energie_interne" ) + result=ENERGIE_INTERNE; + else if ( nom_GrandeurGlobale == "energie_externe" ) + result=ENERGIE_EXTERNE; + else if ( nom_GrandeurGlobale == "energie_bilan" ) + result=ENERGIE_BILAN; + else if ( nom_GrandeurGlobale == "quantite_mouvement" ) + result=QUANTITE_MOUVEMENT; + else if ( nom_GrandeurGlobale == "puissance_acceleration" ) + result=PUISSANCE_ACCELERATION; + else if ( nom_GrandeurGlobale == "puissance_interne" ) + result=PUISSANCE_INTERNE; + else if ( nom_GrandeurGlobale == "puissance_externe" ) + result=PUISSANCE_EXTERNE; + else if ( nom_GrandeurGlobale == "puissance_bilan" ) + result=PUISSANCE_BILAN; + else if ( nom_GrandeurGlobale == "energie_elastique" ) + result=ENERGIE_ELASTIQUE; + else if ( nom_GrandeurGlobale == "energie_plastique" ) + result=ENERGIE_PLASTIQUE; + else if ( nom_GrandeurGlobale == "energie_visqueuse" ) + result=ENERGIE_VISQUEUSE; + else if ( nom_GrandeurGlobale == "energie_hourglass" ) + result=ENERGIE_HOURGLASS_; + else if ( nom_GrandeurGlobale == "energie_penalisation" ) + result=ENERGIE_PENALISATION; + else if ( nom_GrandeurGlobale == "energie_frot_elast" ) + result=ENERGIE_FROT_ELAST; + else if ( nom_GrandeurGlobale == "energie_frot_plast" ) + result=ENERGIE_FROT_PLAST; + else if ( nom_GrandeurGlobale == "energie_frot_visq" ) + result=ENERGIE_FROT_VISQ; + else if ( nom_GrandeurGlobale == "energie_visco_numerique" ) + result=ENERGIE_VISCO_NUMERIQUE; + else if ( nom_GrandeurGlobale == "energie_bulk_viscosity" ) + result=ENERGIE_BULK_VISCOSITY; + else if ( nom_GrandeurGlobale == "puissance_bulk_viscosity" ) + result=PUISSANCE_BULK_VISCOSITY; + else if ( nom_GrandeurGlobale == "volume_total_matiere" ) + result=VOLUME_TOTAL_MATIERE; + else if ( nom_GrandeurGlobale == "energie_stabilisation_membrane_biel" ) + result=ENERGIE_STABILISATION_MEMB_BIEL; + else if ( nom_GrandeurGlobale == "vol_total2D_avec_plan_yz" ) + result=VOL_TOTAL2D_AVEC_PLAN_YZ; + else if ( nom_GrandeurGlobale == "vol_total2D_avec_plan_xz" ) + result=VOL_TOTAL2D_AVEC_PLAN_XZ; + else if ( nom_GrandeurGlobale == "vol_total2D_avec_plan_xy" ) + result=VOL_TOTAL2D_AVEC_PLAN_XY; + else if ( nom_GrandeurGlobale == "norme_de_convergence" ) + result=NORME_CONVERGENCE; + else if ( nom_GrandeurGlobale == "compteur_iteration_algo_global" ) + result=COMPTEUR_ITERATION_ALGO_GLOBAL; + else if ( nom_GrandeurGlobale == "maxpuissext" ) + result=MAXPUISSEXT; + else if ( nom_GrandeurGlobale == "maxpuissint" ) + result=MAXPUISSINT; + else if ( nom_GrandeurGlobale == "maxreaction" ) + result=MAXREACTION; + else if ( nom_GrandeurGlobale == "maxresiduglobal" ) + result=MAXRESIDUGLOBAL; + else if ( nom_GrandeurGlobale == "maxdeltax" ) + result=MAXdeltaX; + else if ( nom_GrandeurGlobale == "maxvardeltax" ) + result=MAXvarDeltaX; + else if ( nom_GrandeurGlobale == "maxvarddl" ) + result=MAXvarDdl; + else if ( nom_GrandeurGlobale == "compteur_increment_charge_algo_global" ) + result=COMPTEUR_INCREMENT_CHARGE_ALGO_GLOBAL; + else if ( nom_GrandeurGlobale == "amor_cinet_visqueux" ) + result=AMOR_CINET_VISQUEUX; + else if ( nom_GrandeurGlobale == "temps_courant" ) + result=TEMPS_COURANT; + else if ( nom_GrandeurGlobale == "algo_global_actuel" ) + result=ALGO_GLOBAL_ACTUEL; + else + { + cout << "\nErreur : nom de grandeur globale inconnu !\n"; + cout << "Id_nom_GrandeurGlobale(string ) \n"; + Sortie(1); + }; + return result; + +}; + + +// test si le string est une grandeur globale +bool EstUneGrandeurGlobale(const string& nom_GrandeurGlobale) +{ + bool result=false; + if ( nom_GrandeurGlobale == "energie_cinetique" ) + result=true; + else if ( nom_GrandeurGlobale == "energie_interne" ) + result=true; + else if ( nom_GrandeurGlobale == "energie_externe" ) + result=true; + else if ( nom_GrandeurGlobale == "energie_bilan" ) + result=true; + else if ( nom_GrandeurGlobale == "quantite_mouvement" ) + result=true; + else if ( nom_GrandeurGlobale == "puissance_acceleration" ) + result=true; + else if ( nom_GrandeurGlobale == "puissance_interne" ) + result=true; + else if ( nom_GrandeurGlobale == "puissance_externe" ) + result=true; + else if ( nom_GrandeurGlobale == "puissance_bilan" ) + result=true; + else if ( nom_GrandeurGlobale == "energie_elastique" ) + result=true; + else if ( nom_GrandeurGlobale == "energie_plastique" ) + result=true; + else if ( nom_GrandeurGlobale == "energie_visqueuse" ) + result=true; + else if ( nom_GrandeurGlobale == "energie_hourglass" ) + result=true; + else if ( nom_GrandeurGlobale == "energie_penalisation" ) + result=true; + else if ( nom_GrandeurGlobale == "energie_frot_elast" ) + result=true; + else if ( nom_GrandeurGlobale == "energie_frot_plast" ) + result=true; + else if ( nom_GrandeurGlobale == "energie_frot_visq" ) + result=true; + else if ( nom_GrandeurGlobale == "energie_visco_numerique" ) + result=true; + else if ( nom_GrandeurGlobale == "energie_bulk_viscosity" ) + result=true; + else if ( nom_GrandeurGlobale == "puissance_bulk_viscosity" ) + result=true; + else if ( nom_GrandeurGlobale == "volume_total_matiere" ) + result=true; + else if ( nom_GrandeurGlobale == "energie_stabilisation_membrane_biel" ) + result=true; + else if ( nom_GrandeurGlobale == "vol_total2D_avec_plan_yz" ) + result=true; + else if ( nom_GrandeurGlobale == "vol_total2D_avec_plan_xz" ) + result=true; + else if ( nom_GrandeurGlobale == "vol_total2D_avec_plan_xy" ) + result=true; + else if ( nom_GrandeurGlobale == "norme_de_convergence" ) + result=true; + else if ( nom_GrandeurGlobale == "compteur_iteration_algo_global" ) + result=true; + else if ( nom_GrandeurGlobale == "maxpuissext" ) + result=true; + else if ( nom_GrandeurGlobale == "maxpuissint" ) + result=true; + else if ( nom_GrandeurGlobale == "maxreaction" ) + result=true; + else if ( nom_GrandeurGlobale == "maxresiduglobal" ) + result=true; + else if ( nom_GrandeurGlobale == "maxdeltax" ) + result=true; + else if ( nom_GrandeurGlobale == "maxvardeltax" ) + result=true; + else if ( nom_GrandeurGlobale == "maxvarddl" ) + result=true; + else if ( nom_GrandeurGlobale == "compteur_increment_charge_algo_global" ) + result=true; + else if ( nom_GrandeurGlobale == "amor_cinet_visqueux" ) + result=true; + else if ( nom_GrandeurGlobale == "temps_courant" ) + result=true; + else if ( nom_GrandeurGlobale == "algo_global_actuel" ) + result=true; + return result; +}; + + +// surcharge de la lecture +istream & operator >> (istream & entree, Enum_GrandeurGlobale & result) + { string nom_GrandeurGlobale; + entree >> nom_GrandeurGlobale; + result = Id_nom_GrandeurGlobale ( nom_GrandeurGlobale); + return entree; + }; + + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_GrandeurGlobale& a) + { // on ecrit la forme caractère + sort << Nom_GrandeurGlobale(a) << " "; + return sort; + }; + diff --git a/Enumeration/Enum_GrandeurGlobale.h b/Enumeration/Enum_GrandeurGlobale.h new file mode 100755 index 0000000..2804f2f --- /dev/null +++ b/Enumeration/Enum_GrandeurGlobale.h @@ -0,0 +1,94 @@ +/*! \file Enum_GrandeurGlobale.h + \brief Définition de l'enuméré concernant les grandeurs globales +*/ +// FICHIER : Enum_GrandeurGlobale.h + +// 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-2021 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: . + + +// Afin de realiser un gain en place memoire, les noms des grandeurs globales +// sont stockes a l'aide d'un type enumere. Les fonctions Nom_GrandeurGlobale et +// Id_nom_GrandeurGlobale rendent possible le lien entre les noms des types d'interpolation +// et les identificateurs de type enumere correspondants. + + +#ifndef ENUM_GRANDEUR_GLOBALE_H +#define ENUM_GRANDEUR_GLOBALE_H +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré concernant les grandeurs globales + +enum Enum_GrandeurGlobale { ENERGIE_CINETIQUE = 0,ENERGIE_INTERNE + ,ENERGIE_EXTERNE, ENERGIE_BILAN,QUANTITE_MOUVEMENT + ,PUISSANCE_ACCELERATION,PUISSANCE_INTERNE,PUISSANCE_EXTERNE + ,PUISSANCE_BILAN,ENERGIE_ELASTIQUE,ENERGIE_PLASTIQUE + ,ENERGIE_VISQUEUSE,ENERGIE_HOURGLASS_,ENERGIE_PENALISATION + ,ENERGIE_FROT_ELAST,ENERGIE_FROT_PLAST,ENERGIE_FROT_VISQ + ,ENERGIE_VISCO_NUMERIQUE,ENERGIE_BULK_VISCOSITY + ,PUISSANCE_BULK_VISCOSITY,VOLUME_TOTAL_MATIERE + ,ENERGIE_STABILISATION_MEMB_BIEL + ,VOL_TOTAL2D_AVEC_PLAN_YZ + ,VOL_TOTAL2D_AVEC_PLAN_XZ,VOL_TOTAL2D_AVEC_PLAN_XY + ,NORME_CONVERGENCE,COMPTEUR_ITERATION_ALGO_GLOBAL + ,MAXPUISSEXT,MAXPUISSINT,MAXREACTION,MAXRESIDUGLOBAL + ,MAXdeltaX,MAXvarDeltaX,MAXvarDdl + ,COMPTEUR_INCREMENT_CHARGE_ALGO_GLOBAL + ,AMOR_CINET_VISQUEUX + ,TEMPS_COURANT + ,ALGO_GLOBAL_ACTUEL + }; +/// @} // end of group + +//***** ne pas oublier de changer la taille maxi -> taille_Enum_GrandeurGlobale +const int taille_Enum_GrandeurGlobale = 38; + +// Retourne un nom a partir de son identificateur de +// type enumere id_GrandeurGlobale correspondant +string Nom_GrandeurGlobale (const Enum_GrandeurGlobale id_GrandeurGlobale) ; + +// Retourne l'identificateur de type enumere associe au nom du type +// nom_GrandeurGlobale +Enum_GrandeurGlobale Id_nom_GrandeurGlobale (const string& nom_GrandeurGlobale); + +// test si le string est une grandeur globale +bool EstUneGrandeurGlobale(const string& nom_GrandeurGlobale); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_GrandeurGlobale& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_GrandeurGlobale& a); + + +#endif + + diff --git a/Enumeration/Enum_IO_XML.cc b/Enumeration/Enum_IO_XML.cc new file mode 100644 index 0000000..f529ad5 --- /dev/null +++ b/Enumeration/Enum_IO_XML.cc @@ -0,0 +1,136 @@ +// FICHIER : Enum_IO_XML.cp + +// 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-2021 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: . + + + +#include "Enum_IO_XML.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +string Nom_Enum_IO_XML (Enum_IO_XML id_Enum_IO_XML) +// Retourne le nom du type de Enum_IO_XML correspondant a l'identificateur +// de type enumere id_Enum_IO_XML +{ + + string result; + switch (id_Enum_IO_XML) + { + case XML_TYPE_GLOBAUX : + result="XML_TYPE_GLOBAUX"; + break; + case XML_IO_POINT_INFO : + result="XML_IO_POINT_INFO"; + break; + case XML_IO_POINT_BI : + result="XML_IO_POINT_BI"; + break; + case XML_IO_ELEMENT_FINI : + result="XML_IO_ELEMENT_FINI"; + break; + case XML_ACTION_INTERACTIVE : + result="XML_ACTION_INTERACTIVE"; + break; + case XML_STRUCTURE_DONNEE : + result="XML_STRUCTURE_DONNEE"; + break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_IO_XML !\n"; + cout << "Nom_Enum_IO_XML(Enum_IO_XML ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_IO_XML Id_nom_Enum_IO_XML (string nom_Enum_IO_XML) +// Retourne la variable de type enumere associe au nom +// de Enum_IO_XML nom_Enum_IO_XML +{ + + Enum_IO_XML result; + if ( nom_Enum_IO_XML=="XML_TYPE_GLOBAUX" ) + result=XML_TYPE_GLOBAUX; + else if ( nom_Enum_IO_XML=="XML_IO_POINT_INFO") + result=XML_IO_POINT_INFO; + else if (nom_Enum_IO_XML=="XML_IO_POINT_BI" ) + result=XML_IO_POINT_BI; + else if (nom_Enum_IO_XML=="XML_IO_ELEMENT_FINI" ) + result=XML_IO_ELEMENT_FINI; + else if (nom_Enum_IO_XML=="XML_ACTION_INTERACTIVE" ) + result=XML_ACTION_INTERACTIVE; + else if (nom_Enum_IO_XML=="XML_STRUCTURE_DONNEE" ) + result=XML_STRUCTURE_DONNEE; + else + { + cout << "\nErreur : nom ** " << nom_Enum_IO_XML << " ** de Enum_IO_XML inconnu !\n"; + cout << "Id_nom_Enum_IO_XML(string nom ) \n"; + Sortie(1); + }; + return result; + +}; + +// surcharge de la lecture +istream & operator >> (istream & entree, Enum_IO_XML & result) + { string nom_Enum_IO_XML; + entree >> nom_Enum_IO_XML; + result = Id_nom_Enum_IO_XML ( nom_Enum_IO_XML); + return entree; + }; + + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_IO_XML& a) + { // on ecrit la forme caractère + sort << Nom_Enum_IO_XML(a) << " "; + return sort; + }; + + + + + + + diff --git a/Enumeration/Enum_IO_XML.h b/Enumeration/Enum_IO_XML.h new file mode 100644 index 0000000..cd3e8b3 --- /dev/null +++ b/Enumeration/Enum_IO_XML.h @@ -0,0 +1,95 @@ +/*! \file Enum_IO_XML.h + \brief Enumération des différentes entree/sortie XML +* \date 20/01/2005 +*/ + +// FICHIER : Enum_IO_XML.h + +// 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-2021 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: 20/01/2005 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Enumération des différentes entree/sortie XML * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + +#ifndef ENUM_ENTREE_SORTIE_XML_H +#define ENUM_ENTREE_SORTIE_XML_H + +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Enumération des différentes entree/sortie XML + +enum Enum_IO_XML { XML_TYPE_GLOBAUX = 1,XML_IO_POINT_INFO,XML_IO_POINT_BI, XML_IO_ELEMENT_FINI + ,XML_ACTION_INTERACTIVE,XML_STRUCTURE_DONNEE}; +/// @} // end of group + +const int nombre_maxi_de_type_de_Enum_IO_XML = 6; + + + +// Retourne un nom de type de Enum_IO_XML a partir de son identificateur de +// type enumere id_Enum_IO_XML correspondant +string Nom_Enum_IO_XML (Enum_IO_XML id_Enum_IO_XML); + +// Retourne l'identificateur de type enumere associe au nom du type +// de Enum_IO_XML nom_Enum_IO_XML +Enum_IO_XML Id_nom_Enum_IO_XML (string nom_Enum_IO_XML); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_IO_XML& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_IO_XML& a); + + +#endif + + diff --git a/Enumeration/Enum_PiPoCo.cc b/Enumeration/Enum_PiPoCo.cc new file mode 100644 index 0000000..415a17b --- /dev/null +++ b/Enumeration/Enum_PiPoCo.cc @@ -0,0 +1,155 @@ +// FICHIER : Enum_PiPoCo.cc + + +// 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-2021 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: . + + +#include "Enum_PiPoCo.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + +// Retourne un nom a partir de son identificateur de +// type enumere Enum_PiPoCo correspondant +string Nom_Enum_PiPoCo (const Enum_PiPoCo id_Enum) +{ string result; + switch (id_Enum) + { + case NON_PoutrePlaqueCoque : result="NON_PoutrePlaqueCoque"; break; + case POUTRE : result="POUTRE"; break; + case PLAQUE : result="PLAQUE"; break; + case COQUE : result="COQUE"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_PiPoCo !\n"; + cout << "Nom_Enum_PiPoCo(Enum_PiPoCo ) \n"; + Sortie(1); + }; + return result; + +}; + +// Retourne l'identificateur de type enumere associe au nom du type nom_Enum +Enum_PiPoCo Id_Enum_PiPoCo (const string& nom_Enum) +{ Enum_PiPoCo result; + if ( nom_Enum == "NON_PoutrePlaqueCoque" ) + result=NON_PoutrePlaqueCoque; + else if ( nom_Enum == "POUTRE" ) + result=POUTRE; + else if ( nom_Enum == "PLAQUE" ) + result=PLAQUE; + else if ( nom_Enum == "COQUE" ) + result=COQUE; + else + { + cout << "\nErreur : nom d'identificateur poutre ou plaque ou coque inconnu !\n"; + cout << "Id_Enum_PiPoCo(char* ) \n"; + Sortie(1); + }; + return result; +}; + +// indique le type en fonction de l'interpolation et du découpage +Enum_PiPoCo TypePiPoCo(Enum_interpol id_interpol,Enum_geom id_geom) +{ Enum_PiPoCo retour = NON_PoutrePlaqueCoque; + +//enum Enum_interpol { RIEN_INTERPOL = 1,CONSTANT +// , LINEAIRE, QUADRATIQUE, QUADRACOMPL, CUBIQUE, CUBIQUE_INCOMPL +// , LINQUAD, HERMITE, SFE1,SFE2,SFE3, SFE3C +// , SFE1_3D,SFE2_3D,SFE3_3D, SFE3C_3D, SEG1, BIE1, BIE2}; + // on ne traite que les cas qui conduise à un retour différent de NON_PoutrePlaqueCoque + switch (id_geom) + { case TRIANGLE : + { //retour = PLAQUE ; // sauf contraire dans la suite, c'est une plaque + // non c'est une membrane !! + switch (id_interpol) + { case SFE1 : case SFE2 : case SFE3 : case SFE3C : + case QSFE1: case QSFE3 : + case SFE1_3D : case SFE2_3D : case SFE3_3D : + case SFE3C_3D : + retour = COQUE; break; + // maintenant cas d'une membrane + case LINEAIRE : case QUADRATIQUE : case QUADRACOMPL : + case CUBIQUE : case CUBIQUE_INCOMPL : + case LINQUAD : case HERMITE : + retour = NON_PoutrePlaqueCoque; break; + // sinon par défaut message: + default: + cout << "\nErreur : ce cas n'est pas traite !\n" + << " id_interpol= " << Nom_interpol(id_interpol) + << " , id_geom= " << Nom_geom(id_geom) ; + cout << "\n TypePiPoCo(Enum_interpol id_interpol,Enum_geom id_geom) \n" + << endl ; + Sortie(1); + }; + break; + } + // case QUADRANGLE : retour=PLAQUE; break; non: une membrane + // case SEG_AXI : retour=PLAQUE; break; non une membrane + case POUT : retour=POUTRE; break; + case PS1 : retour=POUTRE; break; + default: + retour = NON_PoutrePlaqueCoque; + }; + return retour; +}; + +// indique si c'est un élément sfe ou non +bool ElementSfe(Enum_interpol id_interpol) + { return ( (id_interpol >= SFE1) && (id_interpol <= SFE3C_3D) ); + }; + +// surcharge de la lecture +istream & operator >> (istream & entree, Enum_PiPoCo & result) + { char nom_Enum[35]; + entree >> nom_Enum; + result = Id_Enum_PiPoCo ( nom_Enum); + return entree; + }; + + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_PiPoCo& a) + { // on ecrit la forme caractère + sort << Nom_Enum_PiPoCo(a) << " "; + return sort; + }; + diff --git a/Enumeration/Enum_PiPoCo.h b/Enumeration/Enum_PiPoCo.h new file mode 100644 index 0000000..2a79fb2 --- /dev/null +++ b/Enumeration/Enum_PiPoCo.h @@ -0,0 +1,101 @@ +/*! \file Enum_PiPoCo.h + \brief Définir un type énuméré pour la différenciation entre des éléments classiques et le cas poutre plaque ou coque. +* \date 20/06/2007 +*/ + + +// 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-2021 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: 20/06/2007 * + * $ * + * AUTEUR: G RIO (mailto:gerard.rio@univ-ubs.fr) * + * Tel 0297874576 fax : 02.97.87.45.72 * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Définir un type énuméré pour la différenciation entre des * + * éléments classiques et le cas poutre plaque ou coque. * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + + + +#ifndef ENUM_PIPOCO_H +#define ENUM_PIPOCO_H +#include +using namespace std; +#include "Enum_interpol.h" +#include "Enum_geom.h" + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définir un type énuméré pour la différenciation entre des éléments classiques et le cas poutre plaque ou coque. + +enum Enum_PiPoCo { NON_PoutrePlaqueCoque = 0, POUTRE , PLAQUE, COQUE }; +/// @} // end of group + + + + +// Retourne un nom a partir de son identificateur de +// type enumere Enum_PiPoCo correspondant +string Nom_Enum_PiPoCo (const Enum_PiPoCo id_Enum) ; + +// Retourne l'identificateur de type enumere associe au nom du type nom_Enum +Enum_PiPoCo Id_Enum_PiPoCo (const string& nom_Enum); + +// indique si c'est un élément sfe ou non +bool ElementSfe(Enum_interpol id_interpol); + +// indique le type en fonction de l'interpolation et du découpage +Enum_PiPoCo TypePiPoCo(Enum_interpol id_interpol,Enum_geom id_geom); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_PiPoCo& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_PiPoCo& a); + + +#endif + diff --git a/Enumeration/Enum_StabHourglass.cc b/Enumeration/Enum_StabHourglass.cc new file mode 100644 index 0000000..a439f27 --- /dev/null +++ b/Enumeration/Enum_StabHourglass.cc @@ -0,0 +1,128 @@ +// FICHIER Enum_StabHourglass.cc + + +// 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-2021 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: . + + +#include "Enum_StabHourglass.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + +// Retourne le nom a partir de son identificateur de type enumere +string Nom_StabHourglass (Enum_StabHourglass id_nom) +{ + + string result=""; + switch (id_nom) + { + case STABHOURGLASS_NON_DEFINIE : + result="STABHOURGLASS_NON_DEFINIE"; + break; + case STABHOURGLASS_PAR_COMPORTEMENT : + result="STABHOURGLASS_PAR_COMPORTEMENT"; + break; + case STABHOURGLASS_PAR_COMPORTEMENT_REDUIT : + result="STABHOURGLASS_PAR_COMPORTEMENT_REDUIT"; + break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_StabHourglass !\n"; + cout << "Nom_StabHourglass(Enum_StabHourglass ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_StabHourglass Id_Nom_StabHourglass (const char* nom_StabHourglass) +// Retourne la variable de type enumere associee au nom +{ + + Enum_StabHourglass result; + if ( strcmp(nom_StabHourglass,"STABHOURGLASS_NON_DEFINIE")==0 ) + result=STABHOURGLASS_NON_DEFINIE; + else if ( strcmp(nom_StabHourglass,"STABHOURGLASS_PAR_COMPORTEMENT")==0 ) + result=STABHOURGLASS_PAR_COMPORTEMENT; + else if ( strcmp(nom_StabHourglass,"STABHOURGLASS_PAR_COMPORTEMENT_REDUIT")==0 ) + result=STABHOURGLASS_PAR_COMPORTEMENT_REDUIT; + else + { + cout << "\nErreur : nom " << nom_StabHourglass << " du type de stabilisation d'hourglass inconnue !\n"; + cout << "Id_nom_StabHourglass (char* nom) \n"; + Sortie(1); + }; + return result; + +}; + + +// Retourne vrai si le nom passé en argument représente un type reconnu +// sinon false +bool Type_Enum_StabHourglass_existe(const string& nom) +{ bool result; + if ( nom == "STABHOURGLASS_PAR_COMPORTEMENT") {result=true;} + else if ( nom == "STABHOURGLASS_PAR_COMPORTEMENT_REDUIT") {result=true;} + else if ( nom == "STABHOURGLASS_NON_DEFINIE") {result=true;} + else {result = false;} + return result; +}; + + // surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_StabHourglass& a) + { char nom_Enum_StabHourglass[50]; + entree >> nom_Enum_StabHourglass; + a = Id_Nom_StabHourglass ( nom_Enum_StabHourglass); + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_StabHourglass& a) + { // on ecrit la forme caractère + sort << Nom_StabHourglass(a) << " "; + return sort; + }; + + + + + + diff --git a/Enumeration/Enum_StabHourglass.h b/Enumeration/Enum_StabHourglass.h new file mode 100644 index 0000000..69b2f86 --- /dev/null +++ b/Enumeration/Enum_StabHourglass.h @@ -0,0 +1,96 @@ +/*! \file Enum_StabHourglass.h + \brief Enumeration des différentes méthodes permettant de stabiliser les modes d'hourglass +* \date 02/10/2010 +*/ + +// FICHIER : Enum_StabHourglass.h + +// 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-2021 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: 02/10/2010 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Enumeration des différentes méthodes permettant * + * de stabiliser les modes d'hourglass * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + + +#ifndef ENUM_STABHOURGLASS_H +#define ENUM_STABHOURGLASS_H +#include +#include +#include +using namespace std; //introduces namespace std +#include + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Enumeration des différentes méthodes permettant de stabiliser les modes d'hourglass + +enum Enum_StabHourglass { STABHOURGLASS_NON_DEFINIE = 0, STABHOURGLASS_PAR_COMPORTEMENT + , STABHOURGLASS_PAR_COMPORTEMENT_REDUIT}; +/// @} // end of group + + + +// Retourne le nom a partir de son identificateur de type enumere +string Nom_StabHourglass (Enum_StabHourglass id_StabHourglass); + +// Retourne l'identificateur de type enumere associe au nom d'une StabHourglass +Enum_StabHourglass Id_Nom_StabHourglass (const char* nom_StabHourglass) ; + +// Retourne vrai si le nom passé en argument représente un type de StabHourglass reconnu +// sinon false +bool Type_Enum_StabHourglass_existe(const string& nom); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_StabHourglass& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_StabHourglass& a); + +#endif diff --git a/Enumeration/Enum_StabMembrane.cc b/Enumeration/Enum_StabMembrane.cc new file mode 100755 index 0000000..596f033 --- /dev/null +++ b/Enumeration/Enum_StabMembrane.cc @@ -0,0 +1,223 @@ +// FICHIER Enum_StabMembrane.cc + + +// 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-2021 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: . + + +#include "Enum_StabMembrane.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + +// Retourne le nom a partir de son identificateur de type enumere +string Nom_StabMembraneBiel (Enum_StabMembraneBiel id_nom) +{ + + string result=""; + switch (id_nom) + { + case STABMEMBRANE_BIEL_NON_DEFINIE : + result="STABMEMBRANE_BIEL_NON_DEFINIE"; + break; + case STABMEMBRANE_BIEL_PREMIER_ITER : + result="STABMEMBRANE_BIEL_PREMIER_ITER"; + break; + case STABMEMBRANE_BIEL_PREMIER_ITER_INCR : + result="STABMEMBRANE_BIEL_PREMIER_ITER_INCR"; + break; + case STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER : + result="STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER"; + break; + case STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_INCR : + result="STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_INCR"; + break; + case STABMEMBRANE_BIEL_PREMIER_ITER_NORMALE_AU_NOEUD : + result="STABMEMBRANE_BIEL_PREMIER_ITER_NORMALE_AU_NOEUD"; + break; + case STABMEMBRANE_BIEL_PREMIER_ITER_INCR_NORMALE_AU_NOEUD : + result="STABMEMBRANE_BIEL_PREMIER_ITER_INCR_NORMALE_AU_NOEUD"; + break; + case STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_NORMALE_AU_NOEUD : + result="STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_NORMALE_AU_NOEUD"; + break; + case STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_INCR_NORMALE_AU_NOEUD : + result="STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_INCR_NORMALE_AU_NOEUD"; + break; + case STAB_M_B_ITER_1_VIA_F_EXT : + result="STAB_M_B_ITER_1_VIA_F_EXT"; + break; + case STAB_M_B_ITER_INCR_1_VIA_F_EXT : + result="STAB_M_B_ITER_INCR_1_VIA_F_EXT"; + break; + case STAB_M_B_ITER_1_VIA_F_EXT_NORMALE_AU_NOEUD : + result="STAB_M_B_ITER_1_VIA_F_EXT_NORMALE_AU_NOEUD"; + break; + case STAB_M_B_ITER_INCR_1_VIA_F_EXT_NORMALE_AU_NOEUD : + result="STAB_M_B_ITER_INCR_1_VIA_F_EXT_NORMALE_AU_NOEUD"; + break; + + default : + cout << "\nErreur : valeur incorrecte du type Enum_StabMembraneBiel !\n"; + cout << "Nom_StabMembraneBiel(Enum_StabMembraneBiel ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_StabMembraneBiel Id_Enum_StabMembraneBiel (const string& nom_StabMembraneBiel) +// Retourne la variable de type enumere associee au nom +{ + + Enum_StabMembraneBiel result; + if ( nom_StabMembraneBiel == "STABMEMBRANE_BIEL_NON_DEFINIE" ) + result=STABMEMBRANE_BIEL_NON_DEFINIE; + else if ( nom_StabMembraneBiel == "STABMEMBRANE_BIEL_PREMIER_ITER" ) + result=STABMEMBRANE_BIEL_PREMIER_ITER; + else if ( nom_StabMembraneBiel == "STABMEMBRANE_BIEL_PREMIER_ITER_INCR" ) + result=STABMEMBRANE_BIEL_PREMIER_ITER_INCR; + else if ( nom_StabMembraneBiel == "STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER" ) + result=STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER; + else if ( nom_StabMembraneBiel == "STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_INCR" ) + result=STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_INCR; + else if ( nom_StabMembraneBiel == "STABMEMBRANE_BIEL_PREMIER_ITER_NORMALE_AU_NOEUD" ) + result=STABMEMBRANE_BIEL_PREMIER_ITER_NORMALE_AU_NOEUD; + else if ( nom_StabMembraneBiel == "STABMEMBRANE_BIEL_PREMIER_ITER_INCR_NORMALE_AU_NOEUD" ) + result=STABMEMBRANE_BIEL_PREMIER_ITER_INCR_NORMALE_AU_NOEUD; + else if ( nom_StabMembraneBiel == "STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_NORMALE_AU_NOEUD" ) + result=STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_NORMALE_AU_NOEUD; + else if ( nom_StabMembraneBiel == "STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_INCR_NORMALE_AU_NOEUD" ) + result=STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_INCR_NORMALE_AU_NOEUD; + else if ( nom_StabMembraneBiel == "STAB_M_B_ITER_1_VIA_F_EXT" ) + result=STAB_M_B_ITER_1_VIA_F_EXT; + else if ( nom_StabMembraneBiel == "STAB_M_B_ITER_INCR_1_VIA_F_EXT" ) + result=STAB_M_B_ITER_INCR_1_VIA_F_EXT; + else if ( nom_StabMembraneBiel == "STAB_M_B_ITER_1_VIA_F_EXT_NORMALE_AU_NOEUD" ) + result=STAB_M_B_ITER_1_VIA_F_EXT_NORMALE_AU_NOEUD; + else if ( nom_StabMembraneBiel == "STAB_M_B_ITER_INCR_1_VIA_F_EXT_NORMALE_AU_NOEUD" ) + result=STAB_M_B_ITER_INCR_1_VIA_F_EXT_NORMALE_AU_NOEUD; + + else + { + cout << "\nErreur : nom " << nom_StabMembraneBiel << " du type de stabilisation d'hourglass inconnue !\n"; + cout << "Id_nom_StabMembraneBiel (const string& nom) \n"; + Sortie(1); + }; + return result; + +}; + + +// Retourne vrai si le nom passé en argument représente un type reconnu +// sinon false +bool Type_Enum_StabMembraneBiel_existe(const string& nom) +{ bool result; + if ( nom == "STABMEMBRANE_BIEL_PREMIER_ITER") {result=true;} + else if ( nom == "STABMEMBRANE_BIEL_NON_DEFINIE") {result=true;} + else if ( nom == "STABMEMBRANE_BIEL_PREMIER_ITER_INCR") {result=true;} + else if ( nom == "STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER") {result=true;} + else if ( nom == "STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_INCR") {result=true;} + else if ( nom == "STABMEMBRANE_BIEL_PREMIER_ITER_NORMALE_AU_NOEUD") {result=true;} + else if ( nom == "STABMEMBRANE_BIEL_PREMIER_ITER_INCR_NORMALE_AU_NOEUD") {result=true;} + else if ( nom == "STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_NORMALE_AU_NOEUD") {result=true;} + else if ( nom == "STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_INCR_NORMALE_AU_NOEUD") {result=true;} + else if ( nom == "STAB_M_B_ITER_1_VIA_F_EXT") {result=true;} + else if ( nom == "STAB_M_B_ITER_INCR_1_VIA_F_EXT") {result=true;} + else if ( nom == "STAB_M_B_ITER_1_VIA_F_EXT_NORMALE_AU_NOEUD") {result=true;} + else if ( nom == "STAB_M_B_ITER_INCR_1_VIA_F_EXT_NORMALE_AU_NOEUD") {result=true;} + + else {result = false;} + return result; +}; + + +// retourne vrai si le type enumere se termine par _NORMALE_AU_NOEUD +bool Contient_Normale_au_noeud(Enum_StabMembraneBiel id_StabMembraneBiel) +{ bool result; + switch (id_StabMembraneBiel) + { + case STABMEMBRANE_BIEL_NON_DEFINIE : case STABMEMBRANE_BIEL_PREMIER_ITER : + case STABMEMBRANE_BIEL_PREMIER_ITER_INCR : case STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER : + case STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_INCR : + case STAB_M_B_ITER_1_VIA_F_EXT : + case STAB_M_B_ITER_INCR_1_VIA_F_EXT : + result=false; + break; + + case STABMEMBRANE_BIEL_PREMIER_ITER_NORMALE_AU_NOEUD : + case STABMEMBRANE_BIEL_PREMIER_ITER_INCR_NORMALE_AU_NOEUD : + case STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_NORMALE_AU_NOEUD : + case STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_INCR_NORMALE_AU_NOEUD : + case STAB_M_B_ITER_1_VIA_F_EXT_NORMALE_AU_NOEUD : + case STAB_M_B_ITER_INCR_1_VIA_F_EXT_NORMALE_AU_NOEUD : + result=true; + break; + + default : + cout << "\nErreur : valeur incorrecte du type Enum_StabMembraneBiel !\n"; + cout << "Contient_Normale_au_noeud(Enum_StabMembraneBiel id_StabMembraneBiel) \n"; + Sortie(1); + }; + return result; +}; + + + // surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_StabMembraneBiel& a) + { string nom_Enum_StabMembraneBiel; + entree >> nom_Enum_StabMembraneBiel; + a = Id_Enum_StabMembraneBiel ( nom_Enum_StabMembraneBiel); + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_StabMembraneBiel& a) + { // on ecrit la forme caractère + sort << Nom_StabMembraneBiel(a) << " "; + return sort; + }; + + + + + + diff --git a/Enumeration/Enum_StabMembrane.h b/Enumeration/Enum_StabMembrane.h new file mode 100755 index 0000000..61e568b --- /dev/null +++ b/Enumeration/Enum_StabMembrane.h @@ -0,0 +1,111 @@ +/*! \file Enum_StabMembrane.h + \brief Enumeration des différentes méthodes permettant de stabiliser les membranes transversalement +* \date 30/06/2017 +*/ + + +// 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-2021 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: 30/06/2017 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Enumeration des différentes méthodes permettant * + * de stabiliser les membranes transversalement * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + + +#ifndef ENUM_STABMEMBRANE_BIEL_H +#define ENUM_STABMEMBRANE_BIEL_H +#include +#include +#include +using namespace std; //introduces namespace std +#include + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Enumeration des différentes méthodes permettant de stabiliser les membranes transversalement + +enum Enum_StabMembraneBiel { STABMEMBRANE_BIEL_NON_DEFINIE = 0 + ,STABMEMBRANE_BIEL_PREMIER_ITER + ,STABMEMBRANE_BIEL_PREMIER_ITER_INCR + ,STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER + ,STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_INCR + ,STABMEMBRANE_BIEL_PREMIER_ITER_NORMALE_AU_NOEUD + ,STABMEMBRANE_BIEL_PREMIER_ITER_INCR_NORMALE_AU_NOEUD + ,STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_NORMALE_AU_NOEUD + ,STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_INCR_NORMALE_AU_NOEUD + ,STAB_M_B_ITER_1_VIA_F_EXT + ,STAB_M_B_ITER_INCR_1_VIA_F_EXT + ,STAB_M_B_ITER_1_VIA_F_EXT_NORMALE_AU_NOEUD + ,STAB_M_B_ITER_INCR_1_VIA_F_EXT_NORMALE_AU_NOEUD + }; +/// @} // end of group + + + +// Retourne le nom a partir de son identificateur de type enumere +string Nom_StabMembraneBiel (Enum_StabMembraneBiel id_StabMembraneBiel); + +// Retourne l'identificateur de type enumere associe au nom d'une StabMembraneBiel +Enum_StabMembraneBiel Id_Enum_StabMembraneBiel(const string& nom_StabMembraneBiel) ; + +// Retourne vrai si le nom passé en argument représente un type de StabMembraneBiel reconnu +// sinon false +bool Type_Enum_StabMembraneBiel_existe(const string& nom); + +// retourne vrai si le type enumere se termine par _NORMALE_AU_NOEUD +bool Contient_Normale_au_noeud(Enum_StabMembraneBiel id_StabMembraneBiel); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_StabMembraneBiel& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_StabMembraneBiel& a); + +#endif diff --git a/Enumeration/Enum_Suite.cc b/Enumeration/Enum_Suite.cc new file mode 100644 index 0000000..36f95bf --- /dev/null +++ b/Enumeration/Enum_Suite.cc @@ -0,0 +1,123 @@ +// FICHIER : Enum_Suite.cc + + +// 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-2021 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: . + + +#include "Enum_Suite.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +char* Nom_Suite (Enum_Suite id_Suite) +// Retourne le nom de la suite correspondant a l'identificateur +// de type enumere id_Suite +{ + + char* result; + switch (id_Suite) + { + case SUITE_EQUIDISTANTE :result="SUITE_EQUIDISTANTE";break; + case SUITE_ARITHMETIQUE :result="SUITE_ARITHMETIQUE";break; + case SUITE_GEOMETRIQUE :result="SUITE_GEOMETRIQUE";break; + case SUITE_NON_DEFINIE :result="SUITE_NON_DEFINIE";break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_Suite !\n"; + cout << "Nom_Suite(Enum_Suite ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_Suite Id_Nom_Suite (const char* nom_Suite) +// Retourne la variable de type enumere associee au nom de la Suite +{ + + Enum_Suite result; + if ( strcmp(nom_Suite,"SUITE_EQUIDISTANTE")==0 ) + result=SUITE_EQUIDISTANTE; + else if ( strcmp(nom_Suite,"SUITE_ARITHMETIQUE")==0 ) + result=SUITE_ARITHMETIQUE; + else if ( strcmp(nom_Suite,"SUITE_GEOMETRIQUE")==0 ) + result=SUITE_GEOMETRIQUE; + else if ( strcmp(nom_Suite,"SUITE_NON_DEFINIE")==0 ) + result=SUITE_NON_DEFINIE; + else + { + cout << "\nErreur : nom de la Suite inconnu !: " << nom_Suite << "\n"; + cout << "Id_Nom_Suite (char* nom_Suite) \n"; + Sortie(1); + }; + return result; + +}; + +// Retourne vrai si le nom passé en argument représente un type de suite reconnu +// sinon false +bool Type_Enum_Suite_existe(const string& nom) +{ bool result; + if ( nom == "SUITE_EQUIDISTANTE") result=true; + else if ( nom == "SUITE_ARITHMETIQUE") result=true; + else if ( nom == "SUITE_GEOMETRIQUE") result=true; + else if ( nom == "SUITE_NON_DEFINIE") result=true; + else result = false; + return result; +}; + + // surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_Suite& a) + { char nom_Enum_Suite[50]; + entree >> nom_Enum_Suite; + a = Id_Nom_Suite ( nom_Enum_Suite); + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_Suite& a) + { // on ecrit la forme caractère + sort << Nom_Suite(a) << " "; + return sort; + }; + + diff --git a/Enumeration/Enum_TypeQuelconque.cc b/Enumeration/Enum_TypeQuelconque.cc new file mode 100644 index 0000000..91eaa4d --- /dev/null +++ b/Enumeration/Enum_TypeQuelconque.cc @@ -0,0 +1,1731 @@ +// FICHIER : EnumTypeQuelconque.cc + + +// 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-2021 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: . + + +#include "Enum_TypeQuelconque.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + +// tout d'abord on définit la map qui permet de relier les chaines et les types énumérés + // 1) def de la map et des tableaux + map < string, EnumTypeQuelconque , std::less < string> > + ClassPourEnumTypeQuelconque::map_EnumTypeQuelconque; + Tableau < int > ClassPourEnumTypeQuelconque::tt_GLOB; + Tableau < Enum_dure > ClassPourEnumTypeQuelconque::tt_TQ_temps; + + // 2) def de la grandeur statique qui permet de remplir la map + ClassPourEnumTypeQuelconque ClassPourEnumTypeQuelconque::remplir_map; + // le constructeur qui rempli effectivement la map + ClassPourEnumTypeQuelconque::ClassPourEnumTypeQuelconque() + { // remplissage de la map + map_EnumTypeQuelconque["RIEN_TYPEQUELCONQUE"]=RIEN_TYPEQUELCONQUE; + map_EnumTypeQuelconque["sigma_barre_BH_t"]=SIGMA_BARRE_BH_T; + map_EnumTypeQuelconque["contrainte_individuelle_a_t_sans_proportion"]=CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T_SANS_PROPORTION; + map_EnumTypeQuelconque["contrainte_individuelle_a_chaque_loi_a_t"]=CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T; + map_EnumTypeQuelconque["CONTRAINTE_COURANTE"]=CONTRAINTE_COURANTE; + map_EnumTypeQuelconque["DEFORMATION_COURANTE"]=DEFORMATION_COURANTE; + map_EnumTypeQuelconque["VITESSE_DEFORMATION_COURANTE"]=VITESSE_DEFORMATION_COURANTE; + map_EnumTypeQuelconque["ALMANSI"]=ALMANSI; + map_EnumTypeQuelconque["GREEN_LAGRANGE"]=GREEN_LAGRANGE; + map_EnumTypeQuelconque["LOGARITHMIQUE"]=LOGARITHMIQUE; + map_EnumTypeQuelconque["DELTA_DEF"]=DELTA_DEF; + map_EnumTypeQuelconque["ALMANSI_TOTAL"]=ALMANSI_TOTAL; + map_EnumTypeQuelconque["GREEN_LAGRANGE_TOTAL"]=GREEN_LAGRANGE_TOTAL; + map_EnumTypeQuelconque["LOGARITHMIQUE_TOTALE"]=LOGARITHMIQUE_TOTALE; + map_EnumTypeQuelconque["DEF_PRINCIPALES"]=DEF_PRINCIPALES; + map_EnumTypeQuelconque["SIGMA_PRINCIPALES"]=SIGMA_PRINCIPALES; + map_EnumTypeQuelconque["VIT_PRINCIPALES"]=VIT_PRINCIPALES; + map_EnumTypeQuelconque["DEF_DUALE_MISES"]=DEF_DUALE_MISES; + map_EnumTypeQuelconque["DEF_DUALE_MISES_MAXI"]=DEF_DUALE_MISES_MAXI; + map_EnumTypeQuelconque["CONTRAINTE_MISES"]=CONTRAINTE_MISES; + map_EnumTypeQuelconque["CONTRAINTE_MISES_T"]=CONTRAINTE_MISES_T; + map_EnumTypeQuelconque["CONTRAINTE_TRESCA"]=CONTRAINTE_TRESCA; + map_EnumTypeQuelconque["CONTRAINTE_TRESCA_T"]=CONTRAINTE_TRESCA_T; + map_EnumTypeQuelconque["ERREUR_Q"]=ERREUR_Q; + map_EnumTypeQuelconque["DEF_PLASTIQUE_CUMULEE"]=DEF_PLASTIQUE_CUMULEE; + map_EnumTypeQuelconque["ERREUR_SIG_RELATIVE"]=ERREUR_SIG_RELATIVE; + + map_EnumTypeQuelconque["TEMPERATURE_LOI_THERMO_PHYSIQUE"]=TEMPERATURE_LOI_THERMO_PHYSIQUE; + map_EnumTypeQuelconque["PRESSION_LOI_THERMO_PHYSIQUE"]=PRESSION_LOI_THERMO_PHYSIQUE; + map_EnumTypeQuelconque["TEMPERATURE_TRANSITION"]=TEMPERATURE_TRANSITION; + map_EnumTypeQuelconque["VOLUME_SPECIFIQUE"]=VOLUME_SPECIFIQUE; + map_EnumTypeQuelconque["FLUXD"]=FLUXD; + map_EnumTypeQuelconque["GRADT"]=GRADT; + map_EnumTypeQuelconque["DGRADT"]=DGRADT; + map_EnumTypeQuelconque["DELTAGRADT"]=DELTAGRADT; + map_EnumTypeQuelconque["COEFF_DILATATION_LINEAIRE"]=COEFF_DILATATION_LINEAIRE; + map_EnumTypeQuelconque["CONDUCTIVITE"]=CONDUCTIVITE; + map_EnumTypeQuelconque["CAPACITE_CALORIFIQUE"]=CAPACITE_CALORIFIQUE; + map_EnumTypeQuelconque["MODULE_COMPRESSIBILITE"]=MODULE_COMPRESSIBILITE; + map_EnumTypeQuelconque["COEFF_COMPRESSIBILITE"]=COEFF_COMPRESSIBILITE; + map_EnumTypeQuelconque["MODULE_CISAILLEMENT"]=MODULE_CISAILLEMENT; + map_EnumTypeQuelconque["MODULE_COMPRESSIBILITE_TOTAL"]=MODULE_COMPRESSIBILITE_TOTAL; + map_EnumTypeQuelconque["MODULE_CISAILLEMENT_TOTAL"]=MODULE_CISAILLEMENT_TOTAL; + map_EnumTypeQuelconque["E_YOUNG"]=E_YOUNG; + map_EnumTypeQuelconque["NU_YOUNG"]=NU_YOUNG; + map_EnumTypeQuelconque["MU_VISCO"]=MU_VISCO; + map_EnumTypeQuelconque["MU_VISCO_SPHERIQUE"]=MU_VISCO_SPHERIQUE; + map_EnumTypeQuelconque["MODULE_TANGENT_1D"]=MODULE_TANGENT_1D; + map_EnumTypeQuelconque["COMPRESSIBILITE_TANGENTE"]=COMPRESSIBILITE_TANGENTE; + map_EnumTypeQuelconque["NB_INVERSION"]=NB_INVERSION; + map_EnumTypeQuelconque["HYPER_CENTRE_HYSTERESIS"]=HYPER_CENTRE_HYSTERESIS; + map_EnumTypeQuelconque["SIGMA_REF"]=SIGMA_REF; + map_EnumTypeQuelconque["Q_SIG_HYST_Oi_A_R"]=Q_SIG_HYST_Oi_A_R; + map_EnumTypeQuelconque["Q_SIG_HYST_R_A_T"]=Q_SIG_HYST_R_A_T; + map_EnumTypeQuelconque["Q_DELTA_SIG_HYST"]=Q_DELTA_SIG_HYST; + map_EnumTypeQuelconque["COS_ALPHA_HYSTERESIS"]=COS_ALPHA_HYSTERESIS; + map_EnumTypeQuelconque["COS3PHI_SIG_HYSTERESIS"]=COS3PHI_SIG_HYSTERESIS; + map_EnumTypeQuelconque["COS3PHI_DELTA_SIG_HYSTERESIS"]=COS3PHI_DELTA_SIG_HYSTERESIS; + map_EnumTypeQuelconque["FCT_AIDE"]=FCT_AIDE; + map_EnumTypeQuelconque["NB_ITER_TOTAL_RESIDU"]=NB_ITER_TOTAL_RESIDU; + map_EnumTypeQuelconque["NB_INCRE_TOTAL_RESIDU"]=NB_INCRE_TOTAL_RESIDU; + map_EnumTypeQuelconque["NB_APPEL_FCT"]=NB_APPEL_FCT; + map_EnumTypeQuelconque["NB_STEP"]=NB_STEP; + map_EnumTypeQuelconque["ERREUR_RK"]=ERREUR_RK; + map_EnumTypeQuelconque["PRESSION_HYST_REF"]=PRESSION_HYST_REF; + map_EnumTypeQuelconque["PRESSION_HYST_REF_M1"]=PRESSION_HYST_REF_M1; + map_EnumTypeQuelconque["PRESSION_HYST_T"]=PRESSION_HYST_T; + map_EnumTypeQuelconque["PRESSION_HYST"]=PRESSION_HYST; + map_EnumTypeQuelconque["UN_DDL_ENUM_ETENDUE"]=UN_DDL_ENUM_ETENDUE; + map_EnumTypeQuelconque["ENERGIE_ELASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T"] + =ENERGIE_ELASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T; + map_EnumTypeQuelconque["ENERGIE_PLASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T"] + =ENERGIE_PLASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T; + map_EnumTypeQuelconque["ENERGIE_VISQUEUSE_INDIVIDUELLE_A_CHAQUE_LOI_A_T"] + =ENERGIE_VISQUEUSE_INDIVIDUELLE_A_CHAQUE_LOI_A_T; + map_EnumTypeQuelconque["PROPORTION_LOI_MELANGE"]=PROPORTION_LOI_MELANGE; + map_EnumTypeQuelconque["FONC_PONDERATION"]=FONC_PONDERATION; + map_EnumTypeQuelconque["POSITION_GEOMETRIQUE"]=POSITION_GEOMETRIQUE; + map_EnumTypeQuelconque["POSITION_GEOMETRIQUE_t"]=POSITION_GEOMETRIQUE_t; + map_EnumTypeQuelconque["POSITION_GEOMETRIQUE_t0"]=POSITION_GEOMETRIQUE_t0; + map_EnumTypeQuelconque["CRISTALINITE"]=CRISTALINITE; + map_EnumTypeQuelconque["VOLUME_ELEMENT"]=VOLUME_ELEMENT; + map_EnumTypeQuelconque["VOLUME_PTI"]=VOLUME_PTI; + map_EnumTypeQuelconque["EPAISSEUR_MOY_INITIALE"]=EPAISSEUR_MOY_INITIALE; + map_EnumTypeQuelconque["EPAISSEUR_MOY_FINALE"]=EPAISSEUR_MOY_FINALE; + map_EnumTypeQuelconque["SECTION_MOY_INITIALE"]=SECTION_MOY_INITIALE; + map_EnumTypeQuelconque["SECTION_MOY_FINALE"]=SECTION_MOY_FINALE; + map_EnumTypeQuelconque["EPAISSEUR_INITIALE"]=EPAISSEUR_INITIALE; + map_EnumTypeQuelconque["EPAISSEUR_FINALE"]=EPAISSEUR_FINALE; + map_EnumTypeQuelconque["SECTION_INITIALE"]=SECTION_INITIALE; + map_EnumTypeQuelconque["SECTION_FINALE"]=SECTION_FINALE; + map_EnumTypeQuelconque["VOL_ELEM_AVEC_PLAN_REF"]=VOL_ELEM_AVEC_PLAN_REF; + map_EnumTypeQuelconque["INTEG_SUR_VOLUME"]=INTEG_SUR_VOLUME; + map_EnumTypeQuelconque["INTEG_SUR_VOLUME_ET_TEMPS"]=INTEG_SUR_VOLUME_ET_TEMPS; + map_EnumTypeQuelconque["STATISTIQUE"]=STATISTIQUE; + map_EnumTypeQuelconque["STATISTIQUE_ET_TEMPS"]=STATISTIQUE_ET_TEMPS; + map_EnumTypeQuelconque["ENERGIE_HOURGLASS"]=ENERGIE_HOURGLASS; + map_EnumTypeQuelconque["PUISSANCE_BULK"]=PUISSANCE_BULK; + map_EnumTypeQuelconque["ENERGIE_BULK"]=ENERGIE_BULK; + map_EnumTypeQuelconque["ENERGIE_STABMEMB_BIEL"]=ENERGIE_STABMEMB_BIEL; + map_EnumTypeQuelconque["FORCE_STABMEMB_BIEL"]=FORCE_STABMEMB_BIEL; + map_EnumTypeQuelconque["TENSEUR_COURBURE"]=TENSEUR_COURBURE; + map_EnumTypeQuelconque["COURBURES_PRINCIPALES"]=COURBURES_PRINCIPALES; + map_EnumTypeQuelconque["DIRECTIONS_PRINC_COURBURE"]=DIRECTIONS_PRINC_COURBURE; + map_EnumTypeQuelconque["DIRECTIONS_PRINC_SIGMA"]=DIRECTIONS_PRINC_SIGMA; + map_EnumTypeQuelconque["DIRECTIONS_PRINC_DEF"]=DIRECTIONS_PRINC_DEF; + map_EnumTypeQuelconque["DIRECTIONS_PRINC_D"]=DIRECTIONS_PRINC_D; + map_EnumTypeQuelconque["REPERE_LOCAL_ORTHO"]=REPERE_LOCAL_ORTHO; + map_EnumTypeQuelconque["REPERE_LOCAL_H"]=REPERE_LOCAL_H; + map_EnumTypeQuelconque["REPERE_LOCAL_B"]=REPERE_LOCAL_B; + map_EnumTypeQuelconque["REPERE_D_ANISOTROPIE"]=REPERE_D_ANISOTROPIE; + map_EnumTypeQuelconque["EPS_TRANSPORTEE_ANISO"]=EPS_TRANSPORTEE_ANISO; + map_EnumTypeQuelconque["SIGMA_DANS_ANISO"]=SIGMA_DANS_ANISO; + map_EnumTypeQuelconque["DELTA_EPS_TRANSPORTEE_ANISO"]=DELTA_EPS_TRANSPORTEE_ANISO; + map_EnumTypeQuelconque["DELTA_SIGMA_DANS_ANISO"]=DELTA_SIGMA_DANS_ANISO; + map_EnumTypeQuelconque["PARA_ORTHO"]=PARA_ORTHO; + map_EnumTypeQuelconque["SPHERIQUE_EPS"]=SPHERIQUE_EPS; + map_EnumTypeQuelconque["Q_EPS"]=Q_EPS; + map_EnumTypeQuelconque["COS3PHI_EPS"]=COS3PHI_EPS; + map_EnumTypeQuelconque["SPHERIQUE_SIG"]=SPHERIQUE_SIG; + map_EnumTypeQuelconque["Q_SIG"]=Q_SIG; + map_EnumTypeQuelconque["COS3PHI_SIG"]=COS3PHI_SIG; + map_EnumTypeQuelconque["SPHERIQUE_DEPS"]=SPHERIQUE_DEPS; + map_EnumTypeQuelconque["V_vol"]=V_vol; + map_EnumTypeQuelconque["Q_DEPS"]=Q_DEPS; + map_EnumTypeQuelconque["COS3PHI_DEPS"]=COS3PHI_DEPS; + map_EnumTypeQuelconque["POTENTIEL"]=POTENTIEL; + map_EnumTypeQuelconque["FCT_POTENTIEL_ND"]=FCT_POTENTIEL_ND; + map_EnumTypeQuelconque["INVAR_B1"]=INVAR_B1; + map_EnumTypeQuelconque["INVAR_B2"]=INVAR_B2; + map_EnumTypeQuelconque["INVAR_B3"]=INVAR_B3; + map_EnumTypeQuelconque["INVAR_J1"]=INVAR_J1; + map_EnumTypeQuelconque["INVAR_J2"]=INVAR_J2; + map_EnumTypeQuelconque["INVAR_J3"]=INVAR_J3; + map_EnumTypeQuelconque["DEF_EQUIVALENTE"]=DEF_EQUIVALENTE; + map_EnumTypeQuelconque["DEF_EPAISSEUR"]=DEF_EPAISSEUR; + map_EnumTypeQuelconque["D_EPAISSEUR"]=D_EPAISSEUR; + map_EnumTypeQuelconque["DEF_LARGEUR"]=DEF_LARGEUR; + map_EnumTypeQuelconque["D_LARGEUR"]=D_LARGEUR; + map_EnumTypeQuelconque["DEF_MECANIQUE"]=DEF_MECANIQUE; + map_EnumTypeQuelconque["DEF_ASSO_LOI"]=DEF_ASSO_LOI; + map_EnumTypeQuelconque["DEF_P_DANS_V_A"]=DEF_P_DANS_V_A; + map_EnumTypeQuelconque["SIG_EPAISSEUR"]=SIG_EPAISSEUR; + map_EnumTypeQuelconque["SIG_LARGEUR"]=SIG_LARGEUR; + map_EnumTypeQuelconque["FORCE_GENE_EXT"]=FORCE_GENE_EXT; + map_EnumTypeQuelconque["FORCE_GENE_INT"]=FORCE_GENE_INT; + map_EnumTypeQuelconque["FORCE_GENE_EXT_t"]=FORCE_GENE_EXT_t; + map_EnumTypeQuelconque["FORCE_GENE_INT_t"]=FORCE_GENE_INT_t; + map_EnumTypeQuelconque["FORCE_GENE_TOT"]=FORCE_GENE_TOT; + map_EnumTypeQuelconque["RESIDU_GLOBAL"]=RESIDU_GLOBAL; + map_EnumTypeQuelconque["VECT_PRESSION"]=VECT_PRESSION; + map_EnumTypeQuelconque["PRESSION_SCALAIRE"]=PRESSION_SCALAIRE; + map_EnumTypeQuelconque["VECT_FORCE_VOLUM"]=VECT_FORCE_VOLUM; + map_EnumTypeQuelconque["VECT_DIR_FIXE"]=VECT_DIR_FIXE; + map_EnumTypeQuelconque["VECT_SURF_SUIV"]=VECT_SURF_SUIV; + map_EnumTypeQuelconque["VECT_HYDRODYNA_Fn"]=VECT_HYDRODYNA_Fn; + map_EnumTypeQuelconque["VECT_HYDRODYNA_Ft"]=VECT_HYDRODYNA_Ft; + map_EnumTypeQuelconque["VECT_HYDRODYNA_T"]=VECT_HYDRODYNA_T; + map_EnumTypeQuelconque["VECT_LINE"]=VECT_LINE; + map_EnumTypeQuelconque["VECT_LINE_SUIV"]=VECT_LINE_SUIV; + map_EnumTypeQuelconque["VECT_REAC"]=VECT_REAC; + map_EnumTypeQuelconque["VECT_REAC_N"]=VECT_REAC_N; + map_EnumTypeQuelconque["NN_11"]=NN_11; + map_EnumTypeQuelconque["NN_22"]=NN_22; + map_EnumTypeQuelconque["NN_33"]=NN_33; + map_EnumTypeQuelconque["NN_12"]=NN_12; + map_EnumTypeQuelconque["NN_13"]=NN_13; + map_EnumTypeQuelconque["NN_23"]=NN_23; + map_EnumTypeQuelconque["MM_11"]=MM_11; + map_EnumTypeQuelconque["MM_22"]=MM_22; + map_EnumTypeQuelconque["MM_33"]=MM_33; + map_EnumTypeQuelconque["MM_12"]=MM_12; + map_EnumTypeQuelconque["MM_13"]=MM_13; + map_EnumTypeQuelconque["MM_23"]=MM_23; + map_EnumTypeQuelconque["DIRECTION_PLI"]=DIRECTION_PLI; + map_EnumTypeQuelconque["DIRECTION_PLI_NORMEE"]=DIRECTION_PLI_NORMEE; + map_EnumTypeQuelconque["INDIC_CAL_PLIS"]=INDIC_CAL_PLIS; + map_EnumTypeQuelconque["NN_SURF"]=NN_SURF; + map_EnumTypeQuelconque["NN_SURF_t"]=NN_SURF_t; + map_EnumTypeQuelconque["NN_SURF_t0"]=NN_SURF_t0; + map_EnumTypeQuelconque["NOEUD_PROJECTILE_EN_CONTACT"]=NOEUD_PROJECTILE_EN_CONTACT; + map_EnumTypeQuelconque["NOEUD_FACETTE_EN_CONTACT"]=NOEUD_FACETTE_EN_CONTACT; + map_EnumTypeQuelconque["GLISSEMENT_CONTACT"]=GLISSEMENT_CONTACT; + map_EnumTypeQuelconque["PENETRATION_CONTACT"]=PENETRATION_CONTACT; + map_EnumTypeQuelconque["GLISSEMENT_CONTACT_T"]=GLISSEMENT_CONTACT_T; + map_EnumTypeQuelconque["PENETRATION_CONTACT_T"]=PENETRATION_CONTACT_T; + map_EnumTypeQuelconque["FORCE_CONTACT"]=FORCE_CONTACT; + map_EnumTypeQuelconque["FORCE_CONTACT_T"]=FORCE_CONTACT_T; + map_EnumTypeQuelconque["CONTACT_NB_PENET"]=CONTACT_NB_PENET; + map_EnumTypeQuelconque["CONTACT_NB_DECOL"]=CONTACT_NB_DECOL; + map_EnumTypeQuelconque["CONTACT_CAS_SOLIDE"]=CONTACT_CAS_SOLIDE; + map_EnumTypeQuelconque["CONTACT_ENERG_PENAL"]=CONTACT_ENERG_PENAL; + map_EnumTypeQuelconque["CONTACT_COLLANT"]=CONTACT_COLLANT; + map_EnumTypeQuelconque["NUM_ZONE_CONTACT"]=NUM_ZONE_CONTACT; + map_EnumTypeQuelconque["CONTACT_ENERG_GLISSE_ELAS"]=CONTACT_ENERG_GLISSE_ELAS; + map_EnumTypeQuelconque["CONTACT_ENERG_GLISSE_PLAS"]=CONTACT_ENERG_GLISSE_PLAS; + map_EnumTypeQuelconque["CONTACT_ENERG_GLISSE_VISQ"]=CONTACT_ENERG_GLISSE_VISQ; + map_EnumTypeQuelconque["CONTACT_PENALISATION_N"]=CONTACT_PENALISATION_N; + map_EnumTypeQuelconque["CONTACT_PENALISATION_T"]=CONTACT_PENALISATION_T; + map_EnumTypeQuelconque["NORMALE_CONTACT"]=NORMALE_CONTACT; + map_EnumTypeQuelconque["TEMPS_CPU_USER"]=TEMPS_CPU_USER; + map_EnumTypeQuelconque["TEMPS_CPU_LOI_COMP"]=TEMPS_CPU_LOI_COMP; + map_EnumTypeQuelconque["TEMPS_CPU_METRIQUE"]=TEMPS_CPU_METRIQUE; + map_EnumTypeQuelconque["GENERIQUE_UNE_GRANDEUR_GLOBALE"]=GENERIQUE_UNE_GRANDEUR_GLOBALE; + map_EnumTypeQuelconque["GENERIQUE_UNE_CONSTANTE_GLOB_INT_UTILISATEUR"]=GENERIQUE_UNE_CONSTANTE_GLOB_INT_UTILISATEUR; + map_EnumTypeQuelconque["GENERIQUE_UNE_CONSTANTE_GLOB_DOUBLE_UTILISATEUR"]=GENERIQUE_UNE_CONSTANTE_GLOB_DOUBLE_UTILISATEUR; + map_EnumTypeQuelconque["GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0"]=GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0; + map_EnumTypeQuelconque["GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0"]=GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0; + + map_EnumTypeQuelconque["GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_T"]=GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_T; + map_EnumTypeQuelconque["GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT"]=GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT; + map_EnumTypeQuelconque["DEPLACEMENT"]=DEPLACEMENT; + map_EnumTypeQuelconque["VITESSE"]=VITESSE; + map_EnumTypeQuelconque["DELTA_XI"]=DELTA_XI; + map_EnumTypeQuelconque["XI_ITER_0"]=XI_ITER_0; + map_EnumTypeQuelconque["MASSE_RELAX_DYN"]=MASSE_RELAX_DYN; + map_EnumTypeQuelconque["COMP_TORSEUR_REACTION"]=COMP_TORSEUR_REACTION; + map_EnumTypeQuelconque["NUM_NOEUD"]=NUM_NOEUD; + map_EnumTypeQuelconque["NUM_MAIL_NOEUD"]=NUM_MAIL_NOEUD; + map_EnumTypeQuelconque["NUM_ELEMENT"]=NUM_ELEMENT; + map_EnumTypeQuelconque["NUM_MAIL_ELEM"]=NUM_MAIL_ELEM; + map_EnumTypeQuelconque["NUM_PTI"]=NUM_PTI; + map_EnumTypeQuelconque["NUM_FACE"]=NUM_FACE; + map_EnumTypeQuelconque["NUM_ARETE"]=NUM_ARETE; + + // remplissage de tt_GLOB + tt_GLOB.Change_taille(218); // ****** ne pas oublier de redéfinir la taille si l'on ajoute des termes enum + tt_GLOB(RIEN_TYPEQUELCONQUE)=1; + tt_GLOB(SIGMA_BARRE_BH_T)=0; + tt_GLOB(CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T_SANS_PROPORTION)=0; + tt_GLOB(CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T)=0; + tt_GLOB(CONTRAINTE_COURANTE)=1; + tt_GLOB(DEFORMATION_COURANTE)=1; + tt_GLOB(VITESSE_DEFORMATION_COURANTE)=1; + tt_GLOB(ALMANSI)=1; + tt_GLOB(GREEN_LAGRANGE)=1; + tt_GLOB(LOGARITHMIQUE)=1; + tt_GLOB(DELTA_DEF)=1; + tt_GLOB(ALMANSI_TOTAL)=1; + tt_GLOB(GREEN_LAGRANGE_TOTAL)=1; + tt_GLOB(LOGARITHMIQUE_TOTALE)=1; + tt_GLOB(DEF_PRINCIPALES)=1; + tt_GLOB(SIGMA_PRINCIPALES)=1; + tt_GLOB(VIT_PRINCIPALES)=1; + tt_GLOB(DEF_DUALE_MISES)=1; + tt_GLOB(DEF_DUALE_MISES_MAXI)=1; + tt_GLOB(CONTRAINTE_MISES)=1; + tt_GLOB(CONTRAINTE_MISES_T)=1; + tt_GLOB(CONTRAINTE_TRESCA)=1; + tt_GLOB(CONTRAINTE_TRESCA_T)=1; + tt_GLOB(ERREUR_Q)=1; + tt_GLOB(DEF_PLASTIQUE_CUMULEE)=1; + tt_GLOB(ERREUR_SIG_RELATIVE)=1; + tt_GLOB(TEMPERATURE_LOI_THERMO_PHYSIQUE)=1; + tt_GLOB(PRESSION_LOI_THERMO_PHYSIQUE)=1; + tt_GLOB(TEMPERATURE_TRANSITION)=1; + tt_GLOB(VOLUME_SPECIFIQUE)=1; + tt_GLOB(FLUXD)=1; + tt_GLOB(GRADT)=1; + tt_GLOB(DGRADT)=1; + tt_GLOB(DELTAGRADT)=1; + tt_GLOB(COEFF_DILATATION_LINEAIRE)=1; + tt_GLOB(CONDUCTIVITE)=1; + tt_GLOB(CAPACITE_CALORIFIQUE)=1; + tt_GLOB(MODULE_COMPRESSIBILITE)=1; + tt_GLOB(COEFF_COMPRESSIBILITE)=1; + tt_GLOB(MODULE_CISAILLEMENT)=1; + tt_GLOB(MODULE_COMPRESSIBILITE_TOTAL)=1; + tt_GLOB(MODULE_CISAILLEMENT_TOTAL)=1; + tt_GLOB(E_YOUNG)=1; + tt_GLOB(NU_YOUNG)=1; + tt_GLOB(MU_VISCO)=1; + tt_GLOB(MU_VISCO_SPHERIQUE)=1; + tt_GLOB(MODULE_TANGENT_1D)=1; + tt_GLOB(COMPRESSIBILITE_TANGENTE)=1; + tt_GLOB(NB_INVERSION)=1; + tt_GLOB(HYPER_CENTRE_HYSTERESIS)=0; + tt_GLOB(SIGMA_REF)=0; + tt_GLOB(Q_SIG_HYST_Oi_A_R)=1; + tt_GLOB(Q_SIG_HYST_R_A_T)=1; + tt_GLOB(Q_DELTA_SIG_HYST)=1; + tt_GLOB(COS_ALPHA_HYSTERESIS)=1; + tt_GLOB(COS3PHI_SIG_HYSTERESIS)=1; + tt_GLOB(COS3PHI_DELTA_SIG_HYSTERESIS)=1; + tt_GLOB(FCT_AIDE)=1; + tt_GLOB(NB_ITER_TOTAL_RESIDU)=1; + tt_GLOB(NB_INCRE_TOTAL_RESIDU)=1; + tt_GLOB(NB_APPEL_FCT)=1; + tt_GLOB(NB_STEP)=1; + tt_GLOB(ERREUR_RK)=1; + tt_GLOB(PRESSION_HYST_REF)=1; + tt_GLOB(PRESSION_HYST_REF_M1)=1; + tt_GLOB(PRESSION_HYST_T)=1; + tt_GLOB(PRESSION_HYST)=1; + tt_GLOB(UN_DDL_ENUM_ETENDUE)=1; + tt_GLOB(ENERGIE_ELASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T)=1; + tt_GLOB(ENERGIE_PLASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T)=1; + tt_GLOB(ENERGIE_VISQUEUSE_INDIVIDUELLE_A_CHAQUE_LOI_A_T)=1; + tt_GLOB(PROPORTION_LOI_MELANGE)=1; + tt_GLOB(FONC_PONDERATION)=1; + tt_GLOB(POSITION_GEOMETRIQUE)=1; + tt_GLOB(POSITION_GEOMETRIQUE_t)=1; + tt_GLOB(POSITION_GEOMETRIQUE_t0)=1; + tt_GLOB(CRISTALINITE)=1; + tt_GLOB(VOLUME_ELEMENT)=1; + tt_GLOB(VOLUME_PTI)=1; + tt_GLOB(EPAISSEUR_MOY_INITIALE)=1; + tt_GLOB(EPAISSEUR_MOY_FINALE)=1; + tt_GLOB(SECTION_MOY_INITIALE)=1; + tt_GLOB(SECTION_MOY_FINALE)=1; + tt_GLOB(EPAISSEUR_INITIALE)=1; + tt_GLOB(EPAISSEUR_FINALE)=1; + tt_GLOB(SECTION_INITIALE)=1; + tt_GLOB(SECTION_FINALE)=1; + tt_GLOB(VOL_ELEM_AVEC_PLAN_REF)=1; + tt_GLOB(INTEG_SUR_VOLUME)=1; + tt_GLOB(INTEG_SUR_VOLUME_ET_TEMPS)=1; + tt_GLOB(STATISTIQUE)=1; + tt_GLOB(STATISTIQUE_ET_TEMPS)=1; + tt_GLOB(ENERGIE_HOURGLASS)=1; + tt_GLOB(PUISSANCE_BULK)=1; + tt_GLOB(ENERGIE_BULK)=1; + tt_GLOB(ENERGIE_STABMEMB_BIEL)=1; + tt_GLOB(FORCE_STABMEMB_BIEL)=1; + tt_GLOB(TENSEUR_COURBURE)=0; + tt_GLOB(COURBURES_PRINCIPALES)=1; + tt_GLOB(DIRECTIONS_PRINC_COURBURE)=0; + tt_GLOB(DIRECTIONS_PRINC_SIGMA)=1; + tt_GLOB(DIRECTIONS_PRINC_DEF)=1; + tt_GLOB(DIRECTIONS_PRINC_D)=1; + tt_GLOB(REPERE_LOCAL_ORTHO)=1; + tt_GLOB(REPERE_LOCAL_H)=1; + tt_GLOB(REPERE_LOCAL_B)=1; + tt_GLOB(REPERE_D_ANISOTROPIE)=0; + tt_GLOB(EPS_TRANSPORTEE_ANISO)=1; + tt_GLOB(SIGMA_DANS_ANISO)=1; + tt_GLOB(DELTA_EPS_TRANSPORTEE_ANISO)=1; + tt_GLOB(DELTA_SIGMA_DANS_ANISO)=1; + tt_GLOB(PARA_ORTHO)=1; + tt_GLOB(SPHERIQUE_EPS)=1; + tt_GLOB(Q_EPS)=1; + tt_GLOB(COS3PHI_EPS)=1; + tt_GLOB(SPHERIQUE_SIG)=1; + tt_GLOB(Q_SIG)=1; + tt_GLOB(COS3PHI_SIG)=1; + tt_GLOB(SPHERIQUE_DEPS)=1; + tt_GLOB(V_vol)=1; + tt_GLOB(Q_DEPS)=1; + tt_GLOB(COS3PHI_DEPS)=1; + tt_GLOB(POTENTIEL)=1; + tt_GLOB(FCT_POTENTIEL_ND)=1; + tt_GLOB(INVAR_B1)=1; + tt_GLOB(INVAR_B2)=1; + tt_GLOB(INVAR_B3)=1; + tt_GLOB(INVAR_J1)=1; + tt_GLOB(INVAR_J2)=1; + tt_GLOB(INVAR_J3)=1; + tt_GLOB(DEF_EQUIVALENTE)=1; + tt_GLOB(DEF_EPAISSEUR)=1; + tt_GLOB(D_EPAISSEUR)=1; + tt_GLOB(DEF_LARGEUR)=1; + tt_GLOB(D_LARGEUR)=1; + tt_GLOB(DEF_MECANIQUE)=1; + tt_GLOB(DEF_ASSO_LOI)=0; + tt_GLOB(DEF_P_DANS_V_A)=1; + tt_GLOB(SIG_EPAISSEUR)=1; + tt_GLOB(SIG_LARGEUR)=1; + tt_GLOB(FORCE_GENE_EXT)=1; + tt_GLOB(FORCE_GENE_INT)=1; + tt_GLOB(FORCE_GENE_EXT_t)=1; + tt_GLOB(FORCE_GENE_INT_t)=1; + tt_GLOB(FORCE_GENE_TOT)=1; + tt_GLOB(RESIDU_GLOBAL)=1; + tt_GLOB(VECT_PRESSION)=1; + tt_GLOB(PRESSION_SCALAIRE)=1; + tt_GLOB(VECT_FORCE_VOLUM)=1; + tt_GLOB(VECT_DIR_FIXE)=1; + tt_GLOB(VECT_SURF_SUIV)=1; + tt_GLOB(VECT_HYDRODYNA_Fn)=1; + tt_GLOB(VECT_HYDRODYNA_Ft)=1; + tt_GLOB(VECT_HYDRODYNA_T)=1; + tt_GLOB(VECT_LINE)=1; + tt_GLOB(VECT_LINE_SUIV)=1; + tt_GLOB(VECT_REAC)=1; + tt_GLOB(VECT_REAC_N)=1; + tt_GLOB(NN_11)=1; + tt_GLOB(NN_22)=1; + tt_GLOB(NN_33)=1; + tt_GLOB(NN_12)=1; + tt_GLOB(NN_13)=1; + tt_GLOB(NN_23)=1; + tt_GLOB(MM_11)=1; + tt_GLOB(MM_22)=1; + tt_GLOB(MM_33)=1; + tt_GLOB(MM_12)=1; + tt_GLOB(MM_13)=1; + tt_GLOB(MM_23)=1; + tt_GLOB(DIRECTION_PLI)=1; + tt_GLOB(DIRECTION_PLI_NORMEE)=1; + tt_GLOB(INDIC_CAL_PLIS)=1; + tt_GLOB(NN_SURF)=1; + tt_GLOB(NN_SURF_t)=1; + tt_GLOB(NN_SURF_t0)=1; + tt_GLOB(NOEUD_PROJECTILE_EN_CONTACT)=1; + tt_GLOB(NOEUD_FACETTE_EN_CONTACT)=1; + tt_GLOB(GLISSEMENT_CONTACT)=1; + tt_GLOB(PENETRATION_CONTACT)=1; + tt_GLOB(GLISSEMENT_CONTACT_T)=1; + tt_GLOB(PENETRATION_CONTACT_T)=1; + tt_GLOB(FORCE_CONTACT)=1; + tt_GLOB(FORCE_CONTACT_T)=1; + tt_GLOB(CONTACT_NB_PENET)=1; + tt_GLOB(CONTACT_NB_DECOL)=1; + tt_GLOB(CONTACT_CAS_SOLIDE)=1; + tt_GLOB(CONTACT_ENERG_PENAL)=1; + tt_GLOB(CONTACT_COLLANT)=1; + tt_GLOB(NUM_ZONE_CONTACT)=1; + tt_GLOB(CONTACT_ENERG_GLISSE_ELAS)=1; + tt_GLOB(CONTACT_ENERG_GLISSE_PLAS)=1; + tt_GLOB(CONTACT_ENERG_GLISSE_VISQ)=1; + tt_GLOB(CONTACT_PENALISATION_N)=1; + tt_GLOB(CONTACT_PENALISATION_T)=1; + tt_GLOB(NORMALE_CONTACT)=1; + tt_GLOB(TEMPS_CPU_USER)=1; + tt_GLOB(TEMPS_CPU_LOI_COMP)=1; + tt_GLOB(TEMPS_CPU_METRIQUE)=1; + tt_GLOB(GENERIQUE_UNE_GRANDEUR_GLOBALE)=1; + tt_GLOB(GENERIQUE_UNE_CONSTANTE_GLOB_INT_UTILISATEUR)=1; + tt_GLOB(GENERIQUE_UNE_CONSTANTE_GLOB_DOUBLE_UTILISATEUR)=1; + tt_GLOB(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0)=1; + tt_GLOB(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_T)=1; + tt_GLOB(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT)=1; + tt_GLOB(DEPLACEMENT)=1; + tt_GLOB(VITESSE)=1; + tt_GLOB(DELTA_XI)=1; + tt_GLOB(XI_ITER_0)=1; + tt_GLOB(MASSE_RELAX_DYN)=1; + tt_GLOB(COMP_TORSEUR_REACTION)=1; + tt_GLOB(NUM_NOEUD)=1; + tt_GLOB(NUM_MAIL_NOEUD)=1; + tt_GLOB(NUM_ELEMENT)=1; + tt_GLOB(NUM_MAIL_ELEM)=1; + tt_GLOB(NUM_PTI)=1; + tt_GLOB(NUM_FACE)=1; + tt_GLOB(NUM_ARETE)=1; + + // remplissage de tt_TQ_temps + tt_TQ_temps.Change_taille(218); // ****** ne pas oublier de redéfinir la taille si l'on ajoute des termes enum + tt_TQ_temps(RIEN_TYPEQUELCONQUE)=TEMPS_0; + tt_TQ_temps(SIGMA_BARRE_BH_T)=TEMPS_t; + tt_TQ_temps(CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T_SANS_PROPORTION)=TEMPS_tdt; + tt_TQ_temps(CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T)=TEMPS_tdt; + tt_TQ_temps(CONTRAINTE_COURANTE)=TEMPS_tdt; + tt_TQ_temps(DEFORMATION_COURANTE)=TEMPS_tdt; + tt_TQ_temps(VITESSE_DEFORMATION_COURANTE)=TEMPS_tdt; + tt_TQ_temps(ALMANSI)=TEMPS_tdt; + tt_TQ_temps(GREEN_LAGRANGE)=TEMPS_tdt; + tt_TQ_temps(LOGARITHMIQUE)=TEMPS_tdt; + tt_TQ_temps(DELTA_DEF)=TEMPS_tdt; + tt_TQ_temps(ALMANSI_TOTAL)=TEMPS_tdt; + tt_TQ_temps(GREEN_LAGRANGE_TOTAL)=TEMPS_tdt; + tt_TQ_temps(LOGARITHMIQUE_TOTALE)=TEMPS_tdt; + tt_TQ_temps(DEF_PRINCIPALES)=TEMPS_tdt; + tt_TQ_temps(SIGMA_PRINCIPALES)=TEMPS_tdt; + tt_TQ_temps(VIT_PRINCIPALES)=TEMPS_tdt; + tt_TQ_temps(DEF_DUALE_MISES)=TEMPS_tdt; + tt_TQ_temps(DEF_DUALE_MISES_MAXI)=TEMPS_tdt; + tt_TQ_temps(CONTRAINTE_MISES)=TEMPS_tdt; + tt_TQ_temps(CONTRAINTE_MISES_T)=TEMPS_t; + tt_TQ_temps(CONTRAINTE_TRESCA)=TEMPS_tdt; + tt_TQ_temps(CONTRAINTE_TRESCA_T)=TEMPS_t; + tt_TQ_temps(ERREUR_Q)=TEMPS_tdt; + tt_TQ_temps(DEF_PLASTIQUE_CUMULEE)=TEMPS_tdt; + tt_TQ_temps(ERREUR_SIG_RELATIVE)=TEMPS_tdt; + tt_TQ_temps(TEMPERATURE_LOI_THERMO_PHYSIQUE)=TEMPS_tdt; + tt_TQ_temps(PRESSION_LOI_THERMO_PHYSIQUE)=TEMPS_tdt; + tt_TQ_temps(TEMPERATURE_TRANSITION)=TEMPS_tdt; + tt_TQ_temps(VOLUME_SPECIFIQUE)=TEMPS_tdt; + tt_TQ_temps(FLUXD)=TEMPS_tdt; + tt_TQ_temps(GRADT)=TEMPS_tdt; + tt_TQ_temps(DGRADT)=TEMPS_tdt; + tt_TQ_temps(DELTAGRADT)=TEMPS_tdt; + tt_TQ_temps(COEFF_DILATATION_LINEAIRE)=TEMPS_tdt; + tt_TQ_temps(CONDUCTIVITE)=TEMPS_tdt; + tt_TQ_temps(CAPACITE_CALORIFIQUE)=TEMPS_tdt; + tt_TQ_temps(MODULE_COMPRESSIBILITE)=TEMPS_tdt; + tt_TQ_temps(COEFF_COMPRESSIBILITE)=TEMPS_tdt; + tt_TQ_temps(MODULE_CISAILLEMENT)=TEMPS_tdt; + tt_TQ_temps(MODULE_COMPRESSIBILITE_TOTAL)=TEMPS_tdt; + tt_TQ_temps(MODULE_CISAILLEMENT_TOTAL)=TEMPS_tdt; + tt_TQ_temps(E_YOUNG)=TEMPS_tdt; + tt_TQ_temps(NU_YOUNG)=TEMPS_tdt; + tt_TQ_temps(MU_VISCO)=TEMPS_tdt; + tt_TQ_temps(MU_VISCO_SPHERIQUE)=TEMPS_tdt; + tt_TQ_temps(MODULE_TANGENT_1D)=TEMPS_tdt; + tt_TQ_temps(COMPRESSIBILITE_TANGENTE)=TEMPS_tdt; + tt_TQ_temps(NB_INVERSION)=TEMPS_tdt; + tt_TQ_temps(HYPER_CENTRE_HYSTERESIS)=TEMPS_tdt; + tt_TQ_temps(SIGMA_REF)=TEMPS_tdt; + tt_TQ_temps(Q_SIG_HYST_Oi_A_R)=TEMPS_tdt; + tt_TQ_temps(Q_SIG_HYST_R_A_T)=TEMPS_tdt; + tt_TQ_temps(Q_DELTA_SIG_HYST)=TEMPS_tdt; + tt_TQ_temps(COS_ALPHA_HYSTERESIS)=TEMPS_tdt; + tt_TQ_temps(COS3PHI_SIG_HYSTERESIS)=TEMPS_tdt; + tt_TQ_temps(COS3PHI_DELTA_SIG_HYSTERESIS)=TEMPS_tdt; + tt_TQ_temps(FCT_AIDE)=TEMPS_tdt; + tt_TQ_temps(NB_ITER_TOTAL_RESIDU)=TEMPS_tdt; + tt_TQ_temps(NB_INCRE_TOTAL_RESIDU)=TEMPS_tdt; + tt_TQ_temps(NB_APPEL_FCT)=TEMPS_tdt; + tt_TQ_temps(NB_STEP)=TEMPS_tdt; + tt_TQ_temps(ERREUR_RK)=TEMPS_tdt; + tt_TQ_temps(PRESSION_HYST_REF)=TEMPS_tdt; + tt_TQ_temps(PRESSION_HYST_REF_M1)=TEMPS_t; + tt_TQ_temps(PRESSION_HYST_T)=TEMPS_t; + tt_TQ_temps(PRESSION_HYST)=TEMPS_tdt; + tt_TQ_temps(UN_DDL_ENUM_ETENDUE)=TEMPS_tdt; + tt_TQ_temps(ENERGIE_ELASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T)=TEMPS_t; + tt_TQ_temps(ENERGIE_PLASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T)=TEMPS_t; + tt_TQ_temps(ENERGIE_VISQUEUSE_INDIVIDUELLE_A_CHAQUE_LOI_A_T)=TEMPS_t; + tt_TQ_temps(PROPORTION_LOI_MELANGE)=TEMPS_tdt; + tt_TQ_temps(FONC_PONDERATION)=TEMPS_tdt; + tt_TQ_temps(POSITION_GEOMETRIQUE)=TEMPS_tdt; + tt_TQ_temps(POSITION_GEOMETRIQUE_t)=TEMPS_t; + tt_TQ_temps(POSITION_GEOMETRIQUE_t0)=TEMPS_0; + tt_TQ_temps(CRISTALINITE)=TEMPS_tdt; + tt_TQ_temps(VOLUME_ELEMENT)=TEMPS_tdt; + tt_TQ_temps(VOLUME_PTI)=TEMPS_tdt; + tt_TQ_temps(EPAISSEUR_MOY_INITIALE)=TEMPS_0; + tt_TQ_temps(EPAISSEUR_MOY_FINALE)=TEMPS_tdt; + tt_TQ_temps(SECTION_MOY_INITIALE)=TEMPS_0; + tt_TQ_temps(SECTION_MOY_FINALE)=TEMPS_tdt; + tt_TQ_temps(EPAISSEUR_INITIALE)=TEMPS_0; + tt_TQ_temps(EPAISSEUR_FINALE)=TEMPS_tdt; + tt_TQ_temps(SECTION_INITIALE)=TEMPS_0; + tt_TQ_temps(SECTION_FINALE)=TEMPS_tdt; + tt_TQ_temps(VOL_ELEM_AVEC_PLAN_REF)=TEMPS_tdt; + tt_TQ_temps(INTEG_SUR_VOLUME)=TEMPS_tdt; + tt_TQ_temps(INTEG_SUR_VOLUME_ET_TEMPS)=TEMPS_tdt; + tt_TQ_temps(STATISTIQUE)=TEMPS_tdt; + tt_TQ_temps(STATISTIQUE_ET_TEMPS)=TEMPS_tdt; + tt_TQ_temps(ENERGIE_HOURGLASS)=TEMPS_tdt; + tt_TQ_temps(PUISSANCE_BULK)=TEMPS_tdt; + tt_TQ_temps(ENERGIE_BULK)=TEMPS_tdt; + tt_TQ_temps(ENERGIE_STABMEMB_BIEL)=TEMPS_tdt; + tt_TQ_temps(FORCE_STABMEMB_BIEL)=TEMPS_tdt; + tt_TQ_temps(TENSEUR_COURBURE)=TEMPS_tdt; + tt_TQ_temps(COURBURES_PRINCIPALES)=TEMPS_tdt; + tt_TQ_temps(DIRECTIONS_PRINC_COURBURE)=TEMPS_tdt; + tt_TQ_temps(DIRECTIONS_PRINC_SIGMA)=TEMPS_tdt; + tt_TQ_temps(DIRECTIONS_PRINC_DEF)=TEMPS_tdt; + tt_TQ_temps(DIRECTIONS_PRINC_D)=TEMPS_tdt; + tt_TQ_temps(REPERE_LOCAL_ORTHO)=TEMPS_tdt; + tt_TQ_temps(REPERE_LOCAL_H)=TEMPS_tdt; + tt_TQ_temps(REPERE_LOCAL_B)=TEMPS_tdt; + tt_TQ_temps(REPERE_D_ANISOTROPIE)=TEMPS_tdt; + tt_TQ_temps(EPS_TRANSPORTEE_ANISO)=TEMPS_tdt; + tt_TQ_temps(SIGMA_DANS_ANISO)=TEMPS_tdt; + tt_TQ_temps(DELTA_EPS_TRANSPORTEE_ANISO)=TEMPS_tdt; + tt_TQ_temps(DELTA_SIGMA_DANS_ANISO)=TEMPS_tdt; + tt_TQ_temps(PARA_ORTHO)=TEMPS_tdt; + tt_TQ_temps(SPHERIQUE_EPS)=TEMPS_tdt; + tt_TQ_temps(Q_EPS)=TEMPS_tdt; + tt_TQ_temps(COS3PHI_EPS)=TEMPS_tdt; + tt_TQ_temps(SPHERIQUE_SIG)=TEMPS_tdt; + tt_TQ_temps(Q_SIG)=TEMPS_tdt; + tt_TQ_temps(COS3PHI_SIG)=TEMPS_tdt; + tt_TQ_temps(SPHERIQUE_DEPS)=TEMPS_tdt; + tt_TQ_temps(V_vol)=TEMPS_tdt; + tt_TQ_temps(Q_DEPS)=TEMPS_tdt; + tt_TQ_temps(COS3PHI_DEPS)=TEMPS_tdt; + tt_TQ_temps(POTENTIEL)=TEMPS_tdt; + tt_TQ_temps(FCT_POTENTIEL_ND)=TEMPS_tdt; + tt_TQ_temps(INVAR_B1)=TEMPS_tdt; + tt_TQ_temps(INVAR_B2)=TEMPS_tdt; + tt_TQ_temps(INVAR_B3)=TEMPS_tdt; + tt_TQ_temps(INVAR_J1)=TEMPS_tdt; + tt_TQ_temps(INVAR_J2)=TEMPS_tdt; + tt_TQ_temps(INVAR_J3)=TEMPS_tdt; + tt_TQ_temps(DEF_EQUIVALENTE)=TEMPS_tdt; + tt_TQ_temps(DEF_EPAISSEUR)=TEMPS_tdt; + tt_TQ_temps(D_EPAISSEUR)=TEMPS_tdt; + tt_TQ_temps(DEF_LARGEUR)=TEMPS_tdt; + tt_TQ_temps(D_LARGEUR)=TEMPS_tdt; + tt_TQ_temps(DEF_MECANIQUE)=TEMPS_tdt; + tt_TQ_temps(DEF_ASSO_LOI)=TEMPS_tdt; + tt_TQ_temps(DEF_P_DANS_V_A)=TEMPS_tdt; + tt_TQ_temps(SIG_EPAISSEUR)=TEMPS_tdt; + tt_TQ_temps(SIG_LARGEUR)=TEMPS_tdt; + tt_TQ_temps(FORCE_GENE_EXT)=TEMPS_tdt; + tt_TQ_temps(FORCE_GENE_INT)=TEMPS_tdt; + tt_TQ_temps(FORCE_GENE_EXT_t)=TEMPS_t; + tt_TQ_temps(FORCE_GENE_INT_t)=TEMPS_t; + tt_TQ_temps(FORCE_GENE_TOT)=TEMPS_tdt; + tt_TQ_temps(RESIDU_GLOBAL)=TEMPS_tdt; + tt_TQ_temps(VECT_PRESSION)=TEMPS_tdt; + tt_TQ_temps(PRESSION_SCALAIRE)=TEMPS_tdt; + tt_TQ_temps(VECT_FORCE_VOLUM)=TEMPS_tdt; + tt_TQ_temps(VECT_DIR_FIXE)=TEMPS_tdt; + tt_TQ_temps(VECT_SURF_SUIV)=TEMPS_tdt; + tt_TQ_temps(VECT_HYDRODYNA_Fn)=TEMPS_tdt; + tt_TQ_temps(VECT_HYDRODYNA_Ft)=TEMPS_tdt; + tt_TQ_temps(VECT_HYDRODYNA_T)=TEMPS_tdt; + tt_TQ_temps(VECT_LINE)=TEMPS_tdt; + tt_TQ_temps(VECT_LINE_SUIV)=TEMPS_tdt; + tt_TQ_temps(VECT_REAC)=TEMPS_tdt; + tt_TQ_temps(VECT_REAC_N)=TEMPS_tdt; + tt_TQ_temps(NN_11)=TEMPS_tdt; + tt_TQ_temps(NN_22)=TEMPS_tdt; + tt_TQ_temps(NN_33)=TEMPS_tdt; + tt_TQ_temps(NN_12)=TEMPS_tdt; + tt_TQ_temps(NN_13)=TEMPS_tdt; + tt_TQ_temps(NN_23)=TEMPS_tdt; + tt_TQ_temps(MM_11)=TEMPS_tdt; + tt_TQ_temps(MM_22)=TEMPS_tdt; + tt_TQ_temps(MM_33)=TEMPS_tdt; + tt_TQ_temps(MM_12)=TEMPS_tdt; + tt_TQ_temps(MM_13)=TEMPS_tdt; + tt_TQ_temps(MM_23)=TEMPS_tdt; + tt_TQ_temps(DIRECTION_PLI)=TEMPS_tdt; + tt_TQ_temps(DIRECTION_PLI_NORMEE)=TEMPS_tdt; + tt_TQ_temps(INDIC_CAL_PLIS)=TEMPS_tdt; + tt_TQ_temps(NN_SURF)=TEMPS_tdt; + tt_TQ_temps(NN_SURF_t)=TEMPS_t; + tt_TQ_temps(NN_SURF_t0)=TEMPS_0; + tt_TQ_temps(NOEUD_PROJECTILE_EN_CONTACT)=TEMPS_tdt; + tt_TQ_temps(NOEUD_FACETTE_EN_CONTACT)=TEMPS_tdt; + tt_TQ_temps(GLISSEMENT_CONTACT)=TEMPS_tdt; + tt_TQ_temps(PENETRATION_CONTACT)=TEMPS_tdt; + tt_TQ_temps(GLISSEMENT_CONTACT_T)=TEMPS_t; + tt_TQ_temps(PENETRATION_CONTACT_T)=TEMPS_t; + tt_TQ_temps(FORCE_CONTACT)=TEMPS_tdt; + tt_TQ_temps(FORCE_CONTACT_T)=TEMPS_t; + tt_TQ_temps(CONTACT_NB_PENET)=TEMPS_tdt; + tt_TQ_temps(CONTACT_NB_DECOL)=TEMPS_tdt; + tt_TQ_temps(CONTACT_CAS_SOLIDE)=TEMPS_tdt; + tt_TQ_temps(CONTACT_ENERG_PENAL)=TEMPS_tdt; + tt_TQ_temps(CONTACT_COLLANT)=TEMPS_tdt; + tt_TQ_temps(NUM_ZONE_CONTACT)=TEMPS_tdt; + tt_TQ_temps(CONTACT_ENERG_GLISSE_ELAS)=TEMPS_tdt; + tt_TQ_temps(CONTACT_ENERG_GLISSE_PLAS)=TEMPS_tdt; + tt_TQ_temps(CONTACT_ENERG_GLISSE_VISQ)=TEMPS_tdt; + tt_TQ_temps(CONTACT_PENALISATION_N)=TEMPS_tdt; + tt_TQ_temps(CONTACT_PENALISATION_T)=TEMPS_tdt; + tt_TQ_temps(NORMALE_CONTACT)=TEMPS_tdt; + tt_TQ_temps(TEMPS_CPU_USER)=TEMPS_tdt; + tt_TQ_temps(TEMPS_CPU_LOI_COMP)=TEMPS_tdt; + tt_TQ_temps(TEMPS_CPU_METRIQUE)=TEMPS_tdt; + tt_TQ_temps(GENERIQUE_UNE_GRANDEUR_GLOBALE)=TEMPS_tdt; + tt_TQ_temps(GENERIQUE_UNE_CONSTANTE_GLOB_INT_UTILISATEUR)=TEMPS_tdt; + tt_TQ_temps(GENERIQUE_UNE_CONSTANTE_GLOB_DOUBLE_UTILISATEUR)=TEMPS_tdt; + tt_TQ_temps(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0)=TEMPS_0; + tt_TQ_temps(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_T)=TEMPS_t; + tt_TQ_temps(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT)=TEMPS_tdt; + tt_TQ_temps(DEPLACEMENT)=TEMPS_tdt; + tt_TQ_temps(VITESSE)=TEMPS_tdt; + tt_TQ_temps(DELTA_XI)=TEMPS_tdt; + tt_TQ_temps(XI_ITER_0)=TEMPS_tdt; + tt_TQ_temps(MASSE_RELAX_DYN)=TEMPS_tdt; + tt_TQ_temps(COMP_TORSEUR_REACTION)=TEMPS_tdt; + tt_TQ_temps(NUM_NOEUD)=TEMPS_tdt; + tt_TQ_temps(NUM_MAIL_NOEUD)=TEMPS_tdt; + tt_TQ_temps(NUM_ELEMENT)=TEMPS_tdt; + tt_TQ_temps(NUM_MAIL_ELEM)=TEMPS_tdt; + tt_TQ_temps(NUM_PTI)=TEMPS_tdt; + tt_TQ_temps(NUM_FACE)=TEMPS_tdt; + tt_TQ_temps(NUM_ARETE)=TEMPS_tdt; + }; + +string NomTypeQuelconque(EnumTypeQuelconque id_TypeQuelconque) +// Retourne le nom du type de grandeur correspondant a l'identificateur +// de type enumere id_TypeQuelconque +{string result; + switch (id_TypeQuelconque) + {case RIEN_TYPEQUELCONQUE : result="RIEN_TYPEQUELCONQUE"; break; + case SIGMA_BARRE_BH_T : result="sigma_barre_BH_t"; break; + case CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T_SANS_PROPORTION : result="contrainte_individuelle_a_t_sans_proportion"; break; + case CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T : result="contrainte_individuelle_a_chaque_loi_a_t"; break; + case CONTRAINTE_COURANTE : result="CONTRAINTE_COURANTE"; break; + case DEFORMATION_COURANTE : result="DEFORMATION_COURANTE"; break; + case VITESSE_DEFORMATION_COURANTE : result="VITESSE_DEFORMATION_COURANTE"; break; + case ALMANSI : result="ALMANSI"; break; + case GREEN_LAGRANGE : result="GREEN_LAGRANGE"; break; + case LOGARITHMIQUE : result="LOGARITHMIQUE"; break; + case DELTA_DEF : result="DELTA_DEF"; break; + case ALMANSI_TOTAL : result="ALMANSI_TOTAL"; break; + case GREEN_LAGRANGE_TOTAL : result="GREEN_LAGRANGE_TOTAL"; break; + case LOGARITHMIQUE_TOTALE : result="LOGARITHMIQUE_TOTALE"; break; + case DEF_PRINCIPALES : result="DEF_PRINCIPALES"; break; + case SIGMA_PRINCIPALES : result="SIGMA_PRINCIPALES"; break; + case VIT_PRINCIPALES : result="VIT_PRINCIPALES"; break; + case DEF_DUALE_MISES : result="DEF_DUALE_MISES"; break; + case DEF_DUALE_MISES_MAXI : result="DEF_DUALE_MISES_MAXI"; break; + case CONTRAINTE_MISES : result="CONTRAINTE_MISES"; break; + case CONTRAINTE_MISES_T : result="CONTRAINTE_MISES_T"; break; + case CONTRAINTE_TRESCA : result="CONTRAINTE_TRESCA"; break; + case CONTRAINTE_TRESCA_T : result="CONTRAINTE_TRESCA_T"; break; + case ERREUR_Q : result="ERREUR_Q"; break; + case DEF_PLASTIQUE_CUMULEE : result="DEF_PLASTIQUE_CUMULEE"; break; + case ERREUR_SIG_RELATIVE : result="ERREUR_SIG_RELATIVE"; break; + + case TEMPERATURE_LOI_THERMO_PHYSIQUE : result="TEMPERATURE_LOI_THERMO_PHYSIQUE"; break; + case PRESSION_LOI_THERMO_PHYSIQUE : result="PRESSION_LOI_THERMO_PHYSIQUE"; break; + case TEMPERATURE_TRANSITION : result="TEMPERATURE_TRANSITION"; break; + case VOLUME_SPECIFIQUE : result="VOLUME_SPECIFIQUE"; break; + case FLUXD : result="FLUXD"; break; + case GRADT : result="GRADT"; break; + case DGRADT : result="DGRADT"; break; + case DELTAGRADT : result="DELTAGRADT"; break; + case COEFF_DILATATION_LINEAIRE : result="COEFF_DILATATION_LINEAIRE"; break; + case CONDUCTIVITE : result="CONDUCTIVITE"; break; + case CAPACITE_CALORIFIQUE : result="CAPACITE_CALORIFIQUE"; break; + case MODULE_COMPRESSIBILITE : result="MODULE_COMPRESSIBILITE"; break; + case COEFF_COMPRESSIBILITE : result="COEFF_COMPRESSIBILITE"; break; + case MODULE_CISAILLEMENT : result="MODULE_CISAILLEMENT"; break; + case MODULE_COMPRESSIBILITE_TOTAL : result="MODULE_COMPRESSIBILITE_TOTAL"; break; + case MODULE_CISAILLEMENT_TOTAL : result="MODULE_CISAILLEMENT_TOTAL"; break; + case E_YOUNG : result="E_YOUNG"; break; + case NU_YOUNG : result="NU_YOUNG"; break; + case MU_VISCO : result="MU_VISCO"; break; + case MU_VISCO_SPHERIQUE : result="MU_VISCO_SPHERIQUE"; break; + case MODULE_TANGENT_1D : result="MODULE_TANGENT_1D"; break; + case COMPRESSIBILITE_TANGENTE : result="COMPRESSIBILITE_TANGENTE"; break; + case NB_INVERSION : result="NB_INVERSION"; break; + case HYPER_CENTRE_HYSTERESIS : result="HYPER_CENTRE_HYSTERESIS"; break; + case SIGMA_REF : result="SIGMA_REF"; break; + case Q_SIG_HYST_Oi_A_R : result="Q_SIG_HYST_Oi_A_R"; break; + case Q_SIG_HYST_R_A_T : result="Q_SIG_HYST_R_A_T"; break; + case Q_DELTA_SIG_HYST : result="Q_DELTA_SIG_HYST"; break; + case COS_ALPHA_HYSTERESIS : result="COS_ALPHA_HYSTERESIS"; break; + case COS3PHI_SIG_HYSTERESIS : result="COS3PHI_SIG_HYSTERESIS"; break; + case COS3PHI_DELTA_SIG_HYSTERESIS : result="COS3PHI_DELTA_SIG_HYSTERESIS"; break; + case FCT_AIDE : result="FCT_AIDE"; break; + case NB_ITER_TOTAL_RESIDU : result="NB_ITER_TOTAL_RESIDU"; break; + case NB_INCRE_TOTAL_RESIDU : result="NB_INCRE_TOTAL_RESIDU"; break; + case NB_APPEL_FCT : result="NB_APPEL_FCT"; break; + case NB_STEP : result="NB_STEP"; break; + case ERREUR_RK : result="ERREUR_RK"; break; + case PRESSION_HYST_REF : result="PRESSION_HYST_REF"; break; + case PRESSION_HYST_REF_M1 : result="PRESSION_HYST_REF_M1"; break; + case PRESSION_HYST_T : result="PRESSION_HYST_T"; break; + case PRESSION_HYST : result="PRESSION_HYST"; break; + case UN_DDL_ENUM_ETENDUE : result="UN_DDL_ENUM_ETENDUE"; break; + case ENERGIE_ELASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T : result="ENERGIE_ELASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T"; break; + case ENERGIE_PLASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T : result="ENERGIE_PLASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T"; break; + case ENERGIE_VISQUEUSE_INDIVIDUELLE_A_CHAQUE_LOI_A_T : result="ENERGIE_VISQUEUSE_INDIVIDUELLE_A_CHAQUE_LOI_A_T"; break; + case PROPORTION_LOI_MELANGE : result="PROPORTION_LOI_MELANGE"; break; + case FONC_PONDERATION : result="FONC_PONDERATION"; break; + case POSITION_GEOMETRIQUE : result="POSITION_GEOMETRIQUE"; break; + case POSITION_GEOMETRIQUE_t : result="POSITION_GEOMETRIQUE_t"; break; + case POSITION_GEOMETRIQUE_t0 : result="POSITION_GEOMETRIQUE_t0"; break; + case CRISTALINITE : result="CRISTALINITE"; break; + case VOLUME_ELEMENT : result="VOLUME_ELEMENT"; break; + case VOLUME_PTI : result="VOLUME_PTI"; break; + case EPAISSEUR_MOY_INITIALE : result="EPAISSEUR_MOY_INITIALE"; break; + case EPAISSEUR_MOY_FINALE : result="EPAISSEUR_MOY_FINALE"; break; + case SECTION_MOY_INITIALE : result="SECTION_MOY_INITIALE"; break; + case SECTION_MOY_FINALE : result="SECTION_MOY_FINALE"; break; + case EPAISSEUR_INITIALE : result="EPAISSEUR_INITIALE"; break; + case EPAISSEUR_FINALE : result="EPAISSEUR_FINALE"; break; + case SECTION_INITIALE : result="SECTION_INITIALE"; break; + case SECTION_FINALE : result="SECTION_FINALE"; break; + case VOL_ELEM_AVEC_PLAN_REF : result="VOL_ELEM_AVEC_PLAN_REF"; break; + case INTEG_SUR_VOLUME : result="INTEG_SUR_VOLUME"; break; + case INTEG_SUR_VOLUME_ET_TEMPS : result="INTEG_SUR_VOLUME_ET_TEMPS"; break; + case STATISTIQUE : result="STATISTIQUE"; break; + case STATISTIQUE_ET_TEMPS : result="STATISTIQUE_ET_TEMPS"; break; + case ENERGIE_HOURGLASS : result="ENERGIE_HOURGLASS"; break; + case PUISSANCE_BULK : result="PUISSANCE_BULK"; break; + case ENERGIE_BULK : result="ENERGIE_BULK"; break; + case ENERGIE_STABMEMB_BIEL : result="ENERGIE_STABMEMB_BIEL"; break; + case FORCE_STABMEMB_BIEL : result="FORCE_STABMEMB_BIEL"; break; + case TENSEUR_COURBURE : result="TENSEUR_COURBURE"; break; + case COURBURES_PRINCIPALES : result="COURBURES_PRINCIPALES"; break; + case DIRECTIONS_PRINC_COURBURE : result="DIRECTIONS_PRINC_COURBURE"; break; + case DIRECTIONS_PRINC_SIGMA : result="DIRECTIONS_PRINC_SIGMA"; break; + case DIRECTIONS_PRINC_DEF : result="DIRECTIONS_PRINC_DEF"; break; + case DIRECTIONS_PRINC_D : result="DIRECTIONS_PRINC_D"; break; + case REPERE_LOCAL_ORTHO : result="REPERE_LOCAL_ORTHO"; break; + case REPERE_LOCAL_H : result="REPERE_LOCAL_H"; break; + case REPERE_LOCAL_B : result="REPERE_LOCAL_B"; break; + case REPERE_D_ANISOTROPIE : result="REPERE_D_ANISOTROPIE"; break; + case EPS_TRANSPORTEE_ANISO : result="EPS_TRANSPORTEE_ANISO"; break; + case SIGMA_DANS_ANISO : result="SIGMA_DANS_ANISO"; break; + case DELTA_EPS_TRANSPORTEE_ANISO : result="DELTA_EPS_TRANSPORTEE_ANISO"; break; + case DELTA_SIGMA_DANS_ANISO : result="DELTA_SIGMA_DANS_ANISO"; break; + case PARA_ORTHO : result="PARA_ORTHO"; break; + case SPHERIQUE_EPS : result="SPHERIQUE_EPS"; break; + case Q_EPS : result="Q_EPS"; break; + case COS3PHI_EPS : result="COS3PHI_EPS"; break; + case SPHERIQUE_SIG : result="SPHERIQUE_SIG"; break; + case Q_SIG : result="Q_SIG"; break; + case COS3PHI_SIG : result="COS3PHI_SIG"; break; + case SPHERIQUE_DEPS : result="SPHERIQUE_DEPS"; break; + case V_vol : result="V_vol"; break; + case Q_DEPS : result="Q_DEPS"; break; + case COS3PHI_DEPS : result="COS3PHI_DEPS"; break; + case POTENTIEL : result="POTENTIEL"; break; + case FCT_POTENTIEL_ND : result="FCT_POTENTIEL_ND"; break; + case INVAR_B1 : result="INVAR_B1"; break; + case INVAR_B2 : result="INVAR_B2"; break; + case INVAR_B3 : result="INVAR_B3"; break; + case INVAR_J1 : result="INVAR_J1"; break; + case INVAR_J2 : result="INVAR_J2"; break; + case INVAR_J3 : result="INVAR_J3"; break; + case DEF_EQUIVALENTE : result="DEF_EQUIVALENTE"; break; + case DEF_EPAISSEUR : result="DEF_EPAISSEUR"; break; + case D_EPAISSEUR : result="D_EPAISSEUR"; break; + case DEF_LARGEUR : result="DEF_LARGEUR"; break; + case D_LARGEUR : result="D_LARGEUR"; break; + case DEF_MECANIQUE : result="DEF_MECANIQUE"; break; + case DEF_ASSO_LOI : result="DEF_ASSO_LOI"; break; + case DEF_P_DANS_V_A : result="DEF_P_DANS_V_A"; break; + case SIG_EPAISSEUR : result="SIG_EPAISSEUR"; break; + case SIG_LARGEUR : result="SIG_LARGEUR"; break; + case FORCE_GENE_EXT : result="FORCE_GENE_EXT"; break; + case FORCE_GENE_INT : result="FORCE_GENE_INT"; break; + case FORCE_GENE_EXT_t : result="FORCE_GENE_EXT_t"; break; + case FORCE_GENE_INT_t : result="FORCE_GENE_INT_t"; break; + case FORCE_GENE_TOT : result="FORCE_GENE_TOT"; break; + case RESIDU_GLOBAL : result="RESIDU_GLOBAL"; break; + case VECT_PRESSION : result="VECT_PRESSION"; break; + case PRESSION_SCALAIRE : result="PRESSION_SCALAIRE"; break; + case VECT_FORCE_VOLUM : result="VECT_FORCE_VOLUM"; break; + case VECT_DIR_FIXE : result="VECT_DIR_FIXE"; break; + case VECT_SURF_SUIV : result="VECT_SURF_SUIV"; break; + case VECT_HYDRODYNA_Fn : result="VECT_HYDRODYNA_Fn"; break; + case VECT_HYDRODYNA_Ft : result="VECT_HYDRODYNA_Ft"; break; + case VECT_HYDRODYNA_T : result="VECT_HYDRODYNA_T"; break; + case VECT_LINE : result="VECT_LINE"; break; + case VECT_LINE_SUIV : result="VECT_LINE_SUIV"; break; + case VECT_REAC : result="VECT_REAC"; break; + case VECT_REAC_N : result="VECT_REAC_N"; break; + + case NN_11 : result="NN_11"; break; + case NN_22 : result="NN_22"; break; + case NN_33 : result="NN_33"; break; + case NN_12 : result="NN_12"; break; + case NN_13 : result="NN_13"; break; + case NN_23 : result="NN_23"; break; + + case MM_11 : result="MM_11"; break; + case MM_22 : result="MM_22"; break; + case MM_33 : result="MM_33"; break; + case MM_12 : result="MM_12"; break; + case MM_13 : result="MM_13"; break; + case MM_23 : result="MM_23"; break; + + case DIRECTION_PLI : result="DIRECTION_PLI"; break; + case DIRECTION_PLI_NORMEE : result="DIRECTION_PLI_NORMEE"; break; + case INDIC_CAL_PLIS : result="INDIC_CAL_PLIS"; break; + case NN_SURF : result="NN_SURF"; break; + case NN_SURF_t : result="NN_SURF_t"; break; + case NN_SURF_t0 : result="NN_SURF_t0"; break; + case NOEUD_PROJECTILE_EN_CONTACT : result="NOEUD_PROJECTILE_EN_CONTACT"; break; + case NOEUD_FACETTE_EN_CONTACT : result="NOEUD_FACETTE_EN_CONTACT"; break; + case GLISSEMENT_CONTACT : result="GLISSEMENT_CONTACT"; break; + case PENETRATION_CONTACT : result="PENETRATION_CONTACT"; break; + case GLISSEMENT_CONTACT_T : result="GLISSEMENT_CONTACT_T"; break; + case PENETRATION_CONTACT_T : result="PENETRATION_CONTACT_T"; break; + case FORCE_CONTACT : result="FORCE_CONTACT"; break; + case FORCE_CONTACT_T : result="FORCE_CONTACT_T"; break; + case CONTACT_NB_PENET : result="CONTACT_NB_PENET"; break; + case CONTACT_NB_DECOL : result="CONTACT_NB_DECOL"; break; + case CONTACT_CAS_SOLIDE : result="CONTACT_CAS_SOLIDE"; break; + case CONTACT_ENERG_PENAL : result="CONTACT_ENERG_PENAL"; break; + case CONTACT_COLLANT : result="CONTACT_COLLANT"; break; + case NUM_ZONE_CONTACT : result="NUM_ZONE_CONTACT"; break; + case CONTACT_ENERG_GLISSE_ELAS : result="CONTACT_ENERG_GLISSE_ELAS"; break; + case CONTACT_ENERG_GLISSE_PLAS : result="CONTACT_ENERG_GLISSE_PLAS"; break; + case CONTACT_ENERG_GLISSE_VISQ : result="CONTACT_ENERG_GLISSE_VISQ"; break; + case CONTACT_PENALISATION_N : result="CONTACT_PENALISATION_N"; break; + case CONTACT_PENALISATION_T : result="CONTACT_PENALISATION_T"; break; + case NORMALE_CONTACT : result="NORMALE_CONTACT"; break; + case TEMPS_CPU_USER : result="TEMPS_CPU_USER"; break; + case TEMPS_CPU_LOI_COMP : result="TEMPS_CPU_LOI_COMP"; break; + case TEMPS_CPU_METRIQUE : result="TEMPS_CPU_METRIQUE"; break; + case GENERIQUE_UNE_GRANDEUR_GLOBALE : result="GENERIQUE_UNE_GRANDEUR_GLOBALE"; break; + case GENERIQUE_UNE_CONSTANTE_GLOB_INT_UTILISATEUR : result="GENERIQUE_UNE_CONSTANTE_GLOB_INT_UTILISATEUR"; break; + case GENERIQUE_UNE_CONSTANTE_GLOB_DOUBLE_UTILISATEUR : result="GENERIQUE_UNE_CONSTANTE_GLOB_DOUBLE_UTILISATEUR"; break; + case GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0 : result="GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0"; break; + case GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_T : result="GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_T"; break; + case GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT : result="GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT"; break; + case DEPLACEMENT : result="DEPLACEMENT"; break; + case VITESSE : result="VITESSE"; break; + case DELTA_XI : result="DELTA_XI"; break; + case XI_ITER_0 : result="XI_ITER_0"; break; + case MASSE_RELAX_DYN : result="MASSE_RELAX_DYN"; break; + case COMP_TORSEUR_REACTION : result="COMP_TORSEUR_REACTION"; break; + case NUM_NOEUD : result="NUM_NOEUD"; break; + case NUM_MAIL_NOEUD : result="NUM_MAIL_NOEUD"; break; + case NUM_ELEMENT : result="NUM_ELEMENT"; break; + case NUM_MAIL_ELEM : result="NUM_MAIL_ELEM"; break; + case NUM_PTI : result="NUM_PTI"; break; + case NUM_FACE : result="NUM_FACE"; break; + case NUM_ARETE : result="NUM_ARETE"; break; + + default : + cout << "\nErreur : valeur incorrecte du type EnumTypeQuelconque: id_TypeQuelconque=" + << id_TypeQuelconque << " !\n"; + cout << "NomTypeQuelconque(EnumTypeQuelconque ) \n"; + Sortie(1); + }; + return result; +}; + +// idem mais en version courte (sur quelques caractères) +string NomTypeQuelconque_court (EnumTypeQuelconque id_TypeQuelconque) +// Retourne le nom du type de grandeur correspondant a l'identificateur +// de type enumere id_TypeQuelconque +{ string result; + switch (id_TypeQuelconque) + { case RIEN_TYPEQUELCONQUE : result="RIEN"; break; + case SIGMA_BARRE_BH_T : result="sig_b"; break; + case CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T_SANS_PROPORTION : result="sig_i_SP"; break; + case CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T : result="sig_i"; break; + case CONTRAINTE_COURANTE : result="sig_c"; break; + case DEFORMATION_COURANTE : result="def_c"; break; + case VITESSE_DEFORMATION_COURANTE : result="D_c"; break; + case ALMANSI : result="ALMANSI"; break; + case GREEN_LAGRANGE : result="GREEN_LAG"; break; + case LOGARITHMIQUE : result="LOG"; break; + case DELTA_DEF : result="DELTA_DEF"; break; + case ALMANSI_TOTAL : result="ALMANSI_TOT"; break; + case GREEN_LAGRANGE_TOTAL : result="GREEN_LAG_TOT"; break; + case LOGARITHMIQUE_TOTALE : result="LOG_TOT"; break; + case DEF_PRINCIPALES : result="DEF_princ"; break; + case SIGMA_PRINCIPALES : result="SIG_princ"; break; + case VIT_PRINCIPALES : result="VIT_princ"; break; + case DEF_DUALE_MISES : result="DefDualMises"; break; + case DEF_DUALE_MISES_MAXI : result="DefDualMisesMaxi"; break; + case CONTRAINTE_MISES : result="MISES"; break; + case CONTRAINTE_MISES_T : result="MISES_T"; break; + case CONTRAINTE_TRESCA : result="TRESCA"; break; + case CONTRAINTE_TRESCA_T : result="TRESCA_T"; break; + case ERREUR_Q : result="ERR_Q"; break; + case DEF_PLASTIQUE_CUMULEE : result="DEF_PLAST_CUM"; break; + case ERREUR_SIG_RELATIVE : result="ERR_SIG_REL"; break; + + case TEMPERATURE_LOI_THERMO_PHYSIQUE : result="TEMP_THERMO_PHYS"; break; + case PRESSION_LOI_THERMO_PHYSIQUE : result="P_THERMO_PHYS"; break; + case TEMPERATURE_TRANSITION : result="TEMP_TRANSI"; break; + case VOLUME_SPECIFIQUE : result="VOL_SPEC"; break; + case FLUXD : result="FLUXD"; break; + case GRADT : result="GRADT"; break; + case DGRADT : result="DGRADT"; break; + case DELTAGRADT : result="DELTAGRADT"; break; + case COEFF_DILATATION_LINEAIRE : result="COEFF_DILAT_LIN"; break; + case CONDUCTIVITE : result="CONDUC"; break; + case CAPACITE_CALORIFIQUE : result="CAPAC_CALOR"; break; + case MODULE_COMPRESSIBILITE : result="MOD_COMPRES"; break; + case COEFF_COMPRESSIBILITE : result="COEFF_COMPRES"; break; + case MODULE_CISAILLEMENT : result="MOD_CISAIL"; break; + case MODULE_COMPRESSIBILITE_TOTAL : result="MOD_COMPRES_TOT"; break; + case MODULE_CISAILLEMENT_TOTAL : result="MOD_CISAIL_TOT"; break; + case E_YOUNG : result="E_YOUNG"; break; + case NU_YOUNG : result="NU_YOUNG"; break; + case MU_VISCO : result="MU_VISCO"; break; + case MU_VISCO_SPHERIQUE : result="MU_VISCO_SPHERIQUE"; break; + case MODULE_TANGENT_1D : result="MODULE_TANGENT_1D"; break; + case COMPRESSIBILITE_TANGENTE : result="COMPRESSIBILITE_TANGENTE"; break; + case NB_INVERSION : result="NB_INVER"; break; + case HYPER_CENTRE_HYSTERESIS : result="CENTRE_HYSTER"; break; + case SIGMA_REF : result="SIG_REF"; break; + case Q_SIG_HYST_Oi_A_R : result="Q_SIG_HYS_0iR"; break; + case Q_SIG_HYST_R_A_T : result="Q_SIG_HYS_RaT"; break; + case Q_DELTA_SIG_HYST : result="Q_D_SIG_HYST"; break; + case COS_ALPHA_HYSTERESIS : result="COS_ALPHA_HYS"; break; + case COS3PHI_SIG_HYSTERESIS : result="COS3PHI_SIG_HYS"; break; + case COS3PHI_DELTA_SIG_HYSTERESIS : result="CO3PHI_D_SIG_HYS"; break; + case FCT_AIDE : result="FCT_AIDE"; break; + case NB_ITER_TOTAL_RESIDU : result="NB_ITER_TOT_RES"; break; + case NB_INCRE_TOTAL_RESIDU : result="NB_INCR_TOT_RES"; break; + case NB_APPEL_FCT : result="NB_APPEL_FCT"; break; + case NB_STEP : result="NB_STEP"; break; + case ERREUR_RK : result="ERREUR_RK"; break; + case PRESSION_HYST_REF : result="PRESSION_HYST_REF"; break; + case PRESSION_HYST_REF_M1 : result="PRESSION_HYST_REF_M1"; break; + case PRESSION_HYST_T : result="PRESSION_HYST_T"; break; + case PRESSION_HYST : result="PRESSION_HYST"; break; + case UN_DDL_ENUM_ETENDUE : result="DDL_ENUM_ETENDUE"; break; + case ENERGIE_ELASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T : result="ENERG_ELAST_i"; break; + case ENERGIE_PLASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T : result="ENERG_PLAST_i"; break; + case ENERGIE_VISQUEUSE_INDIVIDUELLE_A_CHAQUE_LOI_A_T : result="ENERG_VISQU_i"; break; + case PROPORTION_LOI_MELANGE : result="PROP_LOI_MEL"; break; + case FONC_PONDERATION : result="F_POND"; break; + case POSITION_GEOMETRIQUE : result="POSI_GEOM"; break; + case POSITION_GEOMETRIQUE_t : result="POSI_GEOM_t"; break; + case POSITION_GEOMETRIQUE_t0 : result="POSI_GEOM_t0"; break; + case CRISTALINITE : result="CRISTA"; break; + case VOLUME_ELEMENT : result="VOLUME_ELEMENT"; break; + case VOLUME_PTI : result="VOLUME_PTI"; break; + case EPAISSEUR_MOY_INITIALE : result="EPAISS_MOY_0"; break; + case EPAISSEUR_MOY_FINALE : result="EPAISS_MOY_tdt"; break; + case SECTION_MOY_INITIALE : result="SECT_MOY_0"; break; + case SECTION_MOY_FINALE : result="SECT_MOY_tdt"; break; + case EPAISSEUR_INITIALE : result="EPAISSEUR_INITIALE"; break; + case EPAISSEUR_FINALE : result="EPAISSEUR_FINALE"; break; + case SECTION_INITIALE : result="SECTION_INITIALE"; break; + case SECTION_FINALE : result="SECTION_FINALE"; break; + case VOL_ELEM_AVEC_PLAN_REF : result="VOL_ELE_PLREF"; break; + case INTEG_SUR_VOLUME : result="INTEG_SUR_VOL"; break; + case INTEG_SUR_VOLUME_ET_TEMPS : result="INTEG_SUR_VOL_ET_TEMPS"; break; + case STATISTIQUE : result="STATISTIQUE"; break; + case STATISTIQUE_ET_TEMPS : result="STATISTIQUE_ET_TEMPS"; break; + case ENERGIE_HOURGLASS : result="ENERG_HOURG"; break; + case PUISSANCE_BULK : result="PUISS_BULK"; break; + case ENERGIE_BULK : result="ENERG_BULK"; break; + case ENERGIE_STABMEMB_BIEL : result="ENERGIE_STABMEMB_BIEL"; break; + case FORCE_STABMEMB_BIEL : result="FORCE_STABMEMB_BIEL"; break; + case TENSEUR_COURBURE : result="TENS_COURBURE"; break; + case COURBURES_PRINCIPALES : result="COURBURES_PRINC"; break; + case DIRECTIONS_PRINC_COURBURE : result="DIR_PRINC_CURB"; break; + case DIRECTIONS_PRINC_SIGMA : result="DIR_PRINC_SIG"; break; + case DIRECTIONS_PRINC_DEF : result="DIR_PRINC_DEF"; break; + case DIRECTIONS_PRINC_D : result="DIR_PRINC_D"; break; + case REPERE_LOCAL_ORTHO : result="REP_LOC_ORTHO"; break; + case REPERE_LOCAL_H : result="REP_LOC_H"; break; + case REPERE_LOCAL_B : result="REP_LOC_H"; break; + case REPERE_D_ANISOTROPIE : result="REP_D_ANISO"; break; + case EPS_TRANSPORTEE_ANISO : result="EPS_TRANS_ANISO"; break; + case SIGMA_DANS_ANISO : result="SIGMA_DANS_ANISO"; break; + case DELTA_EPS_TRANSPORTEE_ANISO : result="DELTA_EPS_TRANS_ANISO"; break; + case DELTA_SIGMA_DANS_ANISO : result="DELTA_SIGMA_DANS_ANISO"; break; + case PARA_ORTHO : result="PARA_ORTHO"; break; + case SPHERIQUE_EPS : result="SPHERIQUE_EPS"; break; + case Q_EPS : result="Q_EPS"; break; + case COS3PHI_EPS : result="COS3PHI_EPS"; break; + case SPHERIQUE_SIG : result="SPHERIQUE_SIG"; break; + case Q_SIG : result="Q_SIG"; break; + case COS3PHI_SIG : result="COS3PHI_SIG"; break; + case SPHERIQUE_DEPS : result="SPHERIQUE_DEPS"; break; + case V_vol : result="V_vol"; break; + case Q_DEPS : result="Q_DEPS"; break; + case COS3PHI_DEPS : result="COS3PHI_DEPS"; break; + case POTENTIEL : result="POTENTIEL"; break; + case FCT_POTENTIEL_ND : result="FCT_POTENTIEL_ND"; break; + case INVAR_B1 : result="INVAR_B1"; break; + case INVAR_B2 : result="INVAR_B2"; break; + case INVAR_B3 : result="INVAR_B3"; break; + case INVAR_J1 : result="INVAR_J1"; break; + case INVAR_J2 : result="INVAR_J2"; break; + case INVAR_J3 : result="INVAR_J3"; break; + case DEF_EQUIVALENTE : result="DEF_EQUIVALENTE"; break; + case DEF_EPAISSEUR : result="DEF_EPAISSEUR"; break; + case D_EPAISSEUR : result="D_EPAISSEUR"; break; + case DEF_LARGEUR : result="DEF_LARGEUR"; break; + case D_LARGEUR : result="D_LARGEUR"; break; + case DEF_MECANIQUE : result="DEF_MECANIQUE"; break; + case DEF_ASSO_LOI : result="DEF_ASSO_LOI"; break; + case DEF_P_DANS_V_A : result="DEF_P_DANS_V_A"; break; + case SIG_EPAISSEUR : result="SIG_EPAISSEUR"; break; + case SIG_LARGEUR : result="SIG_LARGEUR"; break; + case FORCE_GENE_EXT : result="FORCE_GENE_EXT"; break; + case FORCE_GENE_INT : result="FORCE_GENE_INT"; break; + case FORCE_GENE_EXT_t : result="FORCE_GENE_EXT_t"; break; + case FORCE_GENE_INT_t : result="FORCE_GENE_INT_t"; break; + case FORCE_GENE_TOT : result="FORCE_GENE_TOT"; break; + case RESIDU_GLOBAL : result="RESIDU_GLOBAL"; break; + case VECT_PRESSION : result="VECT_PRESSION"; break; + case PRESSION_SCALAIRE : result="PRESSION_SCALAIRE"; break; + case VECT_FORCE_VOLUM : result="VECT_FORCE_VOLUM"; break; + case VECT_DIR_FIXE : result="VECT_DIR_FIXE"; break; + case VECT_SURF_SUIV : result="VECT_SURF_SUIV"; break; + case VECT_HYDRODYNA_Fn : result="VECT_HYDRODYNA_Fn"; break; + case VECT_HYDRODYNA_Ft : result="VECT_HYDRODYNA_Ft"; break; + case VECT_HYDRODYNA_T : result="VECT_HYDRODYNA_T"; break; + case VECT_LINE : result="VECT_LINE"; break; + case VECT_LINE_SUIV : result="VECT_LINE_SUIV"; break; + case VECT_REAC : result="VECT_REAC"; break; + case VECT_REAC_N : result="VECT_REAC_N"; break; + + case NN_11 : result="NN_11"; break; + case NN_22 : result="NN_22"; break; + case NN_33 : result="NN_33"; break; + case NN_12 : result="NN_12"; break; + case NN_13 : result="NN_13"; break; + case NN_23 : result="NN_23"; break; + + case MM_11 : result="MM_11"; break; + case MM_22 : result="MM_22"; break; + case MM_33 : result="MM_33"; break; + case MM_12 : result="MM_12"; break; + case MM_13 : result="MM_13"; break; + case MM_23 : result="MM_23"; break; + + case DIRECTION_PLI : result="DIR_PLI"; break; + case DIRECTION_PLI_NORMEE : result="DIR_PLI_NORM"; break; + case INDIC_CAL_PLIS : result="INDIC_CAL_PLIS"; break; + case NN_SURF : result="NN_SURF"; break; + case NN_SURF_t : result="NN_SURF_t"; break; + case NN_SURF_t0 : result="NN_SURF_t0"; break; + case NOEUD_PROJECTILE_EN_CONTACT : result="NOE_PR_CONTACT"; break; + case NOEUD_FACETTE_EN_CONTACT : result="NOE_F_CONTACT"; break; + case GLISSEMENT_CONTACT : result="GLISSE_CONTACT"; break; + case PENETRATION_CONTACT : result="PENE_CONTACT"; break; + case GLISSEMENT_CONTACT_T : result="GLISSE_CONTACT_T"; break; + case PENETRATION_CONTACT_T : result="PENE_CONTACT_T"; break; + case FORCE_CONTACT : result="FORCE_CONTACT"; break; + case FORCE_CONTACT_T : result="FORCE_CONTACT_T"; break; + case CONTACT_NB_PENET : result="CONTACT_NB_PENET"; break; + case CONTACT_NB_DECOL : result="CONTACT_NB_DECOL"; break; + case CONTACT_CAS_SOLIDE : result="CONTACT_CAS_SOLIDE"; break; + case CONTACT_ENERG_PENAL : result="CONTACT_ENERG_PENAL"; break; + case CONTACT_COLLANT : result="CONTACT_COLLANT"; break; + case NUM_ZONE_CONTACT : result="NUM_ZONE_CONTACT"; break; + case CONTACT_ENERG_GLISSE_ELAS : result="CONTACT_ENERG_GLISSE_ELAS"; break; + case CONTACT_ENERG_GLISSE_PLAS : result="CONTACT_ENERG_GLISSE_PLAS"; break; + case CONTACT_ENERG_GLISSE_VISQ : result="CONTACT_ENERG_GLISSE_VISQ"; break; + case CONTACT_PENALISATION_N : result="CONTACT_PENALISATION_N"; break; + case CONTACT_PENALISATION_T : result="CONTACT_PENALISATION_T"; break; + case NORMALE_CONTACT : result="NORMALE_CONTACT"; break; + case TEMPS_CPU_USER : result="TEMPS_CPU_USER"; break; + case TEMPS_CPU_LOI_COMP : result="TEMPS_CPU_LOI_COMP"; break; + case TEMPS_CPU_METRIQUE : result="TEMPS_CPU_METRIQUE"; break; + case GENERIQUE_UNE_GRANDEUR_GLOBALE : result="GEN_GRANDEUR_GLOB"; break; + case GENERIQUE_UNE_CONSTANTE_GLOB_INT_UTILISATEUR : result="GEN_CONST_GLOB_INT_USER"; break; + case GENERIQUE_UNE_CONSTANTE_GLOB_DOUBLE_UTILISATEUR : result="GEN_CONST_GLOB_DOUBLE_USER"; break; + case GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0 : result="GEN_VAR_GLOB_DOUBLE_USER_0"; break; + case GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_T : result="GEN_VAR_GLOB_DOUBLE_USER_T"; break; + case GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT : result="GEN_VAR_GLOB_DOUBLE_USER_TDT"; break; + case DEPLACEMENT : result="DEPLACEMENT"; break; + case VITESSE : result="VITESSE"; break; + case DELTA_XI : result="DELTA_XI"; break; + case XI_ITER_0 : result="XI_ITER_0"; break; + case MASSE_RELAX_DYN : result="MASSE_RELAX_DYN"; break; + case COMP_TORSEUR_REACTION : result="COMP_TORS_REAC"; break; + case NUM_NOEUD : result="NUM_NOEUD"; break; + case NUM_MAIL_NOEUD : result="NUM_MAIL_NOEUD"; break; + case NUM_ELEMENT : result="NUM_ELEMENT"; break; + case NUM_MAIL_ELEM : result="NUM_MAIL_ELEM"; break; + case NUM_PTI : result="NUM_PTI"; break; + case NUM_FACE : result="NUM_FACE"; break; + case NUM_ARETE : result="NUM_ARETE"; break; + default : + cout << "\nErreur : valeur incorrecte du type EnumTypeQuelconque: id_TypeQuelconque=" + << id_TypeQuelconque << " !\n"; + cout << "NomTypeQuelconque_court(EnumTypeQuelconque ) \n"; + Sortie(1); + }; + return result; +}; + +// nom générique, lorsqu'il s'agit de composantes +string NomGeneriqueTypeQuelconque(EnumTypeQuelconque id_TypeQuelconque) +{string result; + switch (id_TypeQuelconque) + {case RIEN_TYPEQUELCONQUE : result="RIEN"; break; + case SIGMA_BARRE_BH_T : result="sig_b"; break; + case CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T_SANS_PROPORTION : result="sig_i_SP"; break; + case CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T : result="sig_i"; break; + case CONTRAINTE_COURANTE : result="sig_c"; break; + case DEFORMATION_COURANTE : result="def_c"; break; + case VITESSE_DEFORMATION_COURANTE : result="D_c"; break; + case ALMANSI : result="ALMANSI"; break; + case GREEN_LAGRANGE : result="GREEN_LAG"; break; + case LOGARITHMIQUE : result="LOG"; break; + case DELTA_DEF : result="DELTA_DEF"; break; + case ALMANSI_TOTAL : result="ALMANSI_TOT"; break; + case GREEN_LAGRANGE_TOTAL : result="GREEN_LAG_TOT"; break; + case LOGARITHMIQUE_TOTALE : result="LOG_TOT"; break; + case DEF_PRINCIPALES : result="DEF_princ"; break; + case SIGMA_PRINCIPALES : result="SIG_princ"; break; + case VIT_PRINCIPALES : result="VIT_princ"; break; + case DEF_DUALE_MISES : result="DefDualMises"; break; + case DEF_DUALE_MISES_MAXI : result="DefDualMisesMaxi"; break; + case CONTRAINTE_MISES : result="MISES"; break; + case CONTRAINTE_MISES_T : result="MISES_T"; break; + case CONTRAINTE_TRESCA : result="TRESCA"; break; + case CONTRAINTE_TRESCA_T : result="TRESCA_T"; break; + case ERREUR_Q : result="ERR_Q"; break; + case DEF_PLASTIQUE_CUMULEE : result="DEF_PLAST_CUM"; break; + case ERREUR_SIG_RELATIVE : result="ERR_SIG_REL"; break; + + case TEMPERATURE_LOI_THERMO_PHYSIQUE : result="TEMP_THERMO_PHYS"; break; + case PRESSION_LOI_THERMO_PHYSIQUE : result="P_THERMO_PHYS"; break; + case TEMPERATURE_TRANSITION : result="TEMP_TRANSI"; break; + case VOLUME_SPECIFIQUE : result="VOL_SPEC"; break; + case FLUXD : result="FLUXD"; break; + case GRADT : result="GRADT"; break; + case DGRADT : result="DGRADT"; break; + case DELTAGRADT : result="DELTAGRADT"; break; + case COEFF_DILATATION_LINEAIRE : result="COEFF_DILAT_LIN"; break; + case CONDUCTIVITE : result="CONDUC"; break; + case CAPACITE_CALORIFIQUE : result="CAPAC_CALOR"; break; + case MODULE_COMPRESSIBILITE : result="MOD_COMPRES"; break; + case COEFF_COMPRESSIBILITE : result="COEFF_COMPRES"; break; + case MODULE_CISAILLEMENT : result="MOD_CISAIL"; break; + case MODULE_COMPRESSIBILITE_TOTAL : result="MOD_COMPRES_TOT"; break; + case MODULE_CISAILLEMENT_TOTAL : result="MOD_CISAIL_TOT"; break; + case E_YOUNG : result="E_YOUNG"; break; + case NU_YOUNG : result="NU_YOUNG"; break; + case MU_VISCO : result="MU_VISCO"; break; + case MU_VISCO_SPHERIQUE : result="MU_VISCO_SPHERIQUE"; break; + case MODULE_TANGENT_1D : result="MODULE_TANGENT_1D"; break; + case COMPRESSIBILITE_TANGENTE : result="COMPRESSIBILITE_TANGENTE"; break; + case NB_INVERSION : result="NB_INVER"; break; + case HYPER_CENTRE_HYSTERESIS : result="CENTRE_HYSTER"; break; + case SIGMA_REF : result="SIG_REF"; break; + case Q_SIG_HYST_Oi_A_R : result="Q_SIG_HYS_0iR"; break; + case Q_SIG_HYST_R_A_T : result="Q_SIG_HYS_RaT"; break; + case Q_DELTA_SIG_HYST : result="Q_D_SIG_HYST"; break; + case COS_ALPHA_HYSTERESIS : result="COS_ALPHA_HYS"; break; + case COS3PHI_SIG_HYSTERESIS : result="COS3PHI_SIG_HYS"; break; + case COS3PHI_DELTA_SIG_HYSTERESIS : result="CO3PHI_D_SIG_HYS"; break; + case FCT_AIDE : result="FCT_AIDE"; break; + case NB_ITER_TOTAL_RESIDU : result="NB_ITER_TOT_RES"; break; + case NB_INCRE_TOTAL_RESIDU : result="NB_INCR_TOT_RES"; break; + case NB_APPEL_FCT : result="NB_APPEL_FCT"; break; + case NB_STEP : result="NB_STEP"; break; + case ERREUR_RK : result="ERREUR_RK"; break; + case PRESSION_HYST_REF : result="PRESSION_HYST_REF"; break; + case PRESSION_HYST_REF_M1 : result="PRESSION_HYST_REF_M1"; break; + case PRESSION_HYST_T : result="PRESSION_HYST_T"; break; + case PRESSION_HYST : result="PRESSION_HYST"; break; + case UN_DDL_ENUM_ETENDUE : result="DDL_ENUM_ETENDUE"; break; + case ENERGIE_ELASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T : result="ENERG_ELAST_i"; break; + case ENERGIE_PLASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T : result="ENERG_PLAST_i"; break; + case ENERGIE_VISQUEUSE_INDIVIDUELLE_A_CHAQUE_LOI_A_T : result="ENERG_VISQU_i"; break; + case PROPORTION_LOI_MELANGE : result="PROP_LOI_MEL"; break; + case FONC_PONDERATION : result="F_POND"; break; + case POSITION_GEOMETRIQUE : result="POSI_GEOM"; break; + case POSITION_GEOMETRIQUE_t : result="POSI_GEOM_t"; break; + case POSITION_GEOMETRIQUE_t0 : result="POSI_GEOM_t0"; break; + case CRISTALINITE : result="CRISTA"; break; + case VOLUME_ELEMENT : result="VOLUME_ELEMENT"; break; + case VOLUME_PTI : result="VOLUME_PTI"; break; + case EPAISSEUR_MOY_INITIALE : result="EPAISS_MOY_0"; break; + case EPAISSEUR_MOY_FINALE : result="EPAISS_MOY_tdt"; break; + case SECTION_MOY_INITIALE : result="SECT_MOY_0"; break; + case SECTION_MOY_FINALE : result="SECT_MOY_tdt"; break; + case EPAISSEUR_INITIALE : result="EPAISSEUR_INITIALE"; break; + case EPAISSEUR_FINALE : result="EPAISSEUR_FINALE"; break; + case SECTION_INITIALE : result="SECTION_INITIALE"; break; + case SECTION_FINALE : result="SECTION_FINALE"; break; + case VOL_ELEM_AVEC_PLAN_REF : result="VOL_ELE_PLREF"; break; + case INTEG_SUR_VOLUME : result="INTEG_SUR_VOL"; break; + case INTEG_SUR_VOLUME_ET_TEMPS : result="INTEG_SUR_VOL_ET_TEMPS"; break; + case STATISTIQUE : result="STATISTIQUE"; break; + case STATISTIQUE_ET_TEMPS : result="STATISTIQUE_ET_TEMPS"; break; + case ENERGIE_HOURGLASS : result="ENERG_HOURG"; break; + case PUISSANCE_BULK : result="PUISS_BULK"; break; + case ENERGIE_BULK : result="ENERG_BULK"; break; + case ENERGIE_STABMEMB_BIEL : result="ENERGIE_STABMEMB_BIEL"; break; + case FORCE_STABMEMB_BIEL : result="FORCE_STABMEMB_BIEL"; break; + case TENSEUR_COURBURE : result="TENS_COURBURE"; break; + case COURBURES_PRINCIPALES : result="COURBURES_PRINC"; break; + case DIRECTIONS_PRINC_COURBURE : result="DIR_PRINC_CURB"; break; + case DIRECTIONS_PRINC_SIGMA : result="DIR_PRINC_SIG"; break; + case DIRECTIONS_PRINC_DEF : result="DIR_PRINC_DEF"; break; + case DIRECTIONS_PRINC_D : result="DIR_PRINC_D"; break; + case REPERE_LOCAL_ORTHO : result="REP_LOC_ORTHO"; break; + case REPERE_LOCAL_H : result="REP_LOC_H"; break; + case REPERE_LOCAL_B : result="REP_LOC_H"; break; + case REPERE_D_ANISOTROPIE : result="REP_D_ANISO"; break; + case EPS_TRANSPORTEE_ANISO : result="EPS_TRANS_ANISO"; break; + case SIGMA_DANS_ANISO : result="SIGMA_DANS_ANISO"; break; + case DELTA_EPS_TRANSPORTEE_ANISO : result="DELTA_EPS_TRANS_ANISO"; break; + case DELTA_SIGMA_DANS_ANISO : result="DELTA_SIGMA_DANS_ANISO"; break; + case PARA_ORTHO : result="PARA_ORTHO"; break; + case SPHERIQUE_EPS : result="SPHERIQUE_EPS"; break; + case Q_EPS : result="Q_EPS"; break; + case COS3PHI_EPS : result="COS3PHI_EPS"; break; + case SPHERIQUE_SIG : result="SPHERIQUE_SIG"; break; + case Q_SIG : result="Q_SIG"; break; + case COS3PHI_SIG : result="COS3PHI_SIG"; break; + case SPHERIQUE_DEPS : result="SPHERIQUE_DEPS"; break; + case V_vol : result="V_vol"; break; + case Q_DEPS : result="Q_DEPS"; break; + case COS3PHI_DEPS : result="COS3PHI_DEPS"; break; + case POTENTIEL : result="POTENTIEL"; break; + case FCT_POTENTIEL_ND : result="FCT_POTENTIEL_ND"; break; + case INVAR_B1 : result="INVAR_B1"; break; + case INVAR_B2 : result="INVAR_B2"; break; + case INVAR_B3 : result="INVAR_B3"; break; + case INVAR_J1 : result="INVAR_J1"; break; + case INVAR_J2 : result="INVAR_J2"; break; + case INVAR_J3 : result="INVAR_J3"; break; + case DEF_EQUIVALENTE : result="DEF_EQUIVALENTE"; break; + case DEF_EPAISSEUR : result="DEF_EPAISSEUR"; break; + case D_EPAISSEUR : result="D_EPAISSEUR"; break; + case DEF_LARGEUR : result="DEF_LARGEUR"; break; + case D_LARGEUR : result="D_LARGEUR"; break; + case DEF_MECANIQUE : result="DEF_MECANIQUE"; break; + case DEF_ASSO_LOI : result="DEF_ASSO_LOI"; break; + case DEF_P_DANS_V_A : result="DEF_P_DANS_V_A"; break; + case SIG_EPAISSEUR : result="SIG_EPAISSEUR"; break; + case SIG_LARGEUR : result="SIG_LARGEUR"; break; + case FORCE_GENE_EXT : result="FORCE_GENE_EXT"; break; + case FORCE_GENE_INT : result="FORCE_GENE_INT"; break; + case FORCE_GENE_EXT_t : result="FORCE_GENE_EXT_t"; break; + case FORCE_GENE_INT_t : result="FORCE_GENE_INT_t"; break; + case FORCE_GENE_TOT : result="FORCE_GENE_TOT"; break; + case RESIDU_GLOBAL : result="RESIDU_GLOBAL"; break; + case VECT_PRESSION : result="VECT_PRESSION"; break; + case PRESSION_SCALAIRE : result="PRESSION_SCALAIRE"; break; + case VECT_FORCE_VOLUM : result="VECT_FORCE_VOLUM"; break; + case VECT_DIR_FIXE : result="VECT_DIR_FIXE"; break; + case VECT_SURF_SUIV : result="VECT_SURF_SUIV"; break; + case VECT_HYDRODYNA_Fn : result="VECT_HYDRODYNA_Fn"; break; + case VECT_HYDRODYNA_Ft : result="VECT_HYDRODYNA_Ft"; break; + case VECT_HYDRODYNA_T : result="VECT_HYDRODYNA_T"; break; + case VECT_LINE : result="VECT_LINE"; break; + case VECT_LINE_SUIV : result="VECT_LINE_SUIV"; break; + case VECT_REAC : result="VECT_REAC"; break; + case VECT_REAC_N : result="VECT_REAC_N"; break; + + case NN_11 : case NN_22 : case NN_33 : + case NN_12 : case NN_13 : case NN_23 : + result="NN_"; break; + + case MM_11 : case MM_22 : case MM_33 : + case MM_12 : case MM_13 : case MM_23 : + result="MM_"; break; + + case DIRECTION_PLI : result="DIR_PLI"; break; + case DIRECTION_PLI_NORMEE : result="DIR_PLI_NORM"; break; + case INDIC_CAL_PLIS : result="INDIC_CAL_PLIS"; break; + case NN_SURF : result="NN_SURF"; break; + case NN_SURF_t : result="NN_SURF_t"; break; + case NN_SURF_t0 : result="NN_SURF_t0"; break; + case NOEUD_PROJECTILE_EN_CONTACT : result="NOE_PR_CONTACT"; break; + case NOEUD_FACETTE_EN_CONTACT : result="NOE_F_CONTACT"; break; + case GLISSEMENT_CONTACT : result="GLISSE_CONTACT"; break; + case PENETRATION_CONTACT : result="PENE_CONTACT"; break; + case GLISSEMENT_CONTACT_T : result="GLISSE_CONTACT_T"; break; + case PENETRATION_CONTACT_T : result="PENE_CONTACT_T"; break; + case FORCE_CONTACT : result="FORCE_CONTACT"; break; + case FORCE_CONTACT_T : result="FORCE_CONTACT_T"; break; + case CONTACT_NB_PENET : result="CONTACT_NB_PENET"; break; + case CONTACT_NB_DECOL : result="CONTACT_NB_DECOL"; break; + case CONTACT_CAS_SOLIDE : result="CONTACT_CAS_SOLIDE"; break; + case CONTACT_ENERG_PENAL : result="CONTACT_ENERG_PENAL"; break; + case CONTACT_COLLANT : result="CONTACT_COLLANT"; break; + case NUM_ZONE_CONTACT : result="NUM_ZONE_CONTACT"; break; + case CONTACT_ENERG_GLISSE_ELAS : result="CONTACT_ENERG_GLISSE_ELAS"; break; + case CONTACT_ENERG_GLISSE_PLAS : result="CONTACT_ENERG_GLISSE_PLAS"; break; + case CONTACT_ENERG_GLISSE_VISQ : result="CONTACT_ENERG_GLISSE_VISQ"; break; + case CONTACT_PENALISATION_N : result="CONTACT_PENALISATION_N"; break; + case CONTACT_PENALISATION_T : result="CONTACT_PENALISATION_T"; break; + case NORMALE_CONTACT : result="NORMALE_CONTACT"; break; + case TEMPS_CPU_USER : result="TEMPS_CPU_USER"; break; + case TEMPS_CPU_LOI_COMP : result="TEMPS_CPU_LOI_COMP"; break; + case TEMPS_CPU_METRIQUE : result="TEMPS_CPU_METRIQUE"; break; + case GENERIQUE_UNE_GRANDEUR_GLOBALE : result="GEN_GRANDEUR_GLOB"; break; + case GENERIQUE_UNE_CONSTANTE_GLOB_INT_UTILISATEUR : result="GEN_CONST_GLOB_INT_USER"; break; + case GENERIQUE_UNE_CONSTANTE_GLOB_DOUBLE_UTILISATEUR : result="GEN_CONST_GLOB_DOUBLE_USER"; break; + case GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0 : result="GEN_VAR_GLOB_DOUBLE_USER_0"; break; + case GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_T : result="GEN_VAR_GLOB_DOUBLE_USER_T"; break; + case GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT : result="GEN_VAR_GLOB_DOUBLE_USER_TDT"; break; + case DEPLACEMENT : result="DEPLACEMENT"; break; + case VITESSE : result="VITESSE"; break; + case DELTA_XI : result="DELTA_XI"; break; + case XI_ITER_0 : result="XI_ITER_0"; break; + case MASSE_RELAX_DYN : result="MASSE_RELAX_DYN"; break; + case COMP_TORSEUR_REACTION : result="COMP_TORSEUR_REACTION"; break; + case NUM_NOEUD : result="NUM_NOEUD"; break; + case NUM_MAIL_NOEUD : result="NUM_MAIL_NOEUD"; break; + case NUM_ELEMENT : result="NUM_ELEMENT"; break; + case NUM_MAIL_ELEM : result="NUM_MAIL_ELEM"; break; + case NUM_PTI : result="NUM_PTI"; break; + case NUM_FACE : result="NUM_FACE"; break; + case NUM_ARETE : result="NUM_ARETE"; break; + + default : + cout << "\nErreur : valeur incorrecte du type EnumTypeQuelconque: id_TypeQuelconque=" + << id_TypeQuelconque << " !\n"; + cout << "NomGenerique(EnumTypeQuelconque ) \n"; + Sortie(1); + }; + return result; +}; + + +EnumTypeQuelconque Id_nomTypeQuelconque (const char* nom_TypeQuelconque) +// Retourne la variable de type enumere associe au nom nom_TypeQuelconque +{ // on vérifie si la variable de type enumere existe + map < string, EnumTypeQuelconque , std::less < string> >& maa=ClassPourEnumTypeQuelconque::map_EnumTypeQuelconque; + map < string, EnumTypeQuelconque , std::less < string> >::iterator il,ilfin= maa.end(); + il = maa.find(nom_TypeQuelconque); + if (il == ilfin) + {// on vérifie si la variable de type enumere existe + cout << "\nErreur : nom du type de grandeur '" < >& maa=ClassPourEnumTypeQuelconque::map_EnumTypeQuelconque; + map < string, EnumTypeQuelconque , std::less < string> >::iterator il,ilfin= maa.end(); + il = maa.find(nom_TypeQuelconque); + if (il == ilfin) + {// on vérifie si la variable de type enumere existe + cout << "\nErreur : nom du type de grandeur '" <> (istream & entree, EnumTypeQuelconque & result) + { char nom_TypeQuelconque[80]; + entree >> nom_TypeQuelconque; + result = Id_nomTypeQuelconque ( nom_TypeQuelconque); + return entree; + }; + +// Retourne le type de grandeur associée au type quelconque +EnumTypeGrandeur Type_de_grandeur_associee(EnumTypeQuelconque typa) +{switch (typa) + {case RIEN_TYPEQUELCONQUE : return RIEN_TYPEGRANDEUR; break; + case SIGMA_BARRE_BH_T : return TENSEURBH; break; + case CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T_SANS_PROPORTION : return TENSEURHH; break; + case CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T : return TENSEURHH; break; + case CONTRAINTE_COURANTE : return TENSEURHH; break; + case DEFORMATION_COURANTE : return TENSEURBB; break; + case VITESSE_DEFORMATION_COURANTE : return TENSEURBB; break; + case ALMANSI : return TENSEURBB; break; + case GREEN_LAGRANGE : return TENSEURBB; break; + case LOGARITHMIQUE : return TENSEURBB; break; + case DELTA_DEF : return TENSEURBB; break; + case ALMANSI_TOTAL : return TENSEURBB; break; + case GREEN_LAGRANGE_TOTAL : return TENSEURBB; break; + case LOGARITHMIQUE_TOTALE : return TENSEURBB; break; + case DEF_PRINCIPALES : return COORDONNEE; break; + case SIGMA_PRINCIPALES : return COORDONNEE; break; + case VIT_PRINCIPALES : return COORDONNEE; break; + case DEF_DUALE_MISES : return SCALAIRE; break; + case DEF_DUALE_MISES_MAXI : return SCALAIRE; break; + case CONTRAINTE_MISES : return SCALAIRE; break; + case CONTRAINTE_MISES_T : return SCALAIRE; break; + case CONTRAINTE_TRESCA : return SCALAIRE; break; + case CONTRAINTE_TRESCA_T : return SCALAIRE; break; + case ERREUR_Q : return SCALAIRE; break; + case DEF_PLASTIQUE_CUMULEE : return SCALAIRE; break; + case ERREUR_SIG_RELATIVE : return SCALAIRE; break; + case TEMPERATURE_LOI_THERMO_PHYSIQUE : return SCALAIRE; break; + case PRESSION_LOI_THERMO_PHYSIQUE : return SCALAIRE; break; + case TEMPERATURE_TRANSITION : return SCALAIRE; break; + case VOLUME_SPECIFIQUE : return SCALAIRE; break; + case FLUXD : return COORDONNEE; break; + case GRADT : return COORDONNEE; break; + case DGRADT : return COORDONNEE; break; + case DELTAGRADT : return COORDONNEE; break; + case COEFF_DILATATION_LINEAIRE : return SCALAIRE; break; + case CONDUCTIVITE : return SCALAIRE; break; + case CAPACITE_CALORIFIQUE : return SCALAIRE; break; + case MODULE_COMPRESSIBILITE : return SCALAIRE; break; + case COEFF_COMPRESSIBILITE : return SCALAIRE; break; + case MODULE_CISAILLEMENT : return SCALAIRE; break; + case MODULE_COMPRESSIBILITE_TOTAL : return SCALAIRE; break; + case MODULE_CISAILLEMENT_TOTAL : return SCALAIRE; break; + case E_YOUNG : return SCALAIRE; break; + case NU_YOUNG : return SCALAIRE; break; + case MU_VISCO : return SCALAIRE; break; + case MU_VISCO_SPHERIQUE : return SCALAIRE; break; + case MODULE_TANGENT_1D : return SCALAIRE; break; + case COMPRESSIBILITE_TANGENTE : return SCALAIRE; break; + case NB_INVERSION : return SCALAIRE; break; + case HYPER_CENTRE_HYSTERESIS : return TENSEURBH; break; + case SIGMA_REF : return TENSEURBH; break; + case Q_SIG_HYST_Oi_A_R : return SCALAIRE; break; + case Q_SIG_HYST_R_A_T : return SCALAIRE; break; + case Q_DELTA_SIG_HYST : return SCALAIRE; break; + case COS_ALPHA_HYSTERESIS : return SCALAIRE; break; + case COS3PHI_SIG_HYSTERESIS : return SCALAIRE; break; + case COS3PHI_DELTA_SIG_HYSTERESIS : return SCALAIRE; break; + case FCT_AIDE : return SCALAIRE; break; + case NB_ITER_TOTAL_RESIDU : return SCALAIRE; break; + case NB_INCRE_TOTAL_RESIDU : return SCALAIRE; break; + case NB_APPEL_FCT : return SCALAIRE; break; + case NB_STEP : return SCALAIRE; break; + case ERREUR_RK : return SCALAIRE; break; + case PRESSION_HYST_REF : return SCALAIRE; break; + case PRESSION_HYST_REF_M1 : return SCALAIRE; break; + case PRESSION_HYST_T : return SCALAIRE; break; + case PRESSION_HYST : return SCALAIRE; break; + case UN_DDL_ENUM_ETENDUE : return SCALAIRE; break; + case ENERGIE_ELASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T : return SCALAIRE; break; + case ENERGIE_PLASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T : return SCALAIRE; break; + case ENERGIE_VISQUEUSE_INDIVIDUELLE_A_CHAQUE_LOI_A_T : return SCALAIRE; break; + case PROPORTION_LOI_MELANGE : return SCALAIRE; break; + case FONC_PONDERATION : return SCALAIRE; break; + case POSITION_GEOMETRIQUE : return COORDONNEE; break; + case POSITION_GEOMETRIQUE_t : return COORDONNEE; break; + case POSITION_GEOMETRIQUE_t0 : return COORDONNEE; break; + case CRISTALINITE : return SCALAIRE; break; + case VOLUME_ELEMENT : return SCALAIRE; break; + case VOLUME_PTI : return SCALAIRE; break; + case EPAISSEUR_MOY_INITIALE : return SCALAIRE; break; + case EPAISSEUR_MOY_FINALE : return SCALAIRE; break; + case SECTION_MOY_INITIALE : return SCALAIRE; break; + case SECTION_MOY_FINALE : return SCALAIRE; break; + case EPAISSEUR_INITIALE : return SCALAIRE; break; + case EPAISSEUR_FINALE : return SCALAIRE; break; + case SECTION_INITIALE : return SCALAIRE; break; + case SECTION_FINALE : return SCALAIRE; break; + case VOL_ELEM_AVEC_PLAN_REF : return COORDONNEE; break; + case INTEG_SUR_VOLUME : return VECTEUR; break; + case INTEG_SUR_VOLUME_ET_TEMPS : return VECTEUR; break; + case STATISTIQUE : return VECTEUR; break; + case STATISTIQUE_ET_TEMPS : return VECTEUR; break; + case ENERGIE_HOURGLASS : return SCALAIRE; break; + case PUISSANCE_BULK : return SCALAIRE; break; + case ENERGIE_BULK : return SCALAIRE; break; + case ENERGIE_STABMEMB_BIEL : return SCALAIRE; break; + case FORCE_STABMEMB_BIEL : return SCALAIRE; break; + case TENSEUR_COURBURE : return TENSEURBB; break; + case COURBURES_PRINCIPALES : return SCALAIRE; break; + case DIRECTIONS_PRINC_COURBURE : return COORDONNEE; break; + case DIRECTIONS_PRINC_SIGMA : return COORDONNEE; break; + case DIRECTIONS_PRINC_DEF : return COORDONNEE; break; + case DIRECTIONS_PRINC_D : return COORDONNEE; break; + case REPERE_LOCAL_ORTHO : return COORDONNEE; break; + case REPERE_LOCAL_H : return COORDONNEE; break; + case REPERE_LOCAL_B : return COORDONNEE; break; + case REPERE_D_ANISOTROPIE : return BASE__H; break; + case EPS_TRANSPORTEE_ANISO : return TENSEURHH; break; + case SIGMA_DANS_ANISO : return TENSEURHH; break; + case DELTA_EPS_TRANSPORTEE_ANISO : return TENSEURHH; break; + case DELTA_SIGMA_DANS_ANISO : return TENSEURHH; break; + case PARA_ORTHO : return VECTEUR; break; + case SPHERIQUE_EPS : return SCALAIRE; break; + case Q_EPS : return SCALAIRE; break; + case COS3PHI_EPS : return SCALAIRE; break; + case SPHERIQUE_SIG : return SCALAIRE; break; + case Q_SIG : return SCALAIRE; break; + case COS3PHI_SIG : return SCALAIRE; break; + case SPHERIQUE_DEPS : return SCALAIRE; break; + case V_vol : return SCALAIRE; break; + case Q_DEPS : return SCALAIRE; break; + case COS3PHI_DEPS : return SCALAIRE; break; + case POTENTIEL : return SCALAIRE; break; + case FCT_POTENTIEL_ND : return VECTEUR; break; + case INVAR_B1 : return SCALAIRE; break; + case INVAR_B2 : return SCALAIRE; break; + case INVAR_B3 : return SCALAIRE; break; + case INVAR_J1 : return SCALAIRE; break; + case INVAR_J2 : return SCALAIRE; break; + case INVAR_J3 : return SCALAIRE; break; + case DEF_EQUIVALENTE : return SCALAIRE; break; + case DEF_EPAISSEUR : return SCALAIRE; break; + case D_EPAISSEUR : return SCALAIRE; break; + case DEF_LARGEUR : return SCALAIRE; break; + case D_LARGEUR : return SCALAIRE; break; + case DEF_MECANIQUE : return TENSEURBB; break; + case DEF_ASSO_LOI : return TENSEURBB; break; + case DEF_P_DANS_V_A : return VECTEUR; break; + case SIG_EPAISSEUR : return SCALAIRE; break; + case SIG_LARGEUR : return SCALAIRE; break; + case FORCE_GENE_EXT : return COORDONNEE; break; + case FORCE_GENE_INT : return COORDONNEE; break; + case FORCE_GENE_EXT_t : return COORDONNEE; break; + case FORCE_GENE_INT_t : return COORDONNEE; break; + case FORCE_GENE_TOT : return COORDONNEE; break; + case RESIDU_GLOBAL : return COORDONNEE; break; + case VECT_PRESSION : return COORDONNEE; break; + case PRESSION_SCALAIRE : return SCALAIRE; break; + case VECT_FORCE_VOLUM : return COORDONNEE; break; + case VECT_DIR_FIXE : return COORDONNEE; break; + case VECT_SURF_SUIV : return COORDONNEE; break; + case VECT_HYDRODYNA_Fn : return COORDONNEE; break; + case VECT_HYDRODYNA_Ft : return COORDONNEE; break; + case VECT_HYDRODYNA_T : return COORDONNEE; break; + case VECT_LINE : return COORDONNEE; break; + case VECT_LINE_SUIV : return COORDONNEE; break; + case VECT_REAC : return COORDONNEE; break; + case VECT_REAC_N : return COORDONNEE; break; + case NN_11 : return SCALAIRE; break; + case NN_22 : return SCALAIRE; break; + case NN_33 : return SCALAIRE; break; + case NN_12 : return SCALAIRE; break; + case NN_13 : return SCALAIRE; break; + case NN_23 : return SCALAIRE; break; + case MM_11 : return SCALAIRE; break; + case MM_22 : return SCALAIRE; break; + case MM_33 : return SCALAIRE; break; + case MM_12 : return SCALAIRE; break; + case MM_13 : return SCALAIRE; break; + case MM_23 : return SCALAIRE; break; + case DIRECTION_PLI : return COORDONNEE; break; + case DIRECTION_PLI_NORMEE : return COORDONNEE; break; + case INDIC_CAL_PLIS : return SCALAIRE; break; + case NN_SURF : return COORDONNEE; break; + case NN_SURF_t : return COORDONNEE; break; + case NN_SURF_t0 : return COORDONNEE; break; + case NOEUD_PROJECTILE_EN_CONTACT : return SCALAIRE; break; + case NOEUD_FACETTE_EN_CONTACT : return SCALAIRE; break; + case GLISSEMENT_CONTACT : return COORDONNEE; break; + case PENETRATION_CONTACT : return COORDONNEE; break; + case GLISSEMENT_CONTACT_T : return COORDONNEE; break; + case PENETRATION_CONTACT_T : return COORDONNEE; break; + case FORCE_CONTACT : return COORDONNEE; break; + case FORCE_CONTACT_T : return COORDONNEE; break; + case CONTACT_NB_PENET : return SCALAIRE; break; + case CONTACT_NB_DECOL : return SCALAIRE; break; + case CONTACT_CAS_SOLIDE : return SCALAIRE; break; + case CONTACT_ENERG_PENAL : return SCALAIRE; break; + case CONTACT_COLLANT : return SCALAIRE; break; + case NUM_ZONE_CONTACT : return SCALAIRE; break; + case CONTACT_ENERG_GLISSE_ELAS : return SCALAIRE; break; + case CONTACT_ENERG_GLISSE_PLAS : return SCALAIRE; break; + case CONTACT_ENERG_GLISSE_VISQ : return SCALAIRE; break; + case CONTACT_PENALISATION_N : return SCALAIRE; break; + case CONTACT_PENALISATION_T : return SCALAIRE; break; + case NORMALE_CONTACT : return COORDONNEE; break; + case TEMPS_CPU_USER : return SCALAIRE; break; + case TEMPS_CPU_LOI_COMP : return SCALAIRE; break; + case TEMPS_CPU_METRIQUE : return SCALAIRE; break; + case GENERIQUE_UNE_GRANDEUR_GLOBALE : return SCALAIRE; break; + case GENERIQUE_UNE_CONSTANTE_GLOB_INT_UTILISATEUR : return SCALAIRE; break; + case GENERIQUE_UNE_CONSTANTE_GLOB_DOUBLE_UTILISATEUR : return SCALAIRE; break; + case GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0 : return SCALAIRE; break; + case GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_T : return SCALAIRE; break; + case GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT : return SCALAIRE; break; + case DEPLACEMENT : return COORDONNEE; break; + case VITESSE : return COORDONNEE; break; + case DELTA_XI : return COORDONNEE; break; + case XI_ITER_0 : return COORDONNEE; break; + case MASSE_RELAX_DYN : return COORDONNEE; break; + case COMP_TORSEUR_REACTION : return SCALAIRE; break; + case NUM_NOEUD : return SCALAIRE; break; + case NUM_MAIL_NOEUD : return SCALAIRE; break; + case NUM_ELEMENT : return SCALAIRE; break; + case NUM_MAIL_ELEM : return SCALAIRE; break; + case NUM_PTI : return SCALAIRE; break; + case NUM_FACE : return SCALAIRE; break; + case NUM_ARETE : return SCALAIRE; break; + + default : + cout << "\nErreur : valeur incorrecte du type EnumTypeQuelconque: typa= " << typa << " !\n"; + cout << "Type_de_grandeur_associee(EnumTypeQuelconque ) \n"; + Sortie(1); + }; + return RIEN_TYPEGRANDEUR; // pour taire le warning +}; + +// retourne le temps auquel la grandeur est définie +Enum_dure EnumTypeQuelconqueTemps(EnumTypeQuelconque typa) + {return ClassPourEnumTypeQuelconque::tt_TQ_temps(typa);}; + +// retour du type d'expression de la grandeur +// = 1 indique si la grandeur est naturellement exprimé dans le repère globale +// = 0 indique que la grandeur est dans le repère naturelle (ou une combinaison) +int EnumTypeQuelconqueGlobale(EnumTypeQuelconque typa) + {return ClassPourEnumTypeQuelconque::tt_GLOB(typa);}; + +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnumTypeQuelconque& a) + { // on ecrit la forme caractère + sort << NomTypeQuelconque(a) << " "; + return sort; + }; + diff --git a/Enumeration/Enum_TypeQuelconque.h b/Enumeration/Enum_TypeQuelconque.h new file mode 100644 index 0000000..17d241c --- /dev/null +++ b/Enumeration/Enum_TypeQuelconque.h @@ -0,0 +1,193 @@ +/*! \file Enum_TypeQuelconque.h + \brief Définition de l'enuméré pour repérer un type quelconque +*/ +// FICHIER : Enum_TypeQuelconque.h + +// 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-2021 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: . + + +// Afin de realiser un gain en place memoire, les noms des types de grandeurs sont +// stockes a l'aide d'un type enumere. Les fonctions NomTypeQuelconque et Id_nomTypeQuelconque rendent +// possible le lien entre les noms des geometries et les identificateurs +// de type enumere correspondants. + + +#ifndef ENUMTYPEQUELCONQUE_H +#define ENUMTYPEQUELCONQUE_H +#include +using namespace std; +#include +#include "ParaGlob.h" +#include "EnumTypeGrandeur.h" +#include "Enum_dure.h" +#include "Tableau_T.h" + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré pour repérer un type quelconque + +enum EnumTypeQuelconque { RIEN_TYPEQUELCONQUE = 1, SIGMA_BARRE_BH_T + ,CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T + ,CONTRAINTE_INDIVIDUELLE_A_CHAQUE_LOI_A_T_SANS_PROPORTION + ,CONTRAINTE_COURANTE,DEFORMATION_COURANTE,VITESSE_DEFORMATION_COURANTE + ,ALMANSI,GREEN_LAGRANGE,LOGARITHMIQUE,DELTA_DEF + ,ALMANSI_TOTAL,GREEN_LAGRANGE_TOTAL,LOGARITHMIQUE_TOTALE + ,DEF_PRINCIPALES,SIGMA_PRINCIPALES,VIT_PRINCIPALES,DEF_DUALE_MISES,DEF_DUALE_MISES_MAXI + ,CONTRAINTE_MISES,CONTRAINTE_MISES_T,CONTRAINTE_TRESCA,CONTRAINTE_TRESCA_T + ,ERREUR_Q,DEF_PLASTIQUE_CUMULEE + ,ERREUR_SIG_RELATIVE + ,TEMPERATURE_LOI_THERMO_PHYSIQUE, PRESSION_LOI_THERMO_PHYSIQUE + ,TEMPERATURE_TRANSITION, VOLUME_SPECIFIQUE + ,FLUXD, GRADT, DGRADT,DELTAGRADT + ,COEFF_DILATATION_LINEAIRE, CONDUCTIVITE, CAPACITE_CALORIFIQUE + ,MODULE_COMPRESSIBILITE,MODULE_CISAILLEMENT,COEFF_COMPRESSIBILITE + ,MODULE_COMPRESSIBILITE_TOTAL,MODULE_CISAILLEMENT_TOTAL + ,E_YOUNG,NU_YOUNG,MU_VISCO,MU_VISCO_SPHERIQUE + ,MODULE_TANGENT_1D,COMPRESSIBILITE_TANGENTE + ,NB_INVERSION,HYPER_CENTRE_HYSTERESIS,SIGMA_REF,Q_SIG_HYST_Oi_A_R,Q_SIG_HYST_R_A_T + ,Q_DELTA_SIG_HYST,COS_ALPHA_HYSTERESIS,COS3PHI_SIG_HYSTERESIS,COS3PHI_DELTA_SIG_HYSTERESIS + ,FCT_AIDE + ,NB_ITER_TOTAL_RESIDU,NB_INCRE_TOTAL_RESIDU,NB_APPEL_FCT,NB_STEP,ERREUR_RK + ,PRESSION_HYST_REF,PRESSION_HYST,PRESSION_HYST_REF_M1,PRESSION_HYST_T + ,UN_DDL_ENUM_ETENDUE,ENERGIE_ELASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T + ,ENERGIE_PLASTIQUE_INDIVIDUELLE_A_CHAQUE_LOI_A_T + ,ENERGIE_VISQUEUSE_INDIVIDUELLE_A_CHAQUE_LOI_A_T + ,PROPORTION_LOI_MELANGE, FONC_PONDERATION + ,POSITION_GEOMETRIQUE,POSITION_GEOMETRIQUE_t,POSITION_GEOMETRIQUE_t0 + ,CRISTALINITE + ,VOLUME_ELEMENT,VOLUME_PTI,EPAISSEUR_MOY_INITIALE, EPAISSEUR_MOY_FINALE + ,SECTION_MOY_INITIALE, SECTION_MOY_FINALE + ,EPAISSEUR_INITIALE, EPAISSEUR_FINALE,SECTION_INITIALE, SECTION_FINALE + ,VOL_ELEM_AVEC_PLAN_REF,INTEG_SUR_VOLUME,INTEG_SUR_VOLUME_ET_TEMPS + ,STATISTIQUE,STATISTIQUE_ET_TEMPS + ,ENERGIE_HOURGLASS,PUISSANCE_BULK,ENERGIE_BULK,ENERGIE_STABMEMB_BIEL,FORCE_STABMEMB_BIEL + ,TENSEUR_COURBURE, COURBURES_PRINCIPALES, DIRECTIONS_PRINC_COURBURE + ,DIRECTIONS_PRINC_SIGMA,DIRECTIONS_PRINC_DEF,DIRECTIONS_PRINC_D + ,REPERE_LOCAL_ORTHO, REPERE_LOCAL_H, REPERE_LOCAL_B + ,REPERE_D_ANISOTROPIE,EPS_TRANSPORTEE_ANISO,SIGMA_DANS_ANISO + ,DELTA_EPS_TRANSPORTEE_ANISO,DELTA_SIGMA_DANS_ANISO + ,PARA_ORTHO + ,SPHERIQUE_EPS,Q_EPS,COS3PHI_EPS,SPHERIQUE_SIG,Q_SIG,COS3PHI_SIG + ,SPHERIQUE_DEPS,V_vol,Q_DEPS,COS3PHI_DEPS,POTENTIEL,FCT_POTENTIEL_ND + ,INVAR_B1,INVAR_B2,INVAR_B3,INVAR_J1,INVAR_J2,INVAR_J3 + ,DEF_EQUIVALENTE,DEF_EPAISSEUR,D_EPAISSEUR,DEF_LARGEUR,D_LARGEUR + ,DEF_MECANIQUE,DEF_ASSO_LOI,DEF_P_DANS_V_A + ,SIG_EPAISSEUR,SIG_LARGEUR + ,FORCE_GENE_EXT,FORCE_GENE_INT,FORCE_GENE_TOT,RESIDU_GLOBAL + ,FORCE_GENE_EXT_t,FORCE_GENE_INT_t + ,VECT_PRESSION,PRESSION_SCALAIRE,VECT_FORCE_VOLUM + ,VECT_DIR_FIXE,VECT_SURF_SUIV,VECT_HYDRODYNA_Fn,VECT_HYDRODYNA_Ft,VECT_HYDRODYNA_T + ,VECT_LINE,VECT_LINE_SUIV,VECT_REAC,VECT_REAC_N + ,NN_11,NN_22,NN_33,NN_12,NN_13,NN_23,MM_11,MM_22,MM_33,MM_12,MM_13,MM_23 + ,DIRECTION_PLI,DIRECTION_PLI_NORMEE,INDIC_CAL_PLIS + ,NN_SURF,NN_SURF_t,NN_SURF_t0 + ,NOEUD_PROJECTILE_EN_CONTACT,NOEUD_FACETTE_EN_CONTACT + ,GLISSEMENT_CONTACT,PENETRATION_CONTACT + ,GLISSEMENT_CONTACT_T,PENETRATION_CONTACT_T + ,FORCE_CONTACT,FORCE_CONTACT_T,CONTACT_NB_PENET + ,CONTACT_NB_DECOL,CONTACT_CAS_SOLIDE + ,CONTACT_ENERG_PENAL,CONTACT_COLLANT,NUM_ZONE_CONTACT + ,CONTACT_ENERG_GLISSE_ELAS,CONTACT_ENERG_GLISSE_PLAS,CONTACT_ENERG_GLISSE_VISQ + ,CONTACT_PENALISATION_N,CONTACT_PENALISATION_T + ,NORMALE_CONTACT + ,TEMPS_CPU_USER,TEMPS_CPU_LOI_COMP,TEMPS_CPU_METRIQUE + ,GENERIQUE_UNE_GRANDEUR_GLOBALE + ,GENERIQUE_UNE_CONSTANTE_GLOB_INT_UTILISATEUR + ,GENERIQUE_UNE_CONSTANTE_GLOB_DOUBLE_UTILISATEUR + ,GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0 + ,GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_T + ,GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT + ,DEPLACEMENT, VITESSE + ,DELTA_XI,XI_ITER_0,MASSE_RELAX_DYN + ,COMP_TORSEUR_REACTION + ,NUM_NOEUD,NUM_MAIL_NOEUD,NUM_ELEMENT,NUM_MAIL_ELEM,NUM_PTI + ,NUM_FACE,NUM_ARETE + }; +/// @} // end of group + +//------****----- +// en fonction des ajouts voir pour mettre à jour éventuellement +// EnumTypeQuelconque Equi_Enum_ddl_en_enu_quelconque(Enum_ddl a); +//------****----- + +/// @addtogroup Group_types_enumeres +/// @{ + +/// def de la map qui fait la liaison entre les string et les énumérés + +class ClassPourEnumTypeQuelconque +{ public: + // def de la map qui fait la liaison entre les string et les énumérés + static map < string, EnumTypeQuelconque , std::less < string> > map_EnumTypeQuelconque; + // def de la grandeur statique qui permet de remplir la map + static ClassPourEnumTypeQuelconque remplir_map; + // le constructeur qui rempli effectivement la map + ClassPourEnumTypeQuelconque(); + // indique le type d'expression de la grandeur + static Tableau < int > tt_GLOB; // = 1 indique si la grandeur est naturellement exprimé dans le repère globale + // = 0 indique que la grandeur est dans le repère naturelle (ou une combinaison) + // indique à quel temps la grandeur est calculée + static Tableau < Enum_dure > tt_TQ_temps; + // nombre de grandeur énumérée existante + static int NombreEnumTypeQuelconque() {return tt_GLOB.Taille();}; + }; +/// @} // end of group + + +// Retourne le nom du type de grandeur a partir de son identificateur de +// type enumere id_TypeQuelconque correspondant +string NomTypeQuelconque (EnumTypeQuelconque id_TypeQuelconque); +// idem mais en version courte (sur quelques caractères) +string NomTypeQuelconque_court (EnumTypeQuelconque id_TypeQuelconque); +// nom générique, lorsqu'il s'agit de composantes +string NomGeneriqueTypeQuelconque(EnumTypeQuelconque id_TypeQuelconque); + +// indique si le string correspond à un type quelconque reconnu ou non +bool Existe_typeQuelconque(const string& nom); + +// Retourne l'identificateur de type enumere associe au nom du type de grandeur +// nom_TypeQuelconque +EnumTypeQuelconque Id_nomTypeQuelconque (const char* nom_TypeQuelconque); +EnumTypeQuelconque Id_nomTypeQuelconque (const string& nom_TypeQuelconque); + +// Retourne le type de grandeur associée au type quelconque +EnumTypeGrandeur Type_de_grandeur_associee(EnumTypeQuelconque typa); +// retourne le temps auquel la grandeur est définie +Enum_dure EnumTypeQuelconqueTemps(EnumTypeQuelconque typa); +// retour du type d'expression de la grandeur +// = 1 indique si la grandeur est naturellement exprimé dans le repère globale +// = 0 indique que la grandeur est dans le repère naturelle (ou une combinaison) +int EnumTypeQuelconqueGlobale(EnumTypeQuelconque typa); +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, EnumTypeQuelconque& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const EnumTypeQuelconque& a); + +#endif diff --git a/Enumeration/Enum_boolddl.cc b/Enumeration/Enum_boolddl.cc new file mode 100644 index 0000000..d3c55e2 --- /dev/null +++ b/Enumeration/Enum_boolddl.cc @@ -0,0 +1,169 @@ +// FICHIER Enum_boolddl.cc + + +// 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-2021 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: . + + +#include "Enum_boolddl.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + +#ifndef Enum_boolddl_deja_inclus + +#ifndef MISE_AU_POINT + inline +#endif +string Nom_boolddl (Enum_boolddl id_nom) +// Retourne le nom du degre de liberte associe +// a l'identificateur de type enumere id_nom +{ + + string result=""; + switch (id_nom) + { + case LIBRE : result="LIBRE"; break; + case FIXE : result="FIXE"; break; + case HSLIBRE : result="HSLIBRE"; break; + case HSFIXE : result="HSFIXE"; break; + case SOUSLIBRE : result="SOUSLIBRE"; break; + case SURFIXE : result="SURFIXE"; break; + case LISIBLE_LIBRE : result="LISIBLE_LIBRE"; break; + case LISIBLE_FIXE : result="LISIBLE_FIXE"; break; + case LISIBLE_SOUSLIBRE : result="LISIBLE_SOUSLIBRE"; break; + case LISIBLE_SURFIXE : result="LISIBLE_SURFIXE"; break; + case HS_LISIBLE_LIBRE : result="HS_LISIBLE_LIBRE"; break; + case HS_LISIBLE_FIXE : result="HS_LISIBLE_FIXE"; break; + case HS_SOUSLIBRE : result="HS_SOUSLIBRE"; break; + case HS_SURFIXE : result="HS_SURFIXE"; break; + case HS_LISIBLE_SOUSLIBRE : result="HS_LISIBLE_SOUSLIBRE"; break; + case HS_LISIBLE_SURFIXE : result="HS_LISIBLE_SURFIXE"; break; + + default : + cout << "\nErreur : valeur incorrecte du type Enum_boolddl !\n"; + cout << "NOM_DDL(Enum_boolddl ) \n"; + Sortie(1); + }; + return result; + +}; + +#ifndef MISE_AU_POINT + inline +#endif +Enum_boolddl Id_nom_boolddl (const string& nom) +// Retourne la variable de type enumere associee au nom du degre +// de liberte nom +{ + + Enum_boolddl result; + if ( nom == "LIBRE" ) result=LIBRE; + else if ( nom == "FIXE" ) result=FIXE; + else if ( nom == "HSLIBRE" ) result=HSLIBRE; + else if ( nom == "HSFIXE" ) result=HSFIXE; + else if ( nom == "SOUSLIBRE" ) result=SOUSLIBRE; + else if ( nom == "SURFIXE" ) result=SURFIXE; + else if ( nom == "LISIBLE_LIBRE" ) result=LISIBLE_LIBRE; + else if ( nom == "LISIBLE_FIXE" ) result=LISIBLE_FIXE; + else if ( nom == "LISIBLE_SOUSLIBRE" ) result=LISIBLE_SOUSLIBRE; + else if ( nom == "LISIBLE_SURFIXE" ) result=LISIBLE_SURFIXE; + else if ( nom == "HS_LISIBLE_LIBRE" ) result=HS_LISIBLE_LIBRE; + else if ( nom == "HS_LISIBLE_FIXE" ) result=HS_LISIBLE_FIXE; + else if ( nom == "HS_SOUSLIBRE" ) result=HS_SOUSLIBRE; + else if ( nom == "HS_SURFIXE" ) result=HS_SURFIXE; + else if ( nom == "HS_LISIBLE_SOUSLIBRE" ) result=HS_LISIBLE_SOUSLIBRE; + else if ( nom == "HS_LISIBLE_SURFIXE" ) result=HS_LISIBLE_SURFIXE; + + else + { + cout << "\nErreur : nom ** " << nom << " ** du degre de liberte inconnu !\n"; + cout << "Id_nom_boolddl (char* nom) \n"; + Sortie(1); + }; + return result; + +}; + + +#ifndef MISE_AU_POINT + inline +#endif +// dit si c'est HS ou pas +// ramène true si HS, false sinon +bool Est_HS(Enum_boolddl id_ddl) +{ switch (id_ddl) + { case HSLIBRE : case HSFIXE :case HS_LISIBLE_LIBRE : + case HS_LISIBLE_FIXE :case HS_SOUSLIBRE : + case HS_SURFIXE :case HS_LISIBLE_SOUSLIBRE : case HS_LISIBLE_SURFIXE : + return true; break; + default : return false; + }; +}; + + + // surcharge de l'operator de lecture +#ifndef MISE_AU_POINT + inline +#endif +istream & operator >> (istream & entree, Enum_boolddl& a) + { char nom_Enum_boolddl[50]; + entree >> nom_Enum_boolddl; + a = Id_nom_boolddl ( nom_Enum_boolddl); + return entree; + }; + + // surcharge de l'operator d'ecriture +#ifndef MISE_AU_POINT + inline +#endif +ostream & operator << (ostream & sort, const Enum_boolddl& a) + { // on ecrit la forme caractère + sort << Nom_boolddl(a) << " "; + return sort; + }; + +#endif + + + + + diff --git a/Enumeration/Enum_boolddl.h b/Enumeration/Enum_boolddl.h new file mode 100644 index 0000000..958fa6b --- /dev/null +++ b/Enumeration/Enum_boolddl.h @@ -0,0 +1,82 @@ +/*! \file Enum_boolddl.h + \brief def de l'enuméré concernant les booléens ddl. +*/ +// FICHIER : Enum_boolddl.h + +// 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-2021 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: . + + +// Afin de realiser un gain en place memoire, et une vérification de type plus aisé qu' avec +// les entiers +// 10 carractere maxi + + +#ifndef ENUM_BOLLDDL_H +#define ENUM_BOLLDDL_H + +//#include "Debug.h" +#include +using namespace std; + + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré concernant les booléens ddl. + +enum Enum_boolddl { LIBRE = 0, FIXE , HSLIBRE,HSFIXE,SOUSLIBRE,SURFIXE + ,LISIBLE_LIBRE,LISIBLE_FIXE,LISIBLE_SOUSLIBRE, LISIBLE_SURFIXE + ,HS_LISIBLE_LIBRE,HS_LISIBLE_FIXE + ,HS_SOUSLIBRE , HS_SURFIXE , HS_LISIBLE_SOUSLIBRE , HS_LISIBLE_SURFIXE}; +/// @} // end of group + +/// Retourne le nom d'un degre de liberte a partir de son identificateur de +/// type enumere id_ddl correspondant +string Nom_boolddl ( Enum_boolddl id_ddl); + +/// Retourne l'identificateur de type enumere associe au nom du degre de liberte +/// nom_ddl + Enum_boolddl Id_nom_boolddl (const string& nom_ddl); + +/// dit si c'est HS ou pas +/// ramène true si HS, false sinon +bool Est_HS(Enum_boolddl id_ddl); + +/// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_boolddl& a); +/// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_boolddl& a); + +// pour faire de l'inline +#ifndef MISE_AU_POINT + #include "Enum_boolddl.cc" + #define Enum_boolddl_deja_inclus +#endif + +#endif diff --git a/Enumeration/Enum_calcul_masse.cc b/Enumeration/Enum_calcul_masse.cc new file mode 100755 index 0000000..2945fa7 --- /dev/null +++ b/Enumeration/Enum_calcul_masse.cc @@ -0,0 +1,115 @@ +// FICHIER : Enum_calcul_masse.cp + +// 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-2021 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: . + + + +#include "Enum_calcul_masse.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +char* Nom_calcul_masse (Enum_calcul_masse id_calcul_masse) +// Retourne le nom du type de calcul_masse correspondant a l'identificateur +// de type enumere id_calcul_masse +{ + + char* result; + switch (id_calcul_masse) + { + case MASSE_DIAG_COEF_EGAUX : + result="MASSE_DIAG_COEF_EGAUX"; + break; + case MASSE_DIAG_COEF_VAR : + result="MASSE_DIAG_COEF_VAR"; + break; + case MASSE_CONSISTANTE : + result="MASSE_CONSISTANTE"; + break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_calcul_masse !\n"; + cout << "Nom_calcul_masse(Enum_calcul_masse ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_calcul_masse Id_nom_calcul_masse (char* nom_calcul_masse) +// Retourne la variable de type enumere associe au nom +// de calcul_masse nom_calcul_masse +{ + + Enum_calcul_masse result; + if ( strcmp(nom_calcul_masse,"MASSE_DIAG_COEF_EGAUX")==0 ) + result=MASSE_DIAG_COEF_EGAUX; + else if ( strcmp(nom_calcul_masse,"MASSE_DIAG_COEF_VAR")==0 ) + result=MASSE_DIAG_COEF_VAR; + else if ( strcmp(nom_calcul_masse,"MASSE_CONSISTANTE")==0 ) + result=MASSE_CONSISTANTE; + else + { + cout << "\nErreur : nom de calcul_masse inconnu !\n"; + cout << "Id_nom_interpol(char* ) \n"; + Sortie(1); + }; + return result; + +}; + +// surcharge de la lecture +istream & operator >> (istream & entree, Enum_calcul_masse & result) + { char nom_calcul_masse[60]; + entree >> nom_calcul_masse; + result = Id_nom_calcul_masse ( nom_calcul_masse); + return entree; + }; + + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_calcul_masse& a) + { // on ecrit la forme caractère + sort << Nom_calcul_masse(a) << " "; + return sort; + }; + diff --git a/Enumeration/Enum_calcul_masse.h b/Enumeration/Enum_calcul_masse.h new file mode 100644 index 0000000..fb3a88c --- /dev/null +++ b/Enumeration/Enum_calcul_masse.h @@ -0,0 +1,91 @@ +/*! \file Enum_calcul_masse.h + \brief def de l'enuméré concernant les types de calcul de masse +* \date 26/12/00 +*/ +// FICHIER : Enum_calcul_masse.h + +// 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-2021 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: 26/12/00 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Enumeration des differents type de calcul de la masse. * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + +#ifndef ENUM_CALCUL_MASSE_H +#define ENUM_CALCUL_MASSE_H + +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ +/// + +/// def de l'enuméré concernant les types de calcul de masse + +enum Enum_calcul_masse { MASSE_DIAG_COEF_EGAUX = 1, MASSE_DIAG_COEF_VAR , MASSE_CONSISTANTE }; +/// @} // end of group + + +// Retourne un nom de type de calcul_masse a partir de son identificateur de +// type enumere id_calcul_masse correspondant +char* Nom_calcul_masse (Enum_calcul_masse id_calcul_masse); + +// Retourne l'identificateur de type enumere associe au nom du type +// de calcul_masse nom_calcul_masse +Enum_calcul_masse Id_nom_calcul_masse (char* nom_calcul_masse); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_calcul_masse& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_calcul_masse& a); + + +#endif + + diff --git a/Enumeration/Enum_categorie_loi_comp.cc b/Enumeration/Enum_categorie_loi_comp.cc new file mode 100644 index 0000000..83e53af --- /dev/null +++ b/Enumeration/Enum_categorie_loi_comp.cc @@ -0,0 +1,155 @@ +// FICHIER : Enum_categorie_loi_comp.cp + +// 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-2021 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: . + + + +#include "Enum_categorie_loi_comp.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +char* Nom_categorie_loi_comp (const Enum_categorie_loi_comp id_comport) +// Retourne le nom de la loi de comportement correspondant a l'identificateur +// de type enumere id_comport +{ + + char* result; + switch (id_comport) + { + case CAT_MECANIQUE : result="CAT_MECANIQUE"; break; + case CAT_THERMO_MECANIQUE : result="CAT_THERMO_MECANIQUE"; break; + case CAT_THERMO_PHYSIQUE : result="CAT_THERMO_PHYSIQUE"; break; + case CAT_FROTTEMENT : result="CAT_FROTTEMENT"; break; + case RIEN_CATEGORIE_LOI_COMP :result="RIEN_CATEGORIE_LOI_COMP"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_categorie_loi_comp !: " << id_comport << " \n"; + cout << "Nom_categorie_loi_comp(Enum_categorie_loi_comp ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_categorie_loi_comp Id_nom_categorie_loi_comp (const char* nom_comport) +// Retourne la variable de type enumere associee au nom de la loi +// de comportement nom_comport +{ + + Enum_categorie_loi_comp result; + if ( strcmp(nom_comport,"CAT_MECANIQUE")==0 ) result=CAT_MECANIQUE; + else if ( strcmp(nom_comport,"CAT_THERMO_MECANIQUE")==0 ) result=CAT_THERMO_MECANIQUE; + else if ( strcmp(nom_comport,"CAT_THERMO_PHYSIQUE")==0 ) result=CAT_THERMO_PHYSIQUE; + else if ( strcmp(nom_comport,"CAT_FROTTEMENT")==0 ) result=CAT_FROTTEMENT; + else if ( strcmp(nom_comport,"RIEN_CATEGORIE_LOI_COMP")==0 ) result=RIEN_CATEGORIE_LOI_COMP; + else + { + cout << "\nErreur : nom de loi de comportement inconnu !: " << nom_comport << " \n"; + cout << "Id_nom_categorie_loi_comp(char* ) \n"; + Sortie(1); + }; + return result; + +}; + + +// indique si oui ou non la categorie est mécanique c'est-à-dire satisfait à Loi_comp_abstraite +bool GroupeMecanique(const Enum_categorie_loi_comp id_comport) + { if (id_comport <= 2) {return true;} else {return false;}; + }; + +// indique si oui ou non la categorie est thermique c'est-à-dire satisfait à CompThermoPhysiqueAbstraite +bool GroupeThermique(const Enum_categorie_loi_comp id_comport) + { if (id_comport == 3) {return true;} else {return false;}; + }; + +// indique si oui ou non la categorie est frottement (de contact) c-a-d lié à CompFrotAbstraite +bool GroupeFrottement(const Enum_categorie_loi_comp id_comport) + { if (id_comport == 4) {return true;} else {return false;}; + }; + +// ramène un énuméré qui correspond à la catégorie la plus complète des deux passés en arguement +// par exemple la catégorie CAT_THERMO_MECANIQUE englobe la catégorie CAT_MECANIQUE +// au paravant on test si les deux sont du même groupe, sinon erreur +Enum_categorie_loi_comp Categorie_loi_comp_la_plus_complete(const Enum_categorie_loi_comp id_comport1, + const Enum_categorie_loi_comp id_comport2) + {// tout d'abord on vérifie qu'ils sont du même groupe + bool meme_groupe=false; + if (id_comport1 == id_comport2) return id_comport1; // cas pas de pb + if (GroupeMecanique(id_comport1) && GroupeMecanique(id_comport2)) // cas du groupe méca + { if (id_comport1 > id_comport2) {return id_comport1;} else {return id_comport2;};} + else if (GroupeThermique(id_comport1) && GroupeThermique(id_comport2)) + { if (id_comport1 > id_comport2) {return id_comport1;} else {return id_comport2;};} + else if (GroupeFrottement(id_comport1) && GroupeFrottement(id_comport2)) + { if (id_comport1 > id_comport2) {return id_comport1;} else {return id_comport2;};} + else + { cout << "\n erreur, les deux categories de loi ne sont pas identique" + << " Enum_categorie_loi_comp Categorie_loi_comp_la_plus_complete(..."; + Sortie(1); + return RIEN_CATEGORIE_LOI_COMP; + }; + }; +// test si deux énumérés correspondent à la même catégorie +bool MemeCategorie(const Enum_categorie_loi_comp id_comport1,const Enum_categorie_loi_comp id_comport2) + { if (GroupeMecanique(id_comport1) && GroupeMecanique(id_comport2)) return true; + if (GroupeThermique(id_comport1) && GroupeThermique(id_comport2)) return true; + if (GroupeFrottement(id_comport1) && GroupeFrottement(id_comport2)) return true; + return false; + }; + + // surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_categorie_loi_comp& a) + { char nom_Enum_comp[50]; + entree >> nom_Enum_comp; + a = Id_nom_categorie_loi_comp ( nom_Enum_comp); + return entree; + }; + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_categorie_loi_comp& a) + { // on ecrit la forme caractère + sort << Nom_categorie_loi_comp(a) << " "; + return sort; + }; + + + diff --git a/Enumeration/Enum_categorie_loi_comp.h b/Enumeration/Enum_categorie_loi_comp.h new file mode 100644 index 0000000..3f6fbfe --- /dev/null +++ b/Enumeration/Enum_categorie_loi_comp.h @@ -0,0 +1,94 @@ +/*! \file Enum_categorie_loi_comp.h + \brief def de l'enuméré concernant les booléens ddl. +*/ +// FICHIER : Enum_categorie_loi_comp.h + +// 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-2021 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: . + + +// Afin de realiser un gain en place memoire, le type de categorie des lois de comportement sont +// stockes a l'aide d'un type enumere. Les fonctions Nom_categorie_comp et Id_nom_categorie_comp +// rendent possible le lien entre les noms des lois de comportement et les identificateurs +// de type enumere correspondants. + + +#ifndef ENUM_CATEGORIE_LOI_COMP_H +#define ENUM_CATEGORIE_LOI_COMP_H +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré concernant catégories de lois de comportement. + +// *** important ****, pour chaque groupe de loi il faut que les catégories qui sont les plus +// générales, donc qui englobent les autres, doivent avoir une position plus haute +// ceci par exemple pour que la fonction Categorie_loi_comp_la_plus_complete fonctionne + +enum Enum_categorie_loi_comp { CAT_MECANIQUE=1,CAT_THERMO_MECANIQUE, CAT_THERMO_PHYSIQUE + ,CAT_FROTTEMENT + ,RIEN_CATEGORIE_LOI_COMP}; +/// @} // end of group + + +// ***** !!!! penser à changer ***** +//****** nbmax_caractere_Enum_categorie_loi_comp si nécessaire ***** +const int nbmax_caractere_Enum_categorie_loi_comp = 26; + +// Retourne le nom d'une loi de comportement a partir de son identificateur de +// type enumere id_categorie_loi_comp correspondant +char* Nom_categorie_loi_comp (const Enum_categorie_loi_comp id_comport); + +// Retourne l'identificateur de type enumere associe au nom de la loi de +// comportement nom_comport +Enum_categorie_loi_comp Id_nom_categorie_loi_comp (const char* nom_comport); + +// indique si oui ou non la categorie est mécanique c'est-à-dire satisfait à Loi_comp_abstraite +bool GroupeMecanique(const Enum_categorie_loi_comp id_comport); + +// indique si oui ou non la categorie est thermique c'est-à-dire satisfait à CompThermoPhysiqueAbstraite +bool GroupeThermique(const Enum_categorie_loi_comp id_comport); + +// indique si oui ou non la categorie est frottement (de contact) c-a-d lié à CompFrotAbstraite +bool GroupeFrottement(const Enum_categorie_loi_comp id_comport); + +// ramène un énuméré qui correspond à la catégorie la plus complète des deux passés en arguement +// par exemple la catégorie CAT_THERMO_MECANIQUE englobe la catégorie CAT_MECANIQUE +// au paravant on test si les deux sont du même groupe, sinon erreur +Enum_categorie_loi_comp Categorie_loi_comp_la_plus_complete(const Enum_categorie_loi_comp id_comport1, + const Enum_categorie_loi_comp id_comport2); +// test si deux énumérés correspondent à la même catégorie +bool MemeCategorie(const Enum_categorie_loi_comp id_comport1,const Enum_categorie_loi_comp id_comport2); +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_categorie_loi_comp& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_categorie_loi_comp& a); + +#endif diff --git a/Enumeration/Enum_chargement.cc b/Enumeration/Enum_chargement.cc new file mode 100755 index 0000000..7aecaa8 --- /dev/null +++ b/Enumeration/Enum_chargement.cc @@ -0,0 +1,133 @@ +// FICHIER : Enum_chargement.cc + + +// 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-2021 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: . + + +#include "Enum_chargement.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +string Nom_chargement (const Enum_chargement id_chargement) +// Retourne le nom du type de chargement correspondant a l'identificateur +// de type enumere id_chargement +{ + + string result; + switch (id_chargement) + { + case RIEN_CHARGEMENT : result="RIEN_CHARGEMENT"; break; + case UNIFORME : result="UNIFORME"; break; + case PRESSION : result="PRESSION"; break; + case PONCTUELLE : result="PONCTUELLE"; break; + case PRESSDIR : result="PRESSDIR"; break; + case PHYDRO : result="PHYDRO"; break; + case LINEIQUE : result="LINEIQUE"; break; + case VOLUMIQUE : result="VOLUMIQUE"; break; + case LINEIC_SUIVEUSE : result="LINEIC_SUIVEUSE"; break; + case P_HYDRODYNA : result="P_HYDRODYNA"; break; + case TORSEUR_PONCT : result="TORSEUR_PONCT"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_chargement !\n"; + cout << "NOM_CHARGEMENT(Enum_chargement ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_chargement Id_nom_chargement (const string& nom_chargement) +// Retourne la variable de type enumere associe au nom +// de chargement nom_chargement +{ + + Enum_chargement result; + if ( nom_chargement == "RIEN_CHARGEMENT" ) + result=RIEN_CHARGEMENT; + else if ( nom_chargement == "UNIFORME" ) + result=UNIFORME; + else if ( nom_chargement == "PRESSION" ) + result=PRESSION; + else if ( nom_chargement == "PONCTUELLE" ) + result=PONCTUELLE; + else if ( nom_chargement == "PRESSDIR" ) + result=PRESSDIR; + else if ( nom_chargement == "PHYDRO" ) + result=PHYDRO; + else if ( nom_chargement == "LINEIQUE" ) + result=LINEIQUE; + else if ( nom_chargement == "VOLUMIQUE" ) + result=VOLUMIQUE; + else if ( nom_chargement == "LINEIC_SUIVEUSE" ) + result=LINEIC_SUIVEUSE; + else if ( nom_chargement == "P_HYDRODYNA" ) + result=P_HYDRODYNA; + else if ( nom_chargement == "TORSEUR_PONCT" ) + result=TORSEUR_PONCT; + else + { + cout << "\nErreur : nom de chargement inconnu !\n"; + cout << "ID_NOM_CHARGEMENT(string ) \n"; + Sortie(1); + }; + return result; + +}; + +// surcharge de la lecture +istream & operator >> (istream & entree, Enum_chargement & result) + { char nom_chargement[35]; + entree >> nom_chargement; + result = Id_nom_chargement ( nom_chargement); + return entree; + }; + + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_chargement& a) + { // on ecrit la forme caractère + sort << Nom_chargement(a) << " "; + return sort; + }; + diff --git a/Enumeration/Enum_chargement.h b/Enumeration/Enum_chargement.h new file mode 100755 index 0000000..191767d --- /dev/null +++ b/Enumeration/Enum_chargement.h @@ -0,0 +1,74 @@ +/*! \file Enum_chargement.h + \brief def de l'enuméré concernant les types de chargement +*/ +// FICHIER : Enum_chargement.h + +// 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-2021 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: . + + +// Afin de realiser un gain en place memoire, les noms de chargement +// sont stockes a l'aide d'un type enumere. Les fonctions Nom_chargement et +// Id_nom_chargement rendent possible le lien entre les noms des types de chargement +// et les identificateurs de type enumere correspondants. + + +#ifndef ENUM_CHARGEMENT_H +#define ENUM_CHARGEMENT_H +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré concernant les types de chargement + +enum Enum_chargement { RIEN_CHARGEMENT = 1,UNIFORME + , PRESSION, PONCTUELLE, PRESSDIR, PHYDRO + , LINEIQUE, VOLUMIQUE, LINEIC_SUIVEUSE,P_HYDRODYNA,TORSEUR_PONCT}; +/// @} // end of group + + + +// Retourne un nom du chargement a partir de son identificateur de +// type enumere id_chargement correspondant +string Nom_chargement (const Enum_chargement id_chargement) ; + +// Retourne l'identificateur de type enumere associe au nom du type +// de chargement nom_chargement +Enum_chargement Id_nom_chargement (const string& nom_chargement); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_chargement& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_chargement& a); + + +#endif + + diff --git a/Enumeration/Enum_comp.cc b/Enumeration/Enum_comp.cc new file mode 100644 index 0000000..5905c5d --- /dev/null +++ b/Enumeration/Enum_comp.cc @@ -0,0 +1,395 @@ +// FICHIER : Enum_comp.cp + + +// 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-2021 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: . + + +#include "Enum_comp.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + +// ----- 1) concernant Enum_comp ------ + +string Nom_comp (const Enum_comp id_comport) +// Retourne le nom de la loi de comportement correspondant a l'identificateur +// de type enumere id_comport +{ + + string result; + switch (id_comport) + { + case ISOELAS : result="ISOELAS"; break; + case ISOELAS1D : result="ISOELAS1D"; break; + case ISOELAS2D_D : result="ISOELAS2D_D"; break; + case ISOELAS2D_C : result="ISOELAS2D_C"; break; + case ISO_ELAS_ESPO1D : result="ISO_ELAS_ESPO1D"; break; + case ISO_ELAS_SE1D : result="ISO_ELAS_SE1D"; break; + case ISO_ELAS_ESPO3D : result="ISO_ELAS_ESPO3D"; break; + case ORTHOELA3D : result="ORTHOELA3D"; break; + case ORTHOELA2D_D : result="ORTHOELA2D_D"; break; + case ORTHOELA2D_C : result="ORTHOELA2D_C"; break; + case HYPO_ORTHO3D : result="HYPO_ORTHO3D"; break; + case HYPO_ORTHO2D_D : result="HYPO_ORTHO2D_D"; break; + case HYPO_ORTHO2D_C : result="HYPO_ORTHO2D_C"; break; + case PROJECTION_ANISOTROPE_3D : result="PROJECTION_ANISOTROPE_3D"; break; + case VISCOELA : result="VISCOELA"; break; + case ISOHYPER : result="ISOHYPER"; break; + case ISOHYPER1 : result="ISOHYPER1"; break; + case ISOHYPER10 : result="ISOHYPER10"; break; + case ISOHYSTE : result="ISOHYSTE";break; + case TRELOAR : result="TRELOAR"; break; + case ISOHYPER3DFAVIER1 : result="ISOHYPER3DFAVIER1"; break; + case ISOHYPER3DFAVIER2 : result="ISOHYPER3DFAVIER2"; break; + case ISOHYPER3DFAVIER3 : result="ISOHYPER3DFAVIER3"; break; + case ISOHYPER3DFAVIER4 : result="ISOHYPER3DFAVIER4"; break; + case ISOHYPER3DORGEAS1 : result="ISOHYPER3DORGEAS1"; break; + case ISOHYPER3DORGEAS2 : result="ISOHYPER3DORGEAS2"; break; + case ISOHYPERBULK3 : result="ISOHYPERBULK3"; break; + case ISOHYPERBULK_GENE : result="ISOHYPERBULK_GENE"; break; + case PRANDTL_REUSS : result="PRANDTL_REUSS"; break; + case PRANDTL_REUSS2D_D : result="PRANDTL_REUSS2D_D"; break; + case PRANDTL_REUSS2D_C : result="PRANDTL_REUSS2D_C"; break; + case PRANDTL_REUSS1D : result="PRANDTL_REUSS1D"; break; + case NEWTON1D : result="NEWTON1D"; break; + case NEWTON2D_C : result="NEWTON2D_C"; break; + case NEWTON2D_D : result="NEWTON2D_D"; break; + case NEWTON3D : result="NEWTON3D"; break; + case MAXWELL1D : result="MAXWELL1D"; break; + case MAXWELL2D_C : result="MAXWELL2D_C"; break; + case MAXWELL2D_D : result="MAXWELL2D_D"; break; + case MAXWELL3D : result="MAXWELL3D"; break; + case LOI_ADDITIVE_EN_SIGMA : result="LOI_ADDITIVE_EN_SIGMA"; break; + case LOI_CRITERE : result="LOI_CRITERE"; break; + case LOI_DES_MELANGES_EN_SIGMA : result="LOI_DES_MELANGES_EN_SIGMA"; break; + case LOI_CONTRAINTES_PLANES : result="LOI_CONTRAINTES_PLANES"; break; + case LOI_CONTRAINTES_PLANES_DOUBLE : result="LOI_CONTRAINTES_PLANES_DOUBLE"; break; + case LOI_DEFORMATIONS_PLANES : result="LOI_DEFORMATIONS_PLANES"; break; + case HYSTERESIS_1D : result="HYSTERESIS_1D"; break; + case HYSTERESIS_3D : result="HYSTERESIS_3D"; break; + case HYSTERESIS_BULK : result="HYSTERESIS_BULK"; break; + case LOI_ISO_THERMO : result="LOI_ISO_THERMO"; break; + case MOONEY_RIVLIN_1D : result="MOONEY_RIVLIN_1D"; break; + case MOONEY_RIVLIN_3D : result="MOONEY_RIVLIN_3D"; break; + case POLY_HYPER3D : result="POLY_HYPER3D"; break; + case HART_SMITH3D : result="HART_SMITH3D"; break; + case MAHEO_HYPER : result="MAHEO_HYPER"; break; + case HYPER_EXTERNE_W : result="HYPER_EXTERNE_W"; break; + case HYPO_ELAS3D : result="HYPO_ELAS3D"; break; + case HYPO_ELAS2D_C : result="HYPO_ELAS2D_C"; break; + case HYPO_ELAS2D_D : result="HYPO_ELAS2D_D"; break; + case HYPO_ELAS1D : result="HYPO_ELAS1D"; break; + case LOI_DE_TAIT : result="LOI_DE_TAIT"; break; + case LOI_VIA_UMAT :result="LOI_VIA_UMAT"; break; + case LOI_VIA_UMAT_CP :result="LOI_VIA_UMAT_CP"; break; + case LOI_COULOMB :result="LOI_COULOMB"; break; + case LOI_RIEN1D :result="LOI_RIEN1D"; break; + case LOI_RIEN2D_D :result="LOI_RIEN2D_D"; break; + case LOI_RIEN2D_C :result="LOI_RIEN2D_C"; break; + case LOI_RIEN3D :result="LOI_RIEN3D"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_comp !: " << id_comport << " \n"; + cout << "NOM_COMP(Enum_comp ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_comp Id_nom_comp (const string& nom_comport) +// Retourne la variable de type enumere associee au nom de la loi +// de comportement nom_comport +{ + + Enum_comp result; + if ( nom_comport == "ISOELAS" ) result=ISOELAS; + else if ( nom_comport == "ISOELAS1D" ) result=ISOELAS1D; + else if ( nom_comport == "ISOELAS2D_D" ) result=ISOELAS2D_D; + else if ( nom_comport == "ISOELAS2D_C" ) result=ISOELAS2D_C; + else if ( nom_comport == "ISO_ELAS_ESPO1D" ) result=ISO_ELAS_ESPO1D; + else if ( nom_comport == "ISO_ELAS_SE1D" ) result=ISO_ELAS_SE1D; + else if ( nom_comport == "ISO_ELAS_ESPO3D" ) result=ISO_ELAS_ESPO3D; + else if ( nom_comport == "ORTHOELA3D" ) result=ORTHOELA3D; + else if ( nom_comport == "ORTHOELA2D_D" ) result=ORTHOELA2D_D; + else if ( nom_comport == "ORTHOELA2D_C" ) result=ORTHOELA2D_C; + else if ( nom_comport == "HYPO_ORTHO3D" ) result=HYPO_ORTHO3D; + else if ( nom_comport == "HYPO_ORTHO2D_D" ) result=HYPO_ORTHO2D_D; + else if ( nom_comport == "HYPO_ORTHO2D_C" ) result=HYPO_ORTHO2D_C; + else if ( nom_comport == "PROJECTION_ANISOTROPE_3D" ) result=PROJECTION_ANISOTROPE_3D; + else if ( nom_comport == "VISCOELA" ) result=VISCOELA; + else if ( nom_comport == "ISOHYPER" ) result=ISOHYPER; + else if ( nom_comport == "ISOHYPER1" ) result=ISOHYPER1; + else if ( nom_comport == "ISOHYPER10" ) result=ISOHYPER10; + else if ( nom_comport == "ISOHYSTE" ) result=ISOHYSTE; + else if ( nom_comport == "TRELOAR" ) result=TRELOAR; + else if ( nom_comport == "ISOHYPER3DFAVIER1" ) result=ISOHYPER3DFAVIER1; + else if ( nom_comport == "ISOHYPER3DFAVIER2" ) result=ISOHYPER3DFAVIER2; + else if ( nom_comport == "ISOHYPER3DFAVIER3" ) result=ISOHYPER3DFAVIER3; + else if ( nom_comport == "ISOHYPER3DFAVIER4" ) result=ISOHYPER3DFAVIER4; + else if ( nom_comport == "ISOHYPER3DORGEAS1" ) result=ISOHYPER3DORGEAS1; + else if ( nom_comport == "ISOHYPER3DORGEAS2" ) result=ISOHYPER3DORGEAS2; + else if ( nom_comport == "ISOHYPERBULK3" ) result=ISOHYPERBULK3; + else if ( nom_comport == "ISOHYPERBULK_GENE" ) result=ISOHYPERBULK_GENE; + else if ( nom_comport == "PRANDTL_REUSS" ) result=PRANDTL_REUSS; + else if ( nom_comport == "PRANDTL_REUSS2D_D" ) result=PRANDTL_REUSS2D_D; + else if ( nom_comport == "PRANDTL_REUSS2D_C" ) result=PRANDTL_REUSS2D_C; + else if ( nom_comport == "PRANDTL_REUSS1D" ) result=PRANDTL_REUSS1D; + else if ( nom_comport == "NEWTON1D" ) result=NEWTON1D; + else if ( nom_comport == "NEWTON2D_C" ) result=NEWTON2D_C; + else if ( nom_comport == "NEWTON2D_D" ) result=NEWTON2D_D; + else if ( nom_comport == "NEWTON3D" ) result=NEWTON3D; + else if ( nom_comport == "MAXWELL1D" ) result=MAXWELL1D; + else if ( nom_comport == "MAXWELL2D_C" ) result=MAXWELL2D_C; + else if ( nom_comport == "MAXWELL2D_D" ) result=MAXWELL2D_D; + else if ( nom_comport == "MAXWELL3D" ) result=MAXWELL3D; + else if ( nom_comport == "LOI_ADDITIVE_EN_SIGMA" ) result=LOI_ADDITIVE_EN_SIGMA; + else if ( nom_comport == "LOI_CRITERE" ) result=LOI_CRITERE; + else if ( nom_comport == "LOI_DES_MELANGES_EN_SIGMA" ) result=LOI_DES_MELANGES_EN_SIGMA; + else if ( nom_comport == "LOI_CONTRAINTES_PLANES" ) result=LOI_CONTRAINTES_PLANES; + else if ( nom_comport == "LOI_CONTRAINTES_PLANES_DOUBLE" ) result=LOI_CONTRAINTES_PLANES_DOUBLE; + else if ( nom_comport == "LOI_DEFORMATIONS_PLANES" ) result=LOI_DEFORMATIONS_PLANES; + else if ( nom_comport == "HYSTERESIS_1D" ) result=HYSTERESIS_1D; + else if ( nom_comport == "HYSTERESIS_3D" ) result=HYSTERESIS_3D; + else if ( nom_comport == "HYSTERESIS_BULK" ) result=HYSTERESIS_BULK; + else if ( nom_comport == "LOI_ISO_THERMO" ) result=LOI_ISO_THERMO; + else if ( nom_comport == "LOI_DE_TAIT" ) result=LOI_DE_TAIT; + else if ( nom_comport == "MOONEY_RIVLIN_1D" ) result=MOONEY_RIVLIN_1D; + else if ( nom_comport == "MOONEY_RIVLIN_3D" ) result=MOONEY_RIVLIN_3D; + else if ( nom_comport == "POLY_HYPER3D" ) result=POLY_HYPER3D; + else if ( nom_comport == "HART_SMITH3D" ) result=HART_SMITH3D; + else if ( nom_comport == "MAHEO_HYPER" ) result=MAHEO_HYPER; + else if ( nom_comport == "HYPER_EXTERNE_W" ) result=HYPER_EXTERNE_W; + else if ( nom_comport == "HYPO_ELAS3D" ) result=HYPO_ELAS3D; + else if ( nom_comport == "HYPO_ELAS2D_C" ) result=HYPO_ELAS2D_C; + else if ( nom_comport == "HYPO_ELAS2D_D" ) result=HYPO_ELAS2D_D; + else if ( nom_comport == "HYPO_ELAS1D" ) result=HYPO_ELAS1D; + else if ( nom_comport == "LOI_VIA_UMAT" ) result=LOI_VIA_UMAT; + else if ( nom_comport == "LOI_VIA_UMAT_CP" ) result=LOI_VIA_UMAT_CP; + else if ( nom_comport == "LOI_COULOMB" ) result=LOI_COULOMB; + else if ( nom_comport == "LOI_RIEN1D" ) result=LOI_RIEN1D; + else if ( nom_comport == "LOI_RIEN2D_D" ) result=LOI_RIEN2D_D; + else if ( nom_comport == "LOI_RIEN2D_C" ) result=LOI_RIEN2D_C; + else if ( nom_comport == "LOI_RIEN3D" ) result=LOI_RIEN3D; + else if ( nom_comport == "RIEN_COMP" ) result=RIEN_COMP; + else + { + cout << "\nErreur : nom de loi de comportement inconnu !: " << nom_comport << " \n"; + cout << "ID_NOM_COMP(string ) \n"; + Sortie(1); + }; + return result; + +}; + +// indique si la loi est inactive mécaniquement +// typiquement de type : LOI_RIEN... ou RIEN_COMP +bool Loi_rien(const Enum_comp id_comport) +{ + bool retour = false; + switch (id_comport) + { + case LOI_DE_TAIT : case LOI_RIEN1D : case LOI_RIEN2D_D : + case LOI_RIEN2D_C : case LOI_RIEN3D : case RIEN_COMP: + retour = true ; + break; + default : + retour = false; + }; + return retour; +}; + + + // surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_comp& a) + { char nom_Enum_comp[50]; + entree >> nom_Enum_comp; + a = Id_nom_comp ( nom_Enum_comp); + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_comp& a) + { // on ecrit la forme caractère + sort << Nom_comp(a) << " "; + return sort; + }; + + +// ----- 2) concernant Enum_comp_3D_CP_DP_1D ----- + +// Retourne le nom a partir de son identificateur du type enumere id_Enum_comp_3D_CP_DP_1D correspondant +string Nom_comp_3D_CP_DP_1D (const Enum_comp_3D_CP_DP_1D id_Enum_comp_3D_CP_DP_1D) +{ + string result; + switch (id_Enum_comp_3D_CP_DP_1D) + { + case COMP_1D : result="COMP_1D"; break; + case COMP_CONTRAINTES_PLANES : result="COMP_CONTRAINTES_PLANES"; break; + case COMP_DEFORMATIONS_PLANES : result="COMP_DEFORMATIONS_PLANES"; break; + case COMP_3D : result="COMP_3D"; break; + case RIEN_COMP_3D_CP_DP_1D : result="RIEN_COMP_3D_CP_DP_1D"; break; + + default : + cout << "\nErreur : valeur incorrecte du type Enum_comp_3D_CP_DP_1D !: " << id_Enum_comp_3D_CP_DP_1D << " \n"; + cout << "Nom_comp_3D_CP_DP_1D(Enum_comp_3D_CP_DP_1D ) \n"; + Sortie(1); + }; + return result; + +}; + +// Retourne l'identificateur de type enumere associe à un nom nom_comp_3D_CP_DP_1D +Enum_comp_3D_CP_DP_1D Id_nom_comp_3D_CP_DP_1D (const string nom_comp_3D_CP_DP_1D) +{ Enum_comp_3D_CP_DP_1D result; + if ( nom_comp_3D_CP_DP_1D == "COMP_1D" ) result= COMP_1D; + else if ( nom_comp_3D_CP_DP_1D == "COMP_CONTRAINTES_PLANES" ) result= COMP_CONTRAINTES_PLANES; + else if ( nom_comp_3D_CP_DP_1D == "COMP_DEFORMATIONS_PLANES" ) result= COMP_DEFORMATIONS_PLANES; + else if ( nom_comp_3D_CP_DP_1D == "COMP_3D" ) result= COMP_3D; + else if ( nom_comp_3D_CP_DP_1D == "RIEN_COMP_3D_CP_DP_1D" ) result= RIEN_COMP_3D_CP_DP_1D; + + else + { + cout << "\nErreur : nom de l'enumere Enum_comp_3D_CP_DP_1D inconnu !: " << nom_comp_3D_CP_DP_1D << " \n"; + cout << "Id_nom_comp_3D_CP_DP_1D(string ) \n"; + Sortie(1); + }; + return result; + +}; + +// indique le type Enum_comp_3D_CP_DP_1D correspondant à une loi de comportement +Enum_comp_3D_CP_DP_1D Comp_3D_CP_DP_1D(const Enum_comp id_comport) +{ Enum_comp_3D_CP_DP_1D result; + switch (id_comport) + { + case ISOELAS : result= COMP_3D; break; + case ISOELAS1D : result= COMP_1D; break; + case ISOELAS2D_D : result= COMP_DEFORMATIONS_PLANES; break; + case ISOELAS2D_C : result= COMP_CONTRAINTES_PLANES; break; + case ISO_ELAS_ESPO1D : result= COMP_1D; break; + case ISO_ELAS_SE1D : result= COMP_1D; break; + case ISO_ELAS_ESPO3D : result= COMP_3D; break; + case ORTHOELA3D : result= COMP_3D; break; + case ORTHOELA2D_D : result= COMP_DEFORMATIONS_PLANES; break; + case ORTHOELA2D_C : result= COMP_CONTRAINTES_PLANES; break; + case HYPO_ORTHO3D : result= COMP_3D; break; + case HYPO_ORTHO2D_D : result= COMP_DEFORMATIONS_PLANES; break; + case HYPO_ORTHO2D_C : result= COMP_CONTRAINTES_PLANES; break; + case PROJECTION_ANISOTROPE_3D : result= COMP_3D; break; + case VISCOELA : result= COMP_3D; break; + case ISOHYPER : result= COMP_3D; break; + case ISOHYPER1 : result= COMP_3D; break; + case ISOHYPER10 : result= COMP_3D; break; + case ISOHYSTE : result= COMP_3D; break; + case TRELOAR : result= COMP_3D; break; + case ISOHYPER3DFAVIER1 : result= COMP_3D; break; + case ISOHYPER3DFAVIER2 : result= COMP_3D; break; + case ISOHYPER3DFAVIER3 : result= COMP_3D; break; + case ISOHYPER3DFAVIER4 : result= COMP_3D; break; + case ISOHYPER3DORGEAS1 : result= COMP_3D; break; + case ISOHYPER3DORGEAS2 : result= COMP_3D; break; + case ISOHYPERBULK3 : result= COMP_3D; break; + case ISOHYPERBULK_GENE : result= COMP_3D; break; + case PRANDTL_REUSS : result= COMP_3D; break; + case PRANDTL_REUSS2D_D : result= COMP_DEFORMATIONS_PLANES; break; + case PRANDTL_REUSS2D_C : result= COMP_CONTRAINTES_PLANES; break; + case PRANDTL_REUSS1D : result= COMP_1D; break; + case NEWTON1D : result= COMP_1D; break; + case NEWTON2D_C : result= COMP_CONTRAINTES_PLANES; break; + case NEWTON2D_D : result= COMP_DEFORMATIONS_PLANES; break; + case NEWTON3D : result= COMP_3D; break; + case MAXWELL1D : result= COMP_1D; break; + case MAXWELL2D_C : result= COMP_CONTRAINTES_PLANES; break; + case MAXWELL2D_D : result= COMP_DEFORMATIONS_PLANES; break; + case MAXWELL3D : result= COMP_3D; break; + case LOI_ADDITIVE_EN_SIGMA : result= RIEN_COMP_3D_CP_DP_1D; break; + case LOI_CRITERE : result= RIEN_COMP_3D_CP_DP_1D; break; + case LOI_DES_MELANGES_EN_SIGMA : result= RIEN_COMP_3D_CP_DP_1D; break; + case LOI_CONTRAINTES_PLANES : result= COMP_CONTRAINTES_PLANES; break; + case LOI_CONTRAINTES_PLANES_DOUBLE : result= COMP_1D; break; + case LOI_DEFORMATIONS_PLANES : result= COMP_DEFORMATIONS_PLANES; break; + case HYSTERESIS_1D : result= COMP_1D; break; + case HYSTERESIS_3D : result= COMP_3D; break; + case HYSTERESIS_BULK : result= COMP_3D; break; + case LOI_ISO_THERMO : result= RIEN_COMP_3D_CP_DP_1D; break; + case LOI_DE_TAIT : result= RIEN_COMP_3D_CP_DP_1D; break; + case MOONEY_RIVLIN_1D : result= COMP_1D; break; + case MOONEY_RIVLIN_3D : result= COMP_3D; break; + case POLY_HYPER3D : result= COMP_3D; break; + case HART_SMITH3D : result= COMP_3D; break; + case MAHEO_HYPER : result= COMP_3D; break; + case HYPER_EXTERNE_W : result= COMP_3D; break; + case HYPO_ELAS3D : result= COMP_3D; break; + case HYPO_ELAS2D_C : result= COMP_CONTRAINTES_PLANES; break; + case HYPO_ELAS2D_D : result= COMP_DEFORMATIONS_PLANES; break; + case HYPO_ELAS1D : result= COMP_1D; break; + case LOI_VIA_UMAT : result= COMP_3D; break; + case LOI_VIA_UMAT_CP : result= COMP_CONTRAINTES_PLANES; break; + case LOI_COULOMB : result= RIEN_COMP_3D_CP_DP_1D; break; + case LOI_RIEN1D : result= COMP_1D; break; + case LOI_RIEN2D_D : result= COMP_DEFORMATIONS_PLANES; break; + case LOI_RIEN2D_C : result= COMP_CONTRAINTES_PLANES; break; + case LOI_RIEN3D : result= COMP_3D; break; + case RIEN_COMP : result= RIEN_COMP_3D_CP_DP_1D; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_comp !: " << id_comport << " \n"; + cout << "Comp_3D_CP_DP_1D(Enum_comp ) \n"; + Sortie(1); + }; + return result; +}; + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_comp_3D_CP_DP_1D& a) + { char nom_Enum_comp_3D_CP_DP_1D[50]; + entree >> nom_Enum_comp_3D_CP_DP_1D; + a = Id_nom_comp_3D_CP_DP_1D( nom_Enum_comp_3D_CP_DP_1D); + return entree; + }; + +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_comp_3D_CP_DP_1D& a) + { // on ecrit la forme caractère + sort << Nom_comp_3D_CP_DP_1D(a) << " "; + return sort; + }; + + diff --git a/Enumeration/Enum_comp.h b/Enumeration/Enum_comp.h new file mode 100644 index 0000000..4bc8cff --- /dev/null +++ b/Enumeration/Enum_comp.h @@ -0,0 +1,125 @@ +/*! \file Enum_comp.h + \brief def de l'enuméré permettant d'identifier chaque loi de comportement +*/ +// FICHIER : Enum_comp.h + +// 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-2021 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: . + + +// Afin de realiser un gain en place memoire, les noms des lois de comportement sont +// stockes a l'aide d'un type enumere. Les fonctions Nom_comp et Id_nom_comp rendent +// possible le lien entre les noms des lois de comportement et les identificateurs +// de type enumere correspondants. + + +#ifndef ENUM_COMP_H +#define ENUM_COMP_H +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + + +/// énuméré permettant d'identifier chaque loi de comportement +enum Enum_comp { ISOELAS=1,ISOELAS1D, ISOELAS2D_D,ISOELAS2D_C,ISO_ELAS_ESPO1D + ,ISO_ELAS_SE1D,ISO_ELAS_ESPO3D + ,ORTHOELA3D,ORTHOELA2D_D,ORTHOELA2D_C + ,HYPO_ORTHO3D,HYPO_ORTHO2D_D,HYPO_ORTHO2D_C + ,PROJECTION_ANISOTROPE_3D + ,VISCOELA,ISOHYPER,ISOHYPER1,ISOHYPER10, ISOHYSTE + ,TRELOAR, ISOHYPER3DFAVIER1,ISOHYPER3DFAVIER2,ISOHYPER3DFAVIER3 + ,ISOHYPER3DFAVIER4,ISOHYPER3DORGEAS1,ISOHYPER3DORGEAS2 + ,ISOHYPERBULK3,ISOHYPERBULK_GENE + ,PRANDTL_REUSS,PRANDTL_REUSS2D_D,PRANDTL_REUSS2D_C + ,PRANDTL_REUSS1D + ,NEWTON1D,NEWTON2D_C,NEWTON2D_D,NEWTON3D + ,HYPO_ELAS3D,HYPO_ELAS2D_C,HYPO_ELAS2D_D,HYPO_ELAS1D + ,MAXWELL1D,MAXWELL2D_C,MAXWELL2D_D,MAXWELL3D + ,LOI_ADDITIVE_EN_SIGMA,LOI_DES_MELANGES_EN_SIGMA,LOI_CRITERE + ,LOI_CONTRAINTES_PLANES,LOI_CONTRAINTES_PLANES_DOUBLE,LOI_DEFORMATIONS_PLANES + ,HYSTERESIS_1D,HYSTERESIS_3D,HYSTERESIS_BULK,LOI_ISO_THERMO + ,MOONEY_RIVLIN_1D,MOONEY_RIVLIN_3D,POLY_HYPER3D,HART_SMITH3D,MAHEO_HYPER + ,HYPER_EXTERNE_W + ,LOI_DE_TAIT,LOI_VIA_UMAT,LOI_VIA_UMAT_CP + ,LOI_COULOMB + ,LOI_RIEN1D,LOI_RIEN2D_D,LOI_RIEN2D_C,LOI_RIEN3D + ,RIEN_COMP}; +/// @} // end of group + + +/// @addtogroup Group_types_enumeres +/// @{ + +/// énuméré permettant de savoir si une loi est : 1D, 2D en deformations planes ou contraintes planes, 3D générale +enum Enum_comp_3D_CP_DP_1D { COMP_1D =1, COMP_CONTRAINTES_PLANES, COMP_DEFORMATIONS_PLANES, COMP_3D , RIEN_COMP_3D_CP_DP_1D}; +/// @} // end of group + + +// ***** !!!! penser à changer ***** +//****** nbmax_caractere_Enum_comp si nécessaire ***** +const int nbmax_caractere_Enum_comp = 26; + +// ----- 1) concernant Enum_comp ------ + +// Retourne le nom d'une loi de comportement a partir de son identificateur de +// type enumere id_comport correspondant +string Nom_comp(const Enum_comp id_comport); + +// Retourne l'identificateur de type enumere associe au nom de la loi de +// comportement nom_comport +Enum_comp Id_nom_comp(const string& nom_comport); + +// indique si la loi est inactive mécaniquement +// typiquement de type : LOI_RIEN... ou RIEN_COMP +bool Loi_rien(const Enum_comp id_comport); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_comp& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_comp& a); + +// ----- 2) concernant Enum_comp_3D_CP_DP_1D ----- + +// Retourne le nom a partir de son identificateur du type enumere id_Enum_comp_3D_CP_DP_1D correspondant +string Nom_comp_3D_CP_DP_1D(const Enum_comp_3D_CP_DP_1D id_Enum_comp_3D_CP_DP_1D); + +// Retourne l'identificateur de type enumere associe à un nom nom_comp_3D_CP_DP_1D +Enum_comp_3D_CP_DP_1D Id_nom_comp_3D_CP_DP_1D(const string nom_comp_3D_CP_DP_1D); + +// indique le type Enum_comp_3D_CP_DP_1D correspondant à une loi de comportement +Enum_comp_3D_CP_DP_1D Comp_3D_CP_DP_1D(const Enum_comp id_comport); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_comp_3D_CP_DP_1D& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_comp_3D_CP_DP_1D& a); + + +#endif diff --git a/Enumeration/Enum_contrainte_mathematique.cc b/Enumeration/Enum_contrainte_mathematique.cc new file mode 100755 index 0000000..9140e3c --- /dev/null +++ b/Enumeration/Enum_contrainte_mathematique.cc @@ -0,0 +1,110 @@ +// FICHIER : Enum_contrainte_mathematique.cc + + +// 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-2021 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: . + + +#include "Enum_contrainte_mathematique.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +string Nom_contrainte_mathematique (const Enum_contrainte_mathematique id_contrainte_mathematique) +// Retourne le nom de la méthode attachée a l'identificateur +// de type enumere id_contrainte_mathematique +{ + + string result; + switch (id_contrainte_mathematique) + { + case MULTIPLICATEUR_DE_LAGRANGE : result="MULTIPLICATEUR_DE_LAGRANGE"; break; + case PENALISATION : result="PENALISATION"; break; + case NEWTON_LOCAL : result="NEWTON_LOCAL"; break; + case PERTURBATION : result="PERTURBATION"; break; + case RIEN_CONTRAINTE_MATHEMATIQUE : result="RIEN_CONTRAINTE_MATHEMATIQUE"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_contrainte_mathematique !: " << id_contrainte_mathematique << " \n"; + cout << "NOM_contrainte_mathematique(Enum_contrainte_mathematique ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_contrainte_mathematique Id_nom_contrainte_mathematique (const string& nom_contrainte_mathematique) +// Retourne la variable de type enumere associee à nom_contrainte_mathematique +{ + + Enum_contrainte_mathematique result; + if ( nom_contrainte_mathematique == "MULTIPLICATEUR_DE_LAGRANGE" ) result=MULTIPLICATEUR_DE_LAGRANGE; + else if ( nom_contrainte_mathematique == "PENALISATION" ) result=PENALISATION; + else if ( nom_contrainte_mathematique == "NEWTON_LOCAL" ) result=NEWTON_LOCAL; + else if ( nom_contrainte_mathematique == "PERTURBATION" ) result=PERTURBATION; + else if ( nom_contrainte_mathematique == "RIEN_CONTRAINTE_MATHEMATIQUE" ) result=RIEN_CONTRAINTE_MATHEMATIQUE; + else + { + cout << "\nErreur : nom de la methode pour imposer la contrainte mathematique inconnue !: " << nom_contrainte_mathematique << " \n"; + cout << "ID_NOM_contrainte_mathematique(string ) \n"; + Sortie(1); + }; + return result; + +}; + + + // surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_contrainte_mathematique& a) + { char nom_Enum_contrainte_mathematique[50]; + entree >> nom_Enum_contrainte_mathematique; + a = Id_nom_contrainte_mathematique ( nom_Enum_contrainte_mathematique); + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_contrainte_mathematique& a) + { // on ecrit la forme caractère + sort << Nom_contrainte_mathematique(a) << " "; + return sort; + }; + + diff --git a/Enumeration/Enum_contrainte_mathematique.h b/Enumeration/Enum_contrainte_mathematique.h new file mode 100755 index 0000000..070b249 --- /dev/null +++ b/Enumeration/Enum_contrainte_mathematique.h @@ -0,0 +1,74 @@ +/*! \file Enum_contrainte_mathematique.h + \brief def de l'enuméré concernant les types de contraintes mathématiques +*/ +// FICHIER : Enum_contrainte_mathematique.h + +// 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-2021 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: . + + +// Afin de realiser un gain en place memoire, les noms des methodes permettant de mettre en place une contrainte +// mathematique sont +// stockes a l'aide d'un type enumere. Les fonctions Nom_contrainte_mathematique et Id_nom_contrainte_mathematique rendent +// possible le lien entre les noms des methodes et les identificateurs +// de type enumere correspondants. + + +#ifndef ENUM_CONTRAINTE_MATHEMATIQUE_H +#define ENUM_CONTRAINTE_MATHEMATIQUE_H +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré concernant les types de contraintes mathématiques + +enum Enum_contrainte_mathematique { MULTIPLICATEUR_DE_LAGRANGE=1,PENALISATION, NEWTON_LOCAL,PERTURBATION,RIEN_CONTRAINTE_MATHEMATIQUE}; +/// @} // end of group + + +// ***** !!!! penser à changer ***** +//****** nbmax_caractere_Enum_contrainte_mathematique si nécessaire ***** +const int nbmax_caractere_Enum_contrainte_mathematique = 50; + +// Retourne le nom d'une méthode a partir de son identificateur de +// type enumere id_contrainte_mathematique correspondant +string Nom_contrainte_mathematique (const Enum_contrainte_mathematique id_contrainte_mathematique); + +// Retourne l'identificateur de type enumere associe au nom de la méthode +// nom_contrainte_mathematique +Enum_contrainte_mathematique Id_nom_contrainte_mathematique (const string& nom_contrainte_mathematique); + + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_contrainte_mathematique& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_contrainte_mathematique& a); + +#endif diff --git a/Enumeration/Enum_crista.cc b/Enumeration/Enum_crista.cc new file mode 100644 index 0000000..a751133 --- /dev/null +++ b/Enumeration/Enum_crista.cc @@ -0,0 +1,115 @@ +// FICHIER : Enum_crista.cc + + +// 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-2021 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: . + + +#include "Enum_crista.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +char* Nom_Enum_crista (Enum_crista id_Enum_crista) +// Retourne le nom du type de Enum_crista correspondant a l'identificateur +// de type enumere id_Enum_crista +{ + + char* result; + switch (id_Enum_crista) + { + case HOFFMAN : + result="HOFFMAN"; + break; + case HOFFMAN2 : + result="HOFFMAN2"; + break; + case CRISTA_PAS_DEFINI : + result="CRISTA_PAS_DEFINI"; + break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_crista !\n"; + cout << "Nom_Enum_crista(Enum_crista ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_crista Id_nom_Enum_crista (const char* nom_Enum_crista) +// Retourne la variable de type enumere associe au nom +// de Enum_crista nom_Enum_crista +{ + + Enum_crista result; + if ( strcmp(nom_Enum_crista,"HOFFMAN")==0 ) + result=HOFFMAN; + else if ( strcmp(nom_Enum_crista,"HOFFMAN2")==0 ) + result=HOFFMAN2; + else if ( strcmp(nom_Enum_crista,"CRISTA_PAS_DEFINI")==0 ) + result=CRISTA_PAS_DEFINI; + else + { + cout << "\nErreur : nom de Enum_crista inconnu !\n"; + cout << "Id_nom_Enum_crista(char* ) \n"; + Sortie(1); + }; + return result; + +}; + +// surcharge de la lecture +istream & operator >> (istream & entree, Enum_crista & result) + { char nom_Enum_crista[45]; + entree >> nom_Enum_crista; + result = Id_nom_Enum_crista ( nom_Enum_crista); + return entree; + }; + + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_crista& a) + { // on ecrit la forme caractère + sort << Nom_Enum_crista(a) << " "; + return sort; + }; + diff --git a/Enumeration/Enum_crista.h b/Enumeration/Enum_crista.h new file mode 100644 index 0000000..25d81bd --- /dev/null +++ b/Enumeration/Enum_crista.h @@ -0,0 +1,94 @@ +/*! \file Enum_crista.h + \brief def Enumération des différents calcul de cristalinité +* \date 04/03/2008 +*/ + +// FICHIER : Enum_crista.h + +// 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-2021 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: Enumération des différents calcul de cristalinité * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + +#ifndef ENUM_CRISTA_H +#define ENUM_CRISTA_H + +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Enumération des différents calcul de cristalinité + +enum Enum_crista { HOFFMAN = 1,HOFFMAN2, CRISTA_PAS_DEFINI }; +const int nombre_maxi_de_type_de_Enum_crista = 2; +/// @} // end of group + + + + +// Retourne un nom de type de Enum_crista a partir de son identificateur de +// type enumere id_Enum_crista correspondant +char* Nom_Enum_crista (Enum_crista id_Enum_crista); + +// Retourne l'identificateur de type enumere associe au nom du type +// de Enum_crista nom_Enum_crista +Enum_crista Id_nom_Enum_crista (const char* nom_Enum_crista) ; + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_crista& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_crista& a); + + +#endif + + diff --git a/Enumeration/Enum_ddl (copy: conflict on 2017-11-21).h b/Enumeration/Enum_ddl (copy: conflict on 2017-11-21).h new file mode 100644 index 0000000..25bc927 --- /dev/null +++ b/Enumeration/Enum_ddl (copy: conflict on 2017-11-21).h @@ -0,0 +1,199 @@ +// FICHIER : Enum_ddl.h + +// Afin de realiser un gain en place memoire, les noms des degres de liberte sont +// stockes a l'aide d'un type enumere. Les fonctions Nom_ddl et Id_nom_ddl rendent +// possible le lien entre les noms des degres de liberte et les identificateurs +// de type enumere correspondants. +// 10 carractere maxi +// NU_DDL correspond au cas ou pas de ddl est defini +// les ddl X1 X2 X3 doivent se suivrent +// les ddl UX, UY, UZ doivent se suivrent +// les ddl VX , VY , VZ, doivent se suivrent +// ne pas changer l'ordre des 3 premiers ddl dans l'enumeration!!!! car on se +// sert du fait que Enum_ddl(1) = X1 etc pour initialiser les ddl des noeud elements +// +// une famille de ddl: se sont des ddl scalaires qui représentent les composantes d'un ddl vectoriel +// ou tensoriel, ou scalaire s'il n'y a qu'une seule grandeur, qui ne dépend pas de la dimension (ex: pression +// ou température) +// une combinaison , c'est un groupe de ddl qui sont relié par le calcul: ex: position, vitesse et accélération +// en dynamique. + + +#ifndef ENUM_DDL_H +#define ENUM_DDL_H + +//#include "Debug.h" +# include "Tableau2_T.h" +#include +using namespace std; +#include "EnumTypeGrandeur.h" +#include "ParaGlob.h" + + +//=============================================================================== +// l'énumération de degré de liberté de base, celle qui sert pour les calculs +// nombre de ddl limité +//=============================================================================== +// ***** !!!! penser à changer la fonction "NbEnum_ddl" et ***** +//****** nbmax_caractere_enum_ddl si nécessaire ***** +// le type énuméré doit commencer à 1, c'est utilisé dans Ddl_enum_etendu par exemple !! +enum Enum_ddl { X1 = 1, X2 , X3, EPAIS , TEMP , UX, UY, UZ , V1 , V2 , V3, + PR, GAMMA1, GAMMA2, GAMMA3, + SIG11,SIG22,SIG33,SIG12,SIG23,SIG13,ERREUR, + EPS11,EPS22,EPS33,EPS12,EPS23,EPS13, + DEPS11,DEPS22,DEPS33,DEPS12,DEPS23,DEPS13, + PROP_CRISTA,DELTA_TEMP,FLUXD1,FLUXD2,FLUXD3,R_TEMP, + GRADT1,GRADT2,GRADT3,DGRADT1,DGRADT2,DGRADT3, + R_X1,R_X2,R_X3,R_EPAIS,R_V1,R_V2,R_V3,R_GAMMA1,R_GAMMA2,R_GAMMA3, + NU_DDL }; +// ***** !!!! penser à changer la fonction "NbEnum_ddl" et ***** +//****** nbmax_caractere_enum_ddl si nécessaire ***** +//****** Nombre_de_famille_de_ddl si nécessaire ***** + +class ClassPourEnum_ddl +{ public: +// friend Enum_ddl Id_nom_ddl (const char* nom); + friend Enum_ddl Id_nom_ddl (const string& nom); +// friend bool ExisteEnum_ddl(const char* nom); + friend bool ExisteEnum_ddl(const string& nom); + // def de la map qui fait la liaison entre les string et les énumérés + static map < string, Enum_ddl , std::less < string> > map_Enum_ddl; + // def de la grandeur statique qui permet de remplir la map + static ClassPourEnum_ddl remplir_map; + // le constructeur qui rempli effectivement la map + ClassPourEnum_ddl(); + // variable de travail + protected: + map < string, Enum_ddl , std::less < string> >::iterator il,ilfin; + }; + +//------------------------------------------------- +// def des fonctions de manipulation des Enum_ddl +//------------------------------------------------- + +// definition du maximum de caractères de la chaine équivalente à l'énumération +const int nbmax_caractere_enum_ddl = 11; +const int nombre_maxi_de_famille_de_ddl = 21; +const int nombre_maxi_de_type_de_ddl = 57; + +// Retourne le nom d'un degre de liberte a partir de son identificateur de +// type enumere id_ddl correspondant +string Nom_ddl (Enum_ddl id_ddl); + +// Retourne l'identificateur de type enumere associe au nom du degre de liberte +// nom_ddl +//Enum_ddl Id_nom_ddl (const char* nom_ddl); +Enum_ddl Id_nom_ddl (const string& nom_ddl); + +// retourne true si l'identificateur existe, false sinon +//bool ExisteEnum_ddl(const char* nom_ddl); +bool ExisteEnum_ddl(const string& nom_ddl); + +// retourne le nombre maxi de ddl existant +inline int NbEnum_ddl() {return nombre_maxi_de_type_de_ddl;}; + +// ramene true si le ddl fait parti d'une liste +// fonction de la dimension du pb: par exemple : X1 ou UY ou VZ +// dans le cas contraire , exemple: T ou EPAIS ramene false +bool FoncDim(const string& nom_ddl); +// idem mais avec l'énumération +bool FoncDim(Enum_ddl id_ddl); + +// ramene le tableau de tous les ddl correspondant au type du ddl passé en paramètre +// ceci en fonction de la dimension (par exemple pour un vecteur, ramène +// les dim ddl correspondant aux composantes +Tableau TableauTypeDdl(Enum_ddl id_ddl); + +// ramene le tableau des ddl mobile correspondant au type du ddl passé en paramètre +// ceci en fonction de la dimension (par exemple pour un vecteur, ramène +// les dim ddl correspondant aux composantes +// par rapport à TableauTypeDdl() la différence concerne le cas axi +// pour ce cas: X3=constant, U3=V3=Gamma3=0 ==> donc ne font pas partie du tableau retour +Tableau TableauTypeDdlmobileAvecAxi(Enum_ddl id_ddl); + + +// indique si le ddl est compatible avec la dimension +// c'est-à-dire qu'il peut exister avec la dimension actuelle : +// par exemple en 1D on ne peut pas avoir de UY, mais UX c'est ok +bool CompatDim(const string& nom_ddl); +bool CompatDim(const Enum_ddl id_ddl); + +// retour le type de grandeur auquel apartient l'énumération +// par exemple : UY : apartiend à un vecteur +// SIG12 : à un tenseur, TEMP : à un scalaire +EnumTypeGrandeur TypeGrandeur(Enum_ddl id_ddl); + +// test si les deux ddl sont de la même famille dimensionnelle, +// par exemple X1 et X3, ou SIG11 et SIG22 +// ramène true si oui, false sinon +bool Meme_famille(Enum_ddl a,Enum_ddl b); + +// ramène le premier ddl de la même famille +Enum_ddl PremierDdlFamille(Enum_ddl a); +// ramène un nom générique pour la famille de ddl du même type +string NomGeneric(Enum_ddl a); + +// ramène de nombre de famille différente qui existe +inline int Nombre_de_famille_de_ddl() {return nombre_maxi_de_famille_de_ddl;}; + +// test si le ddl appartient à la combinaison donné par cas +// cas : spécifie la combinaison : =1 -> combinaison X V GAMMA +// ramène false si cas=0 c'est-à-dire pas de combinaison +bool Dans_combinaison(int cas,Enum_ddl a); + +// ramène tous les membres d'une même combinaison de la même dimension +// y compris "a" +// cas : spécifie la combinaison : +// =0 -> pas de combinaison, ramène "a" +// =1 -> combinaison X V GAMMA +Tableau MemeCombinaison(int cas,Enum_ddl a); + +// ramène tous les membres d'une même combinaison, pour i=1 à dim +// cas = 1 -> combinaison X V GAMMA +// cas = 0 -> pas de combinaison, ramène un tableau de dimension 0 +Tableau Combinaison(int cas); + +// passage de Ui en Xi, c-a-d : UX -> X1, UY -> X2, UZ -> X3 +Enum_ddl UxyzXi(Enum_ddl a); +// passage inverse +Enum_ddl XiUxyz(Enum_ddl a); +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_ddl& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_ddl& a); + +// fonction donnant dans l'ordre des ddl de contraintes, les indices correspondant +// des tenseurs, ceci en fonction du nombre de composante de tenseur +// en retour un tableau : (i)(1) et (i)(2) -> les indices (en entier) du tenseur correspondant +// au i ième ddl de containte à partir de SIG11 +// mais en sautant les ddl qui ne font pas parti de la dimension !!!!! +Tableau2 OrdreContrainte(int nbcomposantes); +// idem en fonction du nombre de composantes +// fonction plus rapide qui pointe sur des tableaux déjà construits à partir d'OrdreContrainte +const Tableau2 & OrdreContrainteR(int nbcomposantes); +// donne directement le premier et le second indice en fonction de l'enum et du nbcomposante +// pour les tenseurs sigma ou pour le tenseur epsilon ou encore pour le tenseur Depsilon +class Deuxentiers {public: int i;int j;}; +Deuxentiers IJind(Enum_ddl a,int nbcomposantes); + +// definition de tableau constant pour éviter de les recalculer à chaque appel +const Tableau2 OrdreContrainte1 = OrdreContrainte(1); +const Tableau2 OrdreContrainte3 = OrdreContrainte(3); +const Tableau2 OrdreContrainte6 = OrdreContrainte(6); + +// passage de enum_ddl vers des réactions enum_ddl correspondantes +// exemple X1 -> R_X1 etc.. +Enum_ddl Vers_enum_reac(Enum_ddl a); +// opération inverse: exemple R_X1 -> X1 +Enum_ddl Enum_reac_vers_enum(Enum_ddl a); +// indique si un ddl est un ddl de réaction on non +bool Ddl_reaction(Enum_ddl a); + +// pour faire de l'inline +#ifndef MISE_AU_POINT + #include "Enum_ddl.cc" + #define Enum_ddl_deja_inclus +#endif + + +#endif diff --git a/Enumeration/Enum_ddl.cc b/Enumeration/Enum_ddl.cc new file mode 100644 index 0000000..ea0a55f --- /dev/null +++ b/Enumeration/Enum_ddl.cc @@ -0,0 +1,1397 @@ +// FICHIER Enum_ddl.cp + + +// 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-2021 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: . + + +#include "Enum_ddl.h" +# include "ParaGlob.h" + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + +#ifndef Enum_ddl_deja_inclus + +//-------------------------- def des grandeurs statiques --------------------- +// du au jeux d'inline, les grandeurs statiques sont définis dans un fichier à part +// Enum_ddl_var_static.cc +// +// il s'agit des variables: map_Enum_ddl, et remplir_map +//-------------------------- fin def des grandeurs statiques --------------------- + + // le constructeur qui rempli effectivement la map +#ifndef MISE_AU_POINT + inline +#endif + ClassPourEnum_ddl::ClassPourEnum_ddl() : + il(),ilfin() + { // remplissage de la map + map_Enum_ddl["X1"]=X1; + map_Enum_ddl["X2"]=X2; + map_Enum_ddl["X3"]=X3; + map_Enum_ddl["EPAIS"]=EPAIS; + map_Enum_ddl["TEMP"]=TEMP; + map_Enum_ddl["UX"]=UX; + map_Enum_ddl["UY"]=UY; + map_Enum_ddl["UZ"]=UZ; + map_Enum_ddl["V1"]=V1; + map_Enum_ddl["V2"]=V2; + map_Enum_ddl["V3"]=V3; + map_Enum_ddl["PR"]=PR; + map_Enum_ddl["GAMMA1"]=GAMMA1; + map_Enum_ddl["GAMMA2"]=GAMMA2; + map_Enum_ddl["GAMMA3"]=GAMMA3; + map_Enum_ddl["SIG11"]=SIG11; + map_Enum_ddl["SIG22"]=SIG22; + map_Enum_ddl["SIG33"]=SIG33; + map_Enum_ddl["SIG12"]=SIG12; + map_Enum_ddl["SIG23"]=SIG23; + map_Enum_ddl["SIG13"]=SIG13; + map_Enum_ddl["ERREUR"]=ERREUR; + map_Enum_ddl["EPS11"]=EPS11; + map_Enum_ddl["EPS22"]=EPS22; + map_Enum_ddl["EPS33"]=EPS33; + map_Enum_ddl["EPS12"]=EPS12; + map_Enum_ddl["EPS23"]=EPS23; + map_Enum_ddl["EPS13"]=EPS13; + map_Enum_ddl["DEPS11"]=DEPS11; + map_Enum_ddl["DEPS22"]=DEPS22; + map_Enum_ddl["DEPS33"]=DEPS33; + map_Enum_ddl["DEPS12"]=DEPS12; + map_Enum_ddl["DEPS23"]=DEPS23; + map_Enum_ddl["DEPS13"]=DEPS13; + map_Enum_ddl["PROP_CRISTA"]=PROP_CRISTA; + map_Enum_ddl["DELTA_TEMP"]=DELTA_TEMP; + map_Enum_ddl["FLUXD1"]=FLUXD1; + map_Enum_ddl["FLUXD2"]=FLUXD2; + map_Enum_ddl["FLUXD3"]=FLUXD3; + map_Enum_ddl["R_TEMP"]=R_TEMP; + map_Enum_ddl["GRADT1"]=GRADT1; + map_Enum_ddl["GRADT2"]=GRADT2; + map_Enum_ddl["GRADT3"]=GRADT3; + map_Enum_ddl["DGRADT1"]=DGRADT1; + map_Enum_ddl["DGRADT2"]=DGRADT2; + map_Enum_ddl["DGRADT3"]=DGRADT3; + map_Enum_ddl["R_X1"]=R_X1; + map_Enum_ddl["R_X2"]=R_X2; + map_Enum_ddl["R_X3"]=R_X3; + map_Enum_ddl["R_EPAIS"]=R_EPAIS; + map_Enum_ddl["R_V1"]=R_V1; + map_Enum_ddl["R_V2"]=R_V2; + map_Enum_ddl["R_V3"]=R_V3; + map_Enum_ddl["R_GAMMA1"]=R_GAMMA1; + map_Enum_ddl["R_GAMMA2"]=R_GAMMA2; + map_Enum_ddl["R_GAMMA3"]=R_GAMMA3; + map_Enum_ddl["NU_DDL"]=NU_DDL; + // définition des itérators de travail + ilfin = map_Enum_ddl.end(); + }; + +#ifndef MISE_AU_POINT + inline +#endif +string Nom_ddl (Enum_ddl id_nom) +// Retourne le nom du degre de liberte associe +// a l'identificateur de type enumere id_nom +{ + string result=""; + switch (id_nom) + {case X1 : result="X1";break; + case X2 : result="X2";break; + case X3 : result="X3";break; + case EPAIS : result="EPAIS";break; + case TEMP : result="TEMP";break; + case UX : result="UX";break; + case UY : result="UY";break; + case UZ : result="UZ";break; + case V1 : result="V1";break; + case V2 : result="V2";break; + case V3 : result="V3";break; + case PR : result="PR";break; + case GAMMA1 :result="GAMMA1";break; + case GAMMA2 :result="GAMMA2";break; + case GAMMA3 :result="GAMMA3";break; + case SIG11 : result="SIG11";break; + case SIG22 : result="SIG22";break; + case SIG33 : result="SIG33";break; + case SIG12 : result="SIG12";break; + case SIG23 : result="SIG23";break; + case SIG13 : result="SIG13";break; + case ERREUR :result="ERREUR";break; + case EPS11 : result="EPS11";break; + case EPS22 : result="EPS22";break; + case EPS33 : result="EPS33";break; + case EPS12 : result="EPS12";break; + case EPS23 : result="EPS23";break; + case EPS13 : result="EPS13";break; + case DEPS11 : result="DEPS11";break; + case DEPS22 : result="DEPS22";break; + case DEPS33 : result="DEPS33";break; + case DEPS12 : result="DEPS12";break; + case DEPS23 : result="DEPS23";break; + case DEPS13 : result="DEPS13";break; + case PROP_CRISTA : result="PROP_CRISTA";break; + case DELTA_TEMP : result="DELTA_TEMP";break; + case FLUXD1 : result="FLUXD1";break; + case FLUXD2 : result="FLUXD2";break; + case FLUXD3 : result="FLUXD3";break; + case R_TEMP : result="R_TEMP";break; + case GRADT1 : result="GRADT1";break; + case GRADT2 : result="GRADT2";break; + case GRADT3 : result="GRADT3";break; + case DGRADT1 : result="DGRADT1";break; + case DGRADT2 : result="DGRADT2";break; + case DGRADT3 : result="DGRADT3";break; + case R_X1 : result="R_X1";break; + case R_X2 : result="R_X2";break; + case R_X3 : result="R_X3";break; + case R_EPAIS : result="R_EPAIS";break; + case R_V1 : result="R_V1";break; + case R_V2 : result="R_V2";break; + case R_V3 : result="R_V3";break; + case R_GAMMA1 : result="R_GAMMA1";break; + case R_GAMMA2 : result="R_GAMMA2";break; + case R_GAMMA3 : result="R_GAMMA3";break; + case NU_DDL :result="NU_DDL";break; + default : + {cout << "\nErreur : valeur incorrecte du type Enum_ddl !\n"; + cout << "NOM_DDL(Enum_ddl ) \n"; + Sortie(1); + } + }; + return result; + +}; + +/*#ifndef MISE_AU_POINT + inline +#endif +Enum_ddl Id_nom_ddl (const char* nom) +// Retourne la variable de type enumere associee au nom du degre +// de liberte nom +// Retourne la variable de type enumere associe au nom nom_TypeQuelconque +{ // on vérifie si la variable de type enumere existe + map < string, Enum_ddl , std::less < string> >& maa=ClassPourEnum_ddl::map_Enum_ddl; + ClassPourEnum_ddl::remplir_map.il = maa.find(nom); + if (ClassPourEnum_ddl::remplir_map.il == ClassPourEnum_ddl::remplir_map.ilfin) + {// on vérifie si la variable de type enumere existe + cout << "\nErreur : nom du degre de liberte inconnu ! (" + << nom << ") \n"; + cout << "ID_NOM_DDL(char* ) \n"; + Sortie(1); + }; + // retour de la grandeur + return (*(ClassPourEnum_ddl::remplir_map.il)).second; +}; +*/ + +#ifndef MISE_AU_POINT + inline +#endif +Enum_ddl Id_nom_ddl (const string& nom) +// Retourne la variable de type enumere associee au nom du degre +// de liberte nom +// Retourne la variable de type enumere associe au nom nom_TypeQuelconque +{ // on vérifie si la variable de type enumere existe + map < string, Enum_ddl , std::less < string> >& maa=ClassPourEnum_ddl::map_Enum_ddl; + ClassPourEnum_ddl::remplir_map.il = maa.find(nom); + if (ClassPourEnum_ddl::remplir_map.il == ClassPourEnum_ddl::remplir_map.ilfin) + {// on vérifie si la variable de type enumere existe + cout << "\nErreur : nom du degre de liberte inconnu ! (" + << nom << ") \n"; + cout << "ID_NOM_DDL(const string& ) \n"; + Sortie(1); + }; + // retour de la grandeur + return (*(ClassPourEnum_ddl::remplir_map.il)).second; +}; + +/*// retourne true si l'identificateur existe, false sinon +#ifndef MISE_AU_POINT + inline +#endif +bool ExisteEnum_ddl(const char* nom) + { + return ( ClassPourEnum_ddl::map_Enum_ddl.find(nom) + != ClassPourEnum_ddl::remplir_map.ilfin); + +}; +*/ +// retourne true si l'identificateur existe, false sinon (cas d'un string) +#ifndef MISE_AU_POINT + inline +#endif +bool ExisteEnum_ddl(const string& nom) + {return ( ClassPourEnum_ddl::map_Enum_ddl.find(nom) + != ClassPourEnum_ddl::remplir_map.ilfin); + }; + +// ramene true si le ddl fait parti d'une liste +// fonction de la dimension du pb: par exemple : X1 ou UY ou VZ +// dans le cas contraire , exemple: T ou EPAIS ramene false +#ifndef MISE_AU_POINT + inline +#endif +bool FoncDim(const string& nom) + { // on récupère tout d'abord l'énuméré + Enum_ddl enu = Id_nom_ddl(nom); + return FoncDim(enu); + }; + + + +// ramene true si le ddl fait parti d'une liste +// fonction de la dimension du pb: par exemple : X1 ou UY ou VZ +// dans le cas contraire , exemple: T ou EPAIS ramene false +// mais ici avec l'énumération +#ifndef MISE_AU_POINT + inline +#endif +bool FoncDim(Enum_ddl id_ddl) + { bool res; + switch (id_ddl) + { case X1 : res=true;break; + case X2 :res=true;break; + case X3 :res=true;break; + case EPAIS :res=false;break; + case TEMP :res=false;break; + case UX :res=true;break; + case UY :res=true;break; + case UZ :res=true;break; + case V1 :res=true;break; + case V2 :res=true;break; + case V3 :res=true;break; + case PR :res=false;break; + case GAMMA1 :res=true;break; + case GAMMA2 :res=true;break; + case GAMMA3 :res=true;break; + case SIG11 :res=true;break; + case SIG22 :res=true;break; + case SIG33 :res=true;break; + case SIG12 :res=true;break; + case SIG23 :res=true;break; + case SIG13 :res=true;break; + case ERREUR :res=false;break; + case EPS11 :res=true;break; + case EPS22 :res=true;break; + case EPS33 :res=true;break; + case EPS12 :res=true;break; + case EPS23 :res=true;break; + case EPS13 :res=true;break; + case DEPS11 :res=true;break; + case DEPS22 :res=true;break; + case DEPS33 :res=true;break; + case DEPS12 :res=true;break; + case DEPS23 :res=true;break; + case DEPS13 :res=true;break; + case PROP_CRISTA :res=false;break; + case DELTA_TEMP :res=false;break; + case FLUXD1 :res=true;break; + case FLUXD2 :res=true;break; + case FLUXD3 :res=true;break; + case R_TEMP :res=false;break; + case GRADT1 :res=true;break; + case GRADT2 :res=true;break; + case GRADT3 :res=true;break; + case DGRADT1 :res=true;break; + case DGRADT2 :res=true;break; + case DGRADT3 :res=true;break; + case R_X1: res=true;break; + case R_X2: res=true;break; + case R_X3: res=true;break; + case R_EPAIS: res=false;break; + case R_V1: res=true;break; + case R_V2: res=true;break; + case R_V3: res=true;break; + case R_GAMMA1: res=true;break; + case R_GAMMA2: res=true;break; + case R_GAMMA3: res=true;break; + case NU_DDL :res=false;break; + default : + { cout << "\nErreur : valeur incorrecte du type Enum_ddl: " + << Nom_ddl(id_ddl) << " !\n"; + cout << "FoncDim(Enum_ddl id_ddl)\n"; + Sortie(1);} + }; + return res; + }; + +// ramene le tableau de tous les ddl correspondant au type du ddl passé en paramètre +// ceci en fonction de la dimension (par exemple pour un COORDONNEE, ramène +// les dim ddl correspondant aux composantes +#ifndef MISE_AU_POINT + inline +#endif +Tableau TableauTypeDdl(Enum_ddl id_ddl) + { // récup du premier ddl de la famille + Enum_ddl premddl = PremierDdlFamille(id_ddl); + // récup de la dimension + int dim = ParaGlob::Dimension(); + // fabrication du tableau + Tableau ta(1); + switch (dim) + { case 1: // dans tous les cas il n'y a qu'une seule grandeur + {ta(1)=premddl; break;} + case 2: + {int taille=NombreElementFoncDim(TypeGrandeur(premddl)); + ta.Change_taille(taille); int posi = premddl -1; + if ((premddl == SIG11)||(premddl==EPS11)||(premddl==DEPS11)) + // cas particulier des tenseurs + {ta(1)=Enum_ddl(1+posi);ta(2)=Enum_ddl(2+posi); + ta(3)=Enum_ddl(4+posi); + } + else // cas ou ça se suit + for (int i=1;i<=taille;i++) ta(i)=Enum_ddl(i+posi); + break; + } + case 3:// on crée le tableau en fonction du type de grandeur + {int taille=NombreElementFoncDim(TypeGrandeur(premddl)); + ta.Change_taille(taille); int posi = premddl -1; + for (int i=1;i<=taille;i++) ta(i)=Enum_ddl(i+posi); + break; + } + }; + return ta; +}; + +// ramene le tableau des ddl mobile correspondant au type du ddl passé en paramètre +// ceci en fonction de la dimension (par exemple pour un COORDONNEE, ramène +// les dim ddl correspondant aux composantes +// par rapport à TableauTypeDdl() la différence concerne le cas axi +// pour ce cas: X3=constant, U3=V3=Gamma3=0 ==> donc ne font pas partie du tableau retour +#ifndef MISE_AU_POINT + inline +#endif +Tableau TableauTypeDdlmobileAvecAxi(Enum_ddl id_ddl) + { // récup du premier ddl de la famille + Enum_ddl premddl = PremierDdlFamille(id_ddl); + // récup de la dimension + int dim = ParaGlob::Dimension(); + // fabrication du tableau + Tableau ta(1); + switch (dim) + { case 1: // dans tous les cas il n'y a qu'une seule grandeur + {ta(1)=premddl; break;} + case 2: + {int taille=NombreElementFoncDim(TypeGrandeur(premddl)); + ta.Change_taille(taille); int posi = premddl -1; + if ((premddl == SIG11)||(premddl==EPS11)||(premddl==DEPS11)) + // cas particulier des tenseurs + {ta(1)=Enum_ddl(1+posi);ta(2)=Enum_ddl(2+posi); + ta(3)=Enum_ddl(4+posi); + } + else // cas ou ça se suit + for (int i=1;i<=taille;i++) ta(i)=Enum_ddl(i+posi); + break; + } + case 3:// on crée le tableau en fonction du type de grandeur + {EnumTypeGrandeur enutype = TypeGrandeur(premddl); + int taille = 0; // init + if ((enutype == COORDONNEE) && (ParaGlob::AxiSymetrie())) + // dans ce cas on ne garde que 2 composante + {taille = 2;} + else // sinon + { taille=NombreElementFoncDim(enutype);}; + ta.Change_taille(taille); int posi = premddl -1; + for (int i=1;i<=taille;i++) ta(i)=Enum_ddl(i+posi); + break; + } + }; + return ta; +}; + + +// indique si le ddl est compatible avec la dimension +#ifndef MISE_AU_POINT + inline +#endif +bool CompatDim(const string& nom) + { bool res; + int dim = ParaGlob::Dimension(); + res = true; // bon a priori, par exemple pour temp, epais, p etc.. + switch (dim) + { case 3: res = true; break; + case 2: + {// on récupère tout d'abord l'énuméré + Enum_ddl enu = Id_nom_ddl(nom); + switch (enu) + {case X3: res=false;break; + case UZ: res=false;break; + case V3: res=false;break; + case GAMMA3: res=false;break; + case SIG33: res=false;break; + case SIG23: res=false;break; + case SIG13: res=false;break; + case EPS33: res=false;break; + case EPS23: res=false;break; + case EPS13: res=false;break; + case DEPS33: res=false;break; + case DEPS23: res=false;break; + case DEPS13: res=false;break; + case R_X3: res=false;break; + case R_EPAIS: res=true;break; + case R_V3: res=false;break; + case R_GAMMA3: res=false;break; + case FLUXD3 :res=false;break; + case GRADT3 :res=false;break; + case DGRADT3 :res=false;break; + default: res=true; break; + }; + break; + } + case 1: + {// on récupère tout d'abord l'énuméré + Enum_ddl enu = Id_nom_ddl(nom); + switch (enu) + {case X2 :res=false;break; + case X3 :res=false;break; + case UY :res=false;break; + case UZ :res=false;break; + case V2 :res=false;break; + case V3 :res=false;break; + case GAMMA2 :res=false;break; + case GAMMA3 :res=false;break; + case SIG22 :res=false;break; + case SIG33 :res=false;break; + case SIG12 :res=false;break; + case SIG23 :res=false;break; + case SIG13 :res=false;break; + case EPS22 :res=false;break; + case EPS33 :res=false;break; + case EPS12 :res=false;break; + case EPS23 :res=false;break; + case EPS13 :res=false;break; + case DEPS22 :res=false;break; + case DEPS33 :res=false;break; + case DEPS12 :res=false;break; + case DEPS23 :res=false;break; + case DEPS13 :res=false;break; + case R_X2: res=false;break; + case R_X3: res=false;break; + case R_EPAIS: res=true;break; + case R_V2: res=false;break; + case R_V3: res=false;break; + case R_GAMMA2: res=false;break; + case R_GAMMA3: res=false;break; + case FLUXD2 :res=false;break; + case FLUXD3 :res=false;break; + case GRADT2 :res=false;break; + case GRADT3 :res=false;break; + case DGRADT2 :res=false;break; + case DGRADT3 :res=false;break; + default: res=true; break; + }; + break; + } + }; // fin du switch sur la dimension + return res; + }; + +// indique si le ddl est compatible avec la dimension +#ifndef MISE_AU_POINT + inline +#endif +bool CompatDim(const Enum_ddl id_ddl) + { bool res; + int dim = ParaGlob::Dimension(); + res = true; // bon a priori, par exemple pour temp, epais, p etc.. + switch (dim) + { case 3: res = true; break; + case 2: + {// on récupère tout d'abord l'énuméré + switch (id_ddl) + {case X3: res=false;break; + case UZ: res=false;break; + case V3: res=false;break; + case GAMMA3: res=false;break; + case SIG33: res=false;break; + case SIG23: res=false;break; + case SIG13: res=false;break; + case EPS33: res=false;break; + case EPS23: res=false;break; + case EPS13: res=false;break; + case DEPS33: res=false;break; + case DEPS23: res=false;break; + case DEPS13: res=false;break; + case R_X3: res=false;break; + case R_EPAIS: res=true;break; + case R_V3: res=false;break; + case R_GAMMA3: res=false;break; + case FLUXD3 :res=false;break; + case GRADT3 :res=false;break; + case DGRADT3 :res=false;break; + default: res=true; break; + }; + break; + } + case 1: + {// on récupère tout d'abord l'énuméré + switch (id_ddl) + {case X2 :res=false;break; + case X3 :res=false;break; + case UY :res=false;break; + case UZ :res=false;break; + case V2 :res=false;break; + case V3 :res=false;break; + case GAMMA2 :res=false;break; + case GAMMA3 :res=false;break; + case SIG22 :res=false;break; + case SIG33 :res=false;break; + case SIG12 :res=false;break; + case SIG23 :res=false;break; + case SIG13 :res=false;break; + case EPS22 :res=false;break; + case EPS33 :res=false;break; + case EPS12 :res=false;break; + case EPS23 :res=false;break; + case EPS13 :res=false;break; + case DEPS22 :res=false;break; + case DEPS33 :res=false;break; + case DEPS12 :res=false;break; + case DEPS23 :res=false;break; + case DEPS13 :res=false;break; + case R_X2: res=false;break; + case R_X3: res=false;break; + case R_EPAIS: res=true;break; + case R_V2: res=false;break; + case R_V3: res=false;break; + case R_GAMMA2: res=false;break; + case R_GAMMA3: res=false;break; + case FLUXD2 :res=false;break; + case FLUXD3 :res=false;break; + case GRADT2 :res=false;break; + case GRADT3 :res=false;break; + case DGRADT2 :res=false;break; + case DGRADT3 :res=false;break; + default: res=true; break; + }; + break; + } + }; // fin du switch sur la dimension + return res; + }; + + +// retour le type de grandeur auquel apartient l'énumération +// par exemple : UY : apartiend à un COORDONNEE +// SIG12 : à un tenseur, TEMP : à un scalaire +#ifndef MISE_AU_POINT + inline +#endif +EnumTypeGrandeur TypeGrandeur(Enum_ddl id_nom) +{ EnumTypeGrandeur res; + switch (id_nom) + { case X1 : res=COORDONNEE;break; + case X2 :res=COORDONNEE;break; + case X3 :res=COORDONNEE;break; + case EPAIS :res=SCALAIRE;break; + case TEMP :res=SCALAIRE;break; + case UX :res=COORDONNEE;break; + case UY :res=COORDONNEE;break; + case UZ :res=COORDONNEE;break; + case V1 :res=COORDONNEE;break; + case V2 :res=COORDONNEE;break; + case V3 :res=COORDONNEE;break; + case PR :res=SCALAIRE;break; + case GAMMA1 :res=COORDONNEE;break; + case GAMMA2 :res=COORDONNEE;break; + case GAMMA3 :res=COORDONNEE;break; + case SIG11 :res=TENSEUR;break; + case SIG22 :res=TENSEUR;break; + case SIG33 :res=TENSEUR;break; + case SIG12 :res=TENSEUR;break; + case SIG23 :res=TENSEUR;break; + case SIG13 :res=TENSEUR;break; + case ERREUR :res=SCALAIRE;break; + case EPS11 :res=TENSEUR;break; + case EPS22 :res=TENSEUR;break; + case EPS33 :res=TENSEUR;break; + case EPS12 :res=TENSEUR;break; + case EPS23 :res=TENSEUR;break; + case EPS13 :res=TENSEUR;break; + case DEPS11 :res=TENSEUR;break; + case DEPS22 :res=TENSEUR;break; + case DEPS33 :res=TENSEUR;break; + case DEPS12 :res=TENSEUR;break; + case DEPS23 :res=TENSEUR;break; + case DEPS13 :res=TENSEUR;break; + case PROP_CRISTA :res=SCALAIRE;break; + case DELTA_TEMP :res=SCALAIRE;break; + case FLUXD1 :res=COORDONNEE;break; + case FLUXD2 :res=COORDONNEE;break; + case FLUXD3 :res=COORDONNEE;break; + case R_TEMP :res=SCALAIRE;break; + case GRADT1 :res=COORDONNEE;break; + case GRADT2 :res=COORDONNEE;break; + case GRADT3 :res=COORDONNEE;break; + case DGRADT1 :res=COORDONNEE;break; + case DGRADT2 :res=COORDONNEE;break; + case DGRADT3 :res=COORDONNEE;break; + case R_X1 :res=COORDONNEE;break; + case R_X2 :res=COORDONNEE;break; + case R_X3 :res=COORDONNEE;break; + case R_EPAIS :res=SCALAIRE;break; + case R_V1 :res=COORDONNEE;break; + case R_V2 :res=COORDONNEE;break; + case R_V3 :res=COORDONNEE;break; + case R_GAMMA1 :res=COORDONNEE;break; + case R_GAMMA2 :res=COORDONNEE;break; + case R_GAMMA3 :res=COORDONNEE;break; + case NU_DDL :res=RIEN_TYPEGRANDEUR;break; + default : + {cout << "\nErreur : valeur incorrecte du type Enum_ddl: " + << Nom_ddl(id_nom) << " !\n"; + cout << "TypeGrandeur(Enum_ddl id_ddl) \n"; + Sortie(1);} + }; + return res; +}; + + +// test si les deux ddl sont de la même famille dimensionnelle, par exemple X1 et X3, ou SIG11 et SIG22 +// ramène true si oui, false sinon +#ifndef MISE_AU_POINT + inline +#endif +bool Meme_famille(Enum_ddl a,Enum_ddl b) + { if (a==b) return true; // cas de la même valeur + // on regarde les formes numériques + // cas des Xi + if ( ((a==X1)||(a==X2)||(a==X3)) + &&((b==X1)||(b==X2)||(b==X3))) + return true; + // cas des Ui + if ( ((a==UX)||(a==UY)||(a==UZ)) + &&((b==UX)||(b==UY)||(b==UZ))) + return true; + // cas des Vi + if ( ((a==V1)||(a==V2)||(a==V3)) + &&((b==V1)||(b==V2)||(b==V3))) + return true; + // cas des GAMMAI + if ( ((a==GAMMA1)||(a==GAMMA2)||(a==GAMMA3)) + &&((b==GAMMA1)||(b==GAMMA2)||(b==GAMMA3))) + return true; + // cas des sigmai + if ( (a>= SIG11) && (a<= SIG13) + && (b>= SIG11) && (b<= SIG13)) + return true; + // cas des epsiloni + if ( (a>= EPS11) && (a<= EPS13) + && (b>= EPS11) && (b<= EPS13)) + return true; + // cas des depsiloni + if ( (a>= DEPS11) && (a<= DEPS13) + && (b>= DEPS11) && (b<= DEPS13)) + return true; + // cas des températures + if ( ((a == TEMP) || (a == DELTA_TEMP)) + && ((b == TEMP) || (b == DELTA_TEMP))) + return true; + // cas des densités de flux thermique + if ( ((a==FLUXD1)||(a==FLUXD2)||(a==FLUXD3)) + &&((b==FLUXD1)||(b==FLUXD2)||(b==FLUXD3))) + return true; + // cas des réactions à la température + if ( (a==R_TEMP) && (b==R_TEMP) ) + return true; + // cas des gradients thermiques + if ( ((a==GRADT1)||(a==GRADT2)||(a==GRADT3)) + &&((b==GRADT1)||(b==GRADT2)||(b==GRADT3))) + return true; + // cas des vitesses de gradient thermique + if ( ((a==DGRADT1)||(a==DGRADT2)||(a==DGRADT3)) + &&((b==DGRADT1)||(b==DGRADT2)||(b==DGRADT3))) + return true; + + // cas des réaction sur les Xi + if ( ((a==R_X1)||(a==R_X2)||(a==R_X3)) + &&((b==R_X1)||(b==R_X2)||(b==R_X3))) + return true; + // cas des réaction sur les Vi + if ( ((a==R_V1)||(a==R_V2)||(a==R_V3)) + &&((b==R_V1)||(b==R_V2)||(b==R_V3))) + return true; + // cas des réaction sur les GAMMAI + if ( ((a==R_GAMMA1)||(a==R_GAMMA2)||(a==R_GAMMA3)) + &&((b==R_GAMMA1)||(b==R_GAMMA2)||(b==R_GAMMA3))) + return true; + // cas des réaction sur EPAIS + if ( (a==R_EPAIS) && (b==R_EPAIS) ) + return true; + // sinon non de la même famille + return false; + }; + + +// ramène le premier ddl de la même famille +#ifndef MISE_AU_POINT + inline +#endif +Enum_ddl PremierDdlFamille(Enum_ddl a) + { switch (a) + { case X1 : return(X1); break; + case X2 : return(X1); break; + case X3 : return(X1); break; + case EPAIS : return(EPAIS); break; + case TEMP : return(TEMP); break; + case UX : return(UX); break; + case UY : return(UX); break; + case UZ : return(UX); break; + case V1 : return(V1); break; + case V2 : return(V1); break; + case V3 : return(V1); break; + case PR : return(PR); break; + case GAMMA1 : return(GAMMA1); break; + case GAMMA2 : return(GAMMA1); break; + case GAMMA3 : return(GAMMA1); break; + case SIG11 : return(SIG11); break; + case SIG22 : return(SIG11); break; + case SIG33 : return(SIG11); break; + case SIG12 : return(SIG11); break; + case SIG23 : return(SIG11); break; + case SIG13 : return(SIG11); break; + case ERREUR : return(ERREUR); break; + case EPS11 : return(EPS11); break; + case EPS22 : return(EPS11); break; + case EPS33 : return(EPS11); break; + case EPS12 : return(EPS11); break; + case EPS23 : return(EPS11); break; + case EPS13 : return(EPS11); break; + case DEPS11 : return(DEPS11); break; + case DEPS22 : return(DEPS11); break; + case DEPS33 : return(DEPS11); break; + case DEPS12 : return(DEPS11); break; + case DEPS23 : return(DEPS11); break; + case DEPS13 : return(DEPS11); break; + case PROP_CRISTA : return(PROP_CRISTA); break; + case DELTA_TEMP : return(DELTA_TEMP); break; + case FLUXD1 : return(FLUXD1); break; + case FLUXD2 : return(FLUXD1); break; + case FLUXD3 : return(FLUXD1); break; + case R_TEMP : return(R_TEMP); break; + case GRADT1 : return(GRADT1); break; + case GRADT2 : return(GRADT1); break; + case GRADT3 : return(GRADT1); break; + case DGRADT1 : return(DGRADT1); break; + case DGRADT2 : return(DGRADT1); break; + case DGRADT3 : return(DGRADT1); break; + case R_X1 : return(R_X1); break; + case R_X2 : return(R_X1); break; + case R_X3 : return(R_X1); break; + case R_EPAIS : return(R_EPAIS); break; + case R_V1 : return(R_V1); break; + case R_V2 : return(R_V1); break; + case R_V3 : return(R_V1); break; + case R_GAMMA1 : return(R_GAMMA1); break; + case R_GAMMA2 : return(R_GAMMA1); break; + case R_GAMMA3 : return(R_GAMMA1); break; + case NU_DDL : return(NU_DDL); break; + default : + {cout << "\nErreur : valeur incorrecte du type Enum_ddl: " + << a; + cout << "\nEnum_ddl PremierDdlFamille(Enum_ddl a)\n"; + Sortie(1); + } + }; + Sortie(1); // cas qui n'arrive jamais, c'est pour faire taire le compilo + return NU_DDL; // + }; + +// ramène un nom générique pour la famille de ddl du même type +#ifndef MISE_AU_POINT + inline +#endif +string NomGeneric(Enum_ddl a) + { string result=""; + switch (a) + {case X1 : result="Xi"; break; + case X2 : result="Xi"; break; + case X3 : result="Xi"; break; + case EPAIS : result="EPAIS"; break; + case TEMP : result="TEMP"; break; + case UX : result="Ui"; break; + case UY : result="Ui"; break; + case UZ : result="Ui"; break; + case V1 : result="Vi"; break; + case V2 : result="Vi"; break; + case V3 : result="Vi"; break; + case PR : result="PR"; break; + case GAMMA1 : result="GAMMAi"; break; + case GAMMA2 : result="GAMMAi"; break; + case GAMMA3 : result="GAMMAi"; break; + case SIG11 : result="Sigmaij"; break; + case SIG22 : result="Sigmaij"; break; + case SIG33 : result="Sigmaij"; break; + case SIG12 : result="Sigmaij"; break; + case SIG23 : result="Sigmaij"; break; + case SIG13 : result="Sigmaij"; break; + case ERREUR : result="ERREUR"; break; + case EPS11 : result="Epsilonij"; break; + case EPS22 : result="Epsilonij"; break; + case EPS33 : result="Epsilonij"; break; + case EPS12 : result="Epsilonij"; break; + case EPS23 : result="Epsilonij"; break; + case EPS13 : result="Epsilonij"; break; + case DEPS11 : result="Dij"; break; + case DEPS22 : result="Dij"; break; + case DEPS33 : result="Dij"; break; + case DEPS12 : result="Dij"; break; + case DEPS23 : result="Dij"; break; + case DEPS13 : result="Dij"; break; + case PROP_CRISTA : result="PROP_CRISTA"; break; + case DELTA_TEMP : result="DELTA_TEMP"; break; + case FLUXD1 : result="FLUXD"; break; + case FLUXD2 : result="FLUXD"; break; + case FLUXD3 : result="FLUXD"; break; + case R_TEMP : result="R_TEMP"; break; + case GRADT1 : result="GRADT"; break; + case GRADT2 : result="GRADT"; break; + case GRADT3 : result="GRADT"; break; + case DGRADT1 : result="DGRADT"; break; + case DGRADT2 : result="DGRADT"; break; + case DGRADT3 : result="DGRADT"; break; + case R_X1 : result="R_Xi"; break; + case R_X2 : result="R_Xi"; break; + case R_X3 : result="R_Xi"; break; + case R_EPAIS : result="R_EPAIS"; break; + case R_V1 : result="R_Vi"; break; + case R_V2 : result="R_Vi"; break; + case R_V3 : result="R_Vi"; break; + case R_GAMMA1 : result="R_GAMMAi"; break; + case R_GAMMA2 : result="R_GAMMAi"; break; + case R_GAMMA3 : result="R_GAMMAi"; break; + case NU_DDL : result="NU_DDL"; break; + default : + {cout << "\nErreur : valeur incorrecte du type Enum_ddl: " + << a; + cout << "\nEnum_ddl NomGeneric(Enum_ddl a)\n"; + Sortie(1); + } + }; + return result; // + }; + + +// test si le ddl appartient à la combinaison donné par cas +// cas : spécifie la combinaison : =1 -> combinaison X V GAMMA +#ifndef MISE_AU_POINT + inline +#endif +bool Dans_combinaison(int cas,Enum_ddl enu) + {bool retour; + switch (cas) + { case 0 : retour = false; break; + case 1 : // cas de l'association X V GAMMA + { Enum_ddl a = PremierDdlFamille(enu); + if ((a==X1)||(a==V1)||(a==GAMMA1)) + retour = true; else retour = false; + break; + } + default : + {cout << "\nErreur : cas de combinaison non encore implanté, cas= " + << cas + << "\n Dans_combinaison(int cas,Enum_ddl a) \n"; + Sortie(1); + } + }; + return retour; + }; + +// récupération d'un enum de grandeurs quelconques équivalentes +// -> retour particulier si il y a une équivalence particulière en grandeur évoluée par exemple +// sinon, un retour sur un scalaire de type enum_évolué, qui contient de toute manière +// les ddl de base +// -> ramène UN_DDL_ENUM_ETENDUE s'il n'y a pas d'équivalent spécifique +#ifndef MISE_AU_POINT + inline +#endif +EnumTypeQuelconque Equi_Enum_ddl_en_enu_quelconque(Enum_ddl a) + { EnumTypeQuelconque result; + switch (a) + {case X1 : case X2 : case X3 : result=POSITION_GEOMETRIQUE; break; + case EPAIS : result=UN_DDL_ENUM_ETENDUE; break; + case TEMP : result=UN_DDL_ENUM_ETENDUE; break; + case UX : case UY : case UZ : result=DEPLACEMENT; break; + case V1 : case V2 : case V3 : result=VITESSE; break; + case PR : result=UN_DDL_ENUM_ETENDUE; break; + case GAMMA1 : result=UN_DDL_ENUM_ETENDUE; break; + case GAMMA2 : result=UN_DDL_ENUM_ETENDUE; break; + case GAMMA3 : result=UN_DDL_ENUM_ETENDUE; break; + case SIG11 : case SIG22 : case SIG33 : case SIG12 : + case SIG23 : case SIG13 : result=CONTRAINTE_COURANTE; break; + case ERREUR : result=UN_DDL_ENUM_ETENDUE; break; + case EPS11 : case EPS22 : case EPS33 : case EPS12 : + case EPS23 : case EPS13 : result=DEFORMATION_COURANTE; break; + case DEPS11 : case DEPS22 : case DEPS33 : case DEPS12 : + case DEPS23 : case DEPS13 : result=VITESSE_DEFORMATION_COURANTE; break; + case PROP_CRISTA : result=UN_DDL_ENUM_ETENDUE; break; + case DELTA_TEMP : result=UN_DDL_ENUM_ETENDUE; break; + case FLUXD1 : case FLUXD2 : case FLUXD3 : result=FLUXD; break; + case R_TEMP : result=UN_DDL_ENUM_ETENDUE; break; + case GRADT1 : case GRADT2 : case GRADT3 : result=GRADT; break; + case DGRADT1 : case DGRADT2 : case DGRADT3 : result=DGRADT; break; + case R_X1 : result=UN_DDL_ENUM_ETENDUE; break; + case R_X2 : result=UN_DDL_ENUM_ETENDUE; break; + case R_X3 : result=UN_DDL_ENUM_ETENDUE; break; + case R_EPAIS : result=UN_DDL_ENUM_ETENDUE; break; + case R_V1 : result=UN_DDL_ENUM_ETENDUE; break; + case R_V2 : result=UN_DDL_ENUM_ETENDUE; break; + case R_V3 : result=UN_DDL_ENUM_ETENDUE; break; + case R_GAMMA1 : result=UN_DDL_ENUM_ETENDUE; break; + case R_GAMMA2 : result=UN_DDL_ENUM_ETENDUE; break; + case R_GAMMA3 : result=UN_DDL_ENUM_ETENDUE; break; + case NU_DDL : result=UN_DDL_ENUM_ETENDUE; break; + default : + {cout << "\nErreur : valeur incorrecte du type Enum_ddl: " + << a; + cout << "\nEnum_ddl NomGeneric(Enum_ddl a)\n"; + Sortie(1); + } + }; + return result; // +}; + + + + + + + +// ramène tous les membres d'une même combinaison de la même dimension +// y compris "a" +// cas : spécifie la combinaison : +// =0 -> pas de combinaison, ramène "a" +// =1 -> combinaison X V GAMMA +#ifndef MISE_AU_POINT + inline +#endif +Tableau MemeCombinaison(int cas,Enum_ddl a) + { Tableau t_ret; + switch (cas) + { case 0 : // cas pas d'association + { t_ret.Change_taille(1); // dimmensionnement du tableau de retour + t_ret(1)=a; + break; + } + case 1 : // cas de l'association X V GAMMA + { t_ret.Change_taille(3); // dimmensionnement du tableau de retour + Enum_ddl b = PremierDdlFamille(a); + #ifdef MISE_AU_POINT + if ( (X1 != b) && (V1 != b) && (GAMMA1 != b)) + // erreur + {cout << "\nErreur : ddl ne faisant pas partie de la combinaison 1, " + << Nom_ddl(a) + << "\n Tableau MemeCombinaison(int cas,Enum_ddl a) \n"; + Sortie(1); + }; + #endif + t_ret(1) = Enum_ddl(X1 + (a-b)); + t_ret(2) = Enum_ddl(V1 + (a-b)); + t_ret(3) = Enum_ddl(GAMMA1 + (a-b)); + break; + } + default : + {cout << "\nErreur : cas de combinaison non encore implanté, cas= " + << cas + << "\n Tableau MemeCombinaison(int cas,Enum_ddl a) \n"; + Sortie(1); + } + }; + return t_ret; + }; + + +#ifndef MISE_AU_POINT + inline +#endif +// ramène tous les membres d'une même combinaison, pour i=1 à dim +Tableau Combinaison(int cas) + { Tableau t_ret; + switch (cas) + {case 0 : // cas pas d'association + { t_ret.Change_taille(0); // dimmensionnement du tableau de retour + break; + } + case 1 : // cas de l'association X V GAMMA + { int dim = ParaGlob::Dimension(); + t_ret.Change_taille(3*dim); // dimmensionnement du tableau de retour + switch (dim) + { case 3: t_ret(3) = X3; t_ret(3+dim) = V3;t_ret(3+2*dim) = GAMMA3; + case 2: t_ret(2) = X2; t_ret(2+dim) = V2;t_ret(2+2*dim) = GAMMA2; + case 1: t_ret(1) = X1; t_ret(1+dim) = V1;t_ret(1+2*dim) = GAMMA1; + }; +// t_ret(1) = X1; t_ret(1+dim) = V1;t_ret(1+2*dim) = GAMMA1; +// if (dim==1) break; +// t_ret(2) = X2; t_ret(2+dim) = V2;t_ret(2+2*dim) = GAMMA2; +// if (dim==2) break; +// t_ret(3) = X3; t_ret(3+dim) = V3;t_ret(3+2*dim) = GAMMA3; + break; + } + default : + {cout << "\nErreur : cas de combinaison non encore implanté, cas= " + << cas + << "\n Tableau Combinaison(int cas) \n"; + Sortie(1); + } + }; + return t_ret; + }; + + +// passage de Ui en Xi, c-a-d : UX -> X1, UY -> X2, UZ -> X3 +#ifndef MISE_AU_POINT + inline +#endif +Enum_ddl UxyzXi(Enum_ddl en) + { if (en == UX) + en = X1; + else if(en == UY) + en = X2; + else if(en == UZ) + en = X3; + else + { + cout << "\nErreur : nom du degre de liberte " << Nom_ddl(en) + << " , different de UX ou UY ou UZ !\n"; + cout << "UxyzXi(Enum_ddl en) \n"; + Sortie(1); + }; + return en; + }; + +// passage inverse +#ifndef MISE_AU_POINT + inline +#endif +Enum_ddl XiUxyz(Enum_ddl en) + { if (en == X1 ) + en = UX; + else if(en == X2) + en = UY; + else if(en == X3) + en = UZ; + else + { + cout << "\nErreur : nom du degre de liberte " << Nom_ddl(en) + << " , different de X1 ou X2 ou X3 !\n"; + cout << "XiUxyzi(Enum_ddl en) \n"; + Sortie(1); + }; + return en; + }; +//----------- pour les Coordonnee -------------- +// retourne l'indice en fonction de l'enum et du nbcomposante +// pour une grandeur de type Coordonnee, sinon erreur +#ifndef MISE_AU_POINT + inline +#endif +int Indice_coor(Enum_ddl a,int nbcomposantes) + {return a-PremierDdlFamille(a)+1;}; + +// fonction donnant dans l'ordre des ddl de contraintes, les indices correspondant +// des tenseurs, ceci en fonction du nombre de composante de tenseur +// en retour un tableau : (i)(1) et (i)(2) -> l'indices du tenseur correspondant +// au i ième ddl de containte à partir de SIG11 +#ifndef MISE_AU_POINT + inline +#endif +Tableau2 OrdreContrainte(int nbcomposantes) + { // def du tableau de retour + Tableau2 ordre(nbcomposantes,2,0); + + switch (nbcomposantes) + { + case 1 : + ordre(1,1) = 1; // -> SIG11 + ordre(1,2) = 1; // " + break; + case 3 : // cas symétrique + ordre(1,1) = 1; // -> SIG11 + ordre(1,2) = 1; // " + ordre(2,1) = 2; // -> SIG22 + ordre(2,2) = 2; // " + ordre(3,1) = 1; // -> SIG12 + ordre(3,2) = 2; // " + break; + case 6 : + ordre(1,1) = 1; // -> SIG11 + ordre(1,2) = 1; // " + ordre(2,1) = 2; // -> SIG22 + ordre(2,2) = 2; // " + ordre(3,1) = 3; // -> SIG33 + ordre(3,2) = 3; // " + ordre(4,1) = 1; // -> SIG12 + ordre(4,2) = 2; // " + ordre(5,1) = 2; // -> SIG23 + ordre(5,2) = 3; // " + ordre(6,1) = 1; // -> SIG13 + ordre(6,2) = 3; // " + break; + case 9 : + // ***** erreur il ne doit pas y avoir le cas de 9 valeurs + // car cela n'a rien à voire avec les enum_ddl + // il s'agit en fait de l'utilisation des fonctions OdVect et idx_i et idx_j + // des tenseurs donc à revoir !! + cout << "\nErreur : valeur incorrecte du nombre de composantes !\n" + << " \n nombre = 9 "; + cout << "\n OrdreContrainte(int nbcomposantes) \n"; + Sortie(1); + + + /* // initialisation avec 9 valeurs différentes correspodantes aux trois + // lignes : (1,1) (1,2) (1,3) ; (2,1) (2,2) (2,3) ; (3,1) (3,2) (3,3) + ordre(1,1) = 1; // -> SIG11 + ordre(1,2) = 1; // " + ordre(2,1) = 1; // -> SIG12 + ordre(2,2) = 2; // " + ordre(3,1) = 1; // -> SIG13 + ordre(3,2) = 3; // " + ordre(4,1) = 2; // -> SIG21 + ordre(4,2) = 1; // " + ordre(5,1) = 2; // -> SIG22 + ordre(5,2) = 2; // " + ordre(6,1) = 2; // -> SIG23 + ordre(6,2) = 3; // " + ordre(7,1) = 3; // -> SIG31 + ordre(7,2) = 1; // " + ordre(8,1) = 3; // -> SIG32 + ordre(8,2) = 2; // " + ordre(9,1) = 3; // -> SIG33 + ordre(9,2) = 3; // "*/ + break; + default : + {cout << "\nErreur : valeur incorrecte du nombre de composantes !\n"; + cout << "OrdreContrainte(int nbcomposantes) \n"; + Sortie(1); + } + }; + return ordre; + }; +// idem en fonction du nombre de composantes +// fonction très rapide qui pointe sur des tableaux déjà construits +#ifndef MISE_AU_POINT + inline +#endif +const Tableau2 & OrdreContrainteR(int nbcomposantes) + {switch (nbcomposantes) + { case 1 : return OrdreContrainte1; break; + case 3 : return OrdreContrainte3; break; + case 6 : return OrdreContrainte6; break; + default : + {cout << "\nErreur : valeur incorrecte du nombre de composantes : " + << nbcomposantes << " !\n"; + cout << "OrdreContrainteR(int nbcomposantes) \n"; + Sortie(1); + } + }; + return OrdreContrainte1; // pour taire le compilo !! + }; + +// donne directement le premier et le second indice en fonction de l'enum et du nbcomposante +// pour les tenseurs sigma ou epsilon ou Depsilon +#ifndef MISE_AU_POINT + inline +#endif +Deuxentiers_enu IJind(Enum_ddl a,int nbcomposantes) + { Enum_ddl b = a; + if ( PremierDdlFamille(a) == EPS11) + b = Enum_ddl(SIG11 + (a-EPS11)); // transfo en équivalent sigma + if ( PremierDdlFamille(a) == DEPS11) + b = Enum_ddl(SIG11 + (a-DEPS11)); // transfo en équivalent sigma + Deuxentiers_enu ret; ret.i=-1; ret.j=-1; + switch (nbcomposantes) + { case 1: + switch (b) + { case SIG11: ret.i=1; ret.j=1;break; + default : + {cout << "\nErreur : valeur incorrecte de l'énumération en fonction du nombre de composantes : " + << "enu= " << Nom_ddl(a) << " nbcomposantes " << nbcomposantes << " !\n"; + cout << "IJind(Enum_ddl a,int nbcomposantes)\n"; + Sortie(1); + } + }; + break; + case 3: + switch (b) + { case SIG11: ret.i=1; ret.j=1;break; + case SIG22: ret.i=2; ret.j=2;break; + case SIG12: ret.i=1; ret.j=2;break; + default : + {cout << "\nErreur : valeur incorrecte de l'énumération en fonction du nombre de composantes : " + << "enu= " << Nom_ddl(a) << " nbcomposantes " << nbcomposantes << " !\n"; + cout << "IJind(Enum_ddl a,int nbcomposantes)\n"; + Sortie(1); + } + }; + break; + case 6: + switch (b) + { case SIG11: ret.i=1; ret.j=1;break; + case SIG22: ret.i=2; ret.j=2;break; + case SIG33: ret.i=3; ret.j=3;break; + case SIG12: ret.i=1; ret.j=2;break; + case SIG23: ret.i=2; ret.j=3;break; + case SIG13: ret.i=1; ret.j=3;break; + default : + {cout << "\nErreur : valeur incorrecte de l'énumération en fonction du nombre de composantes : " + << "enu= " << Nom_ddl(a) << " nbcomposantes " << nbcomposantes << " !\n"; + cout << "IJind(Enum_ddl a,int nbcomposantes)\n"; + Sortie(1); + } + }; + break; + default : + {cout << "\nErreur : valeur incorrecte du nombre de composantes : " + << nbcomposantes << " !\n"; + cout << "IJind(Enum_ddl a,int nbcomposantes)\n"; + Sortie(1); + } + }; + return ret; + }; + +// passage de enum_ddl vers des réactions enum_ddl correspondantes +// exemple X1 -> R_X1 etc.. +#ifndef MISE_AU_POINT + inline +#endif +Enum_ddl Vers_enum_reac(Enum_ddl id_nom) + { Enum_ddl result; + switch (id_nom) + {case X1 : result=R_X1;break; + case X2 : result=R_X2;break; + case X3 : result=R_X3;break; + case EPAIS : result=R_EPAIS;break; + case V1 : result=R_V1;break; + case V2 : result=R_V2;break; + case V3 : result=R_V3;break; + case GAMMA1 :result=R_GAMMA1;break; + case GAMMA2 :result=R_GAMMA2;break; + case GAMMA3 :result=R_GAMMA3;break; + case TEMP :result=R_TEMP;break; + default : + {cout << "\nErreur : enum de reaction non implante pour le ddl : " << Nom_ddl(id_nom) << "!\n"; + cout << "Vers_enum_reac(Enum_ddl ) \n"; + Sortie(1); + } + }; + return result; + }; + +// opération inverse: exemple R_X1 -> X1 +#ifndef MISE_AU_POINT + inline +#endif +Enum_ddl Enum_reac_vers_enum(Enum_ddl id_nom) + { Enum_ddl result; + switch (id_nom) + { case R_X1 : result=X1;break; + case R_X2 : result=X2;break; + case R_X3 : result=X3;break; + case R_EPAIS : result=EPAIS;break; + case R_V1 : result=V1;break; + case R_V2 : result=V2;break; + case R_V3 : result=V3;break; + case R_GAMMA1 :result=GAMMA1;break; + case R_GAMMA2 :result=GAMMA2;break; + case R_GAMMA3 :result=GAMMA3;break; + case R_TEMP :result=TEMP;break; + default : + {cout << "\nErreur : enum de reaction non implante pour le ddl : " << Nom_ddl(id_nom) << "!\n"; + cout << "Enum_reac_vers_enum(Enum_ddl ) \n"; + Sortie(1); + } + }; + return result; + }; + +// indique si un ddl est un ddl de réaction on non +#ifndef MISE_AU_POINT + inline +#endif +bool Ddl_reaction(Enum_ddl id_ddl) + { bool res; + switch (id_ddl) + { case R_X1: res=true;break; + case R_X2: res=true;break; + case R_X3: res=true;break; + case R_EPAIS: res=true;break; + case R_V1: res=true;break; + case R_V2: res=true;break; + case R_V3: res=true;break; + case R_GAMMA1: res=true;break; + case R_GAMMA2: res=true;break; + case R_GAMMA3: res=true;break; + case R_TEMP: res=true;break; + default : res = false; break; + } + return res; + }; + + + // surcharge de l'operator de lecture +#ifndef MISE_AU_POINT + inline +#endif +istream & operator >> (istream & entree, Enum_ddl& a) + { char nom_Enum_ddl[nbmax_caractere_enum_ddl+5]; + entree >> nom_Enum_ddl; + a = Id_nom_ddl ( nom_Enum_ddl); + return entree; + }; + + // surcharge de l'operator d'ecriture +#ifndef MISE_AU_POINT + inline +#endif +ostream & operator << (ostream & sort, const Enum_ddl& a) + { // on ecrit la forme caractère + sort << setw (nbmax_caractere_enum_ddl+2) << Nom_ddl(a) << " "; + return sort; + }; + +#endif + + + + + diff --git a/Enumeration/Enum_ddl.h b/Enumeration/Enum_ddl.h new file mode 100644 index 0000000..a3541ea --- /dev/null +++ b/Enumeration/Enum_ddl.h @@ -0,0 +1,272 @@ +/*! \file Enum_ddl.h + \brief def de l'enuméré concernant les ddl. +*/ +// FICHIER : Enum_ddl.h + +// 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-2021 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: . + +/** @defgroup Group_types_enumeres Group_types_enumeres +* +* \author Gérard Rio +* \version 1.0 +* \date 23/01/97 +* \brief Def de grandeurs enumérées: permet une meilleure lisibilité du code et éventuellement un gain de place +* +*/ + + +/// @addtogroup Group_types_enumeres +/// @{ +/// + + +/// Afin de realiser un gain en place memoire, les noms des degres de liberte sont +/// stockes a l'aide d'un type enumere. Les fonctions Nom_ddl et Id_nom_ddl rendent +/// possible le lien entre les noms des degres de liberte et les identificateurs +/// de type enumere correspondants. +/// 10 carractere maxi +/// NU_DDL correspond au cas ou pas de ddl est defini +/// les ddl X1 X2 X3 doivent se suivrent +/// les ddl UX, UY, UZ doivent se suivrent +/// les ddl VX , VY , VZ, doivent se suivrent +/// ne pas changer l'ordre des 3 premiers ddl dans l'enumeration!!!! car on se +/// sert du fait que Enum_ddl(1) = X1 etc pour initialiser les ddl des noeud elements +/// +/// une famille de ddl: se sont des ddl scalaires qui représentent les composantes d'un ddl vectoriel +/// ou tensoriel, ou scalaire s'il n'y a qu'une seule grandeur, qui ne dépend pas de la dimension (ex: pression +/// ou température) +/// une combinaison , c'est un groupe de ddl qui sont relié par le calcul: ex: position, vitesse et accélération +/// en dynamique. + + +#ifndef ENUM_DDL_H +#define ENUM_DDL_H + +//#include "Debug.h" +# include "Tableau2_T.h" +#include +using namespace std; +#include "EnumTypeGrandeur.h" +#include "ParaGlob.h" +#include "Enum_TypeQuelconque.h" + +//=============================================================================== +// l'énumération de degré de liberté de base, celle qui sert pour les calculs +// nombre de ddl limité +//=============================================================================== +// ***** !!!! penser à changer la fonction "NbEnum_ddl" et ***** +//****** nbmax_caractere_enum_ddl si nécessaire ***** +// le type énuméré doit commencer à 1, c'est utilisé dans Ddl_enum_etendu par exemple !! +enum Enum_ddl { X1 = 1, X2 , X3, EPAIS , TEMP , UX, UY, UZ , V1 , V2 , V3, + PR, GAMMA1, GAMMA2, GAMMA3, + SIG11,SIG22,SIG33,SIG12,SIG23,SIG13,ERREUR, + EPS11,EPS22,EPS33,EPS12,EPS23,EPS13, + DEPS11,DEPS22,DEPS33,DEPS12,DEPS23,DEPS13, + PROP_CRISTA,DELTA_TEMP,FLUXD1,FLUXD2,FLUXD3,R_TEMP, + GRADT1,GRADT2,GRADT3,DGRADT1,DGRADT2,DGRADT3, + R_X1,R_X2,R_X3,R_EPAIS,R_V1,R_V2,R_V3,R_GAMMA1,R_GAMMA2,R_GAMMA3, + NU_DDL }; +// ***** !!!! penser à changer la fonction "NbEnum_ddl" et ***** +//****** nbmax_caractere_enum_ddl si nécessaire ***** +//****** Nombre_de_famille_de_ddl si nécessaire ***** +/// @} // end of group + + +/// @addtogroup Group_types_enumeres +/// @{ + +/// classe utilitaire entre Enum_ddl et une map +class ClassPourEnum_ddl +{ public: +// friend Enum_ddl Id_nom_ddl (const char* nom); + friend Enum_ddl Id_nom_ddl (const string& nom); +// friend bool ExisteEnum_ddl(const char* nom); + friend bool ExisteEnum_ddl(const string& nom); + /// def de la map qui fait la liaison entre les string et les énumérés + static map < string, Enum_ddl , std::less < string> > map_Enum_ddl; + /// def de la grandeur statique qui permet de remplir la map + static ClassPourEnum_ddl remplir_map; + /// le constructeur qui rempli effectivement la map + ClassPourEnum_ddl(); + /// variable de travail + protected: + map < string, Enum_ddl , std::less < string> >::iterator il,ilfin; + }; +/// @} // end of group + +//------------------------------------------------- +// def des fonctions de manipulation des Enum_ddl +//------------------------------------------------- + +/// definition du maximum de caractères de la chaine équivalente à l'énumération +const int nbmax_caractere_enum_ddl = 11; +const int nombre_maxi_de_famille_de_ddl = 21; +const int nombre_maxi_de_type_de_ddl = 57; + +/// Retourne le nom d'un degre de liberte a partir de son identificateur de +/// type enumere id_ddl correspondant +string Nom_ddl (Enum_ddl id_ddl); + +/// Retourne l'identificateur de type enumere associe au nom du degre de liberte +/// nom_ddl +///Enum_ddl Id_nom_ddl (const char* nom_ddl); +Enum_ddl Id_nom_ddl (const string& nom_ddl); + +/// retourne true si l'identificateur existe, false sinon +///bool ExisteEnum_ddl(const char* nom_ddl); +bool ExisteEnum_ddl(const string& nom_ddl); + +/// retourne le nombre maxi de ddl existant +inline int NbEnum_ddl() {return nombre_maxi_de_type_de_ddl;}; + +/// ramene true si le ddl fait parti d'une liste +/// fonction de la dimension du pb: par exemple : X1 ou UY ou VZ +/// dans le cas contraire , exemple: T ou EPAIS ramene false +bool FoncDim(const string& nom_ddl); +/// idem mais avec l'énumération +bool FoncDim(Enum_ddl id_ddl); + +/// ramene le tableau de tous les ddl correspondant au type du ddl passé en paramètre +/// ceci en fonction de la dimension (par exemple pour un COORDONNEE, ramène +/// les dim ddl correspondant aux composantes +Tableau TableauTypeDdl(Enum_ddl id_ddl); + +/// ramene le tableau des ddl mobile correspondant au type du ddl passé en paramètre +/// ceci en fonction de la dimension (par exemple pour un COORDONNEE, ramène +/// les dim ddl correspondant aux composantes +/// par rapport à TableauTypeDdl() la différence concerne le cas axi +/// pour ce cas: X3=constant, U3=V3=Gamma3=0 ==> donc ne font pas partie du tableau retour +Tableau TableauTypeDdlmobileAvecAxi(Enum_ddl id_ddl); + + +/// indique si le ddl est compatible avec la dimension +/// c'est-à-dire qu'il peut exister avec la dimension actuelle : +/// par exemple en 1D on ne peut pas avoir de UY, mais UX c'est ok +bool CompatDim(const string& nom_ddl); +bool CompatDim(const Enum_ddl id_ddl); + +/// retour le type de grandeur auquel apartient l'énumération +/// par exemple : UY : apartiend à un COORDONNEE +/// SIG12 : à un tenseur, TEMP : à un scalaire +EnumTypeGrandeur TypeGrandeur(Enum_ddl id_ddl); + +/// test si les deux ddl sont de la même famille dimensionnelle, +/// par exemple X1 et X3, ou SIG11 et SIG22 +/// ramène true si oui, false sinon +bool Meme_famille(Enum_ddl a,Enum_ddl b); + +/// ramène le premier ddl de la même famille +Enum_ddl PremierDdlFamille(Enum_ddl a); +/// ramène un nom générique pour la famille de ddl du même type +string NomGeneric(Enum_ddl a); + +/// ramène de nombre de famille différente qui existe +inline int Nombre_de_famille_de_ddl() {return nombre_maxi_de_famille_de_ddl;}; + +/// test si le ddl appartient à la combinaison donné par cas +/// cas : spécifie la combinaison : =1 -> combinaison X V GAMMA +/// ramène false si cas=0 c'est-à-dire pas de combinaison +bool Dans_combinaison(int cas,Enum_ddl a); + +/// ramène tous les membres d'une même combinaison de la même dimension +/// y compris "a" +/// cas : spécifie la combinaison : +/// =0 -> pas de combinaison, ramène "a" +/// =1 -> combinaison X V GAMMA +Tableau MemeCombinaison(int cas,Enum_ddl a); + +/// ramène tous les membres d'une même combinaison, pour i=1 à dim +/// cas = 1 -> combinaison X V GAMMA +/// cas = 0 -> pas de combinaison, ramène un tableau de dimension 0 +Tableau Combinaison(int cas); + +/// récupération d'un enum de grandeurs quelconques équivalentes +/// -> retour particulier si il y a une équivalence particulière en grandeur évoluée par exemple +/// sinon, un retour sur un scalaire de type enum_évolué, qui contient de toute manière +/// les ddl de base +/// -> ramène UN_DDL_ENUM_ETENDUE s'il n'y a pas d'équivalent spécifique +EnumTypeQuelconque Equi_Enum_ddl_en_enu_quelconque(Enum_ddl a); + +/// passage de Ui en Xi, c-a-d : UX -> X1, UY -> X2, UZ -> X3 +Enum_ddl UxyzXi(Enum_ddl a); +/// passage inverse +Enum_ddl XiUxyz(Enum_ddl a); +/// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_ddl& a); +/// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_ddl& a); + +///----------- pour les Coordonnee -------------- +/// retourne l'indice en fonction de l'enum et du nbcomposante +/// pour une grandeur de type Coordonnee, sinon erreur +int Indice_coor(Enum_ddl a,int nbcomposantes); + +///----------- pour les tenseurs ------------------ +/// fonction donnant dans l'ordre des ddl de contraintes, les indices correspondant +/// des tenseurs, ceci en fonction du nombre de composante de tenseur +/// en retour un tableau : (i)(1) et (i)(2) -> les indices (en entier) du tenseur correspondant +/// au i ième ddl de containte à partir de SIG11 +/// mais en sautant les ddl qui ne font pas parti de la dimension !!!!! +Tableau2 OrdreContrainte(int nbcomposantes); +/// idem en fonction du nombre de composantes +/// fonction plus rapide qui pointe sur des tableaux déjà construits à partir d'OrdreContrainte +const Tableau2 & OrdreContrainteR(int nbcomposantes); +/// donne directement le premier et le second indice en fonction de l'enum et du nbcomposante +/// pour les tenseurs sigma ou pour le tenseur epsilon ou encore pour le tenseur Depsilon +/// @addtogroup Group_types_enumeres +/// @{ +/// classe utilitaire pour les enum_ddl +class Deuxentiers_enu {public: int i;int j;}; +/// @} // end of group + +Deuxentiers_enu IJind(Enum_ddl a,int nbcomposantes); + +/// definition de tableau constant pour éviter de les recalculer à chaque appel +const Tableau2 OrdreContrainte1 = OrdreContrainte(1); +const Tableau2 OrdreContrainte3 = OrdreContrainte(3); +const Tableau2 OrdreContrainte6 = OrdreContrainte(6); + +//------- fin spécifique tenseur ------------- + +/// passage de enum_ddl vers des réactions enum_ddl correspondantes +/// exemple X1 -> R_X1 etc.. +Enum_ddl Vers_enum_reac(Enum_ddl a); +/// opération inverse: exemple R_X1 -> X1 +Enum_ddl Enum_reac_vers_enum(Enum_ddl a); +/// indique si un ddl est un ddl de réaction on non +bool Ddl_reaction(Enum_ddl a); + +// pour faire de l'inline +#ifndef MISE_AU_POINT + #include "Enum_ddl.cc" + #define Enum_ddl_deja_inclus +#endif + + +#endif diff --git a/Enumeration/Enum_ddl_var_static.cc b/Enumeration/Enum_ddl_var_static.cc new file mode 100644 index 0000000..a090efd --- /dev/null +++ b/Enumeration/Enum_ddl_var_static.cc @@ -0,0 +1,65 @@ +/*! \file Enum_ddl_var_static.cc + \brief def de grandeurs statiques relatives aux Enum_ddl. +*/ +// FICHIER Enum_ddl_var_static.cc + +// 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-2021 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: . + + +// fichier pour définir les variables statics utilisés par Enum_ddl + + +#include "Enum_ddl.h" +# include "ParaGlob.h" + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + +/// @addtogroup Group_types_enumeres +/// @{ + + + +/// tout d'abord on définit la map qui permet de relier les chaines et les types énumérés + /// 1) def de la map et des tableaux + map < string, Enum_ddl , std::less < string> > + ClassPourEnum_ddl::map_Enum_ddl; + + /// 2) def de la grandeur statique qui permet de remplir la map + ClassPourEnum_ddl ClassPourEnum_ddl::remplir_map; +/// @} // end of group + diff --git a/Enumeration/Enum_dure.cc b/Enumeration/Enum_dure.cc new file mode 100644 index 0000000..8d5ce79 --- /dev/null +++ b/Enumeration/Enum_dure.cc @@ -0,0 +1,151 @@ +// FICHIER Enum_dure.cp + + +// 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-2021 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: . + + +#include "Enum_dure.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + +#ifndef Enum_dure_deja_inclus + +#ifndef MISE_AU_POINT + inline +#endif +string Nom_dure (Enum_dure id_nom) +// Retourne le nom du temps associe +// a l'identificateur de type enumere id_nom +{ + + string result=""; + switch (id_nom) + { + case TEMPS_0 : + result="TEMPS_0"; + break; + case TEMPS_t : + result="TEMPS_t"; + break; + case TEMPS_tdt : + result="TEMPS_tdt"; + break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_dure !\n"; + cout << "Nom_dure(Enum_dure ) \n"; + Sortie(1); + }; + return result; + +}; + +#ifndef MISE_AU_POINT + inline +#endif +Enum_dure Id_nom_dure (const string& nom) +// Retourne la variable de type enumere associee au nom du temps +{ + + Enum_dure result; + if ( nom =="TEMPS_0") + result=TEMPS_0; + else if ( nom =="TEMPS_t") + result=TEMPS_t; + else if ( nom == "TEMPS_tdt") + result=TEMPS_tdt; + else + { + cout << "\nErreur : nom du temps " << nom << " inconnu !\n"; + cout << "Id_nom_dure (const string& nom) \n"; + Sortie(1); + }; + return result; + +}; + +#ifndef MISE_AU_POINT + inline +#endif +// test si l'identificateur de type enumere associe au nom du temps +// existe bien : ramène true s'il s'agit bien d'un type reconnu +bool Existe_nom_dure (const string& nom_ddl) +{bool retour = false; + if ( nom_ddl =="TEMPS_0") + retour = true; + else if ( nom_ddl =="TEMPS_t") + retour = true; + else if ( nom_ddl == "TEMPS_tdt") + retour = true; + else + retour = false; + return retour; +}; + + + // surcharge de l'operator de lecture +#ifndef MISE_AU_POINT + inline +#endif +istream & operator >> (istream & entree, Enum_dure& a) + { char nom_Enum_dure[50]; + entree >> nom_Enum_dure; + a = Id_nom_dure ( nom_Enum_dure); + return entree; + }; + + // surcharge de l'operator d'ecriture +#ifndef MISE_AU_POINT + inline +#endif +ostream & operator << (ostream & sort, const Enum_dure& a) + { // on ecrit la forme caractère + sort << Nom_dure(a) << " "; + return sort; + }; + +#endif + + + + + diff --git a/Enumeration/Enum_dure.h b/Enumeration/Enum_dure.h new file mode 100644 index 0000000..f70df4c --- /dev/null +++ b/Enumeration/Enum_dure.h @@ -0,0 +1,103 @@ +/*! \file Enum_dure.h + \brief Défini une énumération en temps. +* \date 19/01/2001 +*/ + +// FICHIER : Enum_dure.h + +// 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-2021 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: 19/01/2001 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Défini une énumération en temps. * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ +// Afin de realiser un gain en place memoire, et une vérification de type plus aisé qu' avec +// les entiers +// 10 carractere maxi + + +#ifndef ENUM_DURE_H +#define ENUM_DURE_H + +//#include "Debug.h" +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Défini une énumération en temps. + +enum Enum_dure { TEMPS_0 = 0, TEMPS_t , TEMPS_tdt }; +/// @} // end of group + + +// Retourne le nom du temps a partir de son identificateur de +// type enumere id_ddl correspondant +string Nom_dure ( Enum_dure id_ddl); + +// Retourne l'identificateur de type enumere associe au nom du temps +Enum_dure Id_nom_dure (const string& nom_ddl); + +// test si l'identificateur de type enumere associe au nom du temps +// existe bien : ramène true s'il s'agit bien d'un type reconnu +bool Existe_nom_dure (const string& nom_ddl); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_dure& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_dure& a); + +// pour faire de l'inline +#ifndef MISE_AU_POINT + #include "Enum_dure.cc" + #define Enum_dure_deja_inclus +#endif + +#endif diff --git a/Enumeration/Enum_geom.cc b/Enumeration/Enum_geom.cc new file mode 100644 index 0000000..0add713 --- /dev/null +++ b/Enumeration/Enum_geom.cc @@ -0,0 +1,172 @@ +// FICHIER : Enum_geom.cp + + +// 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-2021 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: . + + +#include "Enum_geom.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +string Nom_geom (const Enum_geom id_geom) +// Retourne le nom de la geometrie correspondant a l'identificateur +// de type enumere id_geom +{string result; + switch (id_geom) + {case RIEN_GEOM : result="RIEN_GEOM"; break; + case TRIANGLE : result="TRIANGLE"; break; + case QUADRANGLE : result="QUADRANGLE"; break; + case TETRAEDRE : result="TETRAEDRE"; break; + case PENTAEDRE : result="PENTAEDRE"; break; + case HEXAEDRE : result="HEXAEDRE"; break; + case TRIA_AXI : result="TRIA_AXI"; break; + case QUAD_AXI : result="QUAD_AXI"; break; + case SEGMENT : result="SEGMENT"; break; + case SEG_AXI : result="SEG_AXI"; break; + case POINT : result="POINT"; break; + case POINT_CP : result="POINT_CP"; break; + case POUT : result="POUT"; break; + case PS1 : result="PS1"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_geom !\n"; + cout << "NOM_GEOM(Enum_geom ) \n"; + Sortie(1); + }; + return result; +}; + +Enum_geom Id_nom_geom (const string& nom_geom) +// Retourne la variable de type enumere associe au nom +// de geometrie nom_geom +{ Enum_geom result; + if ( nom_geom == "RIEN_GEOM") result=RIEN_GEOM; + else if ( nom_geom == "TRIANGLE" ) result=TRIANGLE; + else if ( nom_geom == "QUADRANGLE" ) result=QUADRANGLE; + else if ( nom_geom == "TETRAEDRE" ) result=TETRAEDRE; + else if ( nom_geom == "PENTAEDRE" ) result=PENTAEDRE; + else if ( nom_geom == "HEXAEDRE" ) result=HEXAEDRE; + else if ( nom_geom == "TRIA_AXI" ) result=TRIA_AXI; + else if ( nom_geom == "QUAD_AXI" ) result=QUAD_AXI; + else if ( nom_geom == "SEGMENT" ) result=SEGMENT; + else if ( nom_geom == "SEG_AXI" ) result=SEG_AXI; + else if ( nom_geom == "POINT" ) result=POINT; + else if ( nom_geom == "POINT_CP" ) result=POINT_CP; + else if ( nom_geom == "POUT" ) result=POUT; + else if ( nom_geom == "PS1" ) result=PS1; + else + { cout << "\nErreur : nom de geometrie '" <> (istream & entree, Enum_geom & result) + { char nom_geom[35]; + entree >> nom_geom; + result = Id_nom_geom ( nom_geom); + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_geom& a) + { // on ecrit la forme caractère + sort << Nom_geom(a) << " "; + return sort; + }; + +// Retourne le type de géométrie générique: POINT_G, LIGNE, SURFACE, VOLUME, +// associée à l'Enum_geom +Enum_type_geom Type_geom_generique(const Enum_geom id_geom) +{ Enum_type_geom result; + switch (id_geom) + { case RIEN_GEOM : result=RIEN_TYPE_GEOM; break; + case TRIANGLE : result=SURFACE; break; + case QUADRANGLE : result=SURFACE; break; + case TETRAEDRE : result=VOLUME; break; + case PENTAEDRE : result=VOLUME; break; + case HEXAEDRE : result=VOLUME; break; + case TRIA_AXI : result=SURFACE; break; + case QUAD_AXI : result=SURFACE; break; + case SEGMENT : result=LIGNE; break; + case SEG_AXI : result=LIGNE; break; + case POINT : result=POINT_G; break; + case POINT_CP : result=POINT_G; break; + case POUT : result=LIGNE; break; + case PS1 : result=LIGNE; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_geom !\n"; + cout << "Type_geom_generique(const Enum_geom id_geom ) \n"; + Sortie(1); + }; + return result; +}; + +// retourne vrai s'il s'agit d'un type axisymétrique +bool TestEnum_geom_axisymetrique(const Enum_geom id_geom) +{ bool result; + switch (id_geom) + { case RIEN_GEOM : result=false; break; + case TRIANGLE : result=false; break; + case QUADRANGLE : result=false; break; + case TETRAEDRE : result=false; break; + case PENTAEDRE : result=false; break; + case HEXAEDRE : result=false; break; + case TRIA_AXI : result=true; break; + case QUAD_AXI : result=true; break; + case SEGMENT : result=false; break; + case SEG_AXI : result=true; break; + case POINT : result=false; break; + case POINT_CP : result=false; break; + case POUT : result=false; break; + case PS1 : result=false; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_geom !\n"; + cout << "TestEnum_geom_axisymetrique(const Enum_geom id_geom ) \n"; + Sortie(1); + }; + return result; +}; + diff --git a/Enumeration/Enum_geom.h b/Enumeration/Enum_geom.h new file mode 100644 index 0000000..d7623b6 --- /dev/null +++ b/Enumeration/Enum_geom.h @@ -0,0 +1,80 @@ +/*! \file Enum_geom.h + \brief Définition de l'enuméré concernant les types de modélisations de géométrie . +*/ +// FICHIER : Enum_geom.h + +// 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-2021 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: . + + +// Afin de realiser un gain en place memoire, les noms des geometrie des elements sont +// stockes a l'aide d'un type enumere. Les fonctions Nom_geom et Id_nom_geom rendent +// possible le lien entre les noms des geometries et les identificateurs +// de type enumere correspondants. + + +#ifndef ENUM_GEOM_H +#define ENUM_GEOM_H +#include +using namespace std; +#include "Enum_type_geom.h" + + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré concernant les types de modélisations de géométrie . + +enum Enum_geom { RIEN_GEOM = 1, TRIANGLE , QUADRANGLE, TETRAEDRE, PENTAEDRE, HEXAEDRE, SEGMENT + ,TRIA_AXI,QUAD_AXI,SEG_AXI + ,POINT,POINT_CP,POUT,PS1 }; +/// @} // end of group + + +//*** si on ajoute un élément, il faut penser à complèter l'énumération: Enum_PiPoCo + +// Retourne le nom d'une geometrie a partir de son identificateur de +// type enumere id_geom correspondant +string Nom_geom (const Enum_geom id_geom); + +// Retourne l'identificateur de type enumere associe au nom de geometrie +// nom_geom +Enum_geom Id_nom_geom (const string& nom_geom); + +// Retourne le type de géométrie générique: POINT_G, LIGNE, SURFACE, VOLUME, +// associée à l'Enum_geom +Enum_type_geom Type_geom_generique(const Enum_geom id_geom); +// retourne vrai s'il s'agit d'un type axisymétrique +bool TestEnum_geom_axisymetrique(const Enum_geom id_geom); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_geom& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_geom& a); + +#endif diff --git a/Enumeration/Enum_interpol.cc b/Enumeration/Enum_interpol.cc new file mode 100644 index 0000000..7a85faa --- /dev/null +++ b/Enumeration/Enum_interpol.cc @@ -0,0 +1,166 @@ +// FICHIER : Enum_interpol.cp + +// 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-2021 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: . + + + +#include "Enum_interpol.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +string Nom_interpol (const Enum_interpol id_interpol) +// Retourne le nom du type d'interpolation correspondant a l'identificateur +// de type enumere id_interpol +{ + + string result; + switch (id_interpol) + { + case RIEN_INTERPOL : result="RIEN_INTERPOL"; break; + case CONSTANT : result="CONSTANT"; break; + case LINEAIRE : result="LINEAIRE"; break; + case QUADRATIQUE : result="QUADRATIQUE"; break; + case QUADRACOMPL : result="QUADRACOMPL"; break; + case CUBIQUE : result="CUBIQUE"; break; + case CUBIQUE_INCOMPL : result="CUBIQUE_INCOMPL"; break; + case LINQUAD : result="LINQUAD"; break; + case HERMITE : result="HERMITE"; break; + case SFE1 : result="SFE1"; break; + case SFE2 : result="SFE2"; break; + case SFE3 : result="SFE3"; break; + case SFE3C : result="SFE3C"; break; + case QSFE3 : result="QSFE3"; break; + case QSFE1 : result="QSFE1"; break; + case SFE1_3D : result="SFE1_3D"; break; + case SFE2_3D : result="SFE2_3D"; break; + case SFE3_3D : result="SFE3_3D"; break; + case SFE3C_3D : result="SFE3C_3D"; break; + case SEG1 : result="SEG1"; break; + case BIE1 : result="BIE1"; break; + case BIE2 : result="BIE2"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_interpol !\n"; + cout << "NOM_INTERPOL(Enum_interpol ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_interpol Id_nom_interpol (const string& nom_interpol) +// Retourne la variable de type enumere associe au nom +// d'interpolation nom_interpol +{ + + Enum_interpol result; + if ( nom_interpol == "RIEN_INTERPOL" ) + result=RIEN_INTERPOL; + else if ( nom_interpol == "CONSTANT" ) + result=CONSTANT; + else if ( nom_interpol == "LINEAIRE" ) + result=LINEAIRE; + else if ( nom_interpol == "QUADRATIQUE" ) + result=QUADRATIQUE; + else if ( nom_interpol == "QUADRACOMPL" ) + result=QUADRACOMPL; + else if ( nom_interpol == "CUBIQUE" ) + result=CUBIQUE; + else if ( nom_interpol == "CUBIQUE_INCOMPL" ) + result=CUBIQUE_INCOMPL; + else if ( nom_interpol == "LINQUAD" ) + result=LINQUAD; + else if ( nom_interpol == "HERMITE" ) + result=HERMITE; + else if ( nom_interpol == "SFE1" ) + result=SFE1; + else if ( nom_interpol == "SFE2" ) + result=SFE2; + else if ( nom_interpol == "SFE3" ) + result=SFE3; + else if ( nom_interpol == "SFE3C" ) + result=SFE3C; + else if ( nom_interpol == "QSFE3" ) + result=QSFE3; + else if ( nom_interpol == "QSFE1" ) + result=QSFE1; + else if ( nom_interpol == "SFE1_3D" ) + result=SFE1_3D; + else if ( nom_interpol == "SFE2_3D" ) + result=SFE2_3D; + else if ( nom_interpol == "SFE3_3D" ) + result=SFE3_3D; + else if ( nom_interpol == "SFE3C_3D" ) + result=SFE3C_3D; + else if ( nom_interpol == "SEG1" ) + result=SEG1; + else if ( nom_interpol == "BIE1" ) + result=BIE1; + else if ( nom_interpol == "BIE2" ) + result=BIE2; + else + { + cout << "\nErreur : nom d'interpolation inconnu !\n"; + cout << "ID_NOM_INTERPOL(string ) \n"; + Sortie(1); + }; + return result; + +}; + +// surcharge de la lecture +istream & operator >> (istream & entree, Enum_interpol & result) + { char nom_interpol[35]; + entree >> nom_interpol; + result = Id_nom_interpol ( nom_interpol); + return entree; + }; + + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_interpol& a) + { // on ecrit la forme caractère + sort << Nom_interpol(a) << " "; + return sort; + }; + diff --git a/Enumeration/Enum_interpol.h b/Enumeration/Enum_interpol.h new file mode 100644 index 0000000..270f22b --- /dev/null +++ b/Enumeration/Enum_interpol.h @@ -0,0 +1,76 @@ +/*! \file Enum_interpol.h + \brief Définition de l'enuméré concernant les différents types d'interpolation +*/ +// FICHIER : Enum_interpol.h + +// 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-2021 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: . + + +// Afin de realiser un gain en place memoire, les noms d'interpolation des elements +// sont stockes a l'aide d'un type enumere. Les fonctions Nom_interpol et +// Id_nom_interpol rendent possible le lien entre les noms des types d'interpolation +// et les identificateurs de type enumere correspondants. + + +#ifndef ENUM_INTERPOL_H +#define ENUM_INTERPOL_H +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré concernant les différents types d'interpolation + +enum Enum_interpol { RIEN_INTERPOL = 1,CONSTANT + , LINEAIRE, QUADRATIQUE, QUADRACOMPL, CUBIQUE, CUBIQUE_INCOMPL + , LINQUAD, HERMITE, SFE1,SFE2,SFE3, SFE3C, QSFE3, QSFE1 + , SFE1_3D,SFE2_3D,SFE3_3D, SFE3C_3D, SEG1, BIE1, BIE2}; +/// @} // end of group + + +//*** si on ajoute un élément, il faut penser à complèter l'énumération: Enum_PiPoCo + +// Retourne un nom d'interpolation a partir de son identificateur de +// type enumere id_interpol correspondant +string Nom_interpol (const Enum_interpol id_interpol) ; + +// Retourne l'identificateur de type enumere associe au nom du type +// d'interpolation nom_interpol +Enum_interpol Id_nom_interpol (const string& nom_interpol); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_interpol& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_interpol& a); + + +#endif + + diff --git a/Enumeration/Enum_liaison_noeud.cc b/Enumeration/Enum_liaison_noeud.cc new file mode 100755 index 0000000..b0e294f --- /dev/null +++ b/Enumeration/Enum_liaison_noeud.cc @@ -0,0 +1,104 @@ +// FICHIER Enum_liaison_noeud.cc + + +// 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-2021 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: . + + +#include "Enum_liaison_noeud.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" + +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + +string Nom_liaison_noeud (Enum_liaison_noeud id_nom) +// Retourne le nom associe +// a l'identificateur de type enumere id_nom +{ + + string result=""; + switch (id_nom) + { + case PAS_LIER : result="PAS_LIER"; break; + case LIER_COMPLET : result="LIER_COMPLET"; break; + + default : + cout << "\nErreur : valeur incorrecte du type Enum_liaison_noeud !\n"; + cout << "Nom_liaison_noeud(Enum_liaison_noeud ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_liaison_noeud Id_nom_liaison_noeud (const string& nom) +// Retourne la variable de type enumere associee au nom +{ + + Enum_liaison_noeud result; + if ( nom == "PAS_LIER" ) result=PAS_LIER; + else if ( nom == "LIER_COMPLET" ) result=LIER_COMPLET; + else + { + cout << "\nErreur : nom ** " << nom << " ** du type de liaison inconnu !\n"; + cout << "Id_nom_liaison_noeud (const string& nom) \n"; + Sortie(1); + }; + return result; + +}; + + + // surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_liaison_noeud& a) + { string nom_Enum_liaison_noeud; + entree >> nom_Enum_liaison_noeud; + a = Id_nom_liaison_noeud ( nom_Enum_liaison_noeud); + return entree; + }; + +ostream & operator << (ostream & sort, const Enum_liaison_noeud& a) + { // on ecrit la forme caractère + sort << Nom_liaison_noeud(a) << " "; + return sort; + }; + + + + + + diff --git a/Enumeration/Enum_liaison_noeud.h b/Enumeration/Enum_liaison_noeud.h new file mode 100755 index 0000000..3534c20 --- /dev/null +++ b/Enumeration/Enum_liaison_noeud.h @@ -0,0 +1,95 @@ +/*! \file Enum_liaison_noeud.h + \brief Enuméré pour définir les différents types de liaison entre noeuds. +* \date 02/09/2016 +*/ + +// FICHIER : Enum_liaison_noeud.h + +// 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-2021 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: 02/09/2016 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Enuméré pour définir les différents types de liaison * + * entre noeuds. * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + +// Afin de realiser un gain en place memoire, et une vérification de type plus aisé qu' avec +// les entiers + + +#ifndef ENUM_LIAISON_NOEUD_H +#define ENUM_LIAISON_NOEUD_H + +//#include "Debug.h" +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Enuméré pour définir les différents types de liaison entre noeuds. + +enum Enum_liaison_noeud { PAS_LIER = 0, LIER_COMPLET }; +/// @} // end of group + + +// Retourne le nom a partir de son identificateur de +// type enumere correspondant +string Nom_liaison_noeud ( Enum_liaison_noeud id_ddl); + +// Retourne l'identificateur de type enumere associe au nom +Enum_liaison_noeud Id_nom_liaison_noeud (const string& nom); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_liaison_noeud& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_liaison_noeud& a); + + +#endif diff --git a/Enumeration/Enum_mat.cc b/Enumeration/Enum_mat.cc new file mode 100644 index 0000000..ff5d8cf --- /dev/null +++ b/Enumeration/Enum_mat.cc @@ -0,0 +1,117 @@ +// FICHIER : Enum_mat.cp + + +// 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-2021 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: . + + +#include "Enum_mat.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +char* Nom_mat (Enum_mat id_mater) +// Retourne le nom du materiau correspondant a l'identificateur +// de type enumere id_mater +{ + + char* result; + switch (id_mater) + { + case ACIER : + result="ACIER"; + break; + case BETON : + result="BETON"; + break; + case COMPOSITE : + result="COMPOSITE"; + break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_mat !\n"; + cout << "NOM_MAT(Enum_mat ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_mat Id_nom_mat (char* nom_mater) +// Retourne la variable de type enumere associe au nom +// de materiau nom_mater +{ + + Enum_mat result; + if ( strcmp(nom_mater,"ACIER")==0 ) + result=ACIER; + else if ( strcmp(nom_mater,"BETON")==0 ) + result=BETON; + else if ( strcmp(nom_mater,"COMPOSITE")==0 ) + result=COMPOSITE; + else + { + cout << "\nErreur : nom de materiau inconnu !\n"; + cout << "ID_NOM_MAT(char* ) \n"; + Sortie(1); + }; + return result; + +}; + + + // surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_mat& a) + { char nom_Enum_mat[150]; + entree >> nom_Enum_mat; + a = Id_nom_mat ( nom_Enum_mat); + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_mat& a) + { // on ecrit la forme caractère + sort << Nom_mat(a) << " "; + return sort; + }; + + + diff --git a/Enumeration/Enum_mat.h b/Enumeration/Enum_mat.h new file mode 100644 index 0000000..058bd7c --- /dev/null +++ b/Enumeration/Enum_mat.h @@ -0,0 +1,70 @@ +/*! \file Enum_mat.h + \brief Définition de l'enuméré concernant les types de matériau. +*/ +// FICHIER : Enum_mat.h + +// 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-2021 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: . + + +// Afin de realiser un gain en place memoire, les noms de materiaux sont +// stockes a l'aide d'un type enumere. Les fonctions Nom_mat et Id_nom_mat rendent +// possible le lien entre le nom des materiaux et les identificateurs +// de type enumere correspondants. + + +#ifndef ENUM_MAT_H +#define ENUM_MAT_H +#include +using namespace std; + + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré concernant les types de matériau. + +enum Enum_mat { ACIER=1, BETON, COMPOSITE }; +/// @} // end of group + + + +// Retourne le nom d'un materiau a partir de son identificateur de +// type enumere id_mater correspondant +char* Nom_mat (Enum_mat id_mater); + +// Retourne l'identificateur de type enumere associe au nom de +// materiau nom_mater +Enum_mat Id_nom_mat (char* nom_mater); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_mat& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_mat& a); + +#endif diff --git a/Enumeration/Enum_matrice.cc b/Enumeration/Enum_matrice.cc new file mode 100755 index 0000000..ec3eade --- /dev/null +++ b/Enumeration/Enum_matrice.cc @@ -0,0 +1,227 @@ +// FICHIER : Enum_matrice.cp + + +// 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-2021 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: . + + +#include "Enum_matrice.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +string Nom_matrice(Enum_matrice id_matrice) +// Retourne le nom du type de matrice correspondant a l'identificateur +// de type enumere id_matrice +{ + string result; + switch (id_matrice) + {case RIEN_MATRICE : result="RIEN_MATRICE"; break; + case CARREE : result="CARREE"; break; + case CARREE_SYMETRIQUE : result="CARREE_SYMETRIQUE"; break; + case RECTANGLE : result="RECTANGLE"; break; + case BANDE_SYMETRIQUE : result="BANDE_SYMETRIQUE"; break; + case BANDE_NON_SYMETRIQUE: result="BANDE_NON_SYMETRIQUE"; break; + case CARREE_LAPACK : result="CARREE_LAPACK"; break; + case CARREE_SYMETRIQUE_LAPACK : result="CARREE_SYMETRIQUE_LAPACK"; break; + case RECTANGLE_LAPACK : result="RECTANGLE_LAPACK"; break; + case BANDE_SYMETRIQUE_LAPACK : result="BANDE_SYMETRIQUE_LAPACK"; break; + case BANDE_NON_SYMETRIQUE_LAPACK : result="BANDE_NON_SYMETRIQUE_LAPACK"; break; + case TRIDIAGONALE_GENE_LAPACK : result="TRIDIAGONALE_GENE_LAPACK"; break; + case TRIDIAGONALE_DEF_POSITIVE_LAPACK : result="TRIDIAGONALE_DEF_POSITIVE_LAPACK"; break; + case CREUSE_NON_COMPRESSEE : result="CREUSE_NON_COMPRESSEE"; break; + case CREUSE_COMPRESSEE_COLONNE : result="CREUSE_COMPRESSEE_COLONNE"; break; + case CREUSE_COMPRESSEE_LIGNE : result="CREUSE_COMPRESSEE_LIGNE"; break; + case DIAGONALE : result="DIAGONALE"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_matrice !\n"; + cout << "Nom_matrice(Enum_matrice ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_matrice Id_nom_matrice(const string& nom_matrice) +// Retourne la variable de type enumere associe au nom +// de matrice nom_matrice +{ + + Enum_matrice result; + if ( nom_matrice == "RIEN_MATRICE" ) + result=RIEN_MATRICE; + else if ( nom_matrice == "CARREE" ) + result=CARREE; + else if ( nom_matrice == "CARREE_SYMETRIQUE" ) + result=CARREE_SYMETRIQUE; + else if ( nom_matrice == "RECTANGLE" ) + result=RECTANGLE; + else if ( nom_matrice == "BANDE_SYMETRIQUE" ) + result=BANDE_SYMETRIQUE; + else if ( nom_matrice == "BANDE_NON_SYMETRIQUE" ) + result=BANDE_NON_SYMETRIQUE; + else if ( nom_matrice == "CARREE_LAPACK" ) + result=CARREE_LAPACK; + else if ( nom_matrice == "CARREE_SYMETRIQUE_LAPACK" ) + result=CARREE_SYMETRIQUE_LAPACK; + else if ( nom_matrice == "RECTANGLE_LAPACK" ) + result=RECTANGLE_LAPACK; + else if ( nom_matrice == "BANDE_SYMETRIQUE_LAPACK" ) + result=BANDE_SYMETRIQUE_LAPACK; + else if ( nom_matrice == "BANDE_NON_SYMETRIQUE_LAPACK" ) + result=BANDE_NON_SYMETRIQUE_LAPACK; + else if ( nom_matrice == "TRIDIAGONALE_GENE_LAPACK" ) + result=TRIDIAGONALE_GENE_LAPACK; + else if ( nom_matrice == "TRIDIAGONALE_DEF_POSITIVE_LAPACK" ) + result=TRIDIAGONALE_DEF_POSITIVE_LAPACK; + else if ( nom_matrice == "CREUSE_NON_COMPRESSEE" ) + result=CREUSE_NON_COMPRESSEE; + else if ( nom_matrice == "CREUSE_COMPRESSEE_COLONNE" ) + result=CREUSE_COMPRESSEE_COLONNE; + else if ( nom_matrice == "CREUSE_COMPRESSEE_LIGNE" ) + result=CREUSE_COMPRESSEE_LIGNE; + else if ( nom_matrice == "DIAGONALE" ) + result=DIAGONALE; + else + { + cout << "\nErreur : nom de matrice inconnu !\n"; + cout << "Id_nom_interpol(string ) \n"; + Sortie(1); + }; + return result; + +}; + +// indique si le type existe ou pas, -> 1 ou 0 +int Existe_Enum_matrice(string& nom_matrice) + +{ + + int result; + if ( nom_matrice == "RIEN_MATRICE" ) + result=1; + else if ( nom_matrice == "CARREE" ) + result=1; + else if ( nom_matrice == "CARREE_SYMETRIQUE" ) + result=1; + else if ( nom_matrice == "RECTANGLE" ) + result=1; + else if ( nom_matrice == "BANDE_SYMETRIQUE" ) + result=1; + else if ( nom_matrice == "BANDE_NON_SYMETRIQUE" ) + result=1; + else if ( nom_matrice == "CARREE_LAPACK" ) + result=1; + else if ( nom_matrice == "CARREE_SYMETRIQUE_LAPACK" ) + result=1; + else if ( nom_matrice == "RECTANGLE_LAPACK" ) + result=1; + else if ( nom_matrice == "BANDE_SYMETRIQUE_LAPACK" ) + result=1; + else if ( nom_matrice == "BANDE_NON_SYMETRIQUE_LAPACK" ) + result=1; + else if ( nom_matrice == "TRIDIAGONALE_GENE_LAPACK" ) + result=1; + else if ( nom_matrice == "TRIDIAGONALE_DEF_POSITIVE_LAPACK" ) + result=1; + else if ( nom_matrice == "CREUSE_NON_COMPRESSEE" ) + result=1; + else if ( nom_matrice == "CREUSE_COMPRESSEE_COLONNE" ) + result=1; + else if ( nom_matrice == "CREUSE_COMPRESSEE_LIGNE" ) + result=1; + else if ( nom_matrice == "DIAGONALE" ) + result=1; + else + {result = 0;}; + return result; + +}; + +// indique si la matrice est de part son type, symétrique ou pas +bool Symetrique_Enum_matrice(Enum_matrice id_matrice) +{ + bool result; + switch (id_matrice) + {case RIEN_MATRICE : result=false; break; + case CARREE : result=false; break; + case CARREE_SYMETRIQUE : result=true; break; + case RECTANGLE : result=false; break; + case BANDE_SYMETRIQUE : result=true; break; + case BANDE_NON_SYMETRIQUE: result=false; break; + case CARREE_LAPACK : result=false; break; + case CARREE_SYMETRIQUE_LAPACK : result=true; break; + case RECTANGLE_LAPACK : result=false; break; + case BANDE_SYMETRIQUE_LAPACK : result=true; break; + case BANDE_NON_SYMETRIQUE_LAPACK : result=false; break; + case TRIDIAGONALE_GENE_LAPACK : result=false; break; + case TRIDIAGONALE_DEF_POSITIVE_LAPACK : result=false; break; + case CREUSE_NON_COMPRESSEE : result=false; break; + case CREUSE_COMPRESSEE_COLONNE : result=false; break; + case CREUSE_COMPRESSEE_LIGNE : result=false; break; + case DIAGONALE : result=true; break; + default : + cout << "\nErreur : valeur incorrecte (id_matrice="<< id_matrice <<") du type Enum_matrice !\n"; + cout << "\n Symetrique(Enum_matrice id_matrice) \n"; + Sortie(1); + }; + return result; + +}; + + +// surcharge de la lecture +istream & operator >> (istream & entree, Enum_matrice & result) + { char nom_matrice[80]; + entree >> nom_matrice; + result = Id_nom_matrice ( nom_matrice); + return entree; + }; + + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_matrice& a) + { // on ecrit la forme caractère + sort << Nom_matrice(a) << " "; + return sort; + }; + diff --git a/Enumeration/Enum_matrice.h b/Enumeration/Enum_matrice.h new file mode 100644 index 0000000..9506344 --- /dev/null +++ b/Enumeration/Enum_matrice.h @@ -0,0 +1,102 @@ +/*! \file Enum_matrice.h + \brief Enumeration des differents type de matrice possible. +* \date 26/12/00 +*/ + +// FICHIER : Enum_matrice.h + +// 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-2021 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: 26/12/00 * + * $ * + * AUTEUR: G RIO * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Enumeration des differents type de matrice possible. * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + +#ifndef ENUMTYPEMATRICE_H +#define ENUMTYPEMATRICE_H + +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Enumeration des differents type de matrice possible. + +enum Enum_matrice { RIEN_MATRICE = 1,CARREE, CARREE_SYMETRIQUE, RECTANGLE + , BANDE_SYMETRIQUE, BANDE_NON_SYMETRIQUE + ,CARREE_LAPACK,CARREE_SYMETRIQUE_LAPACK, RECTANGLE_LAPACK,BANDE_SYMETRIQUE_LAPACK, BANDE_NON_SYMETRIQUE_LAPACK + ,TRIDIAGONALE_GENE_LAPACK , TRIDIAGONALE_DEF_POSITIVE_LAPACK + ,CREUSE_NON_COMPRESSEE, CREUSE_COMPRESSEE_COLONNE, CREUSE_COMPRESSEE_LIGNE, DIAGONALE }; +/// @} // end of group + + + +// Retourne un nom de type de matrice a partir de son identificateur de +// type enumere id_matrice correspondant +string Nom_matrice(Enum_matrice id_matrice); + +// Retourne l'identificateur de type enumere associe au nom du type +// de matrice nom_matrice +Enum_matrice Id_nom_matrice (const string& nom_matrice); + +// indique si le type existe ou pas, -> 1 ou 0 +int Existe_Enum_matrice(string& nom_matrice); + +// indique si la matrice est de part son type, symétrique ou pas +bool Symetrique_Enum_matrice(Enum_matrice id_matrice); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_matrice& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_matrice& a); + + +#endif + + diff --git a/Enumeration/Enum_proj_aniso.cc b/Enumeration/Enum_proj_aniso.cc new file mode 100755 index 0000000..8786364 --- /dev/null +++ b/Enumeration/Enum_proj_aniso.cc @@ -0,0 +1,120 @@ +// FICHIER Enum_proj_aniso.cc + +// 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-2021 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: . + + + +#include "Enum_proj_aniso.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + +// Retourne le nom a partir de son identificateur de type enumere +string Nom_proj_aniso (Enum_proj_aniso id_nom) +{string result=""; + switch (id_nom) + { + case AUCUNE_PROJ_ANISO : + result="AUCUNE_PROJ_ANISO"; + break; + case PROJ_ORTHO : + result="PROJ_ORTHO"; + break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_proj_aniso !\n"; + cout << "Nom_proj_aniso(Enum_proj_aniso ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_proj_aniso Id_Nom_proj_aniso (const string& nom_proj_aniso) +// Retourne la variable de type enumere associee au nom +{ + + Enum_proj_aniso result; + if ( nom_proj_aniso == "AUCUNE_PROJ_ANISO" ) + result=AUCUNE_PROJ_ANISO; + else if ( nom_proj_aniso == "PROJ_ORTHO") + result=PROJ_ORTHO; + else + { + cout << "\nErreur : nom " << nom_proj_aniso << " type de critere de loi inconnue !\n"; + cout << "Id_Nom_proj_aniso (const string& nom_proj_aniso) \n"; + Sortie(1); + }; + return result; + +}; + + +// Retourne vrai si le nom passé en argument représente un type reconnu +// sinon false +bool Type_Enum_proj_aniso_existe(const string& nom) +{ bool result; + if ( nom == "PROJ_ORTHO") {result=true;} + else if ( nom == "AUCUNE_PROJ_ANISO") {result=true;} + else {result = false;} + return result; +}; + + // surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_proj_aniso& a) + { string nom_Enum_proj_aniso; + entree >> nom_Enum_proj_aniso; + a = Id_Nom_proj_aniso ( nom_Enum_proj_aniso); + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_proj_aniso& a) + { // on ecrit la forme caractère + sort << Nom_proj_aniso(a) << " "; + return sort; + }; + + + + + + diff --git a/Enumeration/Enum_proj_aniso.h b/Enumeration/Enum_proj_aniso.h new file mode 100755 index 0000000..d38505c --- /dev/null +++ b/Enumeration/Enum_proj_aniso.h @@ -0,0 +1,95 @@ +/*! \file Enum_Proj_aniso.h + \brief Enumeration des différentes méthodes concernant les techniques de projection anisotrope +* \date 11/06/2019 +*/ + +// FICHIER : Enum_Proj_aniso.h + +// 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-2021 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: 11/06/2019 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + * BUT: Enumeration des différentes méthodes concernant * + * les techniques de projection anisotrope * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + + +#ifndef ENUM_PROJ_ANISO_H +#define ENUM_PROJ_ANISO_H +#include +#include +#include +using namespace std; //introduces namespace std +#include + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Enumeration des différentes méthodes concernant les techniques de projection anisotrope + +enum Enum_proj_aniso { AUCUNE_PROJ_ANISO = 0, PROJ_ORTHO }; +/// @} // end of group + + + +// Retourne le nom a partir de son identificateur de type enumere +string Nom_proj_aniso(Enum_proj_aniso id_proj_aniso); + +// Retourne l'identificateur de type enumere associe au nom d'un proj_aniso +Enum_proj_aniso Id_Nom_proj_aniso(const string& nom_proj_aniso) ; + +// Retourne vrai si le nom passé en argument représente un type de proj_aniso reconnu +// sinon false +bool Type_Enum_proj_aniso_existe(const string& nom); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_proj_aniso& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_proj_aniso& a); + +#endif diff --git a/Enumeration/Enum_suite.h b/Enumeration/Enum_suite.h new file mode 100644 index 0000000..b6c3887 --- /dev/null +++ b/Enumeration/Enum_suite.h @@ -0,0 +1,96 @@ +/*! \file Enum_Suite.h + \brief Enumeration des différentes Suites existantes +* \date 19/01/2001 +*/ + +// FICHIER : Enum_Suite.h + +// 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-2021 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: 19/01/2001 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Enumeration des différentes Suites existantes * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + + +#ifndef ENUM_SUITE_H +#define ENUM_SUITE_H +#include +#include +#include +using namespace std; //introduces namespace std +#include + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Enumeration des différentes Suites existantes + +enum Enum_Suite { SUITE_EQUIDISTANTE = 1, SUITE_ARITHMETIQUE, SUITE_GEOMETRIQUE + ,SUITE_NON_DEFINIE}; +/// @} // end of group + + + +// Retourne le nom d'une Suite a partir de son identificateur de +// type enumere id_Suite correspondant +char* Nom_Suite (Enum_Suite id_Suite); + +// Retourne l'identificateur de type enumere associe au nom d'une Suite +Enum_Suite Id_Nom_Suite (const char* nom_Suite) ; + +// Retourne vrai si le nom passé en argument représente un type de suite reconnu +// sinon false +bool Type_Enum_Suite_existe(const string& nom); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_Suite& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_Suite& a); + +#endif diff --git a/Enumeration/Enum_type_deformation.cc b/Enumeration/Enum_type_deformation.cc new file mode 100644 index 0000000..a1fc681 --- /dev/null +++ b/Enumeration/Enum_type_deformation.cc @@ -0,0 +1,128 @@ +// FICHIER Enum_type_deformation.cp + + +// 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-2021 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: . + + +#include "Enum_type_deformation.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + +#ifndef Enum_type_deformation_deja_inclus + +#ifndef MISE_AU_POINT + inline +#endif +string Nom_type_deformation (const Enum_type_deformation id_nom) +// Retourne le nom du type de deformation associe +// a l'identificateur de type enumere id_nom +{ string result=""; + switch (id_nom) + {case DEFORMATION_STANDART : result=" DEFORMATION_STANDART"; break; + case DEFORMATION_POUTRE_PLAQUE_STANDART : result="DEFORMATION_POUTRE_PLAQUE_STANDART"; break; + case DEFORMATION_LOGARITHMIQUE : result="DEFORMATION_LOGARITHMIQUE"; break; + case DEF_CUMUL_CORROTATIONNEL : result="DEF_CUMUL_CORROTATIONNEL"; break; + case DEF_CUMUL_ROTATION_PROPRE : result="DEF_CUMUL_ROTATION_PROPRE"; break; + case DEFORMATION_CUMU_LOGARITHMIQUE : result="DEFORMATION_CUMU_LOGARITHMIQUE"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_type_deformation !\n"; + cout << "Nom_type_deformation(Enum_type_deformation ) \n"; + Sortie(1); + }; + return result; +}; + +#ifndef MISE_AU_POINT + inline +#endif +Enum_type_deformation Id_nom_type_deformation (const string& nom) +// Retourne la variable de type enumere associee au nom du type de deformation +{Enum_type_deformation result; + if ( nom == "DEFORMATION_STANDART" ) + result=DEFORMATION_STANDART; + else if ( nom == "DEFORMATION_POUTRE_PLAQUE_STANDART" ) + result=DEFORMATION_POUTRE_PLAQUE_STANDART; + else if ( nom == "DEFORMATION_LOGARITHMIQUE" ) + result=DEFORMATION_LOGARITHMIQUE; + else if ( nom == "DEF_CUMUL_CORROTATIONNEL" ) + result=DEF_CUMUL_CORROTATIONNEL; + else if ( nom == "DEF_CUMUL_ROTATION_PROPRE" ) + result=DEF_CUMUL_ROTATION_PROPRE; + else if ( nom == "DEFORMATION_CUMU_LOGARITHMIQUE" ) + result=DEFORMATION_CUMU_LOGARITHMIQUE; + else + {cout << "\nErreur : nom du degre de liberte inconnu !\n"; + cout << "Id_nom_type_deformation (char* nom) \n"; + Sortie(1); + }; + return result; +}; + + + // surcharge de l'operator de lecture +#ifndef MISE_AU_POINT + inline +#endif +istream & operator >> (istream & entree, Enum_type_deformation& a) + { char nom_Enum_type_deformation[50]; + entree >> nom_Enum_type_deformation; + a = Id_nom_type_deformation ( nom_Enum_type_deformation); + return entree; + }; + + // surcharge de l'operator d'ecriture +#ifndef MISE_AU_POINT + inline +#endif +ostream & operator << (ostream & sort, const Enum_type_deformation& a) + { // on ecrit la forme caractère + sort << Nom_type_deformation(a) << " "; + return sort; + }; + +#endif + + + + + diff --git a/Enumeration/Enum_type_deformation.h b/Enumeration/Enum_type_deformation.h new file mode 100644 index 0000000..7eda062 --- /dev/null +++ b/Enumeration/Enum_type_deformation.h @@ -0,0 +1,100 @@ +/*! \file Enum_type_deformation.h + \brief Défini une énumération des différents types de déformations +* \date 28/03/2003 +*/ + +// FICHIER : Enum_type_deformation.h + +// 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-2021 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: 28/03/2003 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Défini une énumération des différents types de déformations.* + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ +// Afin de realiser un gain en place memoire, et une vérification de type plus aisé qu' avec +// les entiers + + +#ifndef ENUM_TYPE_DEFORMATION_H +#define ENUM_TYPE_DEFORMATION_H + +//#include "Debug.h" +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Défini une énumération des différents types de déformations + +enum Enum_type_deformation { DEFORMATION_STANDART=1, DEFORMATION_POUTRE_PLAQUE_STANDART + ,DEFORMATION_LOGARITHMIQUE,DEF_CUMUL_CORROTATIONNEL,DEF_CUMUL_ROTATION_PROPRE + ,DEFORMATION_CUMU_LOGARITHMIQUE}; +/// @} // end of group + + +// Retourne le nom du type de deformation a partir de son identificateur de +// type enumere id_ddl correspondant +string Nom_type_deformation ( const Enum_type_deformation id_ddl) ; + +// Retourne l'identificateur de type enumere associe au nom du type de deformation + Enum_type_deformation Id_nom_type_deformation (const string& nom_ddl) ; + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_type_deformation& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_type_deformation& a); + +// pour faire de l'inline +#ifndef MISE_AU_POINT + #include "Enum_type_deformation.cc" + #define Enum_type_deformation_deja_inclus +#endif + +#endif diff --git a/Enumeration/Enum_type_geom.cc b/Enumeration/Enum_type_geom.cc new file mode 100644 index 0000000..8a9e1dc --- /dev/null +++ b/Enumeration/Enum_type_geom.cc @@ -0,0 +1,108 @@ +// FICHIER : Enum_type_geom.cp + + +// 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-2021 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: . + + +#include "Enum_type_geom.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +string Nom_type_geom (const Enum_type_geom id_type_geom) +// Retourne le nom de la geometrie correspondant a l'identificateur +// de type enumere id_type_geom +{ + + string result; + switch (id_type_geom) + { case RIEN_TYPE_GEOM : result="RIEN_TYPE_GEOM"; break; + case POINT_G : result="POINT_G"; break; + case LIGNE : result="LIGNE"; break; + case SURFACE : result="SURFACE"; break; + case VOLUME : result="VOLUME"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_type_geom !\n"; + cout << "Nom_type_geom(Enum_type_geom ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_type_geom Id_nom_type_geom (const string& nom_type_geom) +// Retourne la variable de type enumere associe au nom +// de geometrie nom_type_geom +{ + + Enum_type_geom result; + if ( nom_type_geom == "RIEN_TYPE_GEOM" ) result=RIEN_TYPE_GEOM; + else if ( nom_type_geom == "POINT_G" ) result=POINT_G; + else if ( nom_type_geom == "LIGNE" ) result=LIGNE; + else if ( nom_type_geom == "SURFACE" ) result=SURFACE; + else if ( nom_type_geom == "VOLUME" ) result=VOLUME; + else + { cout << "\nErreur : nom de geometrie '" <> (istream & entree, Enum_type_geom & result) + { string nom_type_geom; + entree >> nom_type_geom; + result = Id_nom_type_geom ( nom_type_geom); + return entree; + }; + + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_type_geom& a) + { // on ecrit la forme caractère + sort << Nom_type_geom(a) << " "; + return sort; + }; + diff --git a/Enumeration/Enum_type_geom.h b/Enumeration/Enum_type_geom.h new file mode 100644 index 0000000..595aa1b --- /dev/null +++ b/Enumeration/Enum_type_geom.h @@ -0,0 +1,69 @@ +/*! \file Enum_type_geom.h + \brief def de l'enuméré concernant les types de géométrie +*/ +// FICHIER : Enum_type_geom.h + +// 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-2021 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: . + + +// Afin de realiser un gain en place memoire, les noms des geometrie des elements sont +// stockes a l'aide d'un type enumere. Les fonctions Nom_type_geom et Id_nom_type_geom rendent +// possible le lien entre les noms des geometries et les identificateurs +// de type enumere correspondants. + + +#ifndef ENUM_TYPE_GEOM_H +#define ENUM_TYPE_GEOM_H +#include +using namespace std; + + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré concernant les types de géométrie + +enum Enum_type_geom { POINT_G = 1 , LIGNE , SURFACE, VOLUME, RIEN_TYPE_GEOM }; +/// @} // end of group + + +// Retourne le nom d'une geometrie a partir de son identificateur de +// type enumere id_type_geom correspondant +string Nom_type_geom (const Enum_type_geom id_type_geom); + +// Retourne l'identificateur de type enumere associe au nom de geometrie +// nom_type_geom +Enum_type_geom Id_nom_type_geom (const string& nom_type_geom); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_type_geom& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_type_geom& a); + +#endif diff --git a/Enumeration/Enum_type_pt_integ.cc b/Enumeration/Enum_type_pt_integ.cc new file mode 100644 index 0000000..770bb27 --- /dev/null +++ b/Enumeration/Enum_type_pt_integ.cc @@ -0,0 +1,106 @@ +// FICHIER : Enum_type_pt_integ.cc + +// 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-2021 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: . + + + +#include "Enum_type_pt_integ.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + + +string Nom_Enum_type_pt_integ(const Enum_type_pt_integ id_type_pt_integ) +// Retourne un nom de type de point d'integ a partir de son identificateur de +// type enumere correspondant +{ + + string result; + switch (id_type_pt_integ) + { + case PTI_GAUSS : result="PTI_GAUSS"; break; + case PTI_GAUSS_LOBATTO : result="PTI_GAUSS_LOBATTO"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_type_pt_integ !\n"; + cout << "Nom_Enum_type_pt_integ(const Enum_type_pt_integ id_type_pt_integ) \n"; + Sortie(1); + }; + return result; + +}; + +// Retourne l'identificateur de type enumere associe au nom du type +// d'interpolation +Enum_type_pt_integ Id_nom_type_pt_integ (const string& nom_type_pt_integ) +{ + + Enum_type_pt_integ result; + if ( nom_type_pt_integ == "PTI_GAUSS" ) + result=PTI_GAUSS; + else if ( nom_type_pt_integ == "PTI_GAUSS_LOBATTO" ) + result=PTI_GAUSS_LOBATTO; + else + { + cout << "\nErreur : nom de type de point d'integration inconnu !\n"; + cout << "Id_nom_type_pt_integ (const string nom_type_pt_integ) \n"; + Sortie(1); + }; + return result; + +}; + +// surcharge de la lecture +istream & operator >> (istream & entree, Enum_type_pt_integ & result) + { string nom_type_pt_integ; + entree >> nom_type_pt_integ; + result = Id_nom_type_pt_integ( nom_type_pt_integ); + return entree; + }; + + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_type_pt_integ& a) + { // on ecrit la forme caractère + sort << Nom_Enum_type_pt_integ(a) << " "; + return sort; + }; + diff --git a/Enumeration/Enum_type_pt_integ.h b/Enumeration/Enum_type_pt_integ.h new file mode 100644 index 0000000..9fa7893 --- /dev/null +++ b/Enumeration/Enum_type_pt_integ.h @@ -0,0 +1,71 @@ +/*! \file Enum_type_pt_integ.h + \brief def de l'enuméré concernant les types de point d'intégration +*/ +// FICHIER : Enum_type_pt_integ.h + +// 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-2021 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: . + + +// Afin de realiser un gain en place memoire, les noms d'interpolation des elements +// sont stockes a l'aide d'un type enumere. Les fonctions Nom_Enum_type_pt_integ et +// Id_nom_type_pt_integ rendent possible le lien entre les noms des types +// et les identificateurs de type enumere correspondants. + + +#ifndef ENUM_TYPE_PT_INTEG_H +#define ENUM_TYPE_PT_INTEG_H +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré concernant les types de point d'intégration + +enum Enum_type_pt_integ{ PTI_GAUSS = 1,PTI_GAUSS_LOBATTO}; +/// @} // end of group + + +// Retourne un nom de type de point d'integ a partir de son identificateur de +// type enumere correspondant +string Nom_Enum_type_pt_integ (const Enum_type_pt_integ id_type_pt_integ) ; + +// Retourne l'identificateur de type enumere associe au nom du type +// d'interpolation +Enum_type_pt_integ Id_nom_type_pt_integ (const string& nom_type_pt_integ); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_type_pt_integ& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_type_pt_integ& a); + + +#endif + + diff --git a/Enumeration/Enum_type_resolution_matri.cc b/Enumeration/Enum_type_resolution_matri.cc new file mode 100755 index 0000000..d2247f2 --- /dev/null +++ b/Enumeration/Enum_type_resolution_matri.cc @@ -0,0 +1,287 @@ +// FICHIER : Enum_type_resolution_matri.cp + + +// 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-2021 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: . + + +#include "Enum_type_resolution_matri.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + +// =================================================================== +// cas du type de résolution +// =================================================================== + +string Nom_resolution (Enum_type_resolution_matri id_resolution) +// Retourne le nom du type de resolution correspondant a l'identificateur +// de type enumere id_resolution +{ + + string result; + switch (id_resolution) + { + case RIEN_TYPE_RESOLUTION_MATRI : result="RIEN_TYPE_RESOLUTION_MATRI"; break; + case CHOLESKY : result="CHOLESKY"; break; + case SYMETRISATION_PUIS_CHOLESKY : result="SYMETRISATION_PUIS_CHOLESKY"; break; + case GAUSS : result="GAUSS"; break; + case GAUSS_EXPERT : result="GAUSS_EXPERT"; break; + case BI_CONJUG : result="BI_CONJUG"; break; + case BI_CONJUG_STAB : result="BI_CONJUG_STAB"; break; + case CONJUG_GRAD : result="CONJUG_GRAD"; break; + case CONJUG_GRAD_SQUARE : result="CONJUG_GRAD_SQUARE"; break; + case CHEBYSHEV : result="CHEBYSHEV"; break; + case GENE_MINI_RESIDUAL : result="GENE_MINI_RESIDUAL"; break; + case ITERATION_RICHARSON : result="ITERATION_RICHARSON"; break; + case QUASI_MINI_RESIDUAL : result="QUASI_MINI_RESIDUAL"; break; + case DIRECT_DIAGONAL : result="DIRECT_DIAGONAL"; break; + case CRAMER : result="CRAMER"; break; + case LU_EQUILIBRE : result="LU_EQUILIBRE"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_type_resolution_matri !\n"; + cout << "Nom_resolution(Enum_type_resolution_matri ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_type_resolution_matri Id_nom_resolution (string& nom_resolution) +// Retourne la variable de type enumere associe au nom +// de resolution nom_resolution +{ + + Enum_type_resolution_matri result; + if ( nom_resolution == "RIEN_TYPE_RESOLUTION_MATRI" ) + result=RIEN_TYPE_RESOLUTION_MATRI; + else if ( nom_resolution == "SYMETRISATION_PUIS_CHOLESKY" ) + result=SYMETRISATION_PUIS_CHOLESKY; + else if ( nom_resolution == "CHOLESKY" ) + result=CHOLESKY; + else if ( nom_resolution == "GAUSS" ) + result=GAUSS; + else if ( nom_resolution == "GAUSS_EXPERT" ) + result=GAUSS_EXPERT; + else if ( nom_resolution == "BI_CONJUG" ) + result=BI_CONJUG; + else if ( nom_resolution == "BI_CONJUG_STAB" ) + result=BI_CONJUG_STAB; + else if ( nom_resolution == "CONJUG_GRAD" ) + result=CONJUG_GRAD; + else if ( nom_resolution == "CONJUG_GRAD_SQUARE" ) + result=CONJUG_GRAD_SQUARE; + else if ( nom_resolution == "CHEBYSHEV" ) + result=CHEBYSHEV; + else if ( nom_resolution == "GENE_MINI_RESIDUAL" ) + result=GENE_MINI_RESIDUAL; + else if ( nom_resolution == "ITERATION_RICHARSON" ) + result=ITERATION_RICHARSON; + else if ( nom_resolution == "QUASI_MINI_RESIDUAL" ) + result=QUASI_MINI_RESIDUAL; + else if ( nom_resolution == "DIRECT_DIAGONAL" ) + result=DIRECT_DIAGONAL; + else if ( nom_resolution == "CRAMER" ) + result=CRAMER; + else if ( nom_resolution == "LU_EQUILIBRE" ) + result=LU_EQUILIBRE; + else + { string toto(nom_resolution); + cout << "\nErreur : nom de resolution inconnu != " << toto <<"\n"; + cout << "Id_nom_resolution(string ) \n"; + Sortie(1); + }; + return result; + +}; + +// indique si le type existe ou pas, -> 1 ou 0 +int Existe_Enum_type_resolution_matri(string& nom_resolution) +{ + + int result; + if ( nom_resolution == "RIEN_TYPE_RESOLUTION_MATRI" ) + result=1; + else if ( nom_resolution == "SYMETRISATION_PUIS_CHOLESKY" ) + result=1; + else if ( nom_resolution == "CHOLESKY" ) + result=1; + else if ( nom_resolution == "GAUSS" ) + result=1; + else if ( nom_resolution == "GAUSS_EXPERT" ) + result=0; // pour l'instant n'est pas utilisé + else if ( nom_resolution == "BI_CONJUG" ) + result=1; + else if ( nom_resolution == "BI_CONJUG_STAB" ) + result=1; + else if ( nom_resolution == "CONJUG_GRAD" ) + result=1; + else if ( nom_resolution == "CONJUG_GRAD_SQUARE" ) + result=1; + else if ( nom_resolution == "CHEBYSHEV" ) + result=1; + else if ( nom_resolution == "GENE_MINI_RESIDUAL" ) + result=1; + else if ( nom_resolution == "ITERATION_RICHARSON" ) + result=1; + else if ( nom_resolution == "QUASI_MINI_RESIDUAL" ) + result=1; + else if ( nom_resolution == "DIRECT_DIAGONAL" ) + result=1; + else if ( nom_resolution == "CRAMER" ) + result=1; + else if ( nom_resolution == "LU_EQUILIBRE" ) + result=1; + else + { result = 0;}; + return result; + +}; + + +// surcharge de la lecture +istream & operator >> (istream & entree, Enum_type_resolution_matri & result) + { string nom_resolution; + entree >> nom_resolution; + result = Id_nom_resolution ( nom_resolution); + return entree; + }; + + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_type_resolution_matri& a) + { // on ecrit la forme caractère + sort << Nom_resolution(a) << " "; + return sort; + }; + +// =================================================================== +// cas du type de préconditionnement +// =================================================================== + +string Nom_preconditionnement (Enum_preconditionnement id_preconditionnement) +// Retourne le nom du type de preconditionnement correspondant a l'identificateur +// de type enumere id_preconditionnement +{ + + string result; + switch (id_preconditionnement) + { + case RIEN_PRECONDITIONNEMENT : + result="RIEN_PRECONDITIONNEMENT"; + break; + case DIAGONAL : + result="DIAGONAL"; + break; + case ICP : + result="ICP"; + break; + case ILU : + result="ILU"; + break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_preconditionnement !\n"; + cout << "Nom_preconditionnement(Enum_preconditionnement ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_preconditionnement Id_nom_preconditionnement (string nom_preconditionnement) +// Retourne la variable de type enumere associe au nom +// de preconditionnement nom_preconditionnement +{ + + Enum_preconditionnement result; + if ( nom_preconditionnement == "RIEN_PRECONDITIONNEMENT" ) + result=RIEN_PRECONDITIONNEMENT; + else if ( nom_preconditionnement == "DIAGONAL" ) + result=DIAGONAL; + else if ( nom_preconditionnement == "ICP" ) + result=ICP; + else if ( nom_preconditionnement == "ILU" ) + result=ILU; + else + { + cout << "\nErreur : nom de preconditionnement inconnu !\n"; + cout << "Id_nom_preconditionnement(string ) \n"; + Sortie(1); + }; + return result; + +}; + +// indique si le type existe ou pas, -> 1 ou 0 +int Existe_Enum_preconditionnement(string& nom_preconditionnement) +{ + + int result; + if ( nom_preconditionnement == "RIEN_PRECONDITIONNEMENT" ) + result=1; + else if ( nom_preconditionnement == "DIAGONAL" ) + result=1; + else if ( nom_preconditionnement == "ICP" ) + result=1; + else if ( nom_preconditionnement == "ILU" ) + result=1; + else + {result = 0;}; + return result; + +}; + + +// surcharge de la lecture +istream & operator >> (istream & entree, Enum_preconditionnement & result) + { char nom_preconditionnement[45]; + entree >> nom_preconditionnement; + result = Id_nom_preconditionnement ( nom_preconditionnement); + return entree; + }; + + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_preconditionnement& a) + { // on ecrit la forme caractère + sort << Nom_preconditionnement(a) << " "; + return sort; + }; diff --git a/Enumeration/Enum_type_resolution_matri.h b/Enumeration/Enum_type_resolution_matri.h new file mode 100644 index 0000000..688aab6 --- /dev/null +++ b/Enumeration/Enum_type_resolution_matri.h @@ -0,0 +1,131 @@ +/*! \file Enum_type_resolution_matri.h + \brief Enumeration des differents type de résolution de systèmes matricielle possible, ainsi que du préconditionnement éventuel. +* \date 03/01/01 +*/ + +// FICHIER : Enum_type_resolution_matri.h + +// 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-2021 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: 03/01/01 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Enumeration des differents type de résolution de systèmes * + * matricielle possible, ainsi que du préconditionnement * + * éventuel. * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + +#ifndef ENUM_TYPE_RESOLUTION_MATRI_H +#define ENUM_TYPE_RESOLUTION_MATRI_H + +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Enumeration des differents type de résolution de systèmes matricielle possible. + +enum Enum_type_resolution_matri { RIEN_TYPE_RESOLUTION_MATRI = 1,CHOLESKY, SYMETRISATION_PUIS_CHOLESKY, GAUSS, GAUSS_EXPERT, + BI_CONJUG, BI_CONJUG_STAB, CONJUG_GRAD, CONJUG_GRAD_SQUARE, CHEBYSHEV, GENE_MINI_RESIDUAL + ,ITERATION_RICHARSON, QUASI_MINI_RESIDUAL ,DIRECT_DIAGONAL, CRAMER, LU_EQUILIBRE}; + /// @} // end of group + + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Enumeration des differents type de préconditionnement éventuel. + +enum Enum_preconditionnement { RIEN_PRECONDITIONNEMENT = 1, DIAGONAL, ICP, ILU }; + /// @} // end of group + + + +// =================================================================== +// cas du type de résolution +// =================================================================== + +// Retourne un nom de type de résolution a partir de son identificateur de +// type enumere id_resolution correspondant +string Nom_resolution (Enum_type_resolution_matri id_resolution); + +// Retourne l'identificateur de type enumere associe au nom du type +// de resolution nom_resolution +Enum_type_resolution_matri Id_nom_resolution (string& nom_resolution); + +// indique si le type existe ou pas, -> 1 ou 0 +int Existe_Enum_type_resolution_matri(string& nom_resolution); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_type_resolution_matri& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_type_resolution_matri& a); + +// =================================================================== +// cas du type de préconditionnement +// =================================================================== + +// Retourne un nom de type de preconditionnement a partir de son identificateur de +// type enumere id_preconditionnement correspondant +string Nom_preconditionnement (Enum_preconditionnement id_preconditionnement); + +// Retourne l'identificateur de type enumere associe au nom du type +// de preconditionnement nom_preconditionnement +Enum_preconditionnement Id_nom_preconditionnement (string nom_preconditionnement); + +// indique si le type existe ou pas, -> 1 ou 0 +int Existe_Enum_preconditionnement(string& nom_preconditionnement); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_preconditionnement& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_preconditionnement& a); + +#endif + + diff --git a/Enumeration/Enum_type_stocke_deformation.cc b/Enumeration/Enum_type_stocke_deformation.cc new file mode 100644 index 0000000..6aea8b7 --- /dev/null +++ b/Enumeration/Enum_type_stocke_deformation.cc @@ -0,0 +1,129 @@ + +// FICHIER Enum_type_stocke_deformation.cc + + +// 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-2021 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: . + + +#include "Enum_type_stocke_deformation.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + + +#ifndef Enum_type_stocke_deformation_deja_inclus + +#ifndef MISE_AU_POINT + inline +#endif +char* Nom_type_stockage_def (Enum_type_stocke_deformation id_nom) +// Retourne le nom du type associe +// a l'identificateur de type enumere id_nom +{ + + char* result=""; + switch (id_nom) + { + case SAVEDEFRESUL_GENERAL : + result="SAVEDEFRESUL_GENERAL"; + break; + case SAVEDEFRESUL_SFE1 : + result="SAVEDEFRESUL_SFE1"; + break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_type_stocke_deformation !\n"; + cout << "Nom_dure(Enum_type_stocke_deformation ) \n"; + Sortie(1); + }; + return result; + +}; + +#ifndef MISE_AU_POINT + inline +#endif +Enum_type_stocke_deformation Id_nom_type_stockage_def (char* nom) +// Retourne la variable de type enumere associee au nom du type +{ + + Enum_type_stocke_deformation result; + if ( strcmp(nom,"SAVEDEFRESUL_GENERAL")==0 ) + result=SAVEDEFRESUL_GENERAL; + else if ( strcmp(nom,"SAVEDEFRESUL_SFE1")==0 ) + result=SAVEDEFRESUL_SFE1; + else + { + cout << "\nErreur : nom du degre de liberte inconnu !\n"; + cout << "Id_nom_dure (char* nom) \n"; + Sortie(1); + }; + return result; + +}; + + + // surcharge de l'operator de lecture +#ifndef MISE_AU_POINT + inline +#endif +istream & operator >> (istream & entree, Enum_type_stocke_deformation& a) + { char nom_Enum_type_stocke_deformation[50]; + entree >> nom_Enum_type_stocke_deformation; + a = Id_nom_type_stockage_def ( nom_Enum_type_stocke_deformation); + return entree; + }; + + // surcharge de l'operator d'ecriture +#ifndef MISE_AU_POINT + inline +#endif +ostream & operator << (ostream & sort, const Enum_type_stocke_deformation& a) + { // on ecrit la forme caractère + sort << Nom_type_stockage_def(a) << " "; + return sort; + }; + +#endif + + + + + diff --git a/Enumeration/Enum_type_stocke_deformation.h b/Enumeration/Enum_type_stocke_deformation.h new file mode 100644 index 0000000..7def5d6 --- /dev/null +++ b/Enumeration/Enum_type_stocke_deformation.h @@ -0,0 +1,100 @@ +/*! \file Enum_type_stocke_deformation.h + \brief Définir une énumération pour les type de stockage pour les données de déformations à chaque pt de gauss. +* \date 25/mai/2007 +*/ + +// FICHIER : Enum_type_stocke_deformation.h + +// 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-2021 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: 25/mai/2007 * + * $ * + * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Définir une énumération pour les type de stockage pour * + * les données de déformations à chaque pt de gauss. * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ +// Afin de realiser un gain en place memoire, et une vérification de type plus aisé qu' avec +// les entiers +// 30 carracteres maxi + + +#ifndef ENUM_TYPE_STOCKE_DEFORMATION_H +#define ENUM_TYPE_STOCKE_DEFORMATION_H + +//#include "Debug.h" +#include +using namespace std; + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définir une énumération pour les type de stockage pour les données de déformations à chaque pt de gauss. + +enum Enum_type_stocke_deformation { SAVEDEFRESUL_GENERAL = 0, SAVEDEFRESUL_SFE1 }; +/// @} // end of group + + +// Retourne le nom du type a partir de son identificateur de +// type enumere id_ddl correspondant +char* Nom_type_stockage_def ( Enum_type_stocke_deformation id_ddl); + +// Retourne l'identificateur de type enumere associe au nom du type + Enum_type_stocke_deformation Id_nom_type_stockage_def (char* nom_ddl); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_type_stocke_deformation& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_type_stocke_deformation& a); + +// pour faire de l'inline +#ifndef MISE_AU_POINT + #include "Enum_type_stocke_deformation.cc" + #define Enum_type_stocke_deformation_deja_inclus +#endif + +#endif diff --git a/Enumeration/Enum_variable_metrique.cc b/Enumeration/Enum_variable_metrique.cc new file mode 100644 index 0000000..df9cd6d --- /dev/null +++ b/Enumeration/Enum_variable_metrique.cc @@ -0,0 +1,281 @@ +// FICHIER : Enum_variable_metrique.cc + + +// 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-2021 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: . + + +#include "Enum_variable_metrique.h" + + +# include +using namespace std; //introduces namespace std +#include +#include "Sortie.h" +//#ifdef SYSTEM_MAC_OS_X +// #include // a priori ce n'est pas portable +//#el +#if defined SYSTEM_MAC_OS_CARBON + #include // a priori ce n'est pas portable +#else + #include // pour le flot en memoire centrale +#endif +#include + +char* Nom_Enum_variable_metrique (Enum_variable_metrique id_nom) +// Retourne le nom en caractère correspondant a l'identificateur +// de type enumere id_mater +{ + + char* result; + switch (id_nom) + { + case iM0 :result="iM0";break; + case iMt :result="iMt";break; + case idMt :result="idMt";break; + case iMtdt :result="iMtdt";break; + case idMtdt :result="idMtdt";break; + case iV0 :result="iV0";break; + case iVt :result="iVt";break; + case idVt :result="idVt";break; + case iVtdt :result="iVtdt";break; + case idVtdt :result="idVtdt";break; + case igiB_0 :result="igiB_0";break; + case igiB_t :result="igiB_t";break; + case igiB_tdt :result="igiB_tdt";break; + case igiH_0 :result="igiH_0";break; + case igiH_t :result="igiH_t";break; + case igiH_tdt :result="igiH_tdt";break; + case igijBB_0 :result="igijBB_0";break; + case igijBB_t :result="igijBB_t";break; + case igijBB_tdt :result="igijBB_tdt";break; + case igijHH_0 :result="igijHH_0";break; + case igijHH_t :result="igijHH_t";break; + case igijHH_tdt :result="igijHH_tdt";break; + case id_giB_t :result="id_giB_t";break; + case id_giB_tdt :result="id_giB_tdt";break; + case id_giH_t :result="id_giH_t";break; + case id_giH_tdt :result="id_giH_tdt";break; + case id_gijBB_t :result="id_gijBB_t";break; + case id_gijBB_tdt :result="id_gijBB_tdt";break; + case id_gijHH_t : result="id_gijHH_t"; break; + case id_gijHH_tdt : result="id_gijHH_tdt"; break; + case id_jacobien_t : result="id_jacobien_t"; break; + case id_jacobien_tdt : result="id_jacobien_tdt"; break; + case id2_gijBB_tdt : result="id2_gijBB_tdt"; break; + case igradVmoyBB_t : result="igradVBB_t"; break; + case igradVmoyBB_tdt : result="igradVBB_tdt"; break; + case igradVBB_t : result="igradVBB_t"; break; + case igradVBB_tdt : result="igradVBB_tdt"; break; + case id_gradVmoyBB_t : result="id_gradVBB_t"; break; + case id_gradVmoyBB_tdt : result="id_gradVBB_tdt"; break; + case id_gradVBB_t : result="id_gradVBB_t"; break; + case id_gradVBB_tdt : result="id_gradVBB_tdt"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_variable_metrique !\n"; + cout << "Nom_Enum_variable_metrique(Enum_variable_metrique ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_variable_metrique Id_nom_Enum_variable_metrique (char* nom) +// Retourne la variable de type enumere associe au nom +{ + + Enum_variable_metrique result; + if ( strcmp(nom,"iM0")==0 ) result=iM0; + else if ( strcmp(nom,"iMt")==0 ) result=iMt; + else if ( strcmp(nom,"idMt")==0 ) result=idMt; + else if ( strcmp(nom,"iMtdt")==0 ) result=iMtdt; + else if ( strcmp(nom,"idMtdt")==0 ) result=idMtdt; + else if ( strcmp(nom,"iV0")==0 ) result=iV0; + else if ( strcmp(nom,"iVt")==0 ) result=iVt; + else if ( strcmp(nom,"idVt")==0 ) result=idVt; + else if ( strcmp(nom,"iVtdt")==0 ) result=iVtdt; + else if ( strcmp(nom,"idVtdt")==0 ) result=idVtdt; + else if ( strcmp(nom,"igiB_0")==0 ) result=igiB_0; + else if ( strcmp(nom,"igiB_t")==0 ) result=igiB_t; + else if ( strcmp(nom,"igiB_tdt")==0 ) result=igiB_tdt; + else if ( strcmp(nom,"igiH_0")==0 ) result=igiH_0; + else if ( strcmp(nom,"igiH_t")==0 ) result=igiH_t; + else if ( strcmp(nom,"igiH_tdt")==0 ) result=igiH_tdt; + else if ( strcmp(nom,"igijBB_0")==0 ) result=igijBB_0; + else if ( strcmp(nom,"igijBB_t")==0 ) result=igijBB_t; + else if ( strcmp(nom,"igijBB_tdt")==0 ) result=igijBB_tdt; + else if ( strcmp(nom,"igijHH_0")==0 ) result=igijHH_0; + else if ( strcmp(nom,"igijHH_t")==0 ) result=igijHH_t; + else if ( strcmp(nom,"igijHH_tdt")==0 ) result=igijHH_tdt; + else if ( strcmp(nom,"id_giB_t")==0 ) result=id_giB_t; + else if ( strcmp(nom,"id_giB_tdt")==0 ) result=id_giB_tdt; + else if ( strcmp(nom,"id_giH_t")==0 ) result=id_giH_t; + else if ( strcmp(nom,"id_giH_tdt")==0 ) result=id_giH_tdt; + else if ( strcmp(nom,"id_gijBB_t")==0 ) result=id_gijBB_t; + else if ( strcmp(nom,"id_gijBB_tdt")==0 ) result=id_gijBB_tdt; + else if ( strcmp(nom,"id_gijHH_t")==0 ) result=id_gijHH_t; + else if ( strcmp(nom,"id_gijHH_tdt")==0 ) result=id_gijHH_tdt; + else if ( strcmp(nom,"id_jacobien_t")==0 ) result=id_jacobien_t; + else if ( strcmp(nom,"id_jacobien_tdt")==0 ) result=id_jacobien_tdt; + else if ( strcmp(nom,"id2_gijBB_tdt")==0 ) result=id2_gijBB_tdt; + else if ( strcmp(nom,"igradVmoyBB_t")==0 ) result=igradVBB_t; + else if ( strcmp(nom,"igradVmoyBB_tdt")==0 ) result=igradVBB_tdt; + else if ( strcmp(nom,"igradVBB_t")==0 ) result=igradVBB_t; + else if ( strcmp(nom,"igradVBB_tdt")==0 ) result=igradVBB_tdt; + else if ( strcmp(nom,"id_gradVmoyBB_t")==0 ) result=id_gradVBB_t; + else if ( strcmp(nom,"id_gradVmoyBB_tdt")==0 ) result=id_gradVBB_tdt; + else if ( strcmp(nom,"id_gradVBB_t")==0 ) result=id_gradVBB_t; + else if ( strcmp(nom,"id_gradVBB_tdt")==0 ) result=id_gradVBB_tdt; + else + { + cout << "\nErreur : nom inconnu !\n"; + cout << "Id_nom_Enum_variable_metrique(char* ) \n"; + Sortie(1); + }; + return result; + +}; + + + // surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_variable_metrique& a) + { char nom_Enum_variable_metrique[150]; + entree >> nom_Enum_variable_metrique; + a = Id_nom_Enum_variable_metrique ( nom_Enum_variable_metrique); + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_variable_metrique& a) + { // on ecrit la forme caractère + sort << Nom_Enum_variable_metrique(a) << " "; + return sort; + }; + + +char* Nom_Enum_variable_metsfe (Enum_variable_metsfe id_nom) +// Retourne le nom en caractère correspondant a l'identificateur +// de type enumere id_mater +{ + + char* result; + switch (id_nom) + { + case iP0 :result="iP0";break; + case iPt :result="iPt";break; + case idPt :result="idPt";break; + case iPtdt :result="iPtdt";break; + case idPtdt :result="idPtdt";break; + case iaiB_0 :result="iaiB_0";break; + case iaiB_t :result="iaiB_t";break; + case iaiB_tdt :result="iaiB_tdt";break; + case iaiH_0 :result="iaiH_0";break; + case iaiH_t :result="iaiH_t";break; + case iaiH_tdt :result="iaiH_tdt";break; + case iaijBB_0 :result="iaijBB_0";break; + case iaijBB_t :result="iaijBB_t";break; + case iaijBB_tdt :result="iaijBB_tdt";break; + case iaijHH_0 :result="iaijHH_0";break; + case iaijHH_t :result="iaijHH_t";break; + case iaijHH_tdt :result="iaijHH_tdt";break; + case id_aiB_t :result="id_aiB_t";break; + case id_aiB_tdt :result="id_aiB_tdt";break; + case id_aiH_t :result="id_aiH_t";break; + case id_aiH_tdt :result="id_aiH_tdt";break; + case id_aijBB_t :result="id_aijBB_t";break; + case id_aijBB_tdt :result="id_aijBB_tdt";break; + case id_aijHH_t : result="id_aijHH_t"; break; + case id_aijHH_tdt : result="id_aijHH_tdt"; break; + case id_ajacobien_t : result="id_ajacobien_t"; break; + case id_ajacobien_tdt : result="id_ajacobien_tdt"; break; + default : + cout << "\nErreur : valeur incorrecte du type Enum_variable_metsfe !\n"; + cout << "Nom_Enum_variable_metsfe(Enum_variable_metsfe ) \n"; + Sortie(1); + }; + return result; + +}; + +Enum_variable_metsfe Id_nom_Enum_variable_metsfe (char* nom) +// Retourne la variable de type enumere associe au nom +{ + + Enum_variable_metsfe result; + if ( strcmp(nom,"iP0")==0 ) result=iP0; + else if ( strcmp(nom,"iPt")==0 ) result=iPt; + else if ( strcmp(nom,"idPt")==0 ) result=idPt; + else if ( strcmp(nom,"iPtdt")==0 ) result=iPtdt; + else if ( strcmp(nom,"idPtdt")==0 ) result=idPtdt; + else if ( strcmp(nom,"iaiB_0")==0 ) result=iaiB_0; + else if ( strcmp(nom,"iaiB_t")==0 ) result=iaiB_t; + else if ( strcmp(nom,"iaiB_tdt")==0 ) result=iaiB_tdt; + else if ( strcmp(nom,"iaiH_0")==0 ) result=iaiH_0; + else if ( strcmp(nom,"iaiH_t")==0 ) result=iaiH_t; + else if ( strcmp(nom,"iaiH_tdt")==0 ) result=iaiH_tdt; + else if ( strcmp(nom,"iaijBB_0")==0 ) result=iaijBB_0; + else if ( strcmp(nom,"iaijBB_t")==0 ) result=iaijBB_t; + else if ( strcmp(nom,"iaijBB_tdt")==0 ) result=iaijBB_tdt; + else if ( strcmp(nom,"iaijHH_0")==0 ) result=iaijHH_0; + else if ( strcmp(nom,"iaijHH_t")==0 ) result=iaijHH_t; + else if ( strcmp(nom,"iaijHH_tdt")==0 ) result=iaijHH_tdt; + else if ( strcmp(nom,"id_aiB_t")==0 ) result=id_aiB_t; + else if ( strcmp(nom,"id_aiB_tdt")==0 ) result=id_aiB_tdt; + else if ( strcmp(nom,"id_aiH_t")==0 ) result=id_aiH_t; + else if ( strcmp(nom,"id_aiH_tdt")==0 ) result=id_aiH_tdt; + else if ( strcmp(nom,"id_aijBB_t")==0 ) result=id_aijBB_t; + else if ( strcmp(nom,"id_aijBB_tdt")==0 ) result=id_aijBB_tdt; + else if ( strcmp(nom,"id_aijHH_t")==0 ) result=id_aijHH_t; + else if ( strcmp(nom,"id_aijHH_tdt")==0 ) result=id_aijHH_tdt; + else if ( strcmp(nom,"id_ajacobien_t")==0 ) result=id_ajacobien_t; + else if ( strcmp(nom,"id_ajacobien_tdt")==0 ) result=id_ajacobien_tdt; + else + { + cout << "\nErreur : nom inconnu !\n"; + cout << "Id_nom_Enum_variable_metsfe(char* ) \n"; + Sortie(1); + }; + return result; + +}; + + + // surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_variable_metsfe& a) + { char nom_Enum_variable_metsfe[150]; + entree >> nom_Enum_variable_metsfe; + a = Id_nom_Enum_variable_metsfe ( nom_Enum_variable_metsfe); + return entree; + }; + + // surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_variable_metsfe& a) + { // on ecrit la forme caractère + sort << Nom_Enum_variable_metsfe(a) << " "; + return sort; + }; diff --git a/Enumeration/Enum_variable_metrique.h b/Enumeration/Enum_variable_metrique.h new file mode 100644 index 0000000..82c6e99 --- /dev/null +++ b/Enumeration/Enum_variable_metrique.h @@ -0,0 +1,107 @@ +/*! \file Enum_variable_metrique.h + \brief Définition de l'enuméré concernant les grandeurs gérées par les classes métriques +*/ + + +// 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-2021 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: . + + +// FICHIER : Enum_variable_metrique.h + +// Afin de realiser un gain en place memoire, les noms des variables privees utilisees +//dans la classe Met_abstraite sont +// stockes a l'aide d'un type enumere. Les fonctions Nom_Enum_variable_metrique +// et Id_nom_Enum_variable_metrique rendent +// possible le lien entre le nom en charactère et les identificateurs +// de type enumere correspondants. + + +#ifndef ENUM_ENUM_VARIABLE_METRIQUE_H +#define ENUM_ENUM_VARIABLE_METRIQUE_H +#include +using namespace std; + + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré concernant les grandeurs gérées par les classes métriques générales + +enum Enum_variable_metrique { iM0 =1, iMt, idMt, iMtdt, idMtdt, iV0, iVt, idVt, iVtdt, idVtdt + , igiB_0 , igiB_t, igiB_tdt, + igiH_0, igiH_t, igiH_tdt, igijBB_0, igijBB_t, igijBB_tdt, igijHH_0, igijHH_t, + igijHH_tdt, id_giB_t, id_giB_tdt, + id_giH_t, id_giH_tdt, id_gijBB_t, id_gijBB_tdt, id_gijHH_t, id_gijHH_tdt, + id_jacobien_t , id_jacobien_tdt + , id2_gijBB_tdt // variation seconde de la déformation + ,igradVmoyBB_t,igradVmoyBB_tdt,igradVBB_t,igradVBB_tdt // gradient de vitesse moyen et instantannée + ,id_gradVmoyBB_t,id_gradVmoyBB_tdt,id_gradVBB_t,id_gradVBB_tdt // variation du gradient de vitesse + }; +/// @} // end of group + +/// @addtogroup Group_types_enumeres +/// @{ + +/// Définition de l'enuméré concernant les grandeurs spécifiques gérées par les classes métriques plaques, coques et poutres + +enum Enum_variable_metsfe { iP0 =1, iPt, idPt, iPtdt, idPtdt + , iaiB_0 , iaiB_t, iaiB_tdt, + iaiH_0, iaiH_t, iaiH_tdt, iaijBB_0, iaijBB_t, iaijBB_tdt, iaijHH_0, iaijHH_t, + iaijHH_tdt, id_aiB_t, id_aiB_tdt, + id_aiH_t, id_aiH_tdt, id_aijBB_t, id_aijBB_tdt, id_aijHH_t, id_aijHH_tdt, + id_ajacobien_t , id_ajacobien_tdt + }; +/// @} // end of group + + +// Retourne la chaine a partir de son identificateur de +// type enumere id_nom correspondant +char* Nom_Enum_variable_metrique (Enum_variable_metrique id_nom); + +// Retourne l'identificateur de type enumere associe au nom +Enum_variable_metrique Id_nom_Enum_variable_metrique (char* nom); + +// Retourne la chaine a partir de son identificateur de +// type enumere id_nom correspondant +char* Nom_Enum_variable_metsfe (Enum_variable_metsfe id_nom); + +// Retourne l'identificateur de type enumere associe au nom +Enum_variable_metsfe Id_nom_Enum_variable_metsfe (char* nom); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_variable_metrique& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_variable_metrique& a); + +// surcharge de l'operator de lecture +istream & operator >> (istream & entree, Enum_variable_metsfe& a); +// surcharge de l'operator d'ecriture +ostream & operator << (ostream & sort, const Enum_variable_metsfe& a); + +#endif diff --git a/Enumeration/MotCle.cc b/Enumeration/MotCle.cc new file mode 100644 index 0000000..434b91f --- /dev/null +++ b/Enumeration/MotCle.cc @@ -0,0 +1,116 @@ + +// 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-2021 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: . + + +#include "MotCle.h" +#include "string.h" + + // CONSTRUCTEURS : + MotCle::MotCle ( const Tableau& TsousMot) : + lesmotscles(),tabSous(TsousMot),TabSous_taille(TsousMot.Taille()) + { + + lesmotscles.push_back("dynamique_implicite"); lesmotscles.push_back("dynamique_explicite"); + lesmotscles.push_back("dynamique_explicite_tchamwa");lesmotscles.push_back("dynamique_explicite_chung_lee"); + lesmotscles.push_back("dynamique_explicite_zhai"); lesmotscles.push_back("dynamique_Runge_Kutta"); + lesmotscles.push_back("non_dynamique"); lesmotscles.push_back("non_dynamique_avec_contact"); + lesmotscles.push_back("flambement_lineaire_en_implicite_non_dynamique"); + lesmotscles.push_back("informations"); + lesmotscles.push_back("utilitaires"); lesmotscles.push_back("def_schema_xml"); + lesmotscles.push_back("umat_abaqus"); lesmotscles.push_back("dynamique_explicite_bonelli"); + lesmotscles.push_back("dynamique_relaxation_dynam"); lesmotscles.push_back("mixte_statique_dynamique_explicite"); + lesmotscles.push_back("combiner"); + lesmotscles.push_back("TYPE_DE_CALCUL"); lesmotscles.push_back("PARA_TYPE_DE_CALCUL"); + lesmotscles.push_back("==PARA_SPECIFIQUE_SOUS_ALGO=="); + lesmotscles.push_back("==FIN_PARA_SPECIFIQUE_SOUS_ALGO_=="); + lesmotscles.push_back("domaine_esclave"); lesmotscles.push_back("pas_de_sortie_finale_"); + lesmotscles.push_back("nom_maillage"); lesmotscles.push_back("mvt_maitre"); + lesmotscles.push_back("les_courbes_1D"); lesmotscles.push_back("les_fonctions_nD"); + lesmotscles.push_back("choix_materiaux"); lesmotscles.push_back("materiaux"); + lesmotscles.push_back("epaisseurs"); lesmotscles.push_back("largeurs"); + lesmotscles.push_back("inerties"); lesmotscles.push_back("sections"); + lesmotscles.push_back("variation_section"); + lesmotscles.push_back("integrale_sur_volume_"); + lesmotscles.push_back("integrale_sur_vol_et_temps_"); + lesmotscles.push_back("orthotropie"); lesmotscles.push_back("reperes_locaux"); + lesmotscles.push_back("statistique_sur_RefNoeuds_"); + lesmotscles.push_back("statistique_sur_RefNoeuds_et_temps_"); + lesmotscles.push_back("charges"); lesmotscles.push_back("blocages"); + lesmotscles.push_back("masse_addi"); lesmotscles.push_back("initialisation"); + lesmotscles.push_back("typecharge"); lesmotscles.push_back("controle"); + lesmotscles.push_back("controle_contact"); lesmotscles.push_back("noeuds"); + lesmotscles.push_back("elements"); lesmotscles.push_back("resultats"); + lesmotscles.push_back("nom_maillage"); lesmotscles.push_back("flotExterne"); + lesmotscles.push_back("para_syteme_lineaire"); lesmotscles.push_back("para_pilotage_equi_global"); + lesmotscles.push_back("para_dedies_dynamique"); lesmotscles.push_back("para_affichage"); + lesmotscles.push_back("masse_volumique"); lesmotscles.push_back("dilatation_thermique"); + lesmotscles.push_back("para_contact"); lesmotscles.push_back("def_mouvement_solide_initiaux_"); + lesmotscles.push_back("zone_contact"); lesmotscles.push_back("auto_contact"); + lesmotscles.push_back("glue_contact"); lesmotscles.push_back("contact_solide_deformable"); + lesmotscles.push_back("para_calculs_geometriques"); lesmotscles.push_back("para_energie"); + lesmotscles.push_back("condition_limite_lineaire_"); lesmotscles.push_back("renumerotation_tous_maillages_"); + lesmotscles.push_back("renumerotation_des_noeuds_"); lesmotscles.push_back("hourglass_gestion_"); + lesmotscles.push_back("stabilisation_transvers_membrane_biel_"); + lesmotscles.push_back("suppression_noeud_non_references_"); + lesmotscles.push_back("fusion_avec_le_maillage_precedent_"); + lesmotscles.push_back("def_auto_ref_frontiere_"); lesmotscles.push_back("_suite_point_info_"); + lesmotscles.push_back("_fin_point_info_"); lesmotscles.push_back("_pause_point_info_"); + lesmotscles.push_back("repere_anisotropie_"); lesmotscles.push_back("Constantes_utilisateurs_"); + lesmotscles.push_back("Mise_A_jour_Constantes_utilisateurs_"); + lesmotscles_taille=lesmotscles.size(); // la taille + itdeb=lesmotscles.begin(); itfin=lesmotscles.end(); + }; + + +bool MotCle::SimotCle(char* tabcar) + { // recherche dans les mots cles principaux + for (it=itdeb ; it != itfin; it++) + {//string toto = (*it); +// if(strstr(tabcar,(*it))!=NULL) + if(strstr(tabcar,((char*) (*it).c_str())) != NULL) + { +// #ifdef MISE_AU_POINT +// if (ParaGlob::NiveauImpression() > 7) +// { cout << "\n MotCle::SimotCle(... " +// << "\n tabcar= "< + +/// @addtogroup Group_types_enumeres +/// @{ + +/// ici l'énuméré est remplacé par une classe + +class MotCle +{ + public : + // VARIABLES PUBLIQUES : + + + // CONSTRUCTEURS : + MotCle ( const Tableau& TsousMot = tab_Zero_string ); + // DESTRUCTEUR : + ~MotCle () {}; + // METHODES PUBLIQUES : + + /// retourne true s'il y a un mot cle dans la chaine de character + /// false sinon + bool SimotCle(char* tabcar); + + private : + // VARIABLES PROTEGEES : + list lesmotscles; // liste des mots clés + Tableau tabSous; + int TabSous_taille; + int lesmotscles_taille; + list ::iterator itdeb,itfin,it; + }; + /// @} // end of group + + +#endif