// FICHIER Enum_ddl.cp // 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) . // // Herezh++ is distributed under GPL 3 license ou ultérieure. // // Copyright (C) 1997-2022 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 . // // For more information, please consult: . #include "Enum_ddl.h" # include "ParaGlob.h" # include using namespace std; //introduces namespace std #include #include "Sortie.h" //#ifdef SYSTEM_MAC_OS_X // #include // a priori ce n'est pas portable //#el #if defined SYSTEM_MAC_OS_CARBON #include // a priori ce n'est pas portable #else #include // pour le flot en memoire centrale #endif #include #ifndef Enum_ddl_deja_inclus //-------------------------- def des grandeurs statiques --------------------- // du au jeux d'inline, les grandeurs statiques sont définis dans un fichier à part // Enum_ddl_var_static.cc // // il s'agit des variables: map_Enum_ddl, et remplir_map //-------------------------- fin def des grandeurs statiques --------------------- // le constructeur qui rempli effectivement la map #ifndef MISE_AU_POINT inline #endif ClassPourEnum_ddl::ClassPourEnum_ddl() : il(),ilfin() { // remplissage de la map map_Enum_ddl["X1"]=X1; map_Enum_ddl["X2"]=X2; map_Enum_ddl["X3"]=X3; map_Enum_ddl["EPAIS"]=EPAIS; map_Enum_ddl["TEMP"]=TEMP; map_Enum_ddl["UX"]=UX; map_Enum_ddl["UY"]=UY; map_Enum_ddl["UZ"]=UZ; map_Enum_ddl["V1"]=V1; map_Enum_ddl["V2"]=V2; map_Enum_ddl["V3"]=V3; map_Enum_ddl["PR"]=PR; map_Enum_ddl["GAMMA1"]=GAMMA1; map_Enum_ddl["GAMMA2"]=GAMMA2; map_Enum_ddl["GAMMA3"]=GAMMA3; map_Enum_ddl["SIG11"]=SIG11; map_Enum_ddl["SIG22"]=SIG22; map_Enum_ddl["SIG33"]=SIG33; map_Enum_ddl["SIG12"]=SIG12; map_Enum_ddl["SIG23"]=SIG23; map_Enum_ddl["SIG13"]=SIG13; map_Enum_ddl["ERREUR"]=ERREUR; map_Enum_ddl["EPS11"]=EPS11; map_Enum_ddl["EPS22"]=EPS22; map_Enum_ddl["EPS33"]=EPS33; map_Enum_ddl["EPS12"]=EPS12; map_Enum_ddl["EPS23"]=EPS23; map_Enum_ddl["EPS13"]=EPS13; map_Enum_ddl["DEPS11"]=DEPS11; map_Enum_ddl["DEPS22"]=DEPS22; map_Enum_ddl["DEPS33"]=DEPS33; map_Enum_ddl["DEPS12"]=DEPS12; map_Enum_ddl["DEPS23"]=DEPS23; map_Enum_ddl["DEPS13"]=DEPS13; map_Enum_ddl["PROP_CRISTA"]=PROP_CRISTA; map_Enum_ddl["DELTA_TEMP"]=DELTA_TEMP; map_Enum_ddl["FLUXD1"]=FLUXD1; map_Enum_ddl["FLUXD2"]=FLUXD2; map_Enum_ddl["FLUXD3"]=FLUXD3; map_Enum_ddl["R_TEMP"]=R_TEMP; map_Enum_ddl["GRADT1"]=GRADT1; map_Enum_ddl["GRADT2"]=GRADT2; map_Enum_ddl["GRADT3"]=GRADT3; map_Enum_ddl["DGRADT1"]=DGRADT1; map_Enum_ddl["DGRADT2"]=DGRADT2; map_Enum_ddl["DGRADT3"]=DGRADT3; map_Enum_ddl["R_X1"]=R_X1; map_Enum_ddl["R_X2"]=R_X2; map_Enum_ddl["R_X3"]=R_X3; map_Enum_ddl["R_EPAIS"]=R_EPAIS; map_Enum_ddl["R_V1"]=R_V1; map_Enum_ddl["R_V2"]=R_V2; map_Enum_ddl["R_V3"]=R_V3; map_Enum_ddl["R_GAMMA1"]=R_GAMMA1; map_Enum_ddl["R_GAMMA2"]=R_GAMMA2; map_Enum_ddl["R_GAMMA3"]=R_GAMMA3; map_Enum_ddl["NU_DDL"]=NU_DDL; // définition des itérators de travail ilfin = map_Enum_ddl.end(); }; #ifndef MISE_AU_POINT inline #endif string Nom_ddl (Enum_ddl id_nom) // Retourne le nom du degre de liberte associe // a l'identificateur de type enumere id_nom { string result=""; switch (id_nom) {case X1 : result="X1";break; case X2 : result="X2";break; case X3 : result="X3";break; case EPAIS : result="EPAIS";break; case TEMP : result="TEMP";break; case UX : result="UX";break; case UY : result="UY";break; case UZ : result="UZ";break; case V1 : result="V1";break; case V2 : result="V2";break; case V3 : result="V3";break; case PR : result="PR";break; case GAMMA1 :result="GAMMA1";break; case GAMMA2 :result="GAMMA2";break; case GAMMA3 :result="GAMMA3";break; case SIG11 : result="SIG11";break; case SIG22 : result="SIG22";break; case SIG33 : result="SIG33";break; case SIG12 : result="SIG12";break; case SIG23 : result="SIG23";break; case SIG13 : result="SIG13";break; case ERREUR :result="ERREUR";break; case EPS11 : result="EPS11";break; case EPS22 : result="EPS22";break; case EPS33 : result="EPS33";break; case EPS12 : result="EPS12";break; case EPS23 : result="EPS23";break; case EPS13 : result="EPS13";break; case DEPS11 : result="DEPS11";break; case DEPS22 : result="DEPS22";break; case DEPS33 : result="DEPS33";break; case DEPS12 : result="DEPS12";break; case DEPS23 : result="DEPS23";break; case DEPS13 : result="DEPS13";break; case PROP_CRISTA : result="PROP_CRISTA";break; case DELTA_TEMP : result="DELTA_TEMP";break; case FLUXD1 : result="FLUXD1";break; case FLUXD2 : result="FLUXD2";break; case FLUXD3 : result="FLUXD3";break; case R_TEMP : result="R_TEMP";break; case GRADT1 : result="GRADT1";break; case GRADT2 : result="GRADT2";break; case GRADT3 : result="GRADT3";break; case DGRADT1 : result="DGRADT1";break; case DGRADT2 : result="DGRADT2";break; case DGRADT3 : result="DGRADT3";break; case R_X1 : result="R_X1";break; case R_X2 : result="R_X2";break; case R_X3 : result="R_X3";break; case R_EPAIS : result="R_EPAIS";break; case R_V1 : result="R_V1";break; case R_V2 : result="R_V2";break; case R_V3 : result="R_V3";break; case R_GAMMA1 : result="R_GAMMA1";break; case R_GAMMA2 : result="R_GAMMA2";break; case R_GAMMA3 : result="R_GAMMA3";break; case NU_DDL :result="NU_DDL";break; default : {cout << "\nErreur : valeur incorrecte du type Enum_ddl !\n"; cout << "NOM_DDL(Enum_ddl ) \n"; Sortie(1); } }; return result; }; /*#ifndef MISE_AU_POINT inline #endif Enum_ddl Id_nom_ddl (const char* nom) // Retourne la variable de type enumere associee au nom du degre // de liberte nom // Retourne la variable de type enumere associe au nom nom_TypeQuelconque { // on vérifie si la variable de type enumere existe map < string, Enum_ddl , std::less < string> >& maa=ClassPourEnum_ddl::map_Enum_ddl; ClassPourEnum_ddl::remplir_map.il = maa.find(nom); if (ClassPourEnum_ddl::remplir_map.il == ClassPourEnum_ddl::remplir_map.ilfin) {// on vérifie si la variable de type enumere existe cout << "\nErreur : nom du degre de liberte inconnu ! (" << nom << ") \n"; cout << "ID_NOM_DDL(char* ) \n"; Sortie(1); }; // retour de la grandeur return (*(ClassPourEnum_ddl::remplir_map.il)).second; }; */ #ifndef MISE_AU_POINT inline #endif Enum_ddl Id_nom_ddl (const string& nom) // Retourne la variable de type enumere associee au nom du degre // de liberte nom // Retourne la variable de type enumere associe au nom nom_TypeQuelconque { // on vérifie si la variable de type enumere existe map < string, Enum_ddl , std::less < string> >& maa=ClassPourEnum_ddl::map_Enum_ddl; ClassPourEnum_ddl::remplir_map.il = maa.find(nom); if (ClassPourEnum_ddl::remplir_map.il == ClassPourEnum_ddl::remplir_map.ilfin) {// on vérifie si la variable de type enumere existe cout << "\nErreur : nom du degre de liberte inconnu ! (" << nom << ") \n"; cout << "ID_NOM_DDL(const string& ) \n"; Sortie(1); }; // retour de la grandeur return (*(ClassPourEnum_ddl::remplir_map.il)).second; }; /*// retourne true si l'identificateur existe, false sinon #ifndef MISE_AU_POINT inline #endif bool ExisteEnum_ddl(const char* nom) { return ( ClassPourEnum_ddl::map_Enum_ddl.find(nom) != ClassPourEnum_ddl::remplir_map.ilfin); }; */ // retourne true si l'identificateur existe, false sinon (cas d'un string) #ifndef MISE_AU_POINT inline #endif bool ExisteEnum_ddl(const string& nom) {return ( ClassPourEnum_ddl::map_Enum_ddl.find(nom) != ClassPourEnum_ddl::remplir_map.ilfin); }; // 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 #ifndef MISE_AU_POINT inline #endif bool FoncDim(const string& nom) { // on récupère tout d'abord l'énuméré Enum_ddl enu = Id_nom_ddl(nom); return FoncDim(enu); }; // 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 // mais ici avec l'énumération #ifndef MISE_AU_POINT inline #endif bool FoncDim(Enum_ddl id_ddl) { bool res; switch (id_ddl) { case X1 : res=true;break; case X2 :res=true;break; case X3 :res=true;break; case EPAIS :res=false;break; case TEMP :res=false;break; case UX :res=true;break; case UY :res=true;break; case UZ :res=true;break; case V1 :res=true;break; case V2 :res=true;break; case V3 :res=true;break; case PR :res=false;break; case GAMMA1 :res=true;break; case GAMMA2 :res=true;break; case GAMMA3 :res=true;break; case SIG11 :res=true;break; case SIG22 :res=true;break; case SIG33 :res=true;break; case SIG12 :res=true;break; case SIG23 :res=true;break; case SIG13 :res=true;break; case ERREUR :res=false;break; case EPS11 :res=true;break; case EPS22 :res=true;break; case EPS33 :res=true;break; case EPS12 :res=true;break; case EPS23 :res=true;break; case EPS13 :res=true;break; case DEPS11 :res=true;break; case DEPS22 :res=true;break; case DEPS33 :res=true;break; case DEPS12 :res=true;break; case DEPS23 :res=true;break; case DEPS13 :res=true;break; case PROP_CRISTA :res=false;break; case DELTA_TEMP :res=false;break; case FLUXD1 :res=true;break; case FLUXD2 :res=true;break; case FLUXD3 :res=true;break; case R_TEMP :res=false;break; case GRADT1 :res=true;break; case GRADT2 :res=true;break; case GRADT3 :res=true;break; case DGRADT1 :res=true;break; case DGRADT2 :res=true;break; case DGRADT3 :res=true;break; case R_X1: res=true;break; case R_X2: res=true;break; case R_X3: res=true;break; case R_EPAIS: res=false;break; case R_V1: res=true;break; case R_V2: res=true;break; case R_V3: res=true;break; case R_GAMMA1: res=true;break; case R_GAMMA2: res=true;break; case R_GAMMA3: res=true;break; case NU_DDL :res=false;break; default : { cout << "\nErreur : valeur incorrecte du type Enum_ddl: " << Nom_ddl(id_ddl) << " !\n"; cout << "FoncDim(Enum_ddl id_ddl)\n"; Sortie(1);} }; return res; }; // 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 #ifndef MISE_AU_POINT inline #endif Tableau TableauTypeDdl(Enum_ddl id_ddl) { // récup du premier ddl de la famille Enum_ddl premddl = PremierDdlFamille(id_ddl); // récup de la dimension int dim = ParaGlob::Dimension(); // fabrication du tableau Tableau ta(1); switch (dim) { case 1: // dans tous les cas il n'y a qu'une seule grandeur {ta(1)=premddl; break;} case 2: {int taille=NombreElementFoncDim(TypeGrandeur(premddl)); ta.Change_taille(taille); int posi = premddl -1; if ((premddl == SIG11)||(premddl==EPS11)||(premddl==DEPS11)) // cas particulier des tenseurs {ta(1)=Enum_ddl(1+posi);ta(2)=Enum_ddl(2+posi); ta(3)=Enum_ddl(4+posi); } else // cas ou ça se suit for (int i=1;i<=taille;i++) ta(i)=Enum_ddl(i+posi); break; } case 3:// on crée le tableau en fonction du type de grandeur {int taille=NombreElementFoncDim(TypeGrandeur(premddl)); ta.Change_taille(taille); int posi = premddl -1; for (int i=1;i<=taille;i++) ta(i)=Enum_ddl(i+posi); break; } }; return ta; }; // 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 #ifndef MISE_AU_POINT inline #endif Tableau TableauTypeDdlmobileAvecAxi(Enum_ddl id_ddl) { // récup du premier ddl de la famille Enum_ddl premddl = PremierDdlFamille(id_ddl); // récup de la dimension int dim = ParaGlob::Dimension(); // fabrication du tableau Tableau ta(1); switch (dim) { case 1: // dans tous les cas il n'y a qu'une seule grandeur {ta(1)=premddl; break;} case 2: {int taille=NombreElementFoncDim(TypeGrandeur(premddl)); ta.Change_taille(taille); int posi = premddl -1; if ((premddl == SIG11)||(premddl==EPS11)||(premddl==DEPS11)) // cas particulier des tenseurs {ta(1)=Enum_ddl(1+posi);ta(2)=Enum_ddl(2+posi); ta(3)=Enum_ddl(4+posi); } else // cas ou ça se suit for (int i=1;i<=taille;i++) ta(i)=Enum_ddl(i+posi); break; } case 3:// on crée le tableau en fonction du type de grandeur {EnumTypeGrandeur enutype = TypeGrandeur(premddl); int taille = 0; // init if ((enutype == COORDONNEE) && (ParaGlob::AxiSymetrie())) // dans ce cas on ne garde que 2 composante {taille = 2;} else // sinon { taille=NombreElementFoncDim(enutype);}; ta.Change_taille(taille); int posi = premddl -1; for (int i=1;i<=taille;i++) ta(i)=Enum_ddl(i+posi); break; } }; return ta; }; // indique si le ddl est compatible avec la dimension #ifndef MISE_AU_POINT inline #endif bool CompatDim(const string& nom) { bool res; int dim = ParaGlob::Dimension(); res = true; // bon a priori, par exemple pour temp, epais, p etc.. switch (dim) { case 3: res = true; break; case 2: {// on récupère tout d'abord l'énuméré Enum_ddl enu = Id_nom_ddl(nom); switch (enu) {case X3: res=false;break; case UZ: res=false;break; case V3: res=false;break; case GAMMA3: res=false;break; case SIG33: res=false;break; case SIG23: res=false;break; case SIG13: res=false;break; case EPS33: res=false;break; case EPS23: res=false;break; case EPS13: res=false;break; case DEPS33: res=false;break; case DEPS23: res=false;break; case DEPS13: res=false;break; case R_X3: res=false;break; case R_EPAIS: res=true;break; case R_V3: res=false;break; case R_GAMMA3: res=false;break; case FLUXD3 :res=false;break; case GRADT3 :res=false;break; case DGRADT3 :res=false;break; default: res=true; break; }; break; } case 1: {// on récupère tout d'abord l'énuméré Enum_ddl enu = Id_nom_ddl(nom); switch (enu) {case X2 :res=false;break; case X3 :res=false;break; case UY :res=false;break; case UZ :res=false;break; case V2 :res=false;break; case V3 :res=false;break; case GAMMA2 :res=false;break; case GAMMA3 :res=false;break; case SIG22 :res=false;break; case SIG33 :res=false;break; case SIG12 :res=false;break; case SIG23 :res=false;break; case SIG13 :res=false;break; case EPS22 :res=false;break; case EPS33 :res=false;break; case EPS12 :res=false;break; case EPS23 :res=false;break; case EPS13 :res=false;break; case DEPS22 :res=false;break; case DEPS33 :res=false;break; case DEPS12 :res=false;break; case DEPS23 :res=false;break; case DEPS13 :res=false;break; case R_X2: res=false;break; case R_X3: res=false;break; case R_EPAIS: res=true;break; case R_V2: res=false;break; case R_V3: res=false;break; case R_GAMMA2: res=false;break; case R_GAMMA3: res=false;break; case FLUXD2 :res=false;break; case FLUXD3 :res=false;break; case GRADT2 :res=false;break; case GRADT3 :res=false;break; case DGRADT2 :res=false;break; case DGRADT3 :res=false;break; default: res=true; break; }; break; } }; // fin du switch sur la dimension return res; }; // indique si le ddl est compatible avec la dimension #ifndef MISE_AU_POINT inline #endif bool CompatDim(const Enum_ddl id_ddl) { bool res; int dim = ParaGlob::Dimension(); res = true; // bon a priori, par exemple pour temp, epais, p etc.. switch (dim) { case 3: res = true; break; case 2: {// on récupère tout d'abord l'énuméré switch (id_ddl) {case X3: res=false;break; case UZ: res=false;break; case V3: res=false;break; case GAMMA3: res=false;break; case SIG33: res=false;break; case SIG23: res=false;break; case SIG13: res=false;break; case EPS33: res=false;break; case EPS23: res=false;break; case EPS13: res=false;break; case DEPS33: res=false;break; case DEPS23: res=false;break; case DEPS13: res=false;break; case R_X3: res=false;break; case R_EPAIS: res=true;break; case R_V3: res=false;break; case R_GAMMA3: res=false;break; case FLUXD3 :res=false;break; case GRADT3 :res=false;break; case DGRADT3 :res=false;break; default: res=true; break; }; break; } case 1: {// on récupère tout d'abord l'énuméré switch (id_ddl) {case X2 :res=false;break; case X3 :res=false;break; case UY :res=false;break; case UZ :res=false;break; case V2 :res=false;break; case V3 :res=false;break; case GAMMA2 :res=false;break; case GAMMA3 :res=false;break; case SIG22 :res=false;break; case SIG33 :res=false;break; case SIG12 :res=false;break; case SIG23 :res=false;break; case SIG13 :res=false;break; case EPS22 :res=false;break; case EPS33 :res=false;break; case EPS12 :res=false;break; case EPS23 :res=false;break; case EPS13 :res=false;break; case DEPS22 :res=false;break; case DEPS33 :res=false;break; case DEPS12 :res=false;break; case DEPS23 :res=false;break; case DEPS13 :res=false;break; case R_X2: res=false;break; case R_X3: res=false;break; case R_EPAIS: res=true;break; case R_V2: res=false;break; case R_V3: res=false;break; case R_GAMMA2: res=false;break; case R_GAMMA3: res=false;break; case FLUXD2 :res=false;break; case FLUXD3 :res=false;break; case GRADT2 :res=false;break; case GRADT3 :res=false;break; case DGRADT2 :res=false;break; case DGRADT3 :res=false;break; default: res=true; break; }; break; } }; // fin du switch sur la dimension return res; }; // retour le type de grandeur auquel apartient l'énumération // par exemple : UY : apartiend à un COORDONNEE // SIG12 : à un tenseur, TEMP : à un scalaire #ifndef MISE_AU_POINT inline #endif EnumTypeGrandeur TypeGrandeur(Enum_ddl id_nom) { EnumTypeGrandeur res; switch (id_nom) { case X1 : res=COORDONNEE;break; case X2 :res=COORDONNEE;break; case X3 :res=COORDONNEE;break; case EPAIS :res=SCALAIRE;break; case TEMP :res=SCALAIRE;break; case UX :res=COORDONNEE;break; case UY :res=COORDONNEE;break; case UZ :res=COORDONNEE;break; case V1 :res=COORDONNEE;break; case V2 :res=COORDONNEE;break; case V3 :res=COORDONNEE;break; case PR :res=SCALAIRE;break; case GAMMA1 :res=COORDONNEE;break; case GAMMA2 :res=COORDONNEE;break; case GAMMA3 :res=COORDONNEE;break; case SIG11 :res=TENSEUR;break; case SIG22 :res=TENSEUR;break; case SIG33 :res=TENSEUR;break; case SIG12 :res=TENSEUR;break; case SIG23 :res=TENSEUR;break; case SIG13 :res=TENSEUR;break; case ERREUR :res=SCALAIRE;break; case EPS11 :res=TENSEUR;break; case EPS22 :res=TENSEUR;break; case EPS33 :res=TENSEUR;break; case EPS12 :res=TENSEUR;break; case EPS23 :res=TENSEUR;break; case EPS13 :res=TENSEUR;break; case DEPS11 :res=TENSEUR;break; case DEPS22 :res=TENSEUR;break; case DEPS33 :res=TENSEUR;break; case DEPS12 :res=TENSEUR;break; case DEPS23 :res=TENSEUR;break; case DEPS13 :res=TENSEUR;break; case PROP_CRISTA :res=SCALAIRE;break; case DELTA_TEMP :res=SCALAIRE;break; case FLUXD1 :res=COORDONNEE;break; case FLUXD2 :res=COORDONNEE;break; case FLUXD3 :res=COORDONNEE;break; case R_TEMP :res=SCALAIRE;break; case GRADT1 :res=COORDONNEE;break; case GRADT2 :res=COORDONNEE;break; case GRADT3 :res=COORDONNEE;break; case DGRADT1 :res=COORDONNEE;break; case DGRADT2 :res=COORDONNEE;break; case DGRADT3 :res=COORDONNEE;break; case R_X1 :res=COORDONNEE;break; case R_X2 :res=COORDONNEE;break; case R_X3 :res=COORDONNEE;break; case R_EPAIS :res=SCALAIRE;break; case R_V1 :res=COORDONNEE;break; case R_V2 :res=COORDONNEE;break; case R_V3 :res=COORDONNEE;break; case R_GAMMA1 :res=COORDONNEE;break; case R_GAMMA2 :res=COORDONNEE;break; case R_GAMMA3 :res=COORDONNEE;break; case NU_DDL :res=RIEN_TYPEGRANDEUR;break; default : {cout << "\nErreur : valeur incorrecte du type Enum_ddl: " << Nom_ddl(id_nom) << " !\n"; cout << "TypeGrandeur(Enum_ddl id_ddl) \n"; Sortie(1);} }; return res; }; // 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 #ifndef MISE_AU_POINT inline #endif bool Meme_famille(Enum_ddl a,Enum_ddl b) { if (a==b) return true; // cas de la même valeur // on regarde les formes numériques // cas des Xi if ( ((a==X1)||(a==X2)||(a==X3)) &&((b==X1)||(b==X2)||(b==X3))) return true; // cas des Ui if ( ((a==UX)||(a==UY)||(a==UZ)) &&((b==UX)||(b==UY)||(b==UZ))) return true; // cas des Vi if ( ((a==V1)||(a==V2)||(a==V3)) &&((b==V1)||(b==V2)||(b==V3))) return true; // cas des GAMMAI if ( ((a==GAMMA1)||(a==GAMMA2)||(a==GAMMA3)) &&((b==GAMMA1)||(b==GAMMA2)||(b==GAMMA3))) return true; // cas des sigmai if ( (a>= SIG11) && (a<= SIG13) && (b>= SIG11) && (b<= SIG13)) return true; // cas des epsiloni if ( (a>= EPS11) && (a<= EPS13) && (b>= EPS11) && (b<= EPS13)) return true; // cas des depsiloni if ( (a>= DEPS11) && (a<= DEPS13) && (b>= DEPS11) && (b<= DEPS13)) return true; // cas des températures if ( ((a == TEMP) || (a == DELTA_TEMP)) && ((b == TEMP) || (b == DELTA_TEMP))) return true; // cas des densités de flux thermique if ( ((a==FLUXD1)||(a==FLUXD2)||(a==FLUXD3)) &&((b==FLUXD1)||(b==FLUXD2)||(b==FLUXD3))) return true; // cas des réactions à la température if ( (a==R_TEMP) && (b==R_TEMP) ) return true; // cas des gradients thermiques if ( ((a==GRADT1)||(a==GRADT2)||(a==GRADT3)) &&((b==GRADT1)||(b==GRADT2)||(b==GRADT3))) return true; // cas des vitesses de gradient thermique if ( ((a==DGRADT1)||(a==DGRADT2)||(a==DGRADT3)) &&((b==DGRADT1)||(b==DGRADT2)||(b==DGRADT3))) return true; // cas des réaction sur les Xi if ( ((a==R_X1)||(a==R_X2)||(a==R_X3)) &&((b==R_X1)||(b==R_X2)||(b==R_X3))) return true; // cas des réaction sur les Vi if ( ((a==R_V1)||(a==R_V2)||(a==R_V3)) &&((b==R_V1)||(b==R_V2)||(b==R_V3))) return true; // cas des réaction sur les GAMMAI if ( ((a==R_GAMMA1)||(a==R_GAMMA2)||(a==R_GAMMA3)) &&((b==R_GAMMA1)||(b==R_GAMMA2)||(b==R_GAMMA3))) return true; // cas des réaction sur EPAIS if ( (a==R_EPAIS) && (b==R_EPAIS) ) return true; // sinon non de la même famille return false; }; // ramène le premier ddl de la même famille #ifndef MISE_AU_POINT inline #endif Enum_ddl PremierDdlFamille(Enum_ddl a) { switch (a) { case X1 : return(X1); break; case X2 : return(X1); break; case X3 : return(X1); break; case EPAIS : return(EPAIS); break; case TEMP : return(TEMP); break; case UX : return(UX); break; case UY : return(UX); break; case UZ : return(UX); break; case V1 : return(V1); break; case V2 : return(V1); break; case V3 : return(V1); break; case PR : return(PR); break; case GAMMA1 : return(GAMMA1); break; case GAMMA2 : return(GAMMA1); break; case GAMMA3 : return(GAMMA1); break; case SIG11 : return(SIG11); break; case SIG22 : return(SIG11); break; case SIG33 : return(SIG11); break; case SIG12 : return(SIG11); break; case SIG23 : return(SIG11); break; case SIG13 : return(SIG11); break; case ERREUR : return(ERREUR); break; case EPS11 : return(EPS11); break; case EPS22 : return(EPS11); break; case EPS33 : return(EPS11); break; case EPS12 : return(EPS11); break; case EPS23 : return(EPS11); break; case EPS13 : return(EPS11); break; case DEPS11 : return(DEPS11); break; case DEPS22 : return(DEPS11); break; case DEPS33 : return(DEPS11); break; case DEPS12 : return(DEPS11); break; case DEPS23 : return(DEPS11); break; case DEPS13 : return(DEPS11); break; case PROP_CRISTA : return(PROP_CRISTA); break; case DELTA_TEMP : return(DELTA_TEMP); break; case FLUXD1 : return(FLUXD1); break; case FLUXD2 : return(FLUXD1); break; case FLUXD3 : return(FLUXD1); break; case R_TEMP : return(R_TEMP); break; case GRADT1 : return(GRADT1); break; case GRADT2 : return(GRADT1); break; case GRADT3 : return(GRADT1); break; case DGRADT1 : return(DGRADT1); break; case DGRADT2 : return(DGRADT1); break; case DGRADT3 : return(DGRADT1); break; case R_X1 : return(R_X1); break; case R_X2 : return(R_X1); break; case R_X3 : return(R_X1); break; case R_EPAIS : return(R_EPAIS); break; case R_V1 : return(R_V1); break; case R_V2 : return(R_V1); break; case R_V3 : return(R_V1); break; case R_GAMMA1 : return(R_GAMMA1); break; case R_GAMMA2 : return(R_GAMMA1); break; case R_GAMMA3 : return(R_GAMMA1); break; case NU_DDL : return(NU_DDL); break; default : {cout << "\nErreur : valeur incorrecte du type Enum_ddl: " << a; cout << "\nEnum_ddl PremierDdlFamille(Enum_ddl a)\n"; Sortie(1); } }; Sortie(1); // cas qui n'arrive jamais, c'est pour faire taire le compilo return NU_DDL; // }; // ramène un nom générique pour la famille de ddl du même type #ifndef MISE_AU_POINT inline #endif string NomGeneric(Enum_ddl a) { string result=""; switch (a) {case X1 : result="Xi"; break; case X2 : result="Xi"; break; case X3 : result="Xi"; break; case EPAIS : result="EPAIS"; break; case TEMP : result="TEMP"; break; case UX : result="Ui"; break; case UY : result="Ui"; break; case UZ : result="Ui"; break; case V1 : result="Vi"; break; case V2 : result="Vi"; break; case V3 : result="Vi"; break; case PR : result="PR"; break; case GAMMA1 : result="GAMMAi"; break; case GAMMA2 : result="GAMMAi"; break; case GAMMA3 : result="GAMMAi"; break; case SIG11 : result="Sigmaij"; break; case SIG22 : result="Sigmaij"; break; case SIG33 : result="Sigmaij"; break; case SIG12 : result="Sigmaij"; break; case SIG23 : result="Sigmaij"; break; case SIG13 : result="Sigmaij"; break; case ERREUR : result="ERREUR"; break; case EPS11 : result="Epsilonij"; break; case EPS22 : result="Epsilonij"; break; case EPS33 : result="Epsilonij"; break; case EPS12 : result="Epsilonij"; break; case EPS23 : result="Epsilonij"; break; case EPS13 : result="Epsilonij"; break; case DEPS11 : result="Dij"; break; case DEPS22 : result="Dij"; break; case DEPS33 : result="Dij"; break; case DEPS12 : result="Dij"; break; case DEPS23 : result="Dij"; break; case DEPS13 : result="Dij"; break; case PROP_CRISTA : result="PROP_CRISTA"; break; case DELTA_TEMP : result="DELTA_TEMP"; break; case FLUXD1 : result="FLUXD"; break; case FLUXD2 : result="FLUXD"; break; case FLUXD3 : result="FLUXD"; break; case R_TEMP : result="R_TEMP"; break; case GRADT1 : result="GRADT"; break; case GRADT2 : result="GRADT"; break; case GRADT3 : result="GRADT"; break; case DGRADT1 : result="DGRADT"; break; case DGRADT2 : result="DGRADT"; break; case DGRADT3 : result="DGRADT"; break; case R_X1 : result="R_Xi"; break; case R_X2 : result="R_Xi"; break; case R_X3 : result="R_Xi"; break; case R_EPAIS : result="R_EPAIS"; break; case R_V1 : result="R_Vi"; break; case R_V2 : result="R_Vi"; break; case R_V3 : result="R_Vi"; break; case R_GAMMA1 : result="R_GAMMAi"; break; case R_GAMMA2 : result="R_GAMMAi"; break; case R_GAMMA3 : result="R_GAMMAi"; break; case NU_DDL : result="NU_DDL"; break; default : {cout << "\nErreur : valeur incorrecte du type Enum_ddl: " << a; cout << "\nEnum_ddl NomGeneric(Enum_ddl a)\n"; Sortie(1); } }; return result; // }; // test si le ddl appartient à la combinaison donné par cas // cas : spécifie la combinaison : =1 -> combinaison X V GAMMA #ifndef MISE_AU_POINT inline #endif bool Dans_combinaison(int cas,Enum_ddl enu) {bool retour; switch (cas) { case 0 : retour = false; break; case 1 : // cas de l'association X V GAMMA { Enum_ddl a = PremierDdlFamille(enu); if ((a==X1)||(a==V1)||(a==GAMMA1)) retour = true; else retour = false; break; } default : {cout << "\nErreur : cas de combinaison non encore implanté, cas= " << cas << "\n Dans_combinaison(int cas,Enum_ddl a) \n"; Sortie(1); } }; return retour; }; // 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 #ifndef MISE_AU_POINT inline #endif EnumTypeQuelconque Equi_Enum_ddl_en_enu_quelconque(Enum_ddl a) { EnumTypeQuelconque result; switch (a) {case X1 : case X2 : case X3 : result=POSITION_GEOMETRIQUE; break; case EPAIS : result=UN_DDL_ENUM_ETENDUE; break; case TEMP : result=UN_DDL_ENUM_ETENDUE; break; case UX : case UY : case UZ : result=DEPLACEMENT; break; case V1 : case V2 : case V3 : result=VITESSE; break; case PR : result=UN_DDL_ENUM_ETENDUE; break; case GAMMA1 : case GAMMA2 : case GAMMA3 :result=ACCELERATION; break; case SIG11 : case SIG22 : case SIG33 : case SIG12 : case SIG23 : case SIG13 : result=CONTRAINTE_COURANTE; break; case ERREUR : result=UN_DDL_ENUM_ETENDUE; break; case EPS11 : case EPS22 : case EPS33 : case EPS12 : case EPS23 : case EPS13 : result=DEFORMATION_COURANTE; break; case DEPS11 : case DEPS22 : case DEPS33 : case DEPS12 : case DEPS23 : case DEPS13 : result=VITESSE_DEFORMATION_COURANTE; break; case PROP_CRISTA : result=UN_DDL_ENUM_ETENDUE; break; case DELTA_TEMP : result=UN_DDL_ENUM_ETENDUE; break; case FLUXD1 : case FLUXD2 : case FLUXD3 : result=FLUXD; break; case R_TEMP : result=UN_DDL_ENUM_ETENDUE; break; case GRADT1 : case GRADT2 : case GRADT3 : result=GRADT; break; case DGRADT1 : case DGRADT2 : case DGRADT3 : result=DGRADT; break; case R_X1 : result=UN_DDL_ENUM_ETENDUE; break; case R_X2 : result=UN_DDL_ENUM_ETENDUE; break; case R_X3 : result=UN_DDL_ENUM_ETENDUE; break; case R_EPAIS : result=UN_DDL_ENUM_ETENDUE; break; case R_V1 : result=UN_DDL_ENUM_ETENDUE; break; case R_V2 : result=UN_DDL_ENUM_ETENDUE; break; case R_V3 : result=UN_DDL_ENUM_ETENDUE; break; case R_GAMMA1 : result=UN_DDL_ENUM_ETENDUE; break; case R_GAMMA2 : result=UN_DDL_ENUM_ETENDUE; break; case R_GAMMA3 : result=UN_DDL_ENUM_ETENDUE; break; case NU_DDL : result=UN_DDL_ENUM_ETENDUE; break; default : {cout << "\nErreur : valeur incorrecte du type Enum_ddl: " << a; cout << "\nEnum_ddl NomGeneric(Enum_ddl a)\n"; Sortie(1); } }; return result; // }; // 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 #ifndef MISE_AU_POINT inline #endif Tableau MemeCombinaison(int cas,Enum_ddl a) { Tableau t_ret; switch (cas) { case 0 : // cas pas d'association { t_ret.Change_taille(1); // dimmensionnement du tableau de retour t_ret(1)=a; break; } case 1 : // cas de l'association X V GAMMA { t_ret.Change_taille(3); // dimmensionnement du tableau de retour Enum_ddl b = PremierDdlFamille(a); #ifdef MISE_AU_POINT if ( (X1 != b) && (V1 != b) && (GAMMA1 != b)) // erreur {cout << "\nErreur : ddl ne faisant pas partie de la combinaison 1, " << Nom_ddl(a) << "\n Tableau MemeCombinaison(int cas,Enum_ddl a) \n"; Sortie(1); }; #endif t_ret(1) = Enum_ddl(X1 + (a-b)); t_ret(2) = Enum_ddl(V1 + (a-b)); t_ret(3) = Enum_ddl(GAMMA1 + (a-b)); break; } default : {cout << "\nErreur : cas de combinaison non encore implanté, cas= " << cas << "\n Tableau MemeCombinaison(int cas,Enum_ddl a) \n"; Sortie(1); } }; return t_ret; }; #ifndef MISE_AU_POINT inline #endif // ramène tous les membres d'une même combinaison, pour i=1 à dim Tableau Combinaison(int cas) { Tableau t_ret; switch (cas) {case 0 : // cas pas d'association { t_ret.Change_taille(0); // dimmensionnement du tableau de retour break; } case 1 : // cas de l'association X V GAMMA { int dim = ParaGlob::Dimension(); t_ret.Change_taille(3*dim); // dimmensionnement du tableau de retour switch (dim) { case 3: t_ret(3) = X3; t_ret(3+dim) = V3;t_ret(3+2*dim) = GAMMA3; case 2: t_ret(2) = X2; t_ret(2+dim) = V2;t_ret(2+2*dim) = GAMMA2; case 1: t_ret(1) = X1; t_ret(1+dim) = V1;t_ret(1+2*dim) = GAMMA1; }; // t_ret(1) = X1; t_ret(1+dim) = V1;t_ret(1+2*dim) = GAMMA1; // if (dim==1) break; // t_ret(2) = X2; t_ret(2+dim) = V2;t_ret(2+2*dim) = GAMMA2; // if (dim==2) break; // t_ret(3) = X3; t_ret(3+dim) = V3;t_ret(3+2*dim) = GAMMA3; break; } default : {cout << "\nErreur : cas de combinaison non encore implanté, cas= " << cas << "\n Tableau Combinaison(int cas) \n"; Sortie(1); } }; return t_ret; }; // passage de Ui en Xi, c-a-d : UX -> X1, UY -> X2, UZ -> X3 #ifndef MISE_AU_POINT inline #endif Enum_ddl UxyzXi(Enum_ddl en) { if (en == UX) en = X1; else if(en == UY) en = X2; else if(en == UZ) en = X3; else { cout << "\nErreur : nom du degre de liberte " << Nom_ddl(en) << " , different de UX ou UY ou UZ !\n"; cout << "UxyzXi(Enum_ddl en) \n"; Sortie(1); }; return en; }; // passage inverse #ifndef MISE_AU_POINT inline #endif Enum_ddl XiUxyz(Enum_ddl en) { if (en == X1 ) en = UX; else if(en == X2) en = UY; else if(en == X3) en = UZ; else { cout << "\nErreur : nom du degre de liberte " << Nom_ddl(en) << " , different de X1 ou X2 ou X3 !\n"; cout << "XiUxyzi(Enum_ddl en) \n"; Sortie(1); }; return en; }; //----------- pour les Coordonnee -------------- // retourne l'indice en fonction de l'enum et du nbcomposante // pour une grandeur de type Coordonnee, sinon erreur #ifndef MISE_AU_POINT inline #endif int Indice_coor(Enum_ddl a,int nbcomposantes) {return a-PremierDdlFamille(a)+1;}; // 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) -> l'indices du tenseur correspondant // au i ième ddl de containte à partir de SIG11 #ifndef MISE_AU_POINT inline #endif Tableau2 OrdreContrainte(int nbcomposantes) { // def du tableau de retour Tableau2 ordre(nbcomposantes,2,0); switch (nbcomposantes) { case 1 : ordre(1,1) = 1; // -> SIG11 ordre(1,2) = 1; // " break; case 3 : // cas symétrique ordre(1,1) = 1; // -> SIG11 ordre(1,2) = 1; // " ordre(2,1) = 2; // -> SIG22 ordre(2,2) = 2; // " ordre(3,1) = 1; // -> SIG12 ordre(3,2) = 2; // " break; case 6 : ordre(1,1) = 1; // -> SIG11 ordre(1,2) = 1; // " ordre(2,1) = 2; // -> SIG22 ordre(2,2) = 2; // " ordre(3,1) = 3; // -> SIG33 ordre(3,2) = 3; // " ordre(4,1) = 1; // -> SIG12 ordre(4,2) = 2; // " ordre(5,1) = 2; // -> SIG23 ordre(5,2) = 3; // " ordre(6,1) = 1; // -> SIG13 ordre(6,2) = 3; // " break; case 9 : // ***** erreur il ne doit pas y avoir le cas de 9 valeurs // car cela n'a rien à voire avec les enum_ddl // il s'agit en fait de l'utilisation des fonctions OdVect et idx_i et idx_j // des tenseurs donc à revoir !! cout << "\nErreur : valeur incorrecte du nombre de composantes !\n" << " \n nombre = 9 "; cout << "\n OrdreContrainte(int nbcomposantes) \n"; Sortie(1); /* // initialisation avec 9 valeurs différentes correspodantes aux trois // lignes : (1,1) (1,2) (1,3) ; (2,1) (2,2) (2,3) ; (3,1) (3,2) (3,3) ordre(1,1) = 1; // -> SIG11 ordre(1,2) = 1; // " ordre(2,1) = 1; // -> SIG12 ordre(2,2) = 2; // " ordre(3,1) = 1; // -> SIG13 ordre(3,2) = 3; // " ordre(4,1) = 2; // -> SIG21 ordre(4,2) = 1; // " ordre(5,1) = 2; // -> SIG22 ordre(5,2) = 2; // " ordre(6,1) = 2; // -> SIG23 ordre(6,2) = 3; // " ordre(7,1) = 3; // -> SIG31 ordre(7,2) = 1; // " ordre(8,1) = 3; // -> SIG32 ordre(8,2) = 2; // " ordre(9,1) = 3; // -> SIG33 ordre(9,2) = 3; // "*/ break; default : {cout << "\nErreur : valeur incorrecte du nombre de composantes !\n"; cout << "OrdreContrainte(int nbcomposantes) \n"; Sortie(1); } }; return ordre; }; // idem en fonction du nombre de composantes // fonction très rapide qui pointe sur des tableaux déjà construits #ifndef MISE_AU_POINT inline #endif const Tableau2 & OrdreContrainteR(int nbcomposantes) {switch (nbcomposantes) { case 1 : return OrdreContrainte1; break; case 3 : return OrdreContrainte3; break; case 6 : return OrdreContrainte6; break; default : {cout << "\nErreur : valeur incorrecte du nombre de composantes : " << nbcomposantes << " !\n"; cout << "OrdreContrainteR(int nbcomposantes) \n"; Sortie(1); } }; return OrdreContrainte1; // pour taire le compilo !! }; // donne directement le premier et le second indice en fonction de l'enum et du nbcomposante // pour les tenseurs sigma ou epsilon ou Depsilon #ifndef MISE_AU_POINT inline #endif Deuxentiers_enu IJind(Enum_ddl a,int nbcomposantes) { Enum_ddl b = a; if ( PremierDdlFamille(a) == EPS11) b = Enum_ddl(SIG11 + (a-EPS11)); // transfo en équivalent sigma if ( PremierDdlFamille(a) == DEPS11) b = Enum_ddl(SIG11 + (a-DEPS11)); // transfo en équivalent sigma Deuxentiers_enu ret; ret.i=-1; ret.j=-1; switch (nbcomposantes) { case 1: switch (b) { case SIG11: ret.i=1; ret.j=1;break; default : {cout << "\nErreur : valeur incorrecte de l'énumération en fonction du nombre de composantes : " << "enu= " << Nom_ddl(a) << " nbcomposantes " << nbcomposantes << " !\n"; cout << "IJind(Enum_ddl a,int nbcomposantes)\n"; Sortie(1); } }; break; case 3: switch (b) { case SIG11: ret.i=1; ret.j=1;break; case SIG22: ret.i=2; ret.j=2;break; case SIG12: ret.i=1; ret.j=2;break; default : {cout << "\nErreur : valeur incorrecte de l'énumération en fonction du nombre de composantes : " << "enu= " << Nom_ddl(a) << " nbcomposantes " << nbcomposantes << " !\n"; cout << "IJind(Enum_ddl a,int nbcomposantes)\n"; Sortie(1); } }; break; case 6: switch (b) { case SIG11: ret.i=1; ret.j=1;break; case SIG22: ret.i=2; ret.j=2;break; case SIG33: ret.i=3; ret.j=3;break; case SIG12: ret.i=1; ret.j=2;break; case SIG23: ret.i=2; ret.j=3;break; case SIG13: ret.i=1; ret.j=3;break; default : {cout << "\nErreur : valeur incorrecte de l'énumération en fonction du nombre de composantes : " << "enu= " << Nom_ddl(a) << " nbcomposantes " << nbcomposantes << " !\n"; cout << "IJind(Enum_ddl a,int nbcomposantes)\n"; Sortie(1); } }; break; default : {cout << "\nErreur : valeur incorrecte du nombre de composantes : " << nbcomposantes << " !\n"; cout << "IJind(Enum_ddl a,int nbcomposantes)\n"; Sortie(1); } }; return ret; }; // passage de enum_ddl vers des réactions enum_ddl correspondantes // exemple X1 -> R_X1 etc.. #ifndef MISE_AU_POINT inline #endif Enum_ddl Vers_enum_reac(Enum_ddl id_nom) { Enum_ddl result; switch (id_nom) {case X1 : result=R_X1;break; case X2 : result=R_X2;break; case X3 : result=R_X3;break; case EPAIS : result=R_EPAIS;break; case V1 : result=R_V1;break; case V2 : result=R_V2;break; case V3 : result=R_V3;break; case GAMMA1 :result=R_GAMMA1;break; case GAMMA2 :result=R_GAMMA2;break; case GAMMA3 :result=R_GAMMA3;break; case TEMP :result=R_TEMP;break; default : {cout << "\nErreur : enum de reaction non implante pour le ddl : " << Nom_ddl(id_nom) << "!\n"; cout << "Vers_enum_reac(Enum_ddl ) \n"; Sortie(1); } }; return result; }; // opération inverse: exemple R_X1 -> X1 #ifndef MISE_AU_POINT inline #endif Enum_ddl Enum_reac_vers_enum(Enum_ddl id_nom) { Enum_ddl result; switch (id_nom) { case R_X1 : result=X1;break; case R_X2 : result=X2;break; case R_X3 : result=X3;break; case R_EPAIS : result=EPAIS;break; case R_V1 : result=V1;break; case R_V2 : result=V2;break; case R_V3 : result=V3;break; case R_GAMMA1 :result=GAMMA1;break; case R_GAMMA2 :result=GAMMA2;break; case R_GAMMA3 :result=GAMMA3;break; case R_TEMP :result=TEMP;break; default : {cout << "\nErreur : enum de reaction non implante pour le ddl : " << Nom_ddl(id_nom) << "!\n"; cout << "Enum_reac_vers_enum(Enum_ddl ) \n"; Sortie(1); } }; return result; }; // indique si un ddl est un ddl de réaction on non #ifndef MISE_AU_POINT inline #endif bool Ddl_reaction(Enum_ddl id_ddl) { bool res; switch (id_ddl) { case R_X1: res=true;break; case R_X2: res=true;break; case R_X3: res=true;break; case R_EPAIS: res=true;break; case R_V1: res=true;break; case R_V2: res=true;break; case R_V3: res=true;break; case R_GAMMA1: res=true;break; case R_GAMMA2: res=true;break; case R_GAMMA3: res=true;break; case R_TEMP: res=true;break; default : res = false; break; } return res; }; // surcharge de l'operator de lecture #ifndef MISE_AU_POINT inline #endif istream & operator >> (istream & entree, Enum_ddl& a) { char nom_Enum_ddl[nbmax_caractere_enum_ddl+5]; entree >> nom_Enum_ddl; a = Id_nom_ddl ( nom_Enum_ddl); return entree; }; // surcharge de l'operator d'ecriture #ifndef MISE_AU_POINT inline #endif ostream & operator << (ostream & sort, const Enum_ddl& a) { // on ecrit la forme caractère sort << setw (nbmax_caractere_enum_ddl+2) << Nom_ddl(a) << " "; return sort; }; #endif