/*! \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
