rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

introduction des fichiers relatifs aux énumérations globales

Browse source
This commit is contained in:
Gérard Rio 2021-09-15 12:00:56 +02:00
parent 35b39c1586
commit 6021f832fa
86 changed files with 14774 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

130
Enumeration/EnuTypeCL.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "EnuTypeCL.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
// 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 '" <<nom_TypeCL << " 'inconnu !\n";
cout << "Id_nomTypeCL(char* ) \n";
Sortie(1);
};
// retour de la grandeur
return (*il).second;
};
EnuTypeCL Id_nomTypeCL (string& 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 '" <<nom_TypeCL << " 'inconnu !\n";
cout << "Id_nomTypeCL(string& ) \n";
Sortie(1);
};
// retour de la grandeur
return (*il).second;
};
// indique si le string correspond à un type CL reconnu ou non
bool Existe_typeCL(string& nom)
{ return ( ClassPourEnuTypeCL::map_EnuTypeCL.find(nom)
!= ClassPourEnuTypeCL::map_EnuTypeCL.end());};
// surcharge de la lecture
istream & operator >> (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;
};

115
Enumeration/EnuTypeCL.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
using namespace std;
#include <map>
#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

183
Enumeration/EnuTypeQuelParticulier.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "EnuTypeQuelParticulier.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
// 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 '" <<nom_TypeQuelParticulier << " 'inconnu !\n";
cout << "Id_nomTypeQuelParticulier(char* ) \n";
Sortie(1);
};
// retour de la grandeur
return (*il).second;
};
EnuTypeQuelParticulier Id_nomTypeQuelParticulier (string& 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 '" <<nom_TypeQuelParticulier << " 'inconnu !\n";
cout << "Id_nomTypeQuelParticulier(string& ) \n";
Sortie(1);
};
// retour de la grandeur
return (*il).second;
};
// indique si le string correspond à un type quelParticulier reconnu ou non
bool Existe_typeQuelParticulier(string& nom)
{ return ( ClassPourEnuTypeQuelParticulier::map_EnuTypeQuelParticulier.find(nom)
!= ClassPourEnuTypeQuelParticulier::map_EnuTypeQuelParticulier.end());};
// surcharge de la lecture
istream & operator >> (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;
};

110
Enumeration/EnuTypeQuelParticulier.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
using namespace std;
#include <map>
#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

203
Enumeration/EnumCourbe1D.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "EnumCourbe1D.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

103
Enumeration/EnumCourbe1D.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
using namespace std;
#include <string.h>
#include <string>
#include <stdlib.h>
/// @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

180
Enumeration/EnumElemTypeProblem.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "EnumElemTypeProblem.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
#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

84
Enumeration/EnumElemTypeProblem.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <bool.h>
#include <iostream>
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

125
Enumeration/EnumFonction_nD.cc Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "EnumFonction_nD.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

98
Enumeration/EnumFonction_nD.h Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
using namespace std;
#include <string.h>
#include <string>
#include <stdlib.h>
/// @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

112
Enumeration/EnumLangue.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "EnumLangue.h"
# include <iostream>
#include <stdlib.h>
using namespace std; //introduces namespace std
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd> // a priori ce n'est pas portable
#else
#include <string> // pour le flot en memoire centrale
#endif
#include <string>
#include <string.h>
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;
};

93
Enumeration/EnumLangue.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
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

851
Enumeration/EnumTypeCalcul.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "EnumTypeCalcul.h"
#include <stdlib.h>
#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<EnumSousTypeCalcul> & sousTypeCalcul
,list<bool>& 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<EnumSousTypeCalcul> & sousTypeCalcul
,list<bool>& 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 "<<endl;
c = getchar(); // on lit quand même le caractère
}
else // sinon on peut lire
{std::getline (std::cin,rep);
// a priori les prochaines lectures vont utilisées un getline
};
// si la taille de rep == 0 cela veut dire que c'est un retour chariot
if (rep.size()==0)
{rep = "7";
cout << "--> valeur par defaut : 7 "<<endl;
};
if (rep == "fin_prog") {Sortie(1);}
else // sinon
num = ChangeEntier(rep);
if ((num >= 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 "<<endl;
c = getchar(); // on lit quand même le caractère
non_choix_defaut=true;
}
else // sinon on peut lire
{std::getline (std::cin,rep);
// a priori les prochaines lectures vont utilisées un getline
};
if (rep.size()==0)
{rep = "5";
cout << "--> valeur par defaut : 5 "<<endl;
non_choix_defaut=true;
};
if (rep == "fin_prog") {Sortie(1);}
else // sinon
num = ChangeEntier(rep);
//cout << "\n debug info_commande_type_calcul: num= "<< num << flush;
if (rep == "f") num = -1; // cas particulier pour la sortie
if ((num >= -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;
};

172
Enumeration/EnumTypeCalcul.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 23/01/97 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: Enumeration des differents type de calcul possible. *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef ENUMTYPECALCUL_H
#define ENUMTYPECALCUL_H
#include <iostream>
using namespace std;
#include "UtilLecture.h"
#include <list>
/// @addtogroup Group_types_enumeres
/// @{
/// identificateur principal du type de Calcul
enum EnumTypeCalcul { DYNA_IMP = 1, DYNA_EXP,DYNA_EXP_TCHAMWA,DYNA_EXP_CHUNG_LEE,DYNA_EXP_ZHAI,
DYNA_RUNGE_KUTTA,NON_DYNA, NON_DYNA_CONT,
FLAMB_LINEAIRE,INFORMATIONS,UTILITAIRES,DEF_SCHEMA_XML,RIEN_TYPECALCUL,
UMAT_ABAQUS, DYNA_EXP_BONELLI , RELAX_DYNA, STAT_DYNA_EXP ,
COMBINER
};
/// @} // end of group
/// @addtogroup Group_types_enumeres
/// @{
/// identificateur secondaire optionnel du type de Calcul renseigne par exemple
/// sur le fait de calculer l'erreur, une relocation, un raffinement, etc ..
enum EnumSousTypeCalcul { aucun_soustypedecalcul =1, avec_remonte , avec_remonte_erreur,
avec_remonte_erreur_relocation, avec_remonte_erreur_raffinement_relocation,
remonte,remonte_erreur,remonte_erreur_relocation,remonte_erreur_raffinement_relocation,
frontieres,visualisation,LinVersQuad,QuadIncVersQuadComp,relocPtMilieuQuad,sauveCommandesVisu,
lectureCommandesVisu,commandeInteractive,sauveMaillagesEnCours,extrusion2D3D,creation_reference,
prevision_visu_sigma,prevision_visu_epsilon,prevision_visu_erreur,
modif_orientation_element,creationMaillageSFE,suppression_noeud_non_references,renumerotation_des_noeuds,
fusion_de_noeuds,fusion_elements,fusion_maillages,cree_sous_maillage,calcul_geometrique
};
/// @} // end of group
// identificateur pour décrire si le calcul est statique, transitoire, dynamique et autre ...
enum Enum_evolution_temporelle{STATIQUE=1,TRANSITOIRE,DYNAMIQUE,AUCUNE_EVOLUTION};
// Retourne le nom d'un type de calcul a partir de son identificateur de
// type enumere id_TypeCalcul correspondant
string Nom_TypeCalcul (const EnumTypeCalcul id_TypeCalcul);
// Retourne le nom du sous type de calcul a partir de son identificateur de
// type enumere id_SousTypeCalcul correspondant, si il existe sinon retourne : aucun_soustypedecalcul
string Nom_SousTypeCalcul (const EnumSousTypeCalcul id_SousTypeCalcul);
// retourne le type d'évolution temporelle du calcul
Enum_evolution_temporelle Evolution_temporelle_du_calcul(const EnumTypeCalcul id_TypeCalcul);
// Retourne l'identificateur de type enumere associe au nom du type de calcul
EnumTypeCalcul Id_nom_TypeCalcul (const string& nom_TypeCalcul);
// Retourne l'identificateur de type enumere associe au nom du sous type de calcul
EnumSousTypeCalcul Id_nom_SousTypeCalcul (const string& nom_SousTypeCalcul);
// indique si le calcul est de type dynamique explicite ou non
bool DynamiqueExplicite(const EnumTypeCalcul id_TypeCalcul);
// indique si le calcul est de type implicite ou non
bool Implicite(const EnumTypeCalcul id_TypeCalcul);
//lecture du type de calcul et d'une liste de sous-type eventuel
// la lecture se fait via UtilLecture.
// Le booléen indique si le type_calcul ou le sous_type_calcul est actif ou pas
// au niveau de syntaxe on a :
// - tout d'abord le type de calcul suivi ou non de la chaine "avec"
// dans le premier cas le booleen avec_Calcul est mis a true sinon false
// - puis une liste de sous type qui chacun sont précèdé ou non de la chaine "plus"
// dans le premier cas le booleen avec_sousCalcul correspondant est true sinon false
// les sous_types sont stocké par ordre d'arrivé
void LectureTypeCalcul(UtilLecture& lec,EnumTypeCalcul& typeCalcul,bool& avec_Calcul
,list<EnumSousTypeCalcul> & sousTypeCalcul
,list<bool>& avec_sousCalcul);
// affichage des différents type de calcul et choix du type et éventuellement
// de sous type
void Info_commande_type_calcul(UtilLecture& lec,EnumTypeCalcul& typeCalcul,bool& avec_Calcul
,list<EnumSousTypeCalcul> & sousTypeCalcul
,list<bool>& avec_sousCalcul);
// indique s'il y a un sous-type ou pas -> retour vrai s'il y a un sous type
bool SousType(const EnumSousTypeCalcul sousTypeCalcul);
// indique s'il y a remonte ou pas dans le sous-type
bool Remonte_in(const EnumSousTypeCalcul sousTypeCalcul);
// indique s'il y a "avec" ou pas dans le sous-type
bool Avec_in(const EnumSousTypeCalcul sousTypeCalcul);
// indique s'il y a erreur dans le sous-type
bool Erreur_in(const EnumSousTypeCalcul sousTypeCalcul);
// surcharge de l'operator de lecture
istream & operator >> (istream & entree, EnumTypeCalcul& a);
// surcharge de l'operator d'ecriture
ostream & operator << (ostream & sort, const EnumTypeCalcul& a);
// surcharge de l'operator de lecture
istream & operator >> (istream & entree, EnumSousTypeCalcul& a);
// surcharge de l'operator d'ecriture
ostream & operator << (ostream & sort, const EnumSousTypeCalcul& a);
//--------------------- cas de Enum_evolution_temporelle---------------
// Retourne le nom d'un type de Enum_evolution_temporelle a partir de son identificateur de
// type enumere id_Enum_evolution_temporelle correspondant
string Nom_evolution_temporelle (const Enum_evolution_temporelle id_evolution_temporelle);
// Retourne l'identificateur de type enumere associe au nom du type de Enum_evolution_temporelle
Enum_evolution_temporelle Id_nom_evolution_temporelle (const string& nom_evolution_temporelle);
// surcharge de l'operator de lecture
istream & operator >> (istream & entree, Enum_evolution_temporelle& a);
// surcharge de l'operator d'ecriture
ostream & operator << (ostream & sort, const Enum_evolution_temporelle& a);
#endif

119
Enumeration/EnumTypeGradient.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "EnumTypeGradient.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
#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

106
Enumeration/EnumTypeGradient.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
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

247
Enumeration/EnumTypeGrandeur.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "EnumTypeGrandeur.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
#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 '" <<nom_typeGrandeur << " 'inconnu !\n";
cout << "Id_nomTypeGrandeur(string ) \n";
Sortie(1);
};
// retour de la grandeur
return (*il).second;
};
EnumType2Niveau Id_nomType2Niveau (string nom_Type2Niveau)
// Retourne la variable de type enumere associe au nom nom_Type2Niveau
{ // on vérifie si la variable de type enumere existe
map < string, EnumType2Niveau , std::less < string> >& 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 '" <<nom_Type2Niveau << " 'inconnu !\n";
cout << "Id_nomType2Niveau(string ) \n";
Sortie(1);
};
// retour de la grandeur
return (*il).second;
};
// 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
// pour le cas particulier GRANDEUR_QUELCONQUE : retourne -1
int NombreElementFoncDim(EnumTypeGrandeur id_typeGrandeur)
{ switch (id_typeGrandeur)
{ case RIEN_TYPEGRANDEUR : return 0; break;
case SCALAIRE : case SCALAIRE_ENTIER : case SCALAIRE_DOUBLE : case CHAINE_CAR: return 1; break;
case VECTEUR : case COORDONNEE: case COORDONNEEB: case COORDONNEEH: return ParaGlob::Dimension(); break;
case BASE__H : case BASE__B : return (ParaGlob::Dimension() * ParaGlob::Dimension()); break;
case TENSEUR : case TENSEURBB: case TENSEURHH:
switch (ParaGlob::Dimension())
{case 1: return 1; break;
case 2: return 3; break;
case 3: return 6; break;
}
case TENSEUR_NON_SYM : case TENSEURBH: case TENSEURHB: case TENSEUR_NON_SYM_BB: case TENSEUR_NON_SYM_HH:
switch (ParaGlob::Dimension())
{case 1: return 1; break;
case 2: return 4; break;
case 3: return 9; break;
}
case GRANDEUR_QUELCONQUE: return -1;break;
default :
cout << "\nErreur : valeur incorrecte du type EnumTypeGrandeur !\n";
cout << "NomTypeGrandeur(EnumTypeGrandeur ) \n";
Sortie(1);
};
return 0;
};
// indique si c'est un type numérique ou non
bool Type_grandeur_numerique(EnumTypeGrandeur id_typeGrandeur)
{ switch (id_typeGrandeur)
{ case RIEN_TYPEGRANDEUR : return false; break;
case CHAINE_CAR : return false; break;
case SCALAIRE : case SCALAIRE_ENTIER : case SCALAIRE_DOUBLE :
case VECTEUR : case COORDONNEE: case COORDONNEEB: case COORDONNEEH:
case BASE__B : case BASE__H :
case TENSEUR : case TENSEURBB: case TENSEURHH:
case TENSEUR_NON_SYM : case TENSEURBH: case TENSEURHB: case TENSEUR_NON_SYM_BB:
case TENSEUR_NON_SYM_HH:
return true; break;
case GRANDEUR_QUELCONQUE: return false; break; // a priori on ne sait pas, on répond non par précaution
default :
cout << "\nErreur : valeur incorrecte du type EnumTypeGrandeur !\n";
cout << "Type_grandeur_numerique(EnumTypeGrandeur ) \n";
Sortie(1);
};
return 0;
};
// surcharge de la lecture
istream & operator >> (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;
};

111
Enumeration/EnumTypeGrandeur.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
using namespace std;
#include <map>
/// @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

121
Enumeration/EnumTypePilotage.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "EnumTypePilotage.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
#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;
};

69
Enumeration/EnumTypePilotage.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
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

105
Enumeration/EnumTypeViteRotat.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "EnumTypeViteRotat.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

71
Enumeration/EnumTypeViteRotat.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
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

109
Enumeration/EnumTypeVitesseDefor.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "EnumTypeVitesseDefor.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

72
Enumeration/EnumTypeVitesseDefor.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
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

138
Enumeration/Enum_Critere_loi.cc Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_Critere_Loi.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
// 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;
};

96
Enumeration/Enum_Critere_loi.h Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
#include <string.h>
#include <string>
using namespace std; //introduces namespace std
#include <stdlib.h>
/// @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

300
Enumeration/Enum_GrandeurGlobale.cc Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_GrandeurGlobale.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

94
Enumeration/Enum_GrandeurGlobale.h Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
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

136
Enumeration/Enum_IO_XML.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_IO_XML.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

95
Enumeration/Enum_IO_XML.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
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

155
Enumeration/Enum_PiPoCo.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_PiPoCo.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
// 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;
};

101
Enumeration/Enum_PiPoCo.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
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

128
Enumeration/Enum_StabHourglass.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_StabHourglass.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
// 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;
};

96
Enumeration/Enum_StabHourglass.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
#include <string.h>
#include <string>
using namespace std; //introduces namespace std
#include <stdlib.h>
/// @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

223
Enumeration/Enum_StabMembrane.cc Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_StabMembrane.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
// 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;
};

111
Enumeration/Enum_StabMembrane.h Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
#include <string.h>
#include <string>
using namespace std; //introduces namespace std
#include <stdlib.h>
/// @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

123
Enumeration/Enum_Suite.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_Suite.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

1731
Enumeration/Enum_TypeQuelconque.cc Normal file
View file

File diff suppressed because it is too large Load diff

193
Enumeration/Enum_TypeQuelconque.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
using namespace std;
#include <map>
#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

169
Enumeration/Enum_boolddl.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_boolddl.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
#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

82
Enumeration/Enum_boolddl.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
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

115
Enumeration/Enum_calcul_masse.cc Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_calcul_masse.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

91
Enumeration/Enum_calcul_masse.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
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

155
Enumeration/Enum_categorie_loi_comp.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_categorie_loi_comp.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

94
Enumeration/Enum_categorie_loi_comp.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
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

133
Enumeration/Enum_chargement.cc Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_chargement.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

74
Enumeration/Enum_chargement.h Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
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

395
Enumeration/Enum_comp.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_comp.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
// ----- 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;
};

125
Enumeration/Enum_comp.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
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

110
Enumeration/Enum_contrainte_mathematique.cc Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_contrainte_mathematique.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

74
Enumeration/Enum_contrainte_mathematique.h Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
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

115
Enumeration/Enum_crista.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_crista.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

94
Enumeration/Enum_crista.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 04/03/2008 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: 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 <iostream>
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

199
Enumeration/Enum_ddl (copy: conflict on 2017-11-21).h Normal file
View file

@ -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 <iostream>
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<Enum_ddl> 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<Enum_ddl> 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 <Enum_ddl> 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 <Enum_ddl> 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 <int> 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 <int>& 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 <int> OrdreContrainte1 = OrdreContrainte(1);
const Tableau2 <int> OrdreContrainte3 = OrdreContrainte(3);
const Tableau2 <int> 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

1397
Enumeration/Enum_ddl.cc Normal file
View file

File diff suppressed because it is too large Load diff

272
Enumeration/Enum_ddl.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/** @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 <iostream>
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<Enum_ddl> 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<Enum_ddl> 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 <Enum_ddl> 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 <Enum_ddl> 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 <int> 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 <int>& 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 <int> OrdreContrainte1 = OrdreContrainte(1);
const Tableau2 <int> OrdreContrainte3 = OrdreContrainte(3);
const Tableau2 <int> 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

65
Enumeration/Enum_ddl_var_static.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// fichier pour définir les variables statics utilisés par Enum_ddl
#include "Enum_ddl.h"
# include "ParaGlob.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
/// @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

151
Enumeration/Enum_dure.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_dure.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
#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

103
Enumeration/Enum_dure.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
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

172
Enumeration/Enum_geom.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_geom.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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 '" <<nom_geom << " 'inconnu !\n";
cout << "ID_NOM_GEOM(char* ) \n";
Sortie(1);
};
return result;
};
// surcharge de la lecture
istream & operator >> (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;
};

80
Enumeration/Enum_geom.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
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

166
Enumeration/Enum_interpol.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_interpol.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

76
Enumeration/Enum_interpol.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
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

104
Enumeration/Enum_liaison_noeud.cc Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_liaison_noeud.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

95
Enumeration/Enum_liaison_noeud.h Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
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

117
Enumeration/Enum_mat.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_mat.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

70
Enumeration/Enum_mat.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
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

227
Enumeration/Enum_matrice.cc Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_matrice.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

102
Enumeration/Enum_matrice.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
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

120
Enumeration/Enum_proj_aniso.cc Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_proj_aniso.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
// 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;
};

95
Enumeration/Enum_proj_aniso.h Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
#include <string.h>
#include <string>
using namespace std; //introduces namespace std
#include <stdlib.h>
/// @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

96
Enumeration/Enum_suite.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
#include <string.h>
#include <string>
using namespace std; //introduces namespace std
#include <stdlib.h>
/// @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

128
Enumeration/Enum_type_deformation.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_type_deformation.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
#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

100
Enumeration/Enum_type_deformation.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
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

108
Enumeration/Enum_type_geom.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_type_geom.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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 '" <<nom_type_geom << " 'inconnu !\n";
cout << "Id_nom_type_geom(string ) \n";
Sortie(1);
};
return result;
};
// surcharge de la lecture
istream & operator >> (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;
};

69
Enumeration/Enum_type_geom.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
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

106
Enumeration/Enum_type_pt_integ.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_type_pt_integ.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

71
Enumeration/Enum_type_pt_integ.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
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

287
Enumeration/Enum_type_resolution_matri.cc Executable file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_type_resolution_matri.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
// ===================================================================
// 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;
};

131
Enumeration/Enum_type_resolution_matri.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
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

129
Enumeration/Enum_type_stocke_deformation.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_type_stocke_deformation.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
#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

100
Enumeration/Enum_type_stocke_deformation.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* 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 <iostream>
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

281
Enumeration/Enum_variable_metrique.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Enum_variable_metrique.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
//#ifdef SYSTEM_MAC_OS_X
// #include <stringfwd.h> // a priori ce n'est pas portable
//#el
#if defined SYSTEM_MAC_OS_CARBON
#include <stringfwd.h> // a priori ce n'est pas portable
#else
#include <string.h> // pour le flot en memoire centrale
#endif
#include <string>
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;
};

107
Enumeration/Enum_variable_metrique.h Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
// 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 <iostream>
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

116
Enumeration/MotCle.cc Normal file
View file

@ -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) <https://www.irdl.fr/>.
//
// 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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "MotCle.h"
#include "string.h"
// CONSTRUCTEURS :
MotCle::MotCle ( const Tableau<string>& 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= "<<tabcar
// << "\n ((char*) (*it).c_str())= "<<((char*) (*it).c_str())
// << flush;
// };
// #endif
return true;
}
};
// recherche dans les sous mot cle
for (int i=1;i<=TabSous_taille;i++)
// if(strstr(tabcar,tabSous(i))!=NULL)
if(strstr(tabcar,((char*) (tabSous(i).c_str())))!=NULL)
return true;
return false;
}

99
Enumeration/MotCle.h Normal file
View file

@ -0,0 +1,99 @@
/*! \file MotCle.h
\brief def Enumeration des differents mot cle dans le fichier d'entree.
* \date 23/01/97
*/
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 23/01/97 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: Enumeration des differents mot cle dans le fichier d'entree.*
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef ENUM_MOTCLE_H
#define ENUM_MOTCLE_H
#include <iostream>
using namespace std;
// #include "bool.h"
#include "Tableau_T.h"
#include "Constante.h"
#include <list>
/// @addtogroup Group_types_enumeres
/// @{
/// ici l'énuméré est remplacé par une classe
class MotCle
{
public :
// VARIABLES PUBLIQUES :
// CONSTRUCTEURS :
MotCle ( const Tableau<string>& 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 <string> lesmotscles; // liste des mots clés
Tableau <string> tabSous;
int TabSous_taille;
int lesmotscles_taille;
list <string>::iterator itdeb,itfin,it;
};
/// @} // end of group
#endif