// FICHIER : Enum_ddl.h // Afin de realiser un gain en place memoire, les noms des degres de liberte sont // stockes a l'aide d'un type enumere. Les fonctions Nom_ddl et Id_nom_ddl rendent // possible le lien entre les noms des degres de liberte et les identificateurs // de type enumere correspondants. // 10 carractere maxi // NU_DDL correspond au cas ou pas de ddl est defini // les ddl X1 X2 X3 doivent se suivrent // les ddl UX, UY, UZ doivent se suivrent // les ddl VX , VY , VZ, doivent se suivrent // ne pas changer l'ordre des 3 premiers ddl dans l'enumeration!!!! car on se // sert du fait que Enum_ddl(1) = X1 etc pour initialiser les ddl des noeud elements // // une famille de ddl: se sont des ddl scalaires qui représentent les composantes d'un ddl vectoriel // ou tensoriel, ou scalaire s'il n'y a qu'une seule grandeur, qui ne dépend pas de la dimension (ex: pression // ou température) // une combinaison , c'est un groupe de ddl qui sont relié par le calcul: ex: position, vitesse et accélération // en dynamique. #ifndef ENUM_DDL_H #define ENUM_DDL_H //#include "Debug.h" # include "Tableau2_T.h" #include using namespace std; #include "EnumTypeGrandeur.h" #include "ParaGlob.h" //=============================================================================== // l'énumération de degré de liberté de base, celle qui sert pour les calculs // nombre de ddl limité //=============================================================================== // ***** !!!! penser à changer la fonction "NbEnum_ddl" et ***** //****** nbmax_caractere_enum_ddl si nécessaire ***** // le type énuméré doit commencer à 1, c'est utilisé dans Ddl_enum_etendu par exemple !! enum Enum_ddl { X1 = 1, X2 , X3, EPAIS , TEMP , UX, UY, UZ , V1 , V2 , V3, PR, GAMMA1, GAMMA2, GAMMA3, SIG11,SIG22,SIG33,SIG12,SIG23,SIG13,ERREUR, EPS11,EPS22,EPS33,EPS12,EPS23,EPS13, DEPS11,DEPS22,DEPS33,DEPS12,DEPS23,DEPS13, PROP_CRISTA,DELTA_TEMP,FLUXD1,FLUXD2,FLUXD3,R_TEMP, GRADT1,GRADT2,GRADT3,DGRADT1,DGRADT2,DGRADT3, R_X1,R_X2,R_X3,R_EPAIS,R_V1,R_V2,R_V3,R_GAMMA1,R_GAMMA2,R_GAMMA3, NU_DDL }; // ***** !!!! penser à changer la fonction "NbEnum_ddl" et ***** //****** nbmax_caractere_enum_ddl si nécessaire ***** //****** Nombre_de_famille_de_ddl si nécessaire ***** class ClassPourEnum_ddl { public: // friend Enum_ddl Id_nom_ddl (const char* nom); friend Enum_ddl Id_nom_ddl (const string& nom); // friend bool ExisteEnum_ddl(const char* nom); friend bool ExisteEnum_ddl(const string& nom); // def de la map qui fait la liaison entre les string et les énumérés static map < string, Enum_ddl , std::less < string> > map_Enum_ddl; // def de la grandeur statique qui permet de remplir la map static ClassPourEnum_ddl remplir_map; // le constructeur qui rempli effectivement la map ClassPourEnum_ddl(); // variable de travail protected: map < string, Enum_ddl , std::less < string> >::iterator il,ilfin; }; //------------------------------------------------- // def des fonctions de manipulation des Enum_ddl //------------------------------------------------- // definition du maximum de caractères de la chaine équivalente à l'énumération const int nbmax_caractere_enum_ddl = 11; const int nombre_maxi_de_famille_de_ddl = 21; const int nombre_maxi_de_type_de_ddl = 57; // Retourne le nom d'un degre de liberte a partir de son identificateur de // type enumere id_ddl correspondant string Nom_ddl (Enum_ddl id_ddl); // Retourne l'identificateur de type enumere associe au nom du degre de liberte // nom_ddl //Enum_ddl Id_nom_ddl (const char* nom_ddl); Enum_ddl Id_nom_ddl (const string& nom_ddl); // retourne true si l'identificateur existe, false sinon //bool ExisteEnum_ddl(const char* nom_ddl); bool ExisteEnum_ddl(const string& nom_ddl); // retourne le nombre maxi de ddl existant inline int NbEnum_ddl() {return nombre_maxi_de_type_de_ddl;}; // ramene true si le ddl fait parti d'une liste // fonction de la dimension du pb: par exemple : X1 ou UY ou VZ // dans le cas contraire , exemple: T ou EPAIS ramene false bool FoncDim(const string& nom_ddl); // idem mais avec l'énumération bool FoncDim(Enum_ddl id_ddl); // ramene le tableau de tous les ddl correspondant au type du ddl passé en paramètre // ceci en fonction de la dimension (par exemple pour un vecteur, ramène // les dim ddl correspondant aux composantes Tableau TableauTypeDdl(Enum_ddl id_ddl); // ramene le tableau des ddl mobile correspondant au type du ddl passé en paramètre // ceci en fonction de la dimension (par exemple pour un vecteur, ramène // les dim ddl correspondant aux composantes // par rapport à TableauTypeDdl() la différence concerne le cas axi // pour ce cas: X3=constant, U3=V3=Gamma3=0 ==> donc ne font pas partie du tableau retour Tableau TableauTypeDdlmobileAvecAxi(Enum_ddl id_ddl); // indique si le ddl est compatible avec la dimension // c'est-à-dire qu'il peut exister avec la dimension actuelle : // par exemple en 1D on ne peut pas avoir de UY, mais UX c'est ok bool CompatDim(const string& nom_ddl); bool CompatDim(const Enum_ddl id_ddl); // retour le type de grandeur auquel apartient l'énumération // par exemple : UY : apartiend à un vecteur // SIG12 : à un tenseur, TEMP : à un scalaire EnumTypeGrandeur TypeGrandeur(Enum_ddl id_ddl); // test si les deux ddl sont de la même famille dimensionnelle, // par exemple X1 et X3, ou SIG11 et SIG22 // ramène true si oui, false sinon bool Meme_famille(Enum_ddl a,Enum_ddl b); // ramène le premier ddl de la même famille Enum_ddl PremierDdlFamille(Enum_ddl a); // ramène un nom générique pour la famille de ddl du même type string NomGeneric(Enum_ddl a); // ramène de nombre de famille différente qui existe inline int Nombre_de_famille_de_ddl() {return nombre_maxi_de_famille_de_ddl;}; // test si le ddl appartient à la combinaison donné par cas // cas : spécifie la combinaison : =1 -> combinaison X V GAMMA // ramène false si cas=0 c'est-à-dire pas de combinaison bool Dans_combinaison(int cas,Enum_ddl a); // ramène tous les membres d'une même combinaison de la même dimension // y compris "a" // cas : spécifie la combinaison : // =0 -> pas de combinaison, ramène "a" // =1 -> combinaison X V GAMMA Tableau MemeCombinaison(int cas,Enum_ddl a); // ramène tous les membres d'une même combinaison, pour i=1 à dim // cas = 1 -> combinaison X V GAMMA // cas = 0 -> pas de combinaison, ramène un tableau de dimension 0 Tableau Combinaison(int cas); // passage de Ui en Xi, c-a-d : UX -> X1, UY -> X2, UZ -> X3 Enum_ddl UxyzXi(Enum_ddl a); // passage inverse Enum_ddl XiUxyz(Enum_ddl a); // surcharge de l'operator de lecture istream & operator >> (istream & entree, Enum_ddl& a); // surcharge de l'operator d'ecriture ostream & operator << (ostream & sort, const Enum_ddl& a); // fonction donnant dans l'ordre des ddl de contraintes, les indices correspondant // des tenseurs, ceci en fonction du nombre de composante de tenseur // en retour un tableau : (i)(1) et (i)(2) -> les indices (en entier) du tenseur correspondant // au i ième ddl de containte à partir de SIG11 // mais en sautant les ddl qui ne font pas parti de la dimension !!!!! Tableau2 OrdreContrainte(int nbcomposantes); // idem en fonction du nombre de composantes // fonction plus rapide qui pointe sur des tableaux déjà construits à partir d'OrdreContrainte const Tableau2 & OrdreContrainteR(int nbcomposantes); // donne directement le premier et le second indice en fonction de l'enum et du nbcomposante // pour les tenseurs sigma ou pour le tenseur epsilon ou encore pour le tenseur Depsilon class Deuxentiers {public: int i;int j;}; Deuxentiers IJind(Enum_ddl a,int nbcomposantes); // definition de tableau constant pour éviter de les recalculer à chaque appel const Tableau2 OrdreContrainte1 = OrdreContrainte(1); const Tableau2 OrdreContrainte3 = OrdreContrainte(3); const Tableau2 OrdreContrainte6 = OrdreContrainte(6); // passage de enum_ddl vers des réactions enum_ddl correspondantes // exemple X1 -> R_X1 etc.. Enum_ddl Vers_enum_reac(Enum_ddl a); // opération inverse: exemple R_X1 -> X1 Enum_ddl Enum_reac_vers_enum(Enum_ddl a); // indique si un ddl est un ddl de réaction on non bool Ddl_reaction(Enum_ddl a); // pour faire de l'inline #ifndef MISE_AU_POINT #include "Enum_ddl.cc" #define Enum_ddl_deja_inclus #endif #endif