273 lines
11 KiB
C++
Executable file
273 lines
11 KiB
C++
Executable file
/*! \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-2021 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
|