/*! \file Enum_ddl.h \brief def de l'enuméré concernant les ddl. */ // FICHIER : Enum_ddl.h // This file is part of the Herezh++ application. // // The finite element software Herezh++ is dedicated to the field // of mechanics for large transformations of solid structures. // It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600) // INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) . // // Herezh++ is distributed under GPL 3 license ou ultérieure. // // Copyright (C) 1997-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 . // // For more information, please consult: . /** @defgroup Group_types_enumeres Group_types_enumeres * * \author Gérard Rio * \version 1.0 * \date 23/01/97 * \brief Def de grandeurs enumérées: permet une meilleure lisibilité du code et éventuellement un gain de place * */ /// @addtogroup Group_types_enumeres /// @{ /// /// Afin de realiser un gain en place memoire, les noms des degres de liberte sont /// stockes a l'aide d'un type enumere. Les fonctions Nom_ddl et Id_nom_ddl rendent /// possible le lien entre les noms des degres de liberte et les identificateurs /// de type enumere correspondants. /// 10 carractere maxi /// NU_DDL correspond au cas ou pas de ddl est defini /// les ddl X1 X2 X3 doivent se suivrent /// les ddl UX, UY, UZ doivent se suivrent /// les ddl VX , VY , VZ, doivent se suivrent /// ne pas changer l'ordre des 3 premiers ddl dans l'enumeration!!!! car on se /// sert du fait que Enum_ddl(1) = X1 etc pour initialiser les ddl des noeud elements /// /// une famille de ddl: se sont des ddl scalaires qui représentent les composantes d'un ddl vectoriel /// ou tensoriel, ou scalaire s'il n'y a qu'une seule grandeur, qui ne dépend pas de la dimension (ex: pression /// ou température) /// une combinaison , c'est un groupe de ddl qui sont relié par le calcul: ex: position, vitesse et accélération /// en dynamique. #ifndef ENUM_DDL_H #define ENUM_DDL_H //#include "Debug.h" # include "Tableau2_T.h" #include using namespace std; #include "EnumTypeGrandeur.h" #include "ParaGlob.h" #include "Enum_TypeQuelconque.h" //=============================================================================== // l'énumération de degré de liberté de base, celle qui sert pour les calculs // nombre de ddl limité //=============================================================================== // ***** !!!! penser à changer la fonction "NbEnum_ddl" et ***** //****** nbmax_caractere_enum_ddl si nécessaire ***** // le type énuméré doit commencer à 1, c'est utilisé dans Ddl_enum_etendu par exemple !! enum Enum_ddl { X1 = 1, X2 , X3, EPAIS , TEMP , UX, UY, UZ , V1 , V2 , V3, PR, GAMMA1, GAMMA2, GAMMA3, SIG11,SIG22,SIG33,SIG12,SIG23,SIG13,ERREUR, EPS11,EPS22,EPS33,EPS12,EPS23,EPS13, DEPS11,DEPS22,DEPS33,DEPS12,DEPS23,DEPS13, PROP_CRISTA,DELTA_TEMP,FLUXD1,FLUXD2,FLUXD3,R_TEMP, GRADT1,GRADT2,GRADT3,DGRADT1,DGRADT2,DGRADT3, R_X1,R_X2,R_X3,R_EPAIS,R_V1,R_V2,R_V3,R_GAMMA1,R_GAMMA2,R_GAMMA3, NU_DDL }; // ***** !!!! penser à changer la fonction "NbEnum_ddl" et ***** //****** nbmax_caractere_enum_ddl si nécessaire ***** //****** Nombre_de_famille_de_ddl si nécessaire ***** /// @} // end of group /// @addtogroup Group_types_enumeres /// @{ /// classe utilitaire entre Enum_ddl et une map class ClassPourEnum_ddl { public: // friend Enum_ddl Id_nom_ddl (const char* nom); friend Enum_ddl Id_nom_ddl (const string& nom); // friend bool ExisteEnum_ddl(const char* nom); friend bool ExisteEnum_ddl(const string& nom); /// def de la map qui fait la liaison entre les string et les énumérés static map < string, Enum_ddl , std::less < string> > map_Enum_ddl; /// def de la grandeur statique qui permet de remplir la map static ClassPourEnum_ddl remplir_map; /// le constructeur qui rempli effectivement la map ClassPourEnum_ddl(); /// variable de travail protected: map < string, Enum_ddl , std::less < string> >::iterator il,ilfin; }; /// @} // end of group //------------------------------------------------- // def des fonctions de manipulation des Enum_ddl //------------------------------------------------- /// definition du maximum de caractères de la chaine équivalente à l'énumération const int nbmax_caractere_enum_ddl = 11; const int nombre_maxi_de_famille_de_ddl = 21; const int nombre_maxi_de_type_de_ddl = 57; /// Retourne le nom d'un degre de liberte a partir de son identificateur de /// type enumere id_ddl correspondant string Nom_ddl (Enum_ddl id_ddl); /// Retourne l'identificateur de type enumere associe au nom du degre de liberte /// nom_ddl ///Enum_ddl Id_nom_ddl (const char* nom_ddl); Enum_ddl Id_nom_ddl (const string& nom_ddl); /// retourne true si l'identificateur existe, false sinon ///bool ExisteEnum_ddl(const char* nom_ddl); bool ExisteEnum_ddl(const string& nom_ddl); /// retourne le nombre maxi de ddl existant inline int NbEnum_ddl() {return nombre_maxi_de_type_de_ddl;}; /// ramene true si le ddl fait parti d'une liste /// fonction de la dimension du pb: par exemple : X1 ou UY ou VZ /// dans le cas contraire , exemple: T ou EPAIS ramene false bool FoncDim(const string& nom_ddl); /// idem mais avec l'énumération bool FoncDim(Enum_ddl id_ddl); /// ramene le tableau de tous les ddl correspondant au type du ddl passé en paramètre /// ceci en fonction de la dimension (par exemple pour un COORDONNEE, ramène /// les dim ddl correspondant aux composantes Tableau TableauTypeDdl(Enum_ddl id_ddl); /// ramene le tableau des ddl mobile correspondant au type du ddl passé en paramètre /// ceci en fonction de la dimension (par exemple pour un COORDONNEE, ramène /// les dim ddl correspondant aux composantes /// par rapport à TableauTypeDdl() la différence concerne le cas axi /// pour ce cas: X3=constant, U3=V3=Gamma3=0 ==> donc ne font pas partie du tableau retour Tableau TableauTypeDdlmobileAvecAxi(Enum_ddl id_ddl); /// indique si le ddl est compatible avec la dimension /// c'est-à-dire qu'il peut exister avec la dimension actuelle : /// par exemple en 1D on ne peut pas avoir de UY, mais UX c'est ok bool CompatDim(const string& nom_ddl); bool CompatDim(const Enum_ddl id_ddl); /// retour le type de grandeur auquel apartient l'énumération /// par exemple : UY : apartiend à un COORDONNEE /// SIG12 : à un tenseur, TEMP : à un scalaire EnumTypeGrandeur TypeGrandeur(Enum_ddl id_ddl); /// test si les deux ddl sont de la même famille dimensionnelle, /// par exemple X1 et X3, ou SIG11 et SIG22 /// ramène true si oui, false sinon bool Meme_famille(Enum_ddl a,Enum_ddl b); /// ramène le premier ddl de la même famille Enum_ddl PremierDdlFamille(Enum_ddl a); /// ramène un nom générique pour la famille de ddl du même type string NomGeneric(Enum_ddl a); /// ramène de nombre de famille différente qui existe inline int Nombre_de_famille_de_ddl() {return nombre_maxi_de_famille_de_ddl;}; /// test si le ddl appartient à la combinaison donné par cas /// cas : spécifie la combinaison : =1 -> combinaison X V GAMMA /// ramène false si cas=0 c'est-à-dire pas de combinaison bool Dans_combinaison(int cas,Enum_ddl a); /// ramène tous les membres d'une même combinaison de la même dimension /// y compris "a" /// cas : spécifie la combinaison : /// =0 -> pas de combinaison, ramène "a" /// =1 -> combinaison X V GAMMA Tableau MemeCombinaison(int cas,Enum_ddl a); /// ramène tous les membres d'une même combinaison, pour i=1 à dim /// cas = 1 -> combinaison X V GAMMA /// cas = 0 -> pas de combinaison, ramène un tableau de dimension 0 Tableau Combinaison(int cas); /// récupération d'un enum de grandeurs quelconques équivalentes /// -> retour particulier si il y a une équivalence particulière en grandeur évoluée par exemple /// sinon, un retour sur un scalaire de type enum_évolué, qui contient de toute manière /// les ddl de base /// -> ramène UN_DDL_ENUM_ETENDUE s'il n'y a pas d'équivalent spécifique EnumTypeQuelconque Equi_Enum_ddl_en_enu_quelconque(Enum_ddl a); /// passage de Ui en Xi, c-a-d : UX -> X1, UY -> X2, UZ -> X3 Enum_ddl UxyzXi(Enum_ddl a); /// passage inverse Enum_ddl XiUxyz(Enum_ddl a); /// surcharge de l'operator de lecture istream & operator >> (istream & entree, Enum_ddl& a); /// surcharge de l'operator d'ecriture ostream & operator << (ostream & sort, const Enum_ddl& a); ///----------- pour les Coordonnee -------------- /// retourne l'indice en fonction de l'enum et du nbcomposante /// pour une grandeur de type Coordonnee, sinon erreur int Indice_coor(Enum_ddl a,int nbcomposantes); ///----------- pour les tenseurs ------------------ /// fonction donnant dans l'ordre des ddl de contraintes, les indices correspondant /// des tenseurs, ceci en fonction du nombre de composante de tenseur /// en retour un tableau : (i)(1) et (i)(2) -> les indices (en entier) du tenseur correspondant /// au i ième ddl de containte à partir de SIG11 /// mais en sautant les ddl qui ne font pas parti de la dimension !!!!! Tableau2 OrdreContrainte(int nbcomposantes); /// idem en fonction du nombre de composantes /// fonction plus rapide qui pointe sur des tableaux déjà construits à partir d'OrdreContrainte const Tableau2 & OrdreContrainteR(int nbcomposantes); /// donne directement le premier et le second indice en fonction de l'enum et du nbcomposante /// pour les tenseurs sigma ou pour le tenseur epsilon ou encore pour le tenseur Depsilon /// @addtogroup Group_types_enumeres /// @{ /// classe utilitaire pour les enum_ddl class Deuxentiers_enu {public: int i;int j;}; /// @} // end of group Deuxentiers_enu IJind(Enum_ddl a,int nbcomposantes); /// definition de tableau constant pour éviter de les recalculer à chaque appel const Tableau2 OrdreContrainte1 = OrdreContrainte(1); const Tableau2 OrdreContrainte3 = OrdreContrainte(3); const Tableau2 OrdreContrainte6 = OrdreContrainte(6); //------- fin spécifique tenseur ------------- /// passage de enum_ddl vers des réactions enum_ddl correspondantes /// exemple X1 -> R_X1 etc.. Enum_ddl Vers_enum_reac(Enum_ddl a); /// opération inverse: exemple R_X1 -> X1 Enum_ddl Enum_reac_vers_enum(Enum_ddl a); /// indique si un ddl est un ddl de réaction on non bool Ddl_reaction(Enum_ddl a); // pour faire de l'inline #ifndef MISE_AU_POINT #include "Enum_ddl.cc" #define Enum_ddl_deja_inclus #endif #endif