Herezh_dev/Enumeration/Enum_ddl (copy: conflict on 2017-11-21).h

200 lines
8.4 KiB
C
Raw Normal View History

// 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