200 lines
8.4 KiB
C++
Executable file
200 lines
8.4 KiB
C++
Executable file
// 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
|