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

272 lines
11 KiB
C++

/*! \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-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/** @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