// 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-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 <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.

#include "Isovaleurs_Gmsh.h"

// pour le tableau de connection herezh -> gmsh
#include "Visualisation_Gmsh.h"

using namespace std;
#include <iomanip>
#include <algorithm>
#include "CharUtil.h"
#include "Coordonnee2.h"
#include "ConstMath.h"
#include "MathUtil.h"
#include "Banniere.h"
#include "TypeQuelconqueParticulier.h"
#include "Visualisation_Gmsh.h"

// ------- les variables statiques ---------
Isovaleurs_Gmsh::ConstructTabScalVecTensGmsh Isovaleurs_Gmsh::tabScalVecTensGmsh;

// constructeur pour la variable statique

Isovaleurs_Gmsh::ConstructTabScalVecTensGmsh::ConstructTabScalVecTensGmsh():
 // il y a 15 types  d'éléments possibles en sortie d'isovaleurs dans gmsh, les linéaires
 // et les quadratiques, + du texte  en 2D ou 3D  
 scalar_pourView(15),vector_pourView(15),tensor_pourView(15),text_pourView(2)
  	{
     scalar_pourView(15)="SP"; // Scalar point SP 3 1 * nb-time-steps
     vector_pourView(15)="VP"; //Vector point VP 3 3 * nb-time-steps
     tensor_pourView(15)="TP"; //Tensor point TP 3 9 * nb-time-steps

     scalar_pourView(1)="SL"; // Scalar line SL 6 2 * nb-time-steps
     vector_pourView(1)="VL"; //Vector line VL 6 6 * nb-time-steps
     tensor_pourView(1)="TL"; //Tensor line TL 6 18 * nb-time-steps

     scalar_pourView(2)="ST"; // Scalar triangle ST 9 3 * nb-time-steps
     vector_pourView(2)="VT"; //Vector triangle VT 9 9 * nb-time-steps
     tensor_pourView(2)="TP"; //Tensor triangle TT 9 27 * nb-time-steps

     scalar_pourView(3)="SQ"; // Scalar quadrangle SQ 12 4 * nb-time-steps
     vector_pourView(3)="VQ"; //Vector quadrangle VQ 12 12 * nb-time-steps
     tensor_pourView(3)="TQ"; //Tensor quadrangle TQ 12 36 * nb-time-steps

     scalar_pourView(4)="SS"; // Scalar tetrahedron SS 12 4 * nb-time-steps
     vector_pourView(4)="VS"; //Vector tetrahedron VS 12 12 * nb-time-steps
     tensor_pourView(4)="TS"; //Tensor tetrahedron TS 12 36 * nb-time-steps

     scalar_pourView(5)="SH"; // Scalar hexahedron SH 24 8 * nb-time-steps
     vector_pourView(5)="VH"; //Vector hexahedron VH 24 24 * nb-time-steps
     tensor_pourView(5)="TH"; //Tensor hexahedron TH 24 72 * nb-time-steps

     scalar_pourView(6)="SI"; // Scalar prism SI 18 6 * nb-time-steps
     vector_pourView(6)="VI"; //Vector prism VI 18 18 * nb-time-steps
     tensor_pourView(6)="TI"; //Tensor prism TI 18 54 * nb-time-steps

     scalar_pourView(7)="SY"; // Scalar pyramid SY 15 5 * nb-time-steps
     vector_pourView(7)="VY"; //Vector pyramid VY 15 15 * nb-time-steps
     tensor_pourView(7)="TY"; //Tensor pyramid TY 15 45 * nb-time-steps

     scalar_pourView(8)="SL2"; // Second order scalar line SL2 9 3 * nb-time-steps
     vector_pourView(8)="VL2"; //Second order vector line VL2 9 9 * nb-time-steps
     tensor_pourView(8)="TL2"; //Second order tensor line TL2 9 27 * nb-time-steps

     scalar_pourView(9)="ST2"; // Second order scalar triangle ST2 18 6 * nb-time-steps
     vector_pourView(9)="VT2"; //Second order vector triangle VT2 18 18 * nb-time-steps
     tensor_pourView(9)="TT2"; //Second order tensor triangle TT2 18 54 * nb-time-steps

     scalar_pourView(10)="SQ2"; // Second order scalar quadrangle SQ2 27 9 * nb-time-steps
     vector_pourView(10)="VQ2"; //Second order vector quadrangle VQ2 27 27 * nb-time-steps
     tensor_pourView(10)="TQ2"; //Second order tensor quadrangle TQ2 27 81 * nb-time-steps 

     scalar_pourView(11)="SS2"; // Second order scalar tetrahedron SS2 30 10 * nb-time-steps
     vector_pourView(11)="VS2"; //Second order vector tetrahedron VS2 30 30 * nb-time-steps
     tensor_pourView(11)="TS2"; //Second order tensor tetrahedron TS2 30 90 * nb-time-steps

     scalar_pourView(12)="SH2"; // Second order scalar hexahedron SH2 81 27 * nb-time-steps
     vector_pourView(12)="VH2"; //Second order vector hexahedron VH2 81 81 * nb-time-steps
     tensor_pourView(12)="TH2"; //Second order tensor hexahedron TH2 81 243* nb-time-steps

     scalar_pourView(13)="SI2"; // Second order scalar prism SI2 54 18 * nb-time-steps
     vector_pourView(13)="VI2"; //Second order vector prism VI2 54 54 * nb-time-steps
     tensor_pourView(13)="TI2"; //Second order tensor prism TI2 54 162* nb-time-steps

     scalar_pourView(14)="SY2"; // Second order scalar pyramid SY2 42 14 * nb-time-steps
     vector_pourView(14)="VY2"; //Second order vector pyramid VY2 42 42 * nb-time-steps
     tensor_pourView(14)="TY2"; //Second order tensor pyramid TY2 42 126* nb-time-steps

     text_pourView(1) = "T2"; //2D text T2 3 arbitrary
     text_pourView(2) = "T3"; //3D text T3 4 arbitrary 		
 	};

// ------- fin des variables statiques -----



    // CONSTRUCTEURS :
// par defaut
Isovaleurs_Gmsh::Isovaleurs_Gmsh () :
   OrdreVisu("........................................isovaleurs"
             ,"visualisation des isovaleurs","iso")
   ,li_P_gauss_total()//,tab_point_enum()
   ,tp_tp_tp_gauss_base(),map_gauss_base(),map_gauss_basePQ(),map_gauss_baseEVol()
   ,map_gauss_tab_baseEVol(),map_gauss_tab_basePQ()
   ,tabnoeud_type_ddl(),tabnoeud_type_ddl_retenu(),choix_var_ddl()
   ,tabnoeud_type_ddlEtendu(),tabnoeud_type_ddlEtendu_retenu()
   ,a_accumuler_tabnoeud_type_ddlEtendu_retenu()
   ,a_accumuler_tabnoeud_type_ddlEtendu()
   ,tabnoeud_evoluee(),tabnoeud_evoluee_retenu()
   ,a_accumuler_tabnoeud_evoluee_retenu(),a_accumuler_tabnoeud_evoluee()
   ,list_vect_globalPourNoeud(),list_vect_globalPourNoeud_retenu()
   ,tabelement_type_ddl(),tabelement_type_ddl_retenu()
   ,tabelement_evoluee(),tabelement_evoluee_retenu()
   ,tabelement_typeParti(),tabelement_typeParti_retenu()
   ,mailInitial(NULL),lesMail(NULL)
   ,cas_transfert(1)
   ,glob_noe_ddl_retenu(),t_g_noeud_ddl_asortir()
   ,glob_noeud_ddl_etendu_retenu(),t_g_noeud_ddl_etendu_asortir()
   ,glob_noeud_evol_retenu(),t_g_noeud_evoluee_asortir()
   ,glob_elem_ddl_retenu(),t_g_elem_ddl_asortir()
   ,glob_elem_evol_retenu(),t_g_elem_evoluee_asortir()
   ,glob_elem_Parti_retenu(),t_g_elem_typeParti_asortir(),tab_quelconque(2)
   ,nomsGrandeursSortie(),use_hold_gmsh_format(false)
   ,absolue(true),li_glob_restreinte_TQ()
     { for (int i=1; i<=2; i++) tab_quelconque(i)=NULL;
     }; 
     
    // constructeur de copie 
Isovaleurs_Gmsh::Isovaleurs_Gmsh (const Isovaleurs_Gmsh& ord) :
    OrdreVisu(ord) 
   ,li_P_gauss_total(ord.li_P_gauss_total)
 //  ,tab_point_enum(ord.tab_point_enum)
   ,tp_tp_tp_gauss_base(ord.tp_tp_tp_gauss_base)
//   ,map_gauss_base(ord.map_gauss_base)  // PB ???
//   ,map_gauss_basePQ(ord.map_gauss_basePQ),map_gauss_baseEVol(ord.map_gauss_baseEVol) // pb ???
   ,map_gauss_base()
   ,map_gauss_basePQ(),map_gauss_baseEVol()
   ,map_gauss_tab_baseEVol(),map_gauss_tab_basePQ()
   ,tabnoeud_type_ddl(),tabnoeud_type_ddl_retenu(),choix_var_ddl()
   ,tabelement_type_ddl(),tabelement_type_ddl_retenu()
   ,tabnoeud_type_ddlEtendu(ord.tabnoeud_type_ddlEtendu)
   ,tabnoeud_type_ddlEtendu_retenu(ord.tabnoeud_type_ddlEtendu_retenu)
   ,a_accumuler_tabnoeud_type_ddlEtendu_retenu(ord.a_accumuler_tabnoeud_type_ddlEtendu_retenu)
   ,a_accumuler_tabnoeud_type_ddlEtendu(ord.a_accumuler_tabnoeud_type_ddlEtendu)
   ,tabnoeud_evoluee(ord.tabnoeud_evoluee)
   ,tabnoeud_evoluee_retenu(ord.tabnoeud_evoluee_retenu)
   ,a_accumuler_tabnoeud_evoluee(ord.a_accumuler_tabnoeud_evoluee)
   ,a_accumuler_tabnoeud_evoluee_retenu(ord.a_accumuler_tabnoeud_evoluee_retenu)
   ,list_vect_globalPourNoeud(ord.list_vect_globalPourNoeud)
   ,list_vect_globalPourNoeud_retenu(ord.list_vect_globalPourNoeud_retenu)
   ,tabelement_evoluee(ord.tabelement_evoluee)
   ,tabelement_evoluee_retenu(ord.tabelement_evoluee_retenu)
   ,tabelement_typeParti(ord.tabelement_typeParti)
   ,tabelement_typeParti_retenu(ord.tabelement_typeParti_retenu)
   ,mailInitial(ord.mailInitial),lesMail(ord.lesMail)
   ,cas_transfert(ord.cas_transfert)
   ,glob_noe_ddl_retenu(),t_g_noeud_ddl_asortir()
   ,glob_noeud_ddl_etendu_retenu(),t_g_noeud_ddl_etendu_asortir()
   ,glob_noeud_evol_retenu(),t_g_noeud_evoluee_asortir()
   ,glob_elem_ddl_retenu(),t_g_elem_ddl_asortir()
   ,glob_elem_evol_retenu(),t_g_elem_evoluee_asortir()
   ,glob_elem_Parti_retenu(),t_g_elem_typeParti_asortir(),tab_quelconque(2)
   ,nomsGrandeursSortie(ord.nomsGrandeursSortie)
	  ,use_hold_gmsh_format(ord.use_hold_gmsh_format)
   ,absolue(ord.absolue)
   ,li_glob_restreinte_TQ(ord.li_glob_restreinte_TQ)
     { // il y a un pb avec les maps au niveau du constructeur de copie ??
       // impossible de comprendre, mais comme d'une part on ne s'en sert pas souvent et d'autre part à terme on utilisera
       // des tables de hashage, on implante une fonction ayant le même effet mais plus longue
       //  cas de map_gauss_base
       map < string,  List_io < Ddl_enum_etendu > , std::less <string> >::const_iterator im,imfin=ord.map_gauss_base.end();
       for (im = ord.map_gauss_base.begin();im!=imfin;im++)
          map_gauss_base[(*im).first]=(*im).second;
       //  cas de map_gauss_baseEVol
       map < string,  List_io < TypeQuelconque > , std::less <string> >::const_iterator im2,im2fin=ord.map_gauss_baseEVol.end();
       for (im2 = ord.map_gauss_baseEVol.begin();im2!=im2fin;im2++)
          map_gauss_baseEVol[(*im2).first]=(*im2).second;
       //  cas de map_gauss_basePQ
       map < string,  List_io < TypeQuelconque > , std::less <string> >::const_iterator im3,im3fin=ord.map_gauss_basePQ.end();
       for (im3 = ord.map_gauss_basePQ.begin();im3!=im3fin;im3++)
          map_gauss_basePQ[(*im3).first]=(*im3).second;
       // mise à jour du tableau de pointeur
       for (int i=1; i<=2; i++) tab_quelconque(i)=NULL;   
      };
               
    // DESTRUCTEUR :
Isovaleurs_Gmsh::~Isovaleurs_Gmsh () 
     {  };  
    
    // METHODES PUBLIQUES :
// execution de l'ordre
// tab_mail : donne les numéros de maillage concerné
// incre : numéro d'incrément qui en cours
// type_incre : indique si c'est le premier le dernier ou l'incrément courant a visualiser ou pas
// animation : indique si l'on est en animation ou pas
// unseul_incre : indique si oui ou non il y a un seul increment à visualiser
void Isovaleurs_Gmsh::ExeOrdre(ParaGlob * ,const Tableau <int>& tab_mail
                      ,LesMaillages * lesMail,bool ,LesReferences*
                      ,LesLoisDeComp* ,DiversStockage*,Charge*,LesCondLim*
                      ,LesContacts* lesContacts,Resultats*,UtilLecture & entreePrinc
                      ,OrdreVisu::EnumTypeIncre type_incre,int incre
                      ,bool ,const map < string, const double * , std::less <string> >&
                      ,const List_io < TypeQuelconque >& listeVecGlob)
 {// pour simplifier
  // visualisation du maillage pointé si actif
  if (actif)
   { // cas du premier passage , on définit les types de points de gauss associé aux infos à sortir
     if (type_incre == PREMIER_INCRE)
       {ExeOrdrePremierIncrement(tab_mail,lesMail); // ne concerne que les grandeurs définies aux pti
        InitPremierIncrExecutionTransfertAuxNoeuds(); // init pour les transferts aux noeuds, uniquement pour les grandeurs aux pti
		      if(!use_hold_gmsh_format)
		      // dans le cas du nouveau format, on sort au début du fichier : le maillage initiale: noeuds et éléments
		      // ensuite à chaque incrément on ne sortira que les valeurs aux noeuds ou aux éléments
		      // -- ici l'objectif est de tout mettre dans un seul groupe de résultat de manière à pouvoir tout
		      // -- visualiser en même temps
		      // --on ne traite que s'il y a des ddl 
         { bool atraiter = false;
				       {if (   (glob_noe_ddl_retenu.size() != 0)
                || (glob_noeud_ddl_etendu_retenu.size() != 0)
                || (glob_noeud_evol_retenu.size() != 0)
                || (glob_elem_ddl_retenu.size() != 0)
                || (glob_elem_evol_retenu.size() != 0)
                || (glob_elem_Parti_retenu.size() != 0)
               )
                  atraiter = true;
				       };
           if (atraiter)   
					       { // on balaie la liste des noms des différentes grandeurs à sortir en résultat
					         // car on doit sortir le maillage initiale pour chaque grandeur, mais ceci une seule fois
					         list <string>::const_iterator ili,ilifin = nomsGrandeursSortie.end();
					         for (ili=nomsGrandeursSortie.begin();ili != ilifin; ili++)
						          { ostream &sort = entreePrinc.Sort_resultat_Gmsh((*ili));
						            mailInitial->sortie_maillage_initial(tab_mail,lesMail,sort);
						          };
              // dans le cas de contact on alimente des listes particulières
              lesContacts->List_reduite_aux_contact(glob_noeud_evol_retenu
                                                    ,li_glob_restreinte_TQ
                                                    );
              // ajout des conteneurs de manière systématique
              Tableau <List_io < TypeQuelconque > * > tabQ(2);
              tabQ(1)= &li_glob_restreinte_TQ; tabQ(2)=NULL;
              List_io < Ddl_enum_etendu > vide;
              lesMail->AjoutConteneurAuNoeud(vide,tabQ);
					       };
			      };
		     };
     // cas général  
     // -------------------------------------------------------------------------------------------------
     // I - On commence par s'occuper des ddl aux pt d'integ 
     //     ensuite les noeuds car pendant le calcul aux pt integ, on fait le transfert aux noeuds
     //     qui ensuite sera traité pour la visualisation par les noeuds
     // -------------------------------------------------------------------------------------------------
     try
      { CalculAuxPtInteg(tab_mail,lesMail);}
     catch ( ... )
      { cout << "\n erreur dans le calcul aux points d'integration, pour la sortie d'isovaleur "
             << " les fichiers de sortie seront errones "<< endl;
      };
     try
      { CalculAuxElemAuxNoeuds(tab_mail,lesMail);}
     catch ( ... )
       { cout << "\n erreur dans le calcul aux elements ou aux noeuds, pour la sortie d'isovaleur "
              << " les fichiers de sortie seront errones "<< endl;
       };

     // -------------------------------------------------------
     //  II - traitement des degrés de libertés aux noeuds 
     // -------------------------------------------------------
     // dans le cas de contact du aux stockages des infos de contact aux noeuds
     // on fait un prétraitement
     // -> on initialise par défaut les conteneurs
     lesMail->Init_par_defaut_conteneurs(li_glob_restreinte_TQ);
     // -> alimentation par le contact des conteneurs
     lesContacts->Mise_a_jour_Pour_Grandeur_particuliere(li_glob_restreinte_TQ);
 

     if(use_hold_gmsh_format) // choix entre ancien et nouveau format
	      {EcritureAuxNoeuds_ancien_format(tab_mail,lesMail,incre,entreePrinc);}
	    else 	 
	      {EcritureAuxNoeuds(tab_mail,lesMail,incre,entreePrinc);}
   }; //-- fin du choix actif ou pas  
 };

// choix de l'ordre, cet méthode peut entraîner la demande d'informations
// supplémentaires si nécessaire. qui sont ensuite gérer par la classe elle même
void Isovaleurs_Gmsh::ChoixOrdre()
 { bool choix_valide = false;
   cout << "\n ---- isovaleurs ---- ";
   string rep;
   while (!choix_valide)
    {
     try 
      { if (ParaGlob::Francais())
         {cout 
          << "\n (0 ou f ou fin) fin modif"
          << "\n (1) ou (de) parametres par defaut: "
          << "\n (2) ou (to) toutes les isovaleurs "
          << "\n (3) parametres generaux pour la sortie "
          << "\n (4) ddl naturellement defini aux noeuds "
          << "\n (5) grandeurs scalaires venant des pts integ "
          << "\n (6) grandeurs tensoriel venant des pts integ "
          << "\n (7) grandeurs particulieres venant des pts integ "
          << "\n (8) choix de l'ancien format gmsh (faux par defaut) "
          << "\n (9) ddl etendu aux noeuds "
          << "\n (10) grandeurs evoluees aux noeuds ";
          cout << "\n \n reponse ? ";
         }
       else
         {cout 
          << "\n (0 or f or fin) end "
          << "\n (1) or (de) default parameters: "
          << "\n (2) or (to) all the isovalues (not a good idea) "
          << "\n (3) main parameters for the output "
          << "\n (4) principal dof at the nodes "
          << "\n (5) scalar value from the integration points "
          << "\n (6) tensorial values from the integration points "
          << "\n (7) specific values from the integration points "
          << "\n (8) new ou old output format (default new) "
          << "\n (9) extended dof at nodes "
          << "\n (10) tensorial values at nodes ";
          cout << "\n \n reponse ? ";
         }
          rep = lect_return_defaut(false,"f");
          if (rep == "fin_prog") Sortie(1);
          // sinon
          int num = ChangeEntier(rep);
          if ((rep == "0")||(rep == "f")||(rep == "fin")) 
            { choix_valide=true; }
          else if ((rep=="to")||(rep=="2"))
            { ChoixIsovaleur_noeud("to");
              ChoixIsovaleur_ddl_etendu_noeud("to");
              ChoixIsovaleur_evoluee_noeud("to");
              ChoixIsovaleur_ddl_ptinteg("to");
              ChoixIsovaleur_tensorielle_ptinteg("to");
              ChoixIsovaleur_quelc_ptinteg("to");
              ParametresGeneraux("to");
             }  
          else if ((rep=="de")||(rep=="1"))
            { ChoixIsovaleur_noeud("de");
              ChoixIsovaleur_ddl_etendu_noeud("de");
              ChoixIsovaleur_evoluee_noeud("de");
              ChoixIsovaleur_ddl_ptinteg("de");
              ChoixIsovaleur_tensorielle_ptinteg("de");
              ChoixIsovaleur_quelc_ptinteg("de");
              ParametresGeneraux("de");
				          use_hold_gmsh_format=false;
             }  
          else if ((num >= 3)&&(num<=10))
           { choix_valide=false;
             switch (num)
              { case 4:  // "choix des isovaleurs aux noeuds"
                 {ChoixIsovaleur_noeud(" "); 
                  break;}
                case 5:  // "choix des isovaleurs scalaires aux pts integ"
                  {ChoixIsovaleur_ddl_ptinteg(" "); 
                   break;}
                case 6:  // "choix des isovaleurs tensorielles aux pts integ"
                  {ChoixIsovaleur_tensorielle_ptinteg(" "); 
                   break;}
                case 7:  // "choix des grandeurs particulières aux pts integ"
                  {ChoixIsovaleur_quelc_ptinteg(" "); 
                   break;}
                case 3:  //"definition des parametres generaux"
                  { ParametresGeneraux(" "); break;}
					           case 8:  // utilisation de l'ancien format gmsh	
					             { bool choix_val = false;
						              cout << "\n -- par defaut on utilise le nouveau format gmsh (version > = 2.5) ";
						              string rep;
						              while (!choix_val)
					                 { cout << "\n (0 ou f ou fin) fin modif"
					                        << "\n (1) utilisation de l'ancien format  "
					                        << "\n (2) utilisation du nouveau format (valeur par defaut) ";
                        cout << "\n \n reponse ? ";
					                   rep = lect_return_defaut(false,"f");
					                   // sinon
					                   int num = ChangeEntier(rep);
					                   if ((rep == "0")||(rep == "f")||(rep == "fin"))
					                     { choix_val=true; }
								                else
								                  { // def du format
								                    if (num == 1) { use_hold_gmsh_format = true;}
								                    else if (num == 2) { use_hold_gmsh_format = false;}
					                       else 
								                     { cout << "\n Erreur on attendait un entier entre 0 et 1 !!, "
											                         << "\n redonnez une bonne valeur";
									                      choix_val=false;
									                    };
									                 }; 
                      }; //-- fin du while
						              break;	
					             }
                case 9:  // "choix des isovaleurs ddl étendus aux noeuds"
                 {ChoixIsovaleur_ddl_etendu_noeud(" "); 
                  break;}
                case 10:  // "choix des isovaleurs quelconque aux noeuds"
                 {ChoixIsovaleur_evoluee_noeud(" ");
                  break;}
                
                
              }
           } 
          else { cout << "\n Erreur on attendait un entier entre 3 et 10 !!, "
                      << "\n redonnez une bonne valeur"
                      << "\n ou taper fin_prog pour arreter le programme"; 
                 choix_valide=false;
               };
        }    
     catch (ErrSortieFinale)
          // cas d'une direction voulue vers la sortie
          // on relance l'interuption pour le niveau supérieur
        { ErrSortieFinale toto;
          throw (toto);
        }
     catch (...)// erreur de lecture
            {  cout << "\n Erreur on attendait un des mots cles proposés !!, "
                    << "\n redonnez une bonne valeur"
                    << "\n ou taper fin_prog pour arreter le programme"; 
               choix_valide=false;
            };
    }; //-- fin du while
   // appel de la méthode de la classe mère
   OrdreVisu::ChoixOrdre();
   // on introduit certains conteneurs internes des maillages si besoin est en fonction
   // des choix de l'utilisateurs: utiles uniquement pour certaines grandeurs
   lesMail->Intro_Conteneurs_internes_noeud_relier_auto_autres_grandeur(tabnoeud_evoluee_retenu);
   // passage des grandeurs choisies venant des éléments, aux noeuds, lorsque ces grandeurs sont
   // directement diponibles aux noeuds
   Passage_grandeursRetenuesAuxNoeuds_elementsVersNoeuds();
   // on vérifie qu'il n'y a pas de doublon de grandeurs
   VerificationTransfertPossible_et_doublon();
   // %% cas des noeuds %% on initialise les différentes listes internes qui globalisent tous les maillages
   // on le fait ici, plutôt que dans l'exécution, pour faciliter la méthode CreatListNomsTousLesGrandeurs
   GlobalisationListSurTousLesMaillagesPourLesNoeuds();
   // on ajoute les conteneurs internes des maillages si besoin est en fonction
   // des choix de l'utilisateurs
   {Tableau <List_io < TypeQuelconque > * > tabQ(2);
    tabQ(1) = &glob_noeud_evol_retenu; tabQ(2) = NULL;
    lesMail->AjoutConteneurAuNoeud(glob_noeud_ddl_etendu_retenu,tabQ);
   };
   // création de la liste des noms correspondants à tous les grandeurs à sortir (nécessaire pour
   // l'ouverture des fichiers de résultats
   CreatListNomsTousLesGrandeurs();
//----- debug
//cout << "\n debug: Isovaleurs_Gmsh::ChoixOrdre ";
//list <string>::iterator iti,itifin=nomsGrandeursSortie.end();
//cout << "\n la liste des noms ";
//for (iti=nomsGrandeursSortie.begin();iti != itifin;iti++)
//  cout << (*iti) << " ";
//cout << endl;
//----- fin debug        
 };
            
// initialisation : permet d'initialiser les différents paramètres de l'ordre
// lors d'un premier passage des différents incréments
// en virtuelle, a priori est défini si nécessaire dans les classes dérivées
void Isovaleurs_Gmsh::Initialisation(ParaGlob * paraGlob,LesMaillages * lesmail,LesReferences* lesRef
                      ,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage,Charge* charge
                      ,LesCondLim* lesCondLim,LesContacts* lesContacts
                      ,Resultats* resultats,EnumTypeIncre type_incre,int incre
                      ,const map < string, const double * , std::less <string> >& listeVarGlob
                      ,const List_io < TypeQuelconque >& listeVecGlob
                      ,bool fil_calcul) 
   { // initialisation de la liste des différentes isovaleurs possibles
     // uniquement lors du premier et du dernier passage pour économiser 
     if ((type_incre == OrdreVisu::DERNIER_INCRE) || (type_incre == OrdreVisu::PREMIER_INCRE))
        {Init_liste_isovaleur(lesmail,lesContacts,fil_calcul);}
     //appel de l'ordre d'initialisation de la classe mère
     OrdreVisu::Initialisation(paraGlob,lesmail,lesRef,lesLoisDeComp,diversStockage,charge
                      ,lesCondLim,lesContacts,resultats,type_incre,incre
                      ,listeVarGlob,listeVecGlob,fil_calcul);
     choix_var_ddl.Change_taille(lesmail->NbMaillage());                  
     // récup de l'adresse des maillages
     lesMail = lesmail;
     // récupération de la liste des vecteurs globaux
     list_vect_globalPourNoeud = listeVecGlob;
   };
            
// initialisation de la liste des différentes isovaleurs possibles
void Isovaleurs_Gmsh::Init_liste_isovaleur(LesMaillages * lesMail
                            ,LesContacts* lesContacts,bool fil_calcul)
{
  // cas des contacts: a priori il n'y a que des grandeurs définies aux noeuds
  // on définit des conteneurs ad hoc aux noeud
  int nb_maillage = lesMail->NbMaillage();
  if (!fil_calcul)
    {
     {List_io<TypeQuelconque> liste_inter = lesContacts->ListeGrandeurs_particulieres(absolue);
      // on abonde donc le tableau précédent et ceci pour chaque maillage
      // de plus on définie éventuellement les conteneurs aux noeuds
      List_io < Ddl_enum_etendu > li1; // liste vide pour l'appel de AjoutConteneurAuNoeud
      Tableau <List_io < TypeQuelconque > * > tabQ(2); tabQ(1)=&liste_inter;tabQ(2)=NULL;
      for (int i=1;i<=nb_maillage;i++)
        lesMail->AjoutConteneurAuNoeud(li1,tabQ); // ajout éventuel de conteneur
     };

     // récupération des ddl présents dans les maillages aux noeuds: ordonnées et sans doublon
     tabnoeud_type_ddl = lesMail->Les_type_de_ddl_par_noeud(absolue);
     tabelement_type_ddl = lesMail->Les_type_de_ddl_par_element(absolue);
     tabnoeud_type_ddlEtendu = lesMail->Les_type_de_ddl_etendu_par_noeud(absolue);

     // pour les grandeurs quelconques, il faut d'abord effacer les listes, dans dans l'opération
     // d'affectation, il faut exactement les mêmes types de chaque coté du = , ce qui peut ne pas être le cas
     // si d'un appel d'init_liste_isovaleur à l'autre, la liste à changée, ce qui est le cas pour des grandeurs qui
     // apparaissent pendant le calcul
   ////debug
   //cout << "\n debug Isovaleurs_Gmsh::Init_liste_isovaleur( "
   ////     << "\n lesMail->Les_type_de_TypeQuelconque_par_noeud() " << lesMail->Les_type_de_TypeQuelconque_par_noeud() << endl;
   //     << " absolue= "<< absolue << endl;
   ////fin debug

     tabnoeud_evoluee.Change_taille(0);
     tabnoeud_evoluee = lesMail->Les_type_de_TypeQuelconque_par_noeud(absolue);
    
     // maintenant pour les éléments: idem mais sous forme de grandeurs évoluées
     tabelement_evoluee.Change_taille(0);
     tabelement_evoluee = lesMail->Les_type_de_donnees_evolues_internes_par_element(absolue);
     // récupération des grandeurs particulières
     tabelement_typeParti.Change_taille(0);
     tabelement_typeParti = lesMail->Les_type_de_donnees_particulieres_par_element(absolue);
     // initialisation des tableaux, si c'est déjà fait, ne fait rien
    
     if (tabnoeud_type_ddl_retenu.Taille() == 0)
          { tabnoeud_type_ddl_retenu.Change_taille(nb_maillage);// initialisation
            tabnoeud_type_ddlEtendu_retenu.Change_taille(nb_maillage);// initialisation
            a_accumuler_tabnoeud_type_ddlEtendu_retenu.Change_taille(nb_maillage);
            a_accumuler_tabnoeud_type_ddlEtendu.Change_taille(nb_maillage);
            tabnoeud_evoluee_retenu.Change_taille(nb_maillage);
            a_accumuler_tabnoeud_evoluee_retenu.Change_taille(nb_maillage);
            a_accumuler_tabnoeud_evoluee.Change_taille(nb_maillage);
            choix_var_ddl.Change_taille(nb_maillage);// initialisation
            tabelement_type_ddl_retenu.Change_taille(nb_maillage);// initialisation
            tabelement_evoluee_retenu.Change_taille(nb_maillage);// initialisation
            tabelement_typeParti_retenu.Change_taille(nb_maillage);// initialisation
          };
     // passage des grandeurs disponibles venant des éléments, aux noeuds, lorsque ces grandeurs sont
     // directement disponibles aux noeuds
     Passage_grandeursDisponiblesAuxNoeuds_elementsVersNoeuds();
   //debug
   //cout << "\n debug Isovaleurs_Gmsh::Init_liste_isovaleur "
   //     << "\n tabnoeud_type_ddlEtendu " << tabnoeud_type_ddlEtendu(1) << endl;
   //fin debug
     // cas des tableaux d'indicateurs
     t_g_noeud_ddl_asortir.Change_taille(nb_maillage);
     t_g_noeud_ddl_etendu_asortir.Change_taille(nb_maillage);
     t_g_noeud_evoluee_asortir.Change_taille(nb_maillage);
     t_g_elem_ddl_asortir.Change_taille(nb_maillage);
     t_g_elem_evoluee_asortir.Change_taille(nb_maillage);
     t_g_elem_typeParti_asortir.Change_taille(nb_maillage);
    };
};
   
// lecture des paramètres de l'ordre dans un flux
void Isovaleurs_Gmsh::Lecture_parametres_OrdreVisu(UtilLecture & entreePrinc)
 { // si dans le flot il existe l'identificateur adoc on lit sinon on passe
   if (strstr(entreePrinc.tablcarCVisu,"debut_isovaleur_Gmsh")!=NULL)
     {// sauvegarde des parametres actuels
      Tableau < List_io < Ddl_enum_etendu> > tabnoeud_type_ddl_retenu_s(tabnoeud_type_ddl_retenu);
      Tableau <List_io <bool> > choix_var_ddl_s=choix_var_ddl;
      Tableau <List_io < Ddl_enum_etendu > > tabnoeud_type_ddlEtendu_retenu_sauve(tabnoeud_type_ddlEtendu_retenu); // ddl etendu aux noeuds  à visualiser
      Tableau <List_io < TypeQuelconque > >  tabnoeud_evoluee_retenu_sauve(tabnoeud_evoluee_retenu); // grandeurs évoluées aux noeuds
      Tableau <List_io < Ddl_enum_etendu > > tabelement_type_ddl_retenu_s(tabelement_type_ddl_retenu);
      Tableau <List_io < TypeQuelconque > > tabelement_evoluee_retenu_s(tabelement_evoluee_retenu); 
      Tableau <List_io < TypeQuelconque > > tabelement_typeParti_retenu_s(tabelement_typeParti_retenu);
		    bool use_hold_gmsh_format_s = use_hold_gmsh_format;
      // essaie de lecture
      try 
        { string nom,nom1; 
          (*entreePrinc.entCVisu)  >> nom ;
          if (nom != "debut_isovaleur_Gmsh")
            { cout << "\n Erreur en lecture des parametres pour les isovaleurs a partir d'un fichier .CVisu,"
                   << " le premier enregistrement doit etre le mot clef: debut_isovaleur_Gmsh "
                   << " on ne tiens pas compte  des parametres fournis !! ";
              }
          else
           { // appel de l'ordre de la classe mère
             OrdreVisu::Lect_para_OrdreVisu_general(entreePrinc);
             // choix entre nouveau ou ancien maillage
             if (strstr(entreePrinc.tablcarCVisu,"ancien_format_")!=NULL)
					          {(*entreePrinc.entCVisu) >> nom >> use_hold_gmsh_format;
					           if (nom != "ancien_format_")
					            { cout << "\n lecture de l'indicateur d'ancien format, on a lue ( "<< nom 
								                << " ) et on attendait ancien_format_"
								                << " la suite de la lecture du .CVisu risque d'etre completement fausse, on arrete !!" ; 
						             cout << "\n Isovaleurs_Gmsh::Lecture_parametres_OrdreVisu(... ";     
                   UtilLecture::ErrNouvelEnregCVisu sortie(-1) ; throw (sortie);
						           }
					           else // sinon c'est ok
					            {entreePrinc.NouvelleDonneeCVisu();}; // on passe un enregistrement
					          };
             // lecture  du type de sortie des tenseurs
             if (strstr(entreePrinc.tablcarCVisu,"tenseur_en_absolue_")!=NULL)
               {(*entreePrinc.entCVisu) >> nom >> absolue;
					           if (nom != "tenseur_en_absolue_")
					            { cout << "\n lecture de l'indicateur de type de tensue, on a lue ( "<< nom
								                << " ) et on attendait tenseur_en_absolue_"
								                << " la suite de la lecture du .CVisu risque d'etre completement fausse, on arrete !!" ; 
						             cout << "\n Isovaleurs_Gmsh::Lecture_parametres_OrdreVisu(... ";     
                   UtilLecture::ErrNouvelEnregCVisu sortie(-1) ; throw (sortie);
						           }
					           else // sinon c'est ok
					            {entreePrinc.NouvelleDonneeCVisu();}; // on passe un enregistrement
               };
             // puis lecture des parametres propres
             int nb_maillage = lesMail->NbMaillage(); int imail; 
             while (strstr(entreePrinc.tablcarCVisu,"fin_isovaleur_Gmsh")==NULL)
              { (*entreePrinc.entCVisu) >> imail; // lecture du numero de maillage
                if ((imail > nb_maillage)||(imail < 1)) // vérif de la validité du numéro de maillage
                  // si nb maillage trop grand, erreur, on génère une erreur pour arrêter la lecture
                  { cout << "\n erreur, le numero de maillage est errone !! nombre lu " << imail 
                         << " alors que nb_maillage enregistre: " << nb_maillage ;
                    cout << "\n Isovaleurs_Gmsh::Lecture_parametres_OrdreVisu(... ";     
                    UtilLecture::ErrNouvelEnregCVisu sortie(-1) ; throw (sortie);
                  };
                entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                // ---- les ddl aux noeuds a visualiser
                if (strstr(entreePrinc.tablcarCVisu,"debut_tableau_ddl_aux_noeuds")!=NULL)
                   { // lecture de la liste des ddl
                     (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                     // on efface la liste actuelle
                     List_io <Ddl_enum_etendu>& lis_sor = tabnoeud_type_ddl_retenu(imail);
                     lis_sor.clear();
                     // lecture de la liste demandée
                     int compteur=0; // pour éviter une boucle infinie
                     while (compteur < 1000000)
                       { (*entreePrinc.entCVisu) >> nom  ; compteur++;
                         if (nom != "fin_tableau_ddl_aux_noeuds")
                           {if (find(lis_sor.begin(),lis_sor.end(),Ddl_enum_etendu(nom))==lis_sor.end())
                              // il n'existe pas, on le rajoute
                              lis_sor.push_back(Ddl_enum_etendu(nom));
                           }
                         else break;
                        };
                     entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                    }
					           //  variation ou valeur de chaque ddl
                if (strstr(entreePrinc.tablcarCVisu,"debut_tableau_choix_var_ddl_aux_noeuds")!=NULL)
                   { // lecture de la liste des variations de ddl
                     (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                     // on efface la liste actuelle
                     List_io <bool>& choix_v_dd = choix_var_ddl(imail);
                     choix_v_dd.clear();
                     // lecture de la liste demandée
                     int compteur=0; // pour éviter une boucle infinie
                     while (compteur < 1000000)
                       { (*entreePrinc.entCVisu) >> nom  ; compteur++;
                         if (nom != "fin_tableau_choix_var_ddl_aux_noeuds")
                           { choix_v_dd.push_back(ChangeEntier(nom));
                            }
                         else break;
                       };
							              // on vérifie qu'il y a le même nombre que de ddl
							              if ( (choix_var_ddl(imail)).size() != (tabnoeud_type_ddl_retenu(imail)).size())
							               { cout << " \n erreur en lecture du fichier .CVisu dans le cas d'une sortie gmsh "
							                      << " le nombre de ddl lue au noeud " << (tabnoeud_type_ddl_retenu(imail)).size()
									                    << " est different du nombre de choix de variation " << (choix_var_ddl(imail)).size()
									                    << " corriger le fichier !! (ou en faire un nouveau via herezh) ";
							                 Sortie(1);
							               };			  
										
                     entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                    }
                // ** lecture des ddl etendus aux noeuds
                if (strstr(entreePrinc.tablcarCVisu,"debut_tableau_ddl_etendu_aux_noeuds")!=NULL)
                     { // lecture de la liste des ddl
                       (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                       // on efface la liste actuelle
                       List_io <Ddl_enum_etendu>& lis_sor = tabnoeud_type_ddlEtendu_retenu(imail);
                       lis_sor.clear();
                       // lecture de la liste demandée
                       int compteur=0; // pour éviter une boucle infinie
                       while (compteur < 1000000)
                         { (*entreePrinc.entCVisu) >> nom; compteur++;
                           if (nom != "fin_tableau_ddl_etendu_aux_noeuds")
                            {if (find(lis_sor.begin(),lis_sor.end(),Ddl_enum_etendu(nom))==lis_sor.end())
                              // il n'existe pas, on le rajoute
                              lis_sor.push_back(Ddl_enum_etendu(nom));
                            }
                           else break;
                          }
                       entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                     };
                // ** les grandeurs évoluées aux noeuds
					           if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandEvoluee_noeud")!=NULL)
                     { // lecture de la liste des grandeurs évoluées
                       (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                       // on efface la liste actuelle
                       List_io<TypeQuelconque>& tpg_ret = (tabnoeud_evoluee_retenu(imail)); // pour simplifier
                       tpg_ret.clear();
                       list_vect_globalPourNoeud_retenu.clear();  // idem
                       // lecture de la liste demandée
                       int compteur=0; // pour éviter une boucle infinie
                       List_io<TypeQuelconque>& tpg = (tabnoeud_evoluee(imail)); // pour simplifier
                       while (compteur < 1000000)
                         { (*entreePrinc.entCVisu) >> nom; compteur++;
                           if (nom != "fin_list_GrandEvoluee_noeud")
                             { TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom)); // création d'un type quelconque sans grandeur
                               List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                               bool trouve = false;
                               bool dans_global=false; // pour savoir si c'est dans le vecteur global ou pas
                               // si la grandeur n'existe pas au niveau de tabnoeud_evoluee on essaie au niveau des
                               // vecteur globaux
                               if (il == tpg.end())
                                 {il = find(list_vect_globalPourNoeud.begin(),list_vect_globalPourNoeud.end(),a);
                                  if (il != list_vect_globalPourNoeud.end())
                                    trouve = true;dans_global=true;
                                  }
                               else // sinon c'est bon on a trouvé
                                 {trouve = true;}; 
                               // si la grandeur existe on essaie de l'enregistrer sinon on passe
                               if (trouve)
                                {// s'il n'existe pas déjà on l'enregistre vraiment
                                 if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                                  { tpg_ret.push_back(*il);
                                    if (dans_global) list_vect_globalPourNoeud_retenu.push_back(*il);
                                  }
                                 };
                              } 
                           else break;
                          };
                       entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                     };
//debug
//cout << "\n debug Isovaleurs_Gmsh::Lecture_parametres_OrdreVisu "
//     << "\n tabnoeud_evoluee_retenu(imail) "<< tabnoeud_evoluee_retenu(imail)
//     << "\n tabnoeud_evoluee(imail) "<<tabnoeud_evoluee(imail)<< endl;
//fin debug
                // ---- les ddl aux éléments a visualiser
                if (strstr(entreePrinc.tablcarCVisu,"debut_tableau_ddl_aux_elements")!=NULL)
                   { // lecture de la liste des ddl
                     (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                     // on efface la liste actuelle
                     List_io <Ddl_enum_etendu>& lis_sor = tabelement_type_ddl_retenu(imail);
                     lis_sor.clear();
                     // lecture de la liste demandée
                     int compteur=0; // pour éviter une boucle infinie
                     while (compteur < 1000000)
                       { (*entreePrinc.entCVisu) >> nom; compteur++;
                         if (nom != "fin_tableau_ddl_aux_elements")
                           {if (find(lis_sor.begin(),lis_sor.end(),Ddl_enum_etendu(nom))==lis_sor.end())
                              // il n'existe pas, on le rajoute
                              lis_sor.push_back(Ddl_enum_etendu(nom));
                           }
                         else break;
                       };
                     entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
//debug
//cout << "\n debug Isovaleurs_Gmsh::Lecture_parametres_OrdreVisu "
//     << tabelement_type_ddl_retenu(imail) << endl;
//fin debug
                   };
                // ---- les grandeurs évoluées  aux éléments a visualiser
					           if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandEvoluee_element")!=NULL)
                     { // lecture de la liste des grandeurs particulières
                       (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                       // on efface la liste actuelle
                       List_io<TypeQuelconque>& tpg_ret = (tabelement_evoluee_retenu(imail)); // pour simplifier
                       tpg_ret.clear();
                       // lecture de la liste demandée
                       int compteur=0; // pour éviter une boucle infinie
                       List_io<TypeQuelconque>& tpg = (tabelement_evoluee(imail)); // pour simplifier
                       while (compteur < 1000000)
                         { (*entreePrinc.entCVisu) >> nom; compteur++;
                           if (nom != "fin_list_GrandEvoluee_element")
                             { TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom)); // création d'un type quelconque sans grandeur
                               List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                               if (il == tpg.end())
                                {cout << "\n ** attention la grandeur "<<nom
                                      <<" n'est pas presente au niveau des grandeurs evoluees aux elements "
                                      << " on n'en tient pas compte "<<flush;
                                }
                               else // c'est ok
                                // s'il n'existe pas déjà on l'enregistre vraiment
                                {if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                                  { tpg_ret.push_back(*il);}
                                };
                              } 
                           else break;
                          }
                       entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                     };
                // ---- les grandeurs particulières  aux éléments a visualiser
                if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandParticuliere_element")!=NULL)
                     { // lecture de la liste des grandeurs particulières
                       (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                       // on efface la liste actuelle
                       List_io<TypeQuelconque>& tpg_ret = (tabelement_typeParti_retenu(imail)); // pour simplifier
                       tpg_ret.clear();
                       // lecture de la liste demandée
                       int compteur=0; // pour éviter une boucle infinie
                       List_io<TypeQuelconque>& tpg = (tabelement_typeParti(imail)); // pour simplifier
                       while (compteur < 1000000)
                         { (*entreePrinc.entCVisu) >> nom; compteur++;
                           if (nom != "fin_list_GrandParticuliere_element")
                             { // ici on est obliger de tester l'existence du type particulier, s'il n'existe
                               // pas on le crée, car c'est peut-être un type automatique
                               // ensuite à la sortie il y aura une vérification d'existence
                               // pour l'instant on regarde uniquement le mot clé INTEG_SUR_VOLUME
                               TypeQuelconque_enum_etendu tq; // init par défaut
                               if (!TypeQuelconque_enum_etendu::VerifExistence(nom))
                                { // on regarde si le nom contient la partie INTEG_SUR_VOLUME
                                  if (nom.find("INTEG_SUR_VOLUME_ET_TEMPS") != std::string::npos)
                                    {tq =TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
                                      (INTEG_SUR_VOLUME_ET_TEMPS,nom,RIEN_TYPEGRANDEUR);
                                    }
                                  else if (nom.find("INTEG_SUR_VOLUME") != std::string::npos)
                                    {tq =TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
                                      (INTEG_SUR_VOLUME,nom,RIEN_TYPEGRANDEUR);
                                    }
                                  else // sinon on met un message et on met un type par défaut
                                   cout << "\n *** attention le type quelconque "<< nom
                                        << " n'est pas reconnu, aucune sortie prevu pour lui "
                                        << endl;
                                }
                               else
                                {tq = TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom);};
                               TypeQuelconque a(tq); // création d'un type quelconque sans grandeur
                               List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                               // si la grandeur existe on essaie de l'enregistrer sinon on passe
                               if (il != tpg.end()) 
                                {// s'il n'existe pas déjà on l'enregistre vraiment
                                 if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                                  { tpg_ret.push_back(*il);}
                                 }; 
                              } 
                           else break;
                          }
                       entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                     };
//debug
//cout << "\n debug Isovaleurs_Gmsh::Lecture_parametres_OrdreVisu "
//     << "\n 2: tabelement_evoluee_retenu(imail) " << tabelement_type_ddl_retenu(imail)
//     << "\n 3: a_accumuler_tabnoeud_evoluee_retenu(imail) "<<a_accumuler_tabnoeud_evoluee_retenu(imail)<< endl;
//fin debug
              };// -- fin du while sur les maillages
             entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
           }; // -- fin du if then else sur "debut_isovaleur_Gmsh"
         } // -- fin du try    
      catch (ErrSortieFinale)
           // cas d'une direction voulue vers la sortie
           // on relance l'interuption pour le niveau supérieur
         { ErrSortieFinale toto;
           throw (toto);
         }
      catch (...)// erreur de lecture
       {  cout << "\n Erreur en lecture des parametres pour les isovaleurs a partir d'un fichier .CVisu,"
               << " on ne tiens pas compte  des parametres fournis !! ";
          // récup des  parametres sauvées
          tabnoeud_type_ddl_retenu = tabnoeud_type_ddl_retenu_s;
          choix_var_ddl=choix_var_ddl_s;
          tabnoeud_type_ddlEtendu_retenu=tabnoeud_type_ddlEtendu_retenu_sauve;
          tabnoeud_evoluee_retenu=tabnoeud_evoluee_retenu_sauve;
          tabelement_type_ddl_retenu = tabelement_type_ddl_retenu_s;
          tabelement_evoluee_retenu = tabelement_evoluee_retenu_s;
          tabelement_typeParti_retenu = tabelement_typeParti_retenu_s;
			       use_hold_gmsh_format = use_hold_gmsh_format_s;
          if (ParaGlob::NiveauImpression() >= 4)     
             cout  << "\n Isovaleurs_Gmsh::Lecture_parametres_OrdreVisu(..";
       };
     };
   // dans le cas où il y a des vecteurs globaux qui ont été retenus,
   // il faut définir  aux noeuds des conteneurs adéquates
   if (list_vect_globalPourNoeud_retenu.size() != 0)
    { // def de conteneurs pour le passage d'infos
      List_io < Ddl_enum_etendu > lienu; // une liste vide
      List_io < TypeQuelconque > litq; // une autre pour les quelconques
      Tableau <List_io < TypeQuelconque > * > tabQ(2); 
      tabQ(1)= &list_vect_globalPourNoeud_retenu;tabQ(2)=&litq;
      // on est obligé d'utiliser un tableau dont le second terme est nul,
      // ceci pour pouvoir utiliser "AjoutConteneurAuNoeud" tel quel
      int nbmail_total = lesMail->NbMaillage();
      for (int imail=1;imail <= nbmail_total;imail++)
         lesMail->AjoutConteneurAuNoeud(imail,lienu,tabQ);
    };
   
   // on introduit certains conteneurs internes des maillages si besoin est en fonction
   // des choix de l'utilisateurs: utiles uniquement pour certaines grandeurs
   lesMail->Intro_Conteneurs_internes_noeud_relier_auto_autres_grandeur(tabnoeud_evoluee_retenu);
   // passage des grandeurs choisies venant des éléments, aux noeuds, lorsque ces grandeurs sont
   // directement diponibles aux noeuds
   Passage_grandeursRetenuesAuxNoeuds_elementsVersNoeuds();
   // on vérifie qu'il n'y a pas de doublon de grandeurs
   VerificationTransfertPossible_et_doublon();
   // %% cas des noeuds %% on initialise les différentes listes internes qui globalisent tous les maillages
   // on le fait ici, plutôt que dans l'exécution, pour faciliter la méthode CreatListNomsTousLesGrandeurs
   GlobalisationListSurTousLesMaillagesPourLesNoeuds();
   // on ajoute les conteneurs internes des maillages si besoin est en fonction
   // des choix de l'utilisateurs
   {Tableau <List_io < TypeQuelconque > * > tabQ(2);
    tabQ(1) = &glob_noeud_evol_retenu; tabQ(2) = NULL;
    lesMail->AjoutConteneurAuNoeud(glob_noeud_ddl_etendu_retenu,tabQ);
   };
   // création de la liste des noms correspondants à tous les grandeurs à sortir (nécessaire pour
   // l'ouverture des fichiers de résultats
   CreatListNomsTousLesGrandeurs();
 };

// écriture des paramètres de l'ordre dans un flux
void Isovaleurs_Gmsh::Ecriture_parametres_OrdreVisu(UtilLecture & entreePrinc)
 { // récup du flot  
   ostream & sort = (*(entreePrinc.Sort_CommandeVisu()));
   // on commente le fonctionnement
   sort << "\n #  ----------------------------- definition des parametres pour les isovaleurs : ---------------- ";
   // mot clé de démarrage
   sort << "\n debut_isovaleur_Gmsh         # mot cle de debut des parametres pour les isovaleurs"; 
   // appel de l'ordre de la classe mère
   OrdreVisu::Ecrit_para_OrdreVisu_general(entreePrinc);
   // choix entre nouveau ou ancien format		
	  sort << "\n ancien_format_ " << use_hold_gmsh_format 
	       << "  # 1 = ancien format, 0 = nouveau format ";
   // le type de sortie des tenseurs
   sort << "\n# un parametre indiquant si les tenseurs sont en absolue (rep 1) ou suivant un repere ad hoc"
        << "\n# (tangent pour les coques, suivant la fibre moyenne pour les element 1D ) ";
   sort << "\n tenseur_en_absolue_  " <<  absolue;
   // puis les paramètres
   int nb_mail = tabnoeud_type_ddl_retenu.Taille();
   for (int imail=1;imail<=nb_mail;imail++)
    { // ** le numero de maillage
      sort << "\n " << imail << " # le numero de maillage";
      //---- les grandeurs aux noeuds venant des noeuds ----
      // ** ddl aux noeuds
      {sort << "\n #   tableau des ddl  aux noeuds a visualiser, un par maillage";
       sort << "\n debut_tableau_ddl_aux_noeuds " ;
       List_io < Ddl_enum_etendu >::iterator ild,ildfin = tabnoeud_type_ddl_retenu(imail).end();
       for (ild=tabnoeud_type_ddl_retenu(imail).begin();ild!=ildfin;ild++)
         { sort << (*ild)  << " " ;};
       sort << " fin_tableau_ddl_aux_noeuds " ;
      };
		    // ** variation ou valeur de chaque ddl
      {sort << "\n #   tableau des choix_var aux noeuds a visualiser, un par maillage";
       sort << "\n #   choix_var (=1 ou 0)  indique si oui ou non il s'agit de la variation ";
       sort << "\n debut_tableau_choix_var_ddl_aux_noeuds " ;
       List_io <bool>::iterator ilbo,ilbofin=choix_var_ddl(imail).end();
       for (ilbo=choix_var_ddl(imail).begin();ilbo!=ilbofin;ilbo++)
         { sort <<  (*ilbo) << " " ;};
       sort << " fin_tableau_choix_var_ddl_aux_noeuds " ;
      }
      // ** les ddl étendus des noeuds
      {sort << "\n #   tableau des ddl_etendu  aux noeuds a visualiser, un par maillage";
       sort << "\n debut_tableau_ddl_etendu_aux_noeuds " ;
       List_io < Ddl_enum_etendu >::iterator ild,ildfin = tabnoeud_type_ddlEtendu_retenu(imail).end();
       for (ild=tabnoeud_type_ddlEtendu_retenu(imail).begin();ild!=ildfin;ild++)
         { sort << (*ild)  << " " ;};
       sort << " fin_tableau_ddl_etendu_aux_noeuds " ;
      }     
      // ** les grandeurs evoluées aux noeuds
      {sort << "\n #   tableau de grandeurs evoluees  aux noeuds a visualiser, un par maillage";
       sort << "\n deb_list_GrandEvoluee_noeud " ;
       List_io < TypeQuelconque >::iterator ilq,ilqfin=tabnoeud_evoluee_retenu(imail).end();
        for (ilq=tabnoeud_evoluee_retenu(imail).begin();ilq!=ilqfin;ilq++)
          { sort <<  ((*ilq).EnuTypeQuelconque().NomPlein())   << " " ;};
        sort << " fin_list_GrandEvoluee_noeud " ;
      }
      //---- fin des grandeurs aux noeuds venant des noeuds ----
      
      // ---- les ddl aux éléments a visualiser au noeuds par transfert
      // ** les ddl aux éléments
      {sort << "\n #   tableau de ddl aux elements a visualiser, un par maillage";
       sort << "\n debut_tableau_ddl_aux_elements " ;
       List_io < Ddl_enum_etendu >::iterator ild,ildfin = tabelement_type_ddl_retenu(imail).end();
       for (ild=tabelement_type_ddl_retenu(imail).begin();ild!=ildfin;ild++)
         { sort << (*ild) << " " ;};
       sort << " fin_tableau_ddl_aux_elements " ;
      }
      // ** les grandeurs évoluées  aux éléments a visualiser
      {sort << "\n #   tableau de grandeurs evoluees  aux elements a visualiser, un par maillage";
       sort << "\n deb_list_GrandEvoluee_element " ;
       List_io < TypeQuelconque >::iterator ilq,ilqfin=tabelement_evoluee_retenu(imail).end();
       for (ilq=tabelement_evoluee_retenu(imail).begin();ilq!=ilqfin;ilq++)
         { sort << ((*ilq).EnuTypeQuelconque().NomPlein()) << " " ;};
       sort << " fin_list_GrandEvoluee_element " ;
      };
      // ** les grandeurs particulières  aux éléments a visualiser
      {sort << "\n #   tableau de grandeurs particulieres  aux elements a visualiser, un par maillage";
       sort << "\n deb_list_GrandParticuliere_element " ;
       List_io < TypeQuelconque >::iterator ilq,ilqfin=tabelement_typeParti_retenu(imail).end();
       for (ilq=tabelement_typeParti_retenu(imail).begin();ilq!=ilqfin;ilq++)
         { sort <<  ((*ilq).EnuTypeQuelconque().NomPlein())   << " " ;};
       sort << " fin_list_GrandParticuliere_element " ;
      }
    }; // fin de la boucle sur les maillages
  
   // mot clé de fin
   sort << "\n fin_isovaleur_Gmsh         # mot cle de fin des parametres pour les isovaleurs \n"; 
  };

// ======================================== méthodes privées =====================================


// choix de l'isovaleur à visualiser calculée à partir des ddl naturels aux noeuds
void Isovaleurs_Gmsh::ChoixIsovaleur_noeud(const string& choix)
 { // tout d'abord on traite le cas de tous les isovaleurs ou para par défaut
   // ici idem pour les noeuds
   if ((choix=="to")||(choix=="de"))
    { tabnoeud_type_ddl_retenu = tabnoeud_type_ddl;
      // on rempli choix_var_ddl à false par défaut
      int nbmail = tabnoeud_type_ddl.Taille();
      for (int imail = 1;imail<=nbmail;imail++)
       { List_io < Ddl_enum_etendu >& noeud_type_ddl_retenu = tabnoeud_type_ddl_retenu(imail);
         List_io < Ddl_enum_etendu >::iterator ili,ilideb,ilifin=noeud_type_ddl_retenu.end();
         ilideb = noeud_type_ddl_retenu.begin();
         List_io <bool>& choix_v_ddl = choix_var_ddl(imail);
         choix_v_ddl.clear(); // mise à zéro de la liste
         // maintenant on la remplie de valeurs par défaut
         for(ili=ilideb;ili!=ilifin;ili++) choix_v_ddl.push_back(true);
        } 
      return;
    };
   // maintenant on traite le cas interactif   
   int dim = ParaGlob::Dimension();
   bool choix_valide = false;
   string rep;
   cout << "\n  choix d'isovaleur a visualiser ";
   int nbmail = tabnoeud_type_ddl.Taille();
   // update du tableau de ddl à visualiser si nécessaire
   if (tabnoeud_type_ddl_retenu.Taille() != nbmail)
       tabnoeud_type_ddl_retenu.Change_taille(nbmail);

   for (int imail = 1;imail<=nbmail;imail++)
     {choix_valide=false;
      while (!choix_valide) // premier while
      {try 
        { cout << "\n listes de type de ddl a visualiser ";
          cout << "\n Maillage nb: " << imail << " liste des types de ddl disponibles "
               << "\n" << tabnoeud_type_ddl(imail);
          // affichage des ddl retenues si la liste n'est pas vide
          if (tabnoeud_type_ddl_retenu(imail).size() != 0)
            cout << "\n Maillage nb: " << imail << " liste des types de ddl enregistres "
                                     << "\n" << tabnoeud_type_ddl_retenu(imail);                           
          cout << "\n donner le ddl a visulaliser "
               << "\n (to) tous les ddl "
               << "\n ou une liste de ddl "
               << "\n (0 ou f ou fin) fin choix ddl "
               << "\n reponse ?  ";

          cout << "\n donnez la ou les grandeurs que vous voulez visualiser (rep grandeurs?)   "
               << "\n ou toutes les grandeurs sans les reactions            (rep : to)         "
               << "\n ou toutes les grandeurs                               (rep : tr)         "
               << "\n effacer la liste actuelle                             (rep : ef)         "
               << "\n                                       (pour terminer tapez : fin (ou f)) ";



          rep = lect_return_defaut(false,"f");
          if (rep == "fin_prog") Sortie(1);
          bool deplace_ou_valeur_a_demander = false; // pour la gestion 
			       List_io<Ddl_enum_etendu> nouveau_ddl_a_demander;
          if (rep == "to")
           // cas de toutes les grandeurs sans les réactions
           {// on commence par sauvegarder les variations pour tous les ddl de type réaction
			         list<bool> sauve_var_reac;List_io < Ddl_enum_etendu > sauve_ddl;
			         List_io < Ddl_enum_etendu >::iterator idro,idrofin=(tabnoeud_type_ddl_retenu(imail)).end();
			         List_io <bool>::iterator ifo=(choix_var_ddl(imail)).begin();
			         for(idro=(tabnoeud_type_ddl_retenu(imail)).begin();idro != idrofin;idro++,ifo++)
			           if (Ddl_reaction((*idro).Enum()))
			            {sauve_ddl.push_back(*idro); sauve_var_reac.push_back(*ifo);};
            // on vide les listes
			         (tabnoeud_type_ddl_retenu(imail)).clear();
			         (choix_var_ddl(imail)).clear();
			         // on rerempli avec les grandeurs réaction
			         idrofin=sauve_ddl.end();ifo=sauve_var_reac.begin();
			         for (idro=sauve_ddl.begin();idro!=idrofin;idro++,ifo++)
			          {(tabnoeud_type_ddl_retenu(imail)).push_back(*idro);
			           (choix_var_ddl(imail)).push_back(*ifo);
             };
			         // maintenant on ajoute les ddl non réaction
			         List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddl(imail).end();
            for (ite = tabnoeud_type_ddl(imail).begin();ite != itefin; ite++)
              if ( !Ddl_reaction((*ite).Enum()))
                {tabnoeud_type_ddl_retenu(imail).push_back(*ite);
			         	    nouveau_ddl_a_demander.push_back(*ite);
			         	   };
			         // on n'ordonne pas ni supprime les doublons car a priori tabnoeud_type_ddl(imail) ne comporte  pas de doublon
            choix_valide=false; deplace_ou_valeur_a_demander=true;
           }  
          else if (rep == "tr")
           // cas de toutes les grandeurs avec les réactions
           {// on prévient que si on veut une grandeur sous forme de vecteur il faut la demander spécifiquement
            cout << "\n attention, si vous voulez une grandeur vectorielle ou tensorielle: ex: les vecteurs reactions "
				             << "\n il faut refaire un passage en demandant cette grandeur spedifiquement ";
				        // on vide les listes
				        (tabnoeud_type_ddl_retenu(imail)).clear();
			         (choix_var_ddl(imail)).clear();
			         // maintenant on ajoute les ddl non réaction
            List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddl(imail).end();
            for (ite = tabnoeud_type_ddl(imail).begin();ite != itefin; ite++)
                {tabnoeud_type_ddl_retenu(imail).push_back(*ite);
					            nouveau_ddl_a_demander.push_back(*ite);
					           };
				        // on n'ordonne pas ni supprime les doublons car a priori tabnoeud_type_ddl(imail) ne comporte  pas de doublon
				        // si car l'utilisateur peut faire deux appels consécutifs ...
				        nouveau_ddl_a_demander.sort();
				        nouveau_ddl_a_demander.unique();
            choix_valide=false; deplace_ou_valeur_a_demander=true;
           }  
          else if (rep == "ef")
           {// on efface la liste
            (tabnoeud_type_ddl_retenu(imail)).clear();
				        (choix_var_ddl(imail)).clear();
				        choix_valide=false;
           };

          // sinon
          if ((rep == "0") || (rep == "f") || (rep == "fin")) 
              {choix_valide=true;}
//          else if (ExisteEnum_ddl(rep.c_str())) // test pour savoir si c'est vraiment un ddl
          else if (Ddl_enum_etendu::VerifExistence(rep)) // test pour savoir si c'est vraiment un ddl
            { //Enum_ddl enum_d = Id_nom_ddl(rep.c_str());
              //Ddl_enum_etendu ddl_enu_etendue(enum_d);
              Ddl_enum_etendu ddl_enu_etendue(rep);
              // on vérifie si le ddl existe dans la liste proposée
              if (Ddl_enum_etendu::Existe_dans_la_liste(tabnoeud_type_ddl(imail),ddl_enu_etendue))                 
                 { // on regarde si l'on veut uniquement la grandeur scalaire ou tout
					              bool choix_var_valide=false; 
						             bool choixScalaireUniquement = true; 
                   while (!choix_var_valide)
                   {try 
                    { cout << "\n voulez vous uniquement la grandeur scalaire (rep 1) ou toutes les composantes de la grandeur (rep 2) ? \n"
                           << "\n reponse ?  ";
                      rep = lect_chaine();
                      if (rep == "1") {choixScalaireUniquement=true;choix_var_valide=true;}
                      else if (rep == "2") {choixScalaireUniquement=false;choix_var_valide=true;}
                      else {cout << "\n mauvais choix, recommencez";choix_var_valide=false;}
                    }
                    catch (ErrSortieFinale)
                         // cas d'une direction voulue vers la sortie
                         // on relance l'interuption pour le niveau supérieur
                       { ErrSortieFinale toto;
                         throw (toto);
                       }
                    catch (...)// erreur en lecture
                     {  cout << "\n Erreur dans le choix scalaire ou non !!, "
                             << "\n redonnez une bonne valeur";
                        choix_var_valide=false;
                     };
                   }; //-- fin du second while 
                   // dans le cas où le ddl est de type vecteur, on ajoute toutes les composantes
                   EnumTypeGrandeur type_grandeur = ddl_enu_etendue.TypeDeGrandeur(); // le premier type de grandeur
                   if ((!choixScalaireUniquement) && ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE) 
                     || (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH)))
                  	 { // cas d'un type vecteur
                  	   Enum_ddl enu_type_famille = PremierDdlFamille(ddl_enu_etendue.Enum()); 
                  	   // pour l'instant ***** on ne sort que des iso de ddl non étendue donc on peut constituer les
                  	   // ddl du vecteur qui est forcément de dim 3
                      switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
                       { case 3: tabnoeud_type_ddl_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-3)));
							                    nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-3)));
                         case 2: tabnoeud_type_ddl_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-2)));
							                    nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-2)));
                         case 1: tabnoeud_type_ddl_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-1)));
							                    nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-1)));
                       };
                    }
                   else // cas d'une grandeur scalaire simple
                  	 { tabnoeud_type_ddl_retenu(imail).push_back(ddl_enu_etendue);
                      nouveau_ddl_a_demander.push_back(ddl_enu_etendue);
                  	 };
                   deplace_ou_valeur_a_demander=true;
                 }
 /*         else if ( Existe_typeQuelconque(rep)) // cas où c'est un type quelconque
            { //Enum_ddl enum_d = Id_nom_ddl(rep.c_str());
              //Ddl_enum_etendu ddl_enu_etendue(enum_d);
              Ddl_enum_etendu ddl_enu_etendue(rep);
              // on vérifie si le ddl existe dans la liste proposée
              if (   (Ddl_enum_etendu::Existe_dans_la_liste(tabnoeud_type_ddl(imail),ddl_enu_etendue))
                  || (Ddl_enum_etendu::Existe_dans_la_liste(list_vect_globalPourNoeud,ddl_enu_etendue))
                 )
                 { // on regarde si l'on veut uniquement la grandeur scalaire ou tout
					              bool choix_var_valide=false; 
						             bool choixScalaireUniquement = true; 
                   while (!choix_var_valide)
                   {try 
                    { cout << "\n voulez vous uniquement la grandeur scalaire (rep 1) ou toutes les composantes de la grandeur (rep 2) ? \n"
                           << "\n reponse ?  ";
                      cin >> rep;
                      if (rep == "1") {choixScalaireUniquement=true;choix_var_valide=true;}
                      else if (rep == "2") {choixScalaireUniquement=false;choix_var_valide=true;}
                      else {cout << "\n mauvais choix, recommencez";choix_var_valide=false;}
                    }
                    catch (...)// erreur en lecture
                     {  cout << "\n Erreur dans le choix scalaire ou non !!, "
                             << "\n redonnez une bonne valeur";
                        choix_var_valide=false;
                     };
                   }; //-- fin du second while 
                   // dans le cas où le ddl est de type vecteur, on ajoute toutes les composantes
                   EnumTypeGrandeur type_grandeur = ddl_enu_etendue.TypeDeGrandeur(); // le premier type de grandeur
                   if ((!choixScalaireUniquement) && ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE) 
                     || (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH)))
                  	 { // cas d'un type vecteur
                  	   Enum_ddl enu_type_famille = PremierDdlFamille(ddl_enu_etendue.Enum()); 
                  	   // pour l'instant ***** on ne sort que des iso de ddl non étendue donc on peut constituer les
                  	   // ddl du vecteur qui est forcément de dim 3
                      switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
                       { case 3: tabnoeud_type_ddl_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-3)));
							                    nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-3)));
                         case 2: tabnoeud_type_ddl_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-2)));
							                    nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-2)));
                         case 1: tabnoeud_type_ddl_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-1)));
							                    nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-1)));
                       };
                    }
                   else // cas d'une grandeur scalaire simple
                  	 { tabnoeud_type_ddl_retenu(imail).push_back(ddl_enu_etendue);
                      nouveau_ddl_a_demander.push_back(ddl_enu_etendue);
                  	 };
                   deplace_ou_valeur_a_demander=true;
                 } */
              else
                 {cout << "\n ddl inexistant dans la liste proposee, recommencez";
                  choix_valide=false;
                 };
             };
             
          // maintenant on regarde si c'est le ddl on sa variation qui est intéressante
          if (deplace_ou_valeur_a_demander)
             { // on boucle sur les nouveaux ddl scalaire a demander
				   List_io<Ddl_enum_etendu>::iterator uto,utofin=nouveau_ddl_a_demander.end();
					for (uto=nouveau_ddl_a_demander.begin();uto!=utofin;uto++)
				    {// le choix n'est possible que pour les ddl de base, pas les étendues
					  if ((*uto).Nom_vide())
						{  bool choix_var_valide=false; 
							while (!choix_var_valide)
								{try 
								{	cout << "\n valeur du ddl" << *uto << " ou variation entre t=0 et t (rep 1 ou 0 ) ? \n"
										  << "\n reponse ?  ";
									rep = lect_chaine();
									if (rep == "1") {choix_var_ddl(imail).push_back(false);choix_var_valide=true;}
									else if (rep == "0") {choix_var_ddl(imail).push_back(true);choix_var_valide=true;}
									else {cout << "\n mauvais choix, recommencez";choix_var_valide=false;}
								 }
								catch (...)// erreur en lecture
									{	cout << "\n Erreur dans le choix de la variation ou non des ddl !!, "
											  << "\n redonnez une bonne valeur";
										choix_var_valide=false;
									}
								}; //-- fin du second while 
						}
					 else //sinon c'est un ddl étendue, on le met systématiquement à false, ne servira pas après
					   { 	choix_var_ddl(imail).push_back(false);};		
					 };
             };
                                                 
        }
       catch (ErrSortieFinale)
            // cas d'une direction voulue vers la sortie
            // on relance l'interuption pour le niveau supérieur
          { ErrSortieFinale toto;
            throw (toto);
          }
       catch (...)// erreur en lecture
          {  cout << "\n Erreur dans la lecture de ddl !!, "
                  << "\n redonnez une bonne valeur"
                  << "\n ou taper fin_prog pour arreter le programme"; 
             choix_valide=false;
          };
       // maintenant avant d'ordonner et de supprimer les doublons on sauvegarde dans un tableau
		     Tableau <bool> tab_varrr(Ddl_enum_etendu::NBmax_ddl_enum_etendue());
  		   List_io <bool>::iterator ifo=(choix_var_ddl(imail)).begin();
  		   List_io<Ddl_enum_etendu>::iterator utoo,utoofin=tabnoeud_type_ddl_retenu(imail).end();
		     for (utoo=tabnoeud_type_ddl_retenu(imail).begin();utoo!=utoofin;utoo++,ifo++)
            tab_varrr((*utoo).Position())=*ifo;
		     // on supprime les indications de variation qui viennent d'être sauvegardé
		     (choix_var_ddl(imail)).clear();
		     //maintenant on traite la liste des ddl_enum_etendu
       tabnoeud_type_ddl_retenu(imail).sort(); // on ordonne
       tabnoeud_type_ddl_retenu(imail).unique();// on supprime les doublons
		     // et on met les bonnes variation pour les ddl
		     utoofin=tabnoeud_type_ddl_retenu(imail).end();
		     for (utoo=tabnoeud_type_ddl_retenu(imail).begin();utoo!=utoofin;utoo++,ifo++)
          (choix_var_ddl(imail)).push_back(tab_varrr((*utoo).Position()));
		    
// debug		cout << "\n" << tabnoeud_type_ddl_retenu(imail) << "\n et les choix " << choix_var_ddl(imail) << endl; 
		                          
      }; //-- fin du premier while
		    // on vérifie qu'il y a le même nombre que de ddl
		    if ( (choix_var_ddl(imail)).size() != (tabnoeud_type_ddl_retenu(imail)).size())
		      { cout << " \n erreur**** anormale   le nombre de ddl  au noeud "
               << (tabnoeud_type_ddl_retenu(imail)).size()
				           << " est different du nombre de choix de variation "
               << (choix_var_ddl(imail)).size()
				           << " Isovaleurs_Gmsh::ChoixIsovaleur_noeud(const string& choix) ";
		        Sortie(1);
		      };			  
     };//-- fin de la boucle sur les maillages
 };
// choix de l'isovaleur à visualiser calculée à partir des ddl etendu aux noeuds
void Isovaleurs_Gmsh::ChoixIsovaleur_ddl_etendu_noeud(const string& choix)
 { // tout d'abord on traite le cas de tous les isovaleurs ou para par défaut
   // ici idem pour les noeuds
   if ((choix=="to")||(choix=="de"))
    { tabnoeud_type_ddlEtendu_retenu = tabnoeud_type_ddlEtendu;
      a_accumuler_tabnoeud_type_ddlEtendu_retenu=a_accumuler_tabnoeud_type_ddlEtendu;
      return;
    };
   // maintenant on traite le cas interactif   
   int dim = ParaGlob::Dimension();
   bool choix_valide = false;
   string rep;
   cout << "\n  choix d'isovaleur a visualiser ";
   int nbmail = tabnoeud_type_ddlEtendu.Taille();
   // update du tableau de ddl à visualiser si nécessaire
   if (tabnoeud_type_ddlEtendu_retenu.Taille() != nbmail)
       {tabnoeud_type_ddlEtendu_retenu.Change_taille(nbmail);
        a_accumuler_tabnoeud_type_ddlEtendu_retenu.Change_taille(nbmail);
       };

   for (int imail = 1;imail<=nbmail;imail++)
    {choix_valide=false;
     // dans le cas où il n'y a rien n'a visualiser on passe
     if (tabnoeud_type_ddlEtendu(imail).size() == 0)
       {cout << "\n *** aucune grandeur a visualiser pour le maillage "<< imail << endl;
       }
     else
      while (!choix_valide) // premier while
      {try 
        { cout << "\n listes de type de ddl a visualiser ";
          cout << "\n Maillage nb: " << imail << " liste des types de ddl disponibles "
               << "\n" << tabnoeud_type_ddlEtendu(imail);
          // affichage des ddl retenues si la liste n'est pas vide
          if (tabnoeud_type_ddlEtendu_retenu(imail).size() != 0)
            cout << "\n Maillage nb: " << imail << " liste des types de ddl enregistres "
                                     << "\n" << tabnoeud_type_ddlEtendu_retenu(imail);

          cout << "\n donnez la ou les grandeurs que vous voulez visualiser (rep grandeurs?)   "
               << "\n ou toutes les grandeurs                               (rep : to)         "
               << "\n effacer la liste actuelle                             (rep : ef)         "
               << "\n   fin                            (pour terminer tapez : fin (ou f ou 0)) "
               << "\n reponse ?  ";

          rep = lect_return_defaut(false,"f");
          if (rep == "fin_prog") Sortie(1);
			       List_io<Ddl_enum_etendu> nouveau_ddl_a_demander;
          if (rep == "to")
           // cas de toutes les grandeurs 
           {// on prévient que si on veut une grandeur sous forme de vecteur il faut la demander spécifiquement
            cout << "\n attention, si vous voulez une grandeur vectorielle ou tensorielle "
				             << "\n il faut refaire un passage en demandant cette grandeur specifiquement ";
				        // on vide les listes
				        (tabnoeud_type_ddlEtendu_retenu(imail)).clear();
			         // maintenant on ajoute les ddl 
            List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddlEtendu(imail).end();
            for (ite = tabnoeud_type_ddlEtendu(imail).begin();ite != itefin; ite++)
                {tabnoeud_type_ddlEtendu_retenu(imail).push_back(*ite);
					            nouveau_ddl_a_demander.push_back(*ite);
                 // si c'est un ddl a accumuler directement aux noeuds, on enregistre
                 if (find(a_accumuler_tabnoeud_type_ddlEtendu(imail).begin(),a_accumuler_tabnoeud_type_ddlEtendu(imail).end()
                          ,(*ite)) != a_accumuler_tabnoeud_type_ddlEtendu(imail).end())
                    a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail).push_back((*ite));
					           };
				        // on n'ordonne pas ni supprime les doublons car a priori tabnoeud_type_ddlEtendu(imail) ne comporte  pas de doublon
				        // si car l'utilisateur peut faire deux appels consécutifs ...
				        nouveau_ddl_a_demander.sort();nouveau_ddl_a_demander.unique();
            choix_valide=false;
           }  
          else if (rep == "ef")
           {// on efface la liste
            (tabnoeud_type_ddlEtendu_retenu(imail)).clear();
            (a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail)).clear();
				        choix_valide=false;
           };

          // sinon
          if ((rep == "0") || (rep == "f") || (rep == "fin")) 
              {choix_valide=true;}
          else if (Ddl_enum_etendu::VerifExistence(rep)) // test pour savoir si c'est vraiment un ddl
            { //Enum_ddl enum_d = Id_nom_ddl(rep.c_str());
              //Ddl_enum_etendu ddl_enu_etendue(enum_d);
              Ddl_enum_etendu ddl_enu_etendue(rep);
              // on vérifie si le ddl existe dans la liste proposée
              if (Ddl_enum_etendu::Existe_dans_la_liste(tabnoeud_type_ddlEtendu(imail),ddl_enu_etendue))
                 { // on regarde si l'on veut uniquement la grandeur scalaire ou tout
					              bool choix_var_valide=false; 
						             bool choixScalaireUniquement = true;
                   if (ddl_enu_etendue.TypeDeGrandeur() != SCALAIRE)
                    while (!choix_var_valide)
                     {try 
                      { cout << "\n voulez vous uniquement la grandeur scalaire (rep 1) ou toutes les composantes de la grandeur (rep 2) ? \n"
                             << "\n reponse ?  ";
                        rep = lect_chaine();
                        if (rep == "1") {choixScalaireUniquement=true;choix_var_valide=true;}
                        else if (rep == "2") {choixScalaireUniquement=false;choix_var_valide=true;}
                        else {cout << "\n mauvais choix, recommencez";choix_var_valide=false;}
                      }
                      catch (ErrSortieFinale)
                           // cas d'une direction voulue vers la sortie
                           // on relance l'interuption pour le niveau supérieur
                         { ErrSortieFinale toto;
                           throw (toto);
                         }
                      catch (...)// erreur en lecture
                       {  cout << "\n Erreur dans le choix scalaire ou non !!, "
                               << "\n redonnez une bonne valeur";
                          choix_var_valide=false;
                       };
                     }; //-- fin du second while 
                   // dans le cas où le ddl est de type vecteur, on ajoute toutes les composantes
                   EnumTypeGrandeur type_grandeur = ddl_enu_etendue.TypeDeGrandeur(); // le premier type de grandeur
                   List_io<Ddl_enum_etendu>& aaccumuler_inter_retenu = a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail); // pour simplifier
                   List_io<Ddl_enum_etendu>& aaccumuler_inter = a_accumuler_tabnoeud_type_ddlEtendu(imail); // pour simplifier
                   if ((!choixScalaireUniquement) && ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE) 
                     || (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH)))
                  	 { // cas d'un type vecteur
                  	   Enum_ddl enu_type_famille = PremierDdlFamille(ddl_enu_etendue.Enum());
                  	   // pour l'instant ***** on ne sort que des iso de ddl non étendue donc on peut constituer les
                  	   // ddl du vecteur qui est forcément de dim 3
                      switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
                       { case 3:{Ddl_enum_etendu ddl_enum(Enum_ddl(enu_type_famille+dim-3));
                                 tabnoeud_type_ddlEtendu_retenu(imail).push_back(ddl_enum);
                                 nouveau_ddl_a_demander.push_back(ddl_enum);
                                 if (find(aaccumuler_inter.begin(),aaccumuler_inter.end(),ddl_enum) != aaccumuler_inter.end())
                                    aaccumuler_inter_retenu.push_back(ddl_enum);
                                }
                         case 2:{Ddl_enum_etendu ddl_enum(Enum_ddl(enu_type_famille+dim-2));
                                 tabnoeud_type_ddlEtendu_retenu(imail).push_back(ddl_enum);
							                          nouveau_ddl_a_demander.push_back(ddl_enum);
                                 if (find(aaccumuler_inter.begin(),aaccumuler_inter.end(),ddl_enum) != aaccumuler_inter.end())
                                    aaccumuler_inter_retenu.push_back(ddl_enum);
                                }
                         case 1:{Ddl_enum_etendu ddl_enum(Enum_ddl(enu_type_famille+dim-1));
                                 tabnoeud_type_ddlEtendu_retenu(imail).push_back(ddl_enum);
							                          nouveau_ddl_a_demander.push_back(ddl_enum);
                                 if (find(aaccumuler_inter.begin(),aaccumuler_inter.end(),ddl_enum) != aaccumuler_inter.end())
                                    aaccumuler_inter_retenu.push_back(ddl_enum);
                                }
                       };
                    }
                   else // cas d'une grandeur scalaire simple
                  	 { tabnoeud_type_ddlEtendu_retenu(imail).push_back(ddl_enu_etendue);
                      nouveau_ddl_a_demander.push_back(ddl_enu_etendue);
                      if (find(aaccumuler_inter.begin(),aaccumuler_inter.end(),ddl_enu_etendue) != aaccumuler_inter.end())
                                    aaccumuler_inter_retenu.push_back(ddl_enu_etendue);
                  	 };
                 }
 /*         else if ( Existe_typeQuelconque(rep)) // cas où c'est un type quelconque
            { //Enum_ddl enum_d = Id_nom_ddl(rep.c_str());
              //Ddl_enum_etendu ddl_enu_etendue(enum_d);
              Ddl_enum_etendu ddl_enu_etendue(rep);
              // on vérifie si le ddl existe dans la liste proposée
              if (   (Ddl_enum_etendu::Existe_dans_la_liste(tabnoeud_type_ddlEtendu(imail),ddl_enu_etendue))
                  || (Ddl_enum_etendu::Existe_dans_la_liste(list_vect_globalPourNoeud,ddl_enu_etendue))
                 )
                 { // on regarde si l'on veut uniquement la grandeur scalaire ou tout
					              bool choix_var_valide=false; 
						             bool choixScalaireUniquement = true; 
                   while (!choix_var_valide)
                   {try 
                    { cout << "\n voulez vous uniquement la grandeur scalaire (rep 1) ou toutes les composantes de la grandeur (rep 2) ? \n"
                           << "\n reponse ?  ";
                      cin >> rep;
                      if (rep == "1") {choixScalaireUniquement=true;choix_var_valide=true;}
                      else if (rep == "2") {choixScalaireUniquement=false;choix_var_valide=true;}
                      else {cout << "\n mauvais choix, recommencez";choix_var_valide=false;}
                    }
                    catch (...)// erreur en lecture
                     {  cout << "\n Erreur dans le choix scalaire ou non !!, "
                             << "\n redonnez une bonne valeur";
                        choix_var_valide=false;
                     };
                   }; //-- fin du second while 
                   // dans le cas où le ddl est de type vecteur, on ajoute toutes les composantes
                   EnumTypeGrandeur type_grandeur = ddl_enu_etendue.TypeDeGrandeur(); // le premier type de grandeur
                   if ((!choixScalaireUniquement) && ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE) 
                     || (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH)))
                  	 { // cas d'un type vecteur
                  	   Enum_ddl enu_type_famille = PremierDdlFamille(ddl_enu_etendue.Enum()); 
                  	   // pour l'instant ***** on ne sort que des iso de ddl non étendue donc on peut constituer les
                  	   // ddl du vecteur qui est forcément de dim 3
                      switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
                       { case 3: tabnoeud_type_ddlEtendu_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-3)));
							                    nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-3)));
                         case 2: tabnoeud_type_ddlEtendu_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-2)));
							                    nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-2)));
                         case 1: tabnoeud_type_ddlEtendu_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-1)));
							                    nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-1)));
                       };
                    }
                   else // cas d'une grandeur scalaire simple
                  	 { tabnoeud_type_ddlEtendu_retenu(imail).push_back(ddl_enu_etendue);
                      nouveau_ddl_a_demander.push_back(ddl_enu_etendue);
                  	 };
                   deplace_ou_valeur_a_demander=true;
                 } */
              else
                 {cout << "\n ddl inexistant dans la liste proposee, recommencez";
                  choix_valide=false;
                 };
             };
                                                              
        }
       catch (ErrSortieFinale)
            // cas d'une direction voulue vers la sortie
            // on relance l'interuption pour le niveau supérieur
          { ErrSortieFinale toto;
            throw (toto);
          }
       catch (...)// erreur en lecture
          {  cout << "\n Erreur dans la lecture de ddl !!, "
                  << "\n redonnez une bonne valeur"
                  << "\n ou taper fin_prog pour arreter le programme"; 
             choix_valide=false;
          };
       //  on ordonne et supprime les doublons 
       tabnoeud_type_ddlEtendu_retenu(imail).sort(); // on ordonne
       tabnoeud_type_ddlEtendu_retenu(imail).unique();// on supprime les doublons
       a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail).sort(); // on ordonne
       a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail).unique();// on supprime les doublons
		    
// debug		cout << "\n" << tabnoeud_type_ddlEtendu_retenu(imail) << "\n et les choix " << choix_var_ddl(imail) << endl;
		                          
      }; //-- fin du premier while
    };//-- fin de la boucle sur les maillages
 };

// choix de l'isovaleur à visualiser calculée à partir de grandeurs évoluées aux noeuds
void Isovaleurs_Gmsh::ChoixIsovaleur_evoluee_noeud(const string& choix)
  { // tout d'abord on traite le cas de tous les isovaleurs
   if (choix=="to")
    { tabnoeud_evoluee_retenu = tabnoeud_evoluee;
      return;
    }
   else if (choix=="de")
    { // on prend le premier élément de chaque maillage et on statut en fonction de son type
      int nbmail = tabnoeud_evoluee.Taille();
      for (int imail = 1;imail<=nbmail;imail++)
       {List_io < TypeQuelconque >& element_evoluee = tabnoeud_evoluee(imail); // pour simplifier
        List_io < TypeQuelconque >& element_evoluee_retenu = tabnoeud_evoluee_retenu(imail); // pour simplifier
        List_io < TypeQuelconque >::iterator iq,iqfin=element_evoluee.end();
        List_io < TypeQuelconque >::iterator iqev,iqevfin;
        Element& ele = lesMail->Element_LesMaille(imail,1);
        Element::Signature signa =  ele.Signature_element();
        switch (signa.id_problem)
         {case MECA_SOLIDE_DEFORMABLE:
           {// c'est avec les types évoluées que l'on travaille, on sort les forces internes et externes globales            // tout d'abord les grandeurs communes:
            //   a) on sort les forces externes 
            for (iq=element_evoluee.begin();iq!=iqfin;iq++) 
                      {if ((*iq).EnuTypeQuelconque()== FORCE_GENE_EXT) break;};
            if (iq != iqfin) 
             { // on enregistre s'il n'existe pas déjà
               iqevfin=element_evoluee_retenu.end();
               for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++) 
                      {if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_EXT) break;};
               if (iqev == iqevfin)element_evoluee_retenu.push_back(*iq);
             };
            //   b) et les forces internes
            for (iq=element_evoluee.begin();iq!=iqfin;iq++) 
                      {if ((*iq).EnuTypeQuelconque()== FORCE_GENE_INT) break;};
            if (iq != iqfin) 
             { // on enregistre s'il n'existe pas déjà
               iqevfin=element_evoluee_retenu.end();
               for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++) 
                      {if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_INT) break;};
               if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
             }; 
            //   c) les forces internes + externes
            for (iq=element_evoluee.begin();iq!=iqfin;iq++)
                      {if ((*iq).EnuTypeQuelconque()== FORCE_GENE_TOT) break;};
            if (iq != iqfin)
             { // on enregistre s'il n'existe pas déjà
               iqevfin=element_evoluee_retenu.end();
               for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
                      {if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_TOT) break;};
               if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
             };
            //   d) les forces résidues d'équilibre
            for (iq=element_evoluee.begin();iq!=iqfin;iq++)
                      {if ((*iq).EnuTypeQuelconque()== RESIDU_GLOBAL) break;};
            if (iq != iqfin)
             { // on enregistre s'il n'existe pas déjà
               iqevfin=element_evoluee_retenu.end();
               for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
                      {if ((*iqev).EnuTypeQuelconque()== RESIDU_GLOBAL) break;};
               if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
             };
            // puis choix en fonction de l'évolution temporelle
            switch  (Evolution_temporelle_du_calcul(ParaGlob::param->TypeCalcul_maitre()))
             { case DYNAMIQUE:
                { // on sort les vitesses de déformation 
                  for (iq=element_evoluee.begin();iq!=iqfin;iq++) 
                      {if ((*iq).EnuTypeQuelconque()== VITESSE_DEFORMATION_COURANTE) break;};
                  if (iq != iqfin) 
                   { // on enregistre s'il n'existe pas déjà
                     iqevfin=element_evoluee_retenu.end();
                     for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++) 
                            {if ((*iqev).EnuTypeQuelconque()== VITESSE_DEFORMATION_COURANTE) break;};
                     if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
                   }; 
                  break;
                 default:
                   // on ne fait rien
                   break;
                }
             };
             break;
           } //-- fin du cas MECA_SOLIDE_DEFORMABLE
          default: 
            cout << "\n pour l'instant pas de parametre par defaut pour les noeuds !! "
                 << "\n pour le type de problem : " << NomElemTypeProblem(signa.id_problem) 
                 << "\n on continue sur le cas general ";
          };
       }; //-- fin de la boucle sur les maillages 
      return;
     };  
   // maintenant on traite le cas interactif
   string rep;
   bool choix_valide = false;   
   cout << "\n  choix d'isovaleur (grandeurs evoluees) defini aux noeuds, a visualiser ";
   int nbmail = tabnoeud_evoluee.Taille();
   // update du tableau evolues à visualiser si nécessaire
   if (tabnoeud_evoluee_retenu.Taille() != nbmail)
       tabnoeud_evoluee_retenu.Change_taille(nbmail);
   for (int imail = 1;imail<=nbmail;imail++)
    {// on ne traite que s'il y a des grandeurs disponibles
     if ( (tabnoeud_evoluee(imail).size() == 0 )
         && (list_vect_globalPourNoeud.size() == 0))
     { cout << "\n aucune grandeur  n'est definit, donc aucune proposition ";}
     else
     {choix_valide=false;
      while (!choix_valide) // premier while
      {try 
        { cout << "\n (0 ou f ou fin) fin choix grandeurs evoluees ";
          cout << "\n listes de type de grandeur evoluees a visualiser ";
          // affichage des grandeurs retenues si la liste n'est pas vide
          if ((tabnoeud_evoluee_retenu(imail)).size())
             { cout << "\n Maillage nb: " << imail << "\n  liste des types de grandeurs enregistres:   ";  
               List_io < TypeQuelconque >::iterator iet,ietfin = (tabnoeud_evoluee_retenu(imail)).end();
               for (iet=(tabnoeud_evoluee_retenu(imail)).begin();iet!=ietfin;iet++)
                 cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
               cout << endl;  
             };
          cout << "\n Maillage nb: " << imail << " liste des types de grandeurs evoluees disponibles ";
          // tout d'abord celles venant du maillage
          List_io < TypeQuelconque >::iterator iet,ietfin = (tabnoeud_evoluee(imail)).end();
          for (iet=(tabnoeud_evoluee(imail)).begin();iet!=ietfin;iet++)
                     cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
          // puis celles venant de l'algorithme
          {List_io < TypeQuelconque >::iterator iet,ietfin = list_vect_globalPourNoeud.end();
           List_io<TypeQuelconque>& tpg = (tabnoeud_evoluee(imail));
           for (iet=list_vect_globalPourNoeud.begin();iet!=ietfin;iet++)
               { if ( find(tpg.begin(),tpg.end(),(*iet)) == tpg.end()) // on ne sort que si ça n'a pas déjà été sorti
                     cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
               };
          };
          // le menu
          cout << "\n donner la grandeur a visualiser "
               << "\n (to) toutes les grandeurs "
               << "\n (de) les grandeurs par defaut"
               << "\n (une liste de grandeurs evoluees) "
               << "\n (ef)               pour effacer la liste "
               << "\n (0 ou f ou fin)    fin choix grandeur tensorielle "
               << "\n reponse ?  ";
          rep = lect_return_defaut(false,"f");
          if (rep == "fin_prog") Sortie(1);
          if (rep == "to")
           {// cas de toutes les grandeurs
            // tout d'abord venant des maillages
            tabnoeud_evoluee_retenu(imail).clear(); // avec les types évolués il vaut vider avant la recopie
            tabnoeud_evoluee_retenu(imail) = tabnoeud_evoluee(imail);
            // puis  celles venant de l'algorithme
            {List_io<TypeQuelconque>& tpg_ret = (tabnoeud_evoluee_retenu(imail)); // pour simplifier
             List_io<TypeQuelconque>& tpg = list_vect_globalPourNoeud; // pour simplifier
             List_io<TypeQuelconque>::iterator il,ilfin = list_vect_globalPourNoeud.end();
             for (il=list_vect_globalPourNoeud.begin();il != ilfin;il++)
                { tpg_ret.push_back(*il);
                  list_vect_globalPourNoeud_retenu.push_back(*il); // sert pour ajouter les conteneurs aux noeuds
                };
            };
            choix_valide=false;
           };
          // sinon
          if ((rep == "0") || (rep == "f") || (rep == "fin")) 
            {choix_valide=true;}
          else if (rep=="ef")
            { tabnoeud_evoluee_retenu(imail).clear();
              list_vect_globalPourNoeud_retenu.clear();
            }
          else if (rep=="de")
            {List_io < TypeQuelconque >& element_evoluee = tabnoeud_evoluee(imail); // pour simplifier
             List_io < TypeQuelconque >& element_evoluee_retenu = tabnoeud_evoluee_retenu(imail); // pour simplifier
             List_io < TypeQuelconque >::iterator iq,iqfin=element_evoluee.end();
             List_io < TypeQuelconque >::iterator iqev,iqevfin;
             Element& ele = lesMail->Element_LesMaille(imail,1);
             Element::Signature signa =  ele.Signature_element();
             switch (signa.id_problem)
              {case MECA_SOLIDE_DEFORMABLE:
                {// c'est avec les types évoluées que l'on travaille, on sort les forces internes et externes globales            // tout d'abord les grandeurs communes:
                 //   a) on sort les forces externes
                 for (iq=element_evoluee.begin();iq!=iqfin;iq++)
                           {if ((*iq).EnuTypeQuelconque()== FORCE_GENE_EXT) break;};
                 if (iq != iqfin)
                  { // on enregistre s'il n'existe pas déjà
                    iqevfin=element_evoluee_retenu.end();
                    for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
                           {if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_EXT) break;};
                    if (iqev == iqevfin)element_evoluee_retenu.push_back(*iq);
                  };
                 //   b) et les forces internes
                 for (iq=element_evoluee.begin();iq!=iqfin;iq++)
                           {if ((*iq).EnuTypeQuelconque()== FORCE_GENE_INT) break;};
                 if (iq != iqfin)
                  { // on enregistre s'il n'existe pas déjà
                    iqevfin=element_evoluee_retenu.end();
                    for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
                           {if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_INT) break;};
                    if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
                  };
                 //   c) les forces internes + externes
                 for (iq=element_evoluee.begin();iq!=iqfin;iq++)
                           {if ((*iq).EnuTypeQuelconque()== FORCE_GENE_TOT) break;};
                 if (iq != iqfin)
                  { // on enregistre s'il n'existe pas déjà
                    iqevfin=element_evoluee_retenu.end();
                    for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
                           {if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_TOT) break;};
                    if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
                  };
                 //   d) les forces résidues d'équilibre
                 for (iq=element_evoluee.begin();iq!=iqfin;iq++)
                           {if ((*iq).EnuTypeQuelconque()== RESIDU_GLOBAL) break;};
                 if (iq != iqfin)
                  { // on enregistre s'il n'existe pas déjà
                    iqevfin=element_evoluee_retenu.end();
                    for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
                           {if ((*iqev).EnuTypeQuelconque()== RESIDU_GLOBAL) break;};
                    if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
                  };
                 // puis choix en fonction de l'évolution temporelle
                 switch  (Evolution_temporelle_du_calcul(ParaGlob::param->TypeCalcul_maitre()))
                  { case DYNAMIQUE:
                     { // on sort les vitesses de déformation
                       for (iq=element_evoluee.begin();iq!=iqfin;iq++)
                           {if ((*iq).EnuTypeQuelconque()== VITESSE_DEFORMATION_COURANTE) break;};
                       if (iq != iqfin)
                        { // on enregistre s'il n'existe pas déjà
                          iqevfin=element_evoluee_retenu.end();
                          for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
                                 {if ((*iqev).EnuTypeQuelconque()== VITESSE_DEFORMATION_COURANTE) break;};
                          if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
                        };
                       break;
                      default:
                        // on ne fait rien
                        break;
                     }
                  };
                  break;
                } //-- fin du cas MECA_SOLIDE_DEFORMABLE
               default:
                 cout << "\n pour l'instant pas de parametre par defaut pour les noeuds !! "
                      << "\n pour le type de problem : " << NomElemTypeProblem(signa.id_problem)
                      << "\n on continue sur le cas general ";
               };
            }
          else if (TypeQuelconque_enum_etendu::VerifExistence(rep) ) // vérif que c'est une grandeur possible
            { // maintenant on vérifie qu'elle appartient à la liste des grandeurs disponibles
              TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
              bool trouve=false; // init pour le message d'erreur
              // tout d'abord vérif pour celles venant du maillage
              {List_io<TypeQuelconque>& tpg_ret = (tabnoeud_evoluee_retenu(imail)); // pour simplifier
               List_io<TypeQuelconque>& tpg = (tabnoeud_evoluee(imail)); // pour simplifier
               if (find(tpg.begin(),tpg.end(),a) != tpg.end())
                { // il existe -> enregistrement
                  List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                  // s'il n'existe pas déjà on l'enregistre vraiment
                  if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                       tpg_ret.push_back(*il);
                  trouve = true; // on a bien trouvé une grandeur
                };
              };
              // puis  vérif pour celles venant de l'algorithme
              {List_io<TypeQuelconque>& tpg_ret = (tabnoeud_evoluee_retenu(imail)); // pour simplifier
               List_io<TypeQuelconque>& tpg = list_vect_globalPourNoeud; // pour simplifier
               if (find(tpg.begin(),tpg.end(),a) != tpg.end())
               { // il existe -> enregistrement
                 List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                 // s'il n'existe pas déjà on l'enregistre vraiment
                 if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                   { tpg_ret.push_back(*il);
                     list_vect_globalPourNoeud_retenu.push_back(*il); // sert pour ajouter les conteneurs aux noeuds
                   };
                 trouve = true; // on a bien trouvé une grandeur
                 // on sort un message pour indiquer que la grandeur globale ne sera
                 // disponible qu'au fil du calcul
                 {cout << "\n ---- attention, la grandeur suivante ne sera disponible qu'au fil du calcul ----";
                  cout << "\n " << ((*il).EnuTypeQuelconque().NomPlein()) ;
                 };
               };
              };
              if (!trouve)
               { cout << "\n erreur, grandeur non disponible !, recommencez ";};
            };
          // on supprime les doublons dans la liste retenue
          (tabnoeud_evoluee_retenu(imail)).sort();
          (tabnoeud_evoluee_retenu(imail)).unique();
          list_vect_globalPourNoeud.sort();
          list_vect_globalPourNoeud.unique();
        }
       catch (ErrSortieFinale)
            // cas d'une direction voulue vers la sortie
            // on relance l'interuption pour le niveau supérieur
          { ErrSortieFinale toto;
            throw (toto);
          }
       catch (...)// erreur en lecture
        {  cout << "\n Erreur dans la lecture evolues !!, "
                << "\n redonnez une bonne valeur"
                << "\n ou taper fin_prog pour arreter le programme";
           choix_valide=false;
        };
      }; //-- fin du premier while
      tabnoeud_evoluee_retenu(imail).sort(); // on ordonne
      tabnoeud_evoluee_retenu(imail).unique();// on supprime les doublons
      // on parcours la liste a_accumuler_tabnoeud_evoluee pour savoir le type d'accumulation à mettre en place
      
     {List_io<TypeQuelconque>& aaccum_ret = (a_accumuler_tabnoeud_evoluee_retenu(imail)); // pour simplifier
      List_io<TypeQuelconque>& aaccum = (a_accumuler_tabnoeud_evoluee(imail)); // pour simplifier
      List_io<TypeQuelconque>& tpg_ret = (tabnoeud_evoluee_retenu(imail)); // pour simplifier
      List_io < TypeQuelconque >::iterator iq,iqfin=tpg_ret.end();
      for (iq=tpg_ret.begin();iq!=iqfin;iq++)
       if (find(aaccum.begin(),aaccum.end(),(*iq)) != aaccum.end())
         aaccum_ret.push_back(*iq);// accumulation simple
      //on ordonne et supprime les doublons
      aaccum_ret.sort();aaccum_ret.unique();
     };
      
     }; //-- fin de if (tabelement_typeParti(imail).size() != 0 )                          
    };//-- fin de la boucle sur les maillages  
 };  
 
// choix de l'isovaleur à visualiser calculée à partir des ddl aux points d'intégrations
void Isovaleurs_Gmsh::ChoixIsovaleur_ddl_ptinteg(const string& choix)
 { // tout d'abord on traite le cas de tous les isovaleurs
   if (choix=="to")
    { tabelement_type_ddl_retenu = tabelement_type_ddl;
      return;
     }
   else if (choix=="de")
    { // pour l'instant aucun éléments par défaut
      return;
     };  
   // maintenant on traite le cas interactif
   string rep;
   bool choix_valide = false;   
   cout << "\n  choix d'isovaleur (grandeurs scalaires) venant des pts d'integ a visualiser ";
   int nbmail = tabelement_type_ddl.Taille();
   // update du tableau de ddl à visualiser si nécessaire
   if (tabelement_type_ddl_retenu.Taille() != nbmail)
       tabelement_type_ddl_retenu.Change_taille(nbmail);
   for (int imail = 1;imail<=nbmail;imail++)
    {// on ne traite que s'il y a des grandeurs disponibles
     if (tabelement_type_ddl(imail).size() != 0 )
     {choix_valide=false;
      while (!choix_valide) // premier while
      {try 
        { cout << "\n listes de type de ddl a visualiser ";
          cout << "\n Maillage nb: " << imail << " liste des types de ddl disponibles "
                                     << "\n" << tabelement_type_ddl(imail);
          // affichage des ddl retenues si la liste n'est pas vide
          if (tabelement_type_ddl_retenu(imail).size() != 0)
            cout << "\n Maillage nb: " << imail << " liste des types de ddl enregistres "
                                     << "\n" << tabelement_type_ddl_retenu(imail);                           
          cout << "\n donner le ddl a visulaliser "
               << "\n (to) tous les ddl "
               << "\n (une liste de ddl) "
               << "\n (ef)               pour effacer la liste "
               << "\n (ef1)              effacer un ddl de la liste "
               << "\n (0 ou f ou fin)    fin choix ddl "
               << "\n reponse ?  ";
          rep = lect_return_defaut(false,"f");
          if (rep == "fin_prog") Sortie(1);
          if (rep == "to")
           {// cas de tous les ddl
            tabelement_type_ddl_retenu(imail) = tabelement_type_ddl(imail);
            choix_valide=false;
            };
          // sinon
          if ((rep == "0") || (rep == "f") || (rep == "fin")) 
              {choix_valide=true;}
          else if (rep=="ef")
            { tabelement_type_ddl_retenu(imail).clear();
              }
          else if (rep=="ef1")
           { cout << "\n donnez le ddl "; rep = lect_chaine();
             if(Ddl_enum_etendu::VerifExistence(rep))
              {Ddl_enum_etendu ddl_enu_etendue(rep);
               List_io < Ddl_enum_etendu >::iterator position=
               find (tabelement_type_ddl_retenu(imail).begin(),tabelement_type_ddl_retenu(imail).end(),ddl_enu_etendue);
               if (position!=tabelement_type_ddl_retenu(imail).end())
                 {tabelement_type_ddl_retenu(imail).erase(position);}
               else
                 {cout << "\n ddl inexistant dans la liste proposee, recommencez";};
               }
             else
               {cout << "\n ddl inexistant dans la liste proposee, recommencez";};
            }
          else if (Ddl_enum_etendu::VerifExistence(rep)) // test pour savoir si c'est vraiment un ddl
            { Ddl_enum_etendu ddl_enu_etendue(rep);
              // on vérifie si le ddl existe dans la liste proposée
              if (Ddl_enum_etendu::Existe_dans_la_liste(tabelement_type_ddl(imail),ddl_enu_etendue))
                 {tabelement_type_ddl_retenu(imail).push_back(ddl_enu_etendue);
                 }
              else
                 {cout << "\n ddl inexistant dans la liste proposee, recommencez";
                  choix_valide=false;
                  }
             }     
          }
        catch (ErrSortieFinale)
             // cas d'une direction voulue vers la sortie
             // on relance l'interuption pour le niveau supérieur
           { ErrSortieFinale toto;
             throw (toto);
           }
        catch (...)// erreur en lecture
          {  cout << "\n Erreur dans la lecture de ddl !!, "
                  << "\n redonnez une bonne valeur"
                  << "\n ou taper fin_prog pour arreter le programme"; 
             choix_valide=false;
           }
      } //-- fin du premier while 
      tabelement_type_ddl_retenu(imail).sort(); // on ordonne
      tabelement_type_ddl_retenu(imail).unique();// on supprime les doublons                           
      }; //-- fin de if (tabelement_typeParti(imail).size() != 0 )                          
     };//-- fin de la boucle sur les maillages  
  };  
// exeoOrdre: cas du premier increments
// ne concerne que les grandeurs définies aux pti
void Isovaleurs_Gmsh::ExeOrdrePremierIncrement(const Tableau <int>& tab_mail,LesMaillages * )
{   // pour simplifier
    int nbmail = tab_mail.Taille();
    // dimensionnement en taille
    tp_tp_tp_gauss_base.Change_taille(nbmail);
    // intialisation de li_P_gauss_total
    li_P_gauss_total.clear();
    // idem pour map_gauss_base
    map_gauss_base.clear();
    map_gauss_basePQ.clear();
    map_gauss_baseEVol.clear();
    
    // --- boucle sur les maillages ---
    for (int im=1;im<=nbmail;im++)
      {int numMail=tab_mail(im);
       Tableau < Tableau < P_gauss > >& tp_tp_gauss_base = tp_tp_tp_gauss_base(im); // pour simplifier
       // 1) on récupère tout d'abord le nombre d'éléments différents dans le maillage     
       const List_io <Element::Signature>& li_sig_elem = (mailInitial->Tab_liste_type_element())(numMail);
       // 2) on cherche la liste des types de ddl différents associés à des pt de gauss
       List_io < Enum_ddl >  lisEnumDdl; // liste de tous les premiers ddl différents
       // 2-A) cas des ddl étendue
       List_io < Ddl_enum_etendu >& element_type_ddl_retenu=tabelement_type_ddl_retenu(numMail); // pour simplifier
       List_io < Ddl_enum_etendu >::iterator iel,ielfin=element_type_ddl_retenu.end();
       for (iel=element_type_ddl_retenu.begin();iel!=ielfin;iel++)
        { Enum_ddl pr_ddl = PremierDdlFamille((*iel).Enum()); // récup du premier ddl
          if (find(lisEnumDdl.begin(),lisEnumDdl.end(),pr_ddl)== lisEnumDdl.end())
              lisEnumDdl.push_back(pr_ddl);
         };
       // 2-B) cas des grandeurs quelconques pour les grandeurs évoluées: tensorielles
       List_io < TypeQuelconque >& element_evoluee_retenu=tabelement_evoluee_retenu(numMail); // pour simplifier
       List_io < TypeQuelconque >::iterator ielEV,ielfinEV=element_evoluee_retenu.end();
       for (ielEV=element_evoluee_retenu.begin();ielEV!=ielfinEV;ielEV++)
        { Enum_ddl pr_ddl = PremierDdlFamille((*ielEV).Enum()); // récup du premier ddl
          if (find(lisEnumDdl.begin(),lisEnumDdl.end(),pr_ddl)== lisEnumDdl.end())
              lisEnumDdl.push_back(pr_ddl);
         };
       // 2-C) cas des grandeurs quelconques pour les grandeurs particulières
       List_io < TypeQuelconque >& element_typeParti_retenu=tabelement_typeParti_retenu(numMail); // pour simplifier
       List_io < TypeQuelconque >::iterator ielPQ,ielfinPQ=element_typeParti_retenu.end();
       for (ielPQ=element_typeParti_retenu.begin();ielPQ!=ielfinPQ;ielPQ++)
        { Enum_ddl pr_ddl = PremierDdlFamille((*ielPQ).Enum()); // récup du premier ddl
          if (find(lisEnumDdl.begin(),lisEnumDdl.end(),pr_ddl)== lisEnumDdl.end())
              lisEnumDdl.push_back(pr_ddl);
         };
       // 3) maintenant on boucle sur les types de ddl différents et sur les types d'éléments pour construire
       // la définition des pt d'integ associés aux infos à sortir
       List_io <Element::Signature>::const_iterator ifin=li_sig_elem.end();
       List_io < Enum_ddl >::iterator iddle,iddlefin= lisEnumDdl.end();
       List_io <Element::Signature>::const_iterator ipos;
       // récup du tableau de sous maillages 
       const Tableau < List_io < Element* > >  & tab_sous_mesh 
                              = (mailInitial->Tableau_de_sous_maillage())(numMail);
       int nbsmax =  tab_sous_mesh.Taille(); // récup du nombre de sous maillage
       // définition d'un tableau intermédiaire permettant de retrouver le P_gauss dans la liste li_P_gauss_total 
       Tableau < Tableau < P_gauss *> > tab_point_enum(nbsmax); 

       // récup de la liste de noms de sous maillage
       const  List_io <string>& li_nom_sous_mesh 
                              = (mailInitial->Tab_listes_nom_sousMaillage())(numMail);
       
       // important: *** on boucle d'abord sur les types d'éléments c'est-à-dire les sous maillages
       // et à l'intérieur on boucle sur les ddl, because, c'est dans cet ordre que l'on sort les résultats 
       // --> l'enjeux c'est l'ordre des éléments de tp_gauss_base                       
       tp_tp_gauss_base.Change_taille(li_sig_elem.size());
       int ism = 1; // init numéro de sous maillage
       // init nom de sous maillage
       List_io <string>::const_iterator inom=li_nom_sous_mesh.begin();                       
       for (ipos= li_sig_elem.begin();ipos!=ifin;ipos++,ism++,inom++)
        {List_io < P_gauss > lip_gauss_base ; // intermédiaire pour construire le tableau tp_gauss_base
         int numero_ddl = 1;
         for (iddle=lisEnumDdl.begin();iddle!=iddlefin;iddle++,numero_ddl++)
           { // récup du premier élément qui sert d'élément courant
             const Element & ele = (*(*(tab_sous_mesh(ism).begin())));
             tab_point_enum(ism).Change_taille(nombre_maxi_de_type_de_ddl); // dimensionnement du tableau indirecte 
             // on commence par regarder s'il n'y a pas déjà un groupe de pt_integ qui convient
             // le nombre de pt d'integ est contenu dans l'élément géométrique associé
             Isovaleurs_Gmsh::P_gauss pt_gauss_inter // ici seule compte le pointeur de géométrie
                             (&(ele.ElementGeometrie(*iddle)),"toto",(*iddle),numMail);
                             // car lorsque l'on a créer le groupe on a demander l'élément géométrique
                             // relatif au ddl, donc contenant le bon nombre de pt d'integ
             list < Isovaleurs_Gmsh::P_gauss >::iterator 
                         li_P=find(li_P_gauss_total.begin(),li_P_gauss_total.end(),pt_gauss_inter);
             if (li_P != li_P_gauss_total.end())
              {// cas ou un group existant existe déjà, enregistrement
               li_P_gauss_total.push_front(Isovaleurs_Gmsh::P_gauss
                          ((*li_P).elemgeom,(*li_P).nom_groupe_pt_integ,(*iddle),numMail));
               tab_point_enum(ism)(*iddle)=&(*(li_P_gauss_total.begin()));          
               // si ce groupe de point de gauss n'est pas enregistré pour ce maillage on l'enregistre
               // mais on n'enregistre que les groupes avec des noms différents et/ou des 
               list < Isovaleurs_Gmsh::P_gauss >::iterator 
                         li_gb=find(lip_gauss_base.begin(),lip_gauss_base.end(),pt_gauss_inter);
               if (li_gb == lip_gauss_base.end())            
                      lip_gauss_base.push_front((*(li_P_gauss_total.begin()))); // remplissage de la liste mini
               }
             else
              {// sinon on en construit un autre  
               // création du nom de référence pour le groupe de pt d'integ
               // ce nom intègre également le nom de l'élément geométrique, le type d'interpolation, le nb de pt
               // d'integ -> ainsi il ne doit jamais y avoir deux noms identiques  pour des éléments géométriques différents
               // par contre on peut avoir le même nom pour deux Enum_ddl associés différents, ça veut dire que ces enum
               // utilisent les mêmes pt d'integ
               ostrstream tab_out;
               ElemGeomC0& elegeom = (ele.ElementGeometrie(*iddle));
               tab_out << "gr_ptInteg_:" << (*inom)  << "_nbddl_" << numero_ddl << "_m_" << numMail << "_" 
                       // volontairement on ne sort que des chiffres (correspondant au type enuméré) par concision
                       << int(elegeom.TypeGeometrie()) << int(elegeom.TypeInterpolation()) << elegeom.Nbi() << ends;
               string nom_pt_integ_sous_maillage = tab_out.str() ;  // le nom
               li_P_gauss_total.push_front(Isovaleurs_Gmsh::P_gauss
                            (&elegeom,nom_pt_integ_sous_maillage,(*iddle),numMail));
               tab_point_enum(ism)(*iddle)=&(*(li_P_gauss_total.begin()));          
               lip_gauss_base.push_front((*(li_P_gauss_total.begin()))); // remplissage de la liste mini
               
   	           // fin     
              }; //-- fin de la construction d'un nouveau groupe
            }; //-- fin de la boucle sur les types différents d'énum ddl

   	     // e >> ---- construction de tp_tp_gauss_base 
   	     Tableau < P_gauss >& tp_gauss_base =  tp_tp_gauss_base(ism); 
         list < P_gauss >::iterator inga,ingafin=lip_gauss_base.end();
         tp_gauss_base.Change_taille(lip_gauss_base.size());
         int nbpg=lip_gauss_base.size(); // si l'on veut garder le même ordre que durant la création de lip_gauss_base
         // il faut décroitre (car lip_gauss_base est rempli par des push_front)
         for (inga=lip_gauss_base.begin();inga!=ingafin;inga++,nbpg--)
             tp_gauss_base(nbpg)=(*inga);

     	  }; //-- fin de la boucle sur les types différents d'éléments, donc de sous maillage
 	     
  	    // a >> ---- maintenant on définit le tableau tab_point_enum
  	    //      ou on met à jour s'il y a plusieurs maillage
       // b >> ----- calcul de la liste des ddl étendues associé aux groupes de pt_gauss
       // on passe en revue tous les ddl étendue
       for (iel=element_type_ddl_retenu.begin();iel!=ielfin;iel++)
         { Enum_ddl pr_ddl = PremierDdlFamille((*iel).Enum()); // récup du premier ddl
           for (int jsm =1; jsm <= nbsmax; jsm++)
               map_gauss_base[tab_point_enum(jsm)(pr_ddl)->nom_groupe_pt_integ].push_back((*iel)); 
          };          
       // c >> ----- idem pour les types évolués tensorielles
       // on passe en revue tous les types quelconques
       for (ielEV=element_evoluee_retenu.begin();ielEV!=ielfinEV;ielEV++)
         { Enum_ddl pr_ddl = PremierDdlFamille((*ielEV).Enum()); // récup du premier ddl
           for (int jsm =1; jsm <= nbsmax; jsm++)
               map_gauss_baseEVol[tab_point_enum(jsm)(pr_ddl)->nom_groupe_pt_integ].push_back((*ielEV)); 
          };          
       // d >> ----- idem pour les types quelconques pour les grandeurs particulières
       // on passe en revue tous les types quelconques
       for (ielPQ=element_typeParti_retenu.begin();ielPQ!=ielfinPQ;ielPQ++)
         { //cout << "\n debug de isoGmsh " <<  (*((*ielPQ).Grandeur_pointee())) << endl; // débug
           Enum_ddl pr_ddl = PremierDdlFamille((*ielPQ).Enum()); // récup du premier ddl
           for (int jsm =1; jsm <= nbsmax; jsm++)
               map_gauss_basePQ[tab_point_enum(jsm)(pr_ddl)->nom_groupe_pt_integ].push_back((*ielPQ)); 
          };
             
// débug
//{
//cout << "\n " << tp_tp_gauss_base << endl;  //// débug 
//int nbsmax =  tab_sous_mesh.Taille(); // récup du nombre de sous maillage 
//for (int ism=1;ism<=nbsmax;ism++)
//   { // récup du premier élément qui sert d'élément courant
//     const Element & ele = (*(*(tab_sous_mesh(ism).begin())));
//     ElemGeomC0& elegeom = (ele.ElementGeometrie(SIG11));
//     cout << "\n" <<elegeom.TypeGeometrie() << elegeom.TypeInterpolation() << elegeom.Nbi() << endl;
//   };
//}
// fin débug
           
      }; //-- fin de la boucle sur les maillages
    // ----- maintenant pour les types évoluées et quelconques on construit les map de tableaux de listes ---
    map_gauss_tab_baseEVol.clear();
    map_gauss_tab_basePQ.clear();
    // on boucle sur les maillages puis les sous_maillages puis sur les groupes de pt de gauss
    for (int im=1;im<=nbmail;im++)
     {Tableau < Tableau < P_gauss > > & tp_tp_gauss_base = tp_tp_tp_gauss_base(im);
      int nbsmax =  tp_tp_gauss_base.Taille(); // récup en fait du nombre de sous maillage
      for (int ism = 1; ism<= nbsmax; ism++)
       {Tableau < P_gauss >& tp_gauss_base = tp_tp_gauss_base(ism);
        int tp_taille=tp_gauss_base.Taille();
        for (int ing=1;ing<=tp_taille;ing++)
          {P_gauss& gauss_enCours = (tp_gauss_base(ing)); // pour simplifier
           string& nom = gauss_enCours.nom_groupe_pt_integ; // pour simplifier
           int nb_ptinteg = gauss_enCours.elemgeom->Nbi();
           // si la liste existe on crée un tableau de liste identique: ceci pour les évoluées 
           if (map_gauss_baseEVol.find(nom)!=map_gauss_baseEVol.end())
               map_gauss_tab_baseEVol[nom] // en l'adressant on le crée s'il n'existe pas
        	          .Change_taille(nb_ptinteg,map_gauss_baseEVol[nom]); // def du tableau de listes
           // idem pour les listes de grandeurs quelconques
           if (map_gauss_basePQ.find(nom)!=map_gauss_basePQ.end())
               map_gauss_tab_basePQ[nom] // en l'adressant on le crée s'il n'existe pas
        	          .Change_taille(nb_ptinteg,map_gauss_basePQ[nom]); // def du tableau de listes
 //          cout << "\n debug de isoGmsh " <<  (*((*map_gauss_basePQ[nom].begin()).Grandeur_pointee())) << endl; // débug
 //          cout << "\n debug de isoGmsh " <<  (*((*map_gauss_tab_basePQ[nom](1).begin()).Grandeur_pointee())) << endl; // débug	          
       	          
          }
       };
     };
    
};

// calcul des grandeurs aux points d'intégration
void Isovaleurs_Gmsh::CalculAuxPtInteg(const Tableau <int>& tab_mail,LesMaillages * lesMail)
{ // dans le cas où l'on transfert aux noeuds, on initialise les compteurs    
  lesMail->InitUpdateAuNoeud(glob_elem_ddl_retenu,tab_quelconque,cas_transfert);
  int nbmail = tab_mail.Taille();
  for (int im=1;im<=nbmail;im++)  // on boucle sur les maillages
     {int numMail=tab_mail(im);
      Tableau < Tableau < P_gauss > >& tp_tp_gauss_base = tp_tp_tp_gauss_base(im);
       { // on cré un bloc pour éviter d'utiliser des variables en dehors
         // récup du tableau de sous maillages 
         const  Tableau < List_io <  Element* > >  & tab_sous_mesh 
                                = (mailInitial->Tableau_de_sous_maillage())(numMail);
         int nbsmax =  tab_sous_mesh.Taille(); // récup du nombre de sous maillage 
         // 1- on boucle sur les différents sous maillages
         for (int ism=1;ism<=nbsmax;ism++)
          { // on boucle sur les groupes de pt de gauss relatifs à ce sous-maillage
            Tableau < P_gauss >& tp_gauss_base = tp_tp_gauss_base(ism);
            int tp_taille=tp_gauss_base.Taille();
            Tableau <Tableau <double> >   tab_val; // tableau de travail
            for (int ing=1;ing<=tp_taille;ing++)
             {P_gauss& gauss_enCours = (tp_gauss_base(ing)); // pour simplifier
              // on recherche les liste de ddl étendue et/ou de type quelconque à sortir
              // a) cas des ddl étendue
              List_io < Ddl_enum_etendu >* lidsor = NULL;
              if (map_gauss_base.find(gauss_enCours.nom_groupe_pt_integ)!=map_gauss_base.end())
                lidsor=&(map_gauss_base[gauss_enCours.nom_groupe_pt_integ]);
              
              // b) cas des types évoluées tensorielles 
              List_io < TypeQuelconque > * lidsorEV = NULL;
              Tableau < List_io < TypeQuelconque > >* tablidsorEV = NULL;
              if (map_gauss_tab_baseEVol.find(gauss_enCours.nom_groupe_pt_integ)!=map_gauss_tab_baseEVol.end())
                {tablidsorEV=&(map_gauss_tab_baseEVol[gauss_enCours.nom_groupe_pt_integ]);
                 // pour la liste on pointe via la map de liste simple, la liste servira d'une part 
                 // pour les identificateurs (enum), et d'autre part de liste de travail pour le passage au noeud 
                 lidsorEV = &(map_gauss_baseEVol[gauss_enCours.nom_groupe_pt_integ]);
                };
              // c) cas des types quelconques pour les grandeurs particulières
              List_io < TypeQuelconque >* lidsorPQ = NULL;
              Tableau < List_io < TypeQuelconque > >* tablidsorPQ = NULL;
              if (map_gauss_basePQ.find(gauss_enCours.nom_groupe_pt_integ)!=map_gauss_basePQ.end())
                {tablidsorPQ=&(map_gauss_tab_basePQ[gauss_enCours.nom_groupe_pt_integ]);
                 // pour la liste on pointe via la map de liste simple, la liste servira d'une part 
                 // pour les identificateurs (enum), et d'autre part de liste de travail pour le passage au noeud 
                 lidsorPQ = &(map_gauss_basePQ[gauss_enCours.nom_groupe_pt_integ]);
                };
              // --- on balaie tous les éléments du sous_maillage pour calculer les valeurs aux pts d'integ
              List_io < Element* >& sous_mesh = tab_sous_mesh(ism);
              List_io < Element* >::const_iterator ils,ilsfin=sous_mesh.end();
              for (ils=sous_mesh.begin();ils!=ilsfin;ils++)
                 { // recup de l'element
                   Element & ele = *(*ils);
                   // contrairement au cas de Gid, ici il n'y a pas de sortie aux points d'integ, car gmsh ne gère
                   // pas les points d'intégration donc on utilise directement la numérotation d'herezh
                   int nb_pt_gauss = gauss_enCours.elemgeom->Nbi(); // récup du nombre de pt d'integ
                   // dimensionnement des tableaux de sortie
                   tab_val.Change_taille(nb_pt_gauss); 
                   // on balaie le nombre de pt d'integ
                   for (int iptinteg=1;iptinteg<=nb_pt_gauss;iptinteg++)
                    { bool sortie_retour_a_la_ligne=false;
                      Tableau <double > & tab = tab_val(iptinteg); // pour simplifier
                      // on récupère les infos correspondant aux  ddl
                      // si les grandeurs n'existent pas, elles sont initialisées dans la méthode
                      if (lidsor != NULL) 
                          tab = ele.Valeur_a_diff_temps(absolue,TEMPS_tdt,*lidsor,iptinteg);
                      // idem pour les grandeurs évoluées tensorielle
                      // ici lidsorEV ne sert que de drapeau, le véritable conteneur c'est tablidsorEV
                      // qui va contenir à la fin, les data pour "tous" les pt d'integ
                      // ** pour les grandeurs tensorielles exprimées avec gmsh, elles doivent-être obligatoirement
                      // ** exprimées dans le repère global, donc en absolue, car sinon cela n'a pas de sens car on ne
                      // ** connait pas le repère local, donc on force la sortie en absolue
                      bool absolue_tensorielle_gmsh = true;
                      if (lidsorEV != NULL) 
                        { List_io < TypeQuelconque > & listsorEVduPtInteg = (*tablidsorEV)(iptinteg);
                          ele.ValTensorielle_a_diff_temps(absolue_tensorielle_gmsh,TEMPS_tdt,listsorEVduPtInteg,iptinteg);
//---- pour le debug
//cout << " \n Isovaleurs_Gmsh::EcritureAuxPtInteg listsorEVduPtInteg" << listsorEVduPtInteg << endl;
//--- fin pour le debug 
                        };
                      // idem pour les grandeurs quelconque
                      // ici lidsorPQ ne sert que de drapeau, le véritable conteneur c'est tablidsorPQ
                      // qui va contenir à la fin, les data pour "tous" les pt d'integ
                      if (lidsorPQ != NULL) 
                        { List_io < TypeQuelconque >& listsorPQduPtInteg = (*tablidsorPQ)(iptinteg);
                          ele.Grandeur_particuliere(absolue,listsorPQduPtInteg,iptinteg);
                        };
                     }; //-- fin de boucle sur les pt de gauss
                   //  transert aux noeuds   
                    {int cas_transfert=1; // pour l'instant le seul mis en place
                     // cas des ddl
                     if (lidsor != NULL) 
                          lesMail->TransfertPtIntegAuNoeud(numMail,ele,*lidsor,tab_val,cas_transfert);
                     // cas des grandeurs évoluées tensorielles
                     if (lidsorEV != NULL) 
                          // ici la liste pointée par lidsorEV sert de liste de travail pour TransfertPtIntegAuNoeud
                          lesMail->TransfertPtIntegAuNoeud(numMail,ele,(*tablidsorEV),*lidsorEV,cas_transfert);
                   // cas des grandeurs quelconques
//---- pour le debug
//cout << " \n Isovaleurs_Gmsh::EcritureAuxPtInteg " << (*tablidsorPQ) << endl;
//--- fin pour le debug 
                     if (lidsorPQ != NULL) 
                          // ici la liste pointée par lidsorPQ sert de liste de travail pour TransfertPtIntegAuNoeud
                           lesMail->TransfertPtIntegAuNoeud(numMail,ele,(*tablidsorPQ),*lidsorPQ,cas_transfert);
                    };
                   }; //fin boucle sur element  
             }; //-- fin boucle sur les groupes de pt de gauss
           };//-- fin de la boucle sur les sous maillages
       }; // fin du bloc relatif aux sorties aux pt d'intégration
     }; //-- fin de la boucle sur les maillages
  // transfert aux noeuds: on effectue la dernière étape
  lesMail->FinTransfertPtIntegAuNoeud(glob_elem_ddl_retenu,tab_quelconque,cas_transfert);        
		
};
  
// écriture des grandeurs aux noeuds à l'ancien format
void Isovaleurs_Gmsh::EcritureAuxNoeuds_ancien_format(const Tableau <int>& tab_mail,LesMaillages * lesMail
                                        ,int incre,UtilLecture & entreePrinc)
{ // pour simplifier
  int nbmail = tab_mail.Taille();
  // ici l'objectif est de tout mettre dans un seul groupe de résultat de manière à pouvoir tout
  // visualiser en même temps 
  // on ne traite que s'il y a des ddl 
  bool atraiter = false;
  if (    (glob_noe_ddl_retenu.size() != 0)
        || (glob_noeud_ddl_etendu_retenu.size() != 0)
        || (glob_noeud_evol_retenu.size() != 0)
        || (glob_elem_ddl_retenu.size() != 0)
        || (glob_elem_evol_retenu.size() != 0)
        || (glob_elem_Parti_retenu.size() != 0)
       )
  
          atraiter = true;
  if (atraiter)
   { 
     // on balaie la liste des noms des différentes grandeurs à sortir en résultat
     // car on doit sortir les coordonnées pour chaque grandeur !! pas très performant
     list <string>::const_iterator ili,ilifin = nomsGrandeursSortie.end();
     for (ili=nomsGrandeursSortie.begin();ili != ilifin; ili++)
     	{ ostream &sort = entreePrinc.Sort_resultat_Gmsh((*ili));
          // ------- entete commenter du numéro d'incrément (ne sert pas pour gmsh) --------------------
          sort << "\n//------------------- increment "<<incre<<" ----------------------------\n";
          // ----- on commence par sortir les noeuds avec un identificateur, pour optimiser la taille fichier
          SortieDefCoordonnees_old_format(sort,incre,nbmail,tab_mail,lesMail);
     	};
      
     // ramène le tableau t_Egmsh
     // t_Egmsh(im)(ie): donne pour le maillage im, et pour l'élément ie, le numéro gmsh de l'élément
     const Tableau < Tableau < int > >& t_Egmsh = mailInitial->TabEgmsh(); 
     // récup de la connection herezh->gmsh
     // t_GmshHer(i)(j) : donne pour le noeud j de l'élément i de gmsh, le numéro d'herezh  
     const Tableau < Tableau < int > >& tGmshHer = Visualisation_Gmsh::Tab_GmshHer(); 

     // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
     // a) cas des ddl initiaux définis aux noeuds
     if (glob_noe_ddl_retenu.size() != 0)
     {// on utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
      // maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
      List_io < Ddl_enum_etendu >::iterator il,ilfin=glob_noe_ddl_retenu.end();
      Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
      Tableau <List_io < bool >::iterator > t_choix_var_ddl(nbmail);
      for (int im =1; im <= nbmail; im++)
         {t_indic_sortie(im)=t_g_noeud_ddl_asortir(im).begin();
			       t_choix_var_ddl(im)=choix_var_ddl(im).begin();
			      };
      int numero = 0; // car ce n'est pas un tableau, cf. utilisation d'EnteteView
      for (il=glob_noe_ddl_retenu.begin();il != ilfin;il++)
      { Enum_ddl ddl = (*il).Enum(); // récup du ddl de base
		      Ddl_enum_etendu ddl_etendu = (*il); // le ddl étendue associé
		      bool ddl_basique = (*il).Nom_vide();
		      string nom_sortie;
		      if (ddl_basique)
           nom_sortie = Nom_ddl(ddl);
		      else 	  
           nom_sortie = ddl_etendu.Nom();
		  
		      ostream& sort = entreePrinc.Sort_resultat_Gmsh(nom_sortie+"_ddl_noe");
        // def de l'entete
        EnteteView(sort,incre,nom_sortie,numero);
        // -- sortie des grandeurs
        // on balaie les maillages
        
        for (int im =1; im <= nbmail; im++)
         {// on ne continue que si le ddl est à sortir
          if (*(t_indic_sortie(im)))
          	{int numMail = tab_mail(im);
             List_io <bool>&  choix_var_ddl_unMail = choix_var_ddl(numMail);
             int nbmaxelem = lesMail->Nombre_element(numMail);
             int dcaN = mailInitial->DecalNumNoeud(numMail);
             for (int numElem = 1; numElem <= nbmaxelem; numElem++)
          	   {Element& elem  = lesMail->Element_LesMaille(numMail,numElem); // récup de l'élément
                Tableau<Noeud *>& t_n = elem.Tab_noeud();
                int num_elem_gmsh = t_Egmsh(im)(numElem);  // numéro de classement du type d'élément gmsh
                // maintenant on sort en fonction de  d'élément
                //-- 1) le type
   // ***** a complèter pour les éléments quadratiques incomplet et les autres non possibles *****            
                sort << "\n" << tabScalVecTensGmsh.scalar_pourView(num_elem_gmsh)<< "(";
                //-- 2) les coordonnées des noeuds
                // on considère le nombre de noeuds de la sortie gmsh, et non celui de l'élément (qui peut-être
                // plus grand dans le cas d'un sfe, ou plus petit dans le cas d'un quadratique incomplet !)
                int nbNmax = tGmshHer(num_elem_gmsh).Taille(); //t_n.Taille();
                for (int ino=1;ino<=nbNmax;ino++) // ino = numéro gmsh
                 { int num_her = tGmshHer(num_elem_gmsh)(ino); // --> num HZpp
                   int num_N = t_n(num_her)->Num_noeud()+dcaN; // num global
                   SortieUseUneCoordonnee(incre,sort,(ino == nbNmax),num_N);
                 };
                //-- 3)  les grandeurs
					           bool varddl = *(t_choix_var_ddl(im)); // variation ou pas
                for (int ino=1;ino<nbNmax;ino++) // sortie des grandeurs sauf la dernière
                 { int num_her = tGmshHer(num_elem_gmsh)(ino); // --> num HZpp
					              // il y a un choix suivant que c'est un ddl de base ou un ddl étendu
						             if (ddl_basique)
							             { if (t_n(num_her)->Existe_ici(ddl)) 
								               { if (varddl) // cas de la variation
							                   {sort << (t_n(num_her)->Valeur_tdt(ddl)-t_n(num_her)->Valeur_0(ddl)) 
								                        <<",";}
							                  else { sort << t_n(num_her)->Valeur_tdt(ddl) <<",";}
								               }
							               else  // si la valeur n'existe pas on sort 0  
								               {sort << 0 <<",";};
							             }	
						             else // sinon c'est un ddl étendue	
							             { if (t_n(num_her)->Existe_ici_ddlEtendu(ddl_etendu)) 
								               { sort << (t_n(num_her)->DdlEtendue(ddl_etendu).ConstValeur()) <<",";}
							               else  // si la valeur n'existe pas on sort 0  
								               {sort << 0 <<",";};
							             };	
                 };
                // puis la dernière valeur  
                int num_her_max = tGmshHer(num_elem_gmsh)(nbNmax); // --> num HZpp
					           if (ddl_basique)
					            { if (t_n(num_her_max)->Existe_ici(ddl)) 
                    {if (varddl) // cas de la variation
							               {sort << (t_n(num_her_max)->Valeur_tdt(ddl)-t_n(num_her_max)->Valeur_0(ddl)) 
									                   <<"};";}
						               else { sort << t_n(num_her_max)->Valeur_tdt(ddl) <<"};";};
							             }
						             else  // si la valeur n'existe pas on sort 0  
                    {sort << 0 <<"};";};
					            }
					           else // sinon c'est un ddl étendue	
					            { if (t_n(num_her_max)->Existe_ici_ddlEtendu(ddl_etendu)) 
							             { sort << (t_n(num_her_max)->DdlEtendue(ddl_etendu).ConstValeur()) <<"};";}
						             else  // si la valeur n'existe pas on sort 0  
                     {sort << 0 <<"};";};
					            };	
          	   };
          	};
         };
        // fin de la view
        sort << "\n }; "; 
        // mise à jour des pointeurs de choix
        for (int im =1; im <= nbmail; im++)
           {t_indic_sortie(im)++;t_choix_var_ddl(im)++;}
      }; //-- fin de la boucle sur les enum aux noeud
     }; //--// fin du test s'il y a des enum à sortir ou nom
     
     // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
     // b) cas des ddl venant d'un transfert aux noeuds des grandeurs aux pt d'integ
     //    on ne sort que les incréments différents de 0, car pour l'incrément 0 pas de grandeurs licites aux pt integ
     if ((glob_elem_ddl_retenu.size() != 0) && (incre != 0))    
     {// on utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
      // maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
      List_io < Ddl_enum_etendu >::iterator il,ilfin=glob_elem_ddl_retenu.end();
      Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
      for (int im =1; im <= nbmail; im++)
         t_indic_sortie(im)=t_g_elem_ddl_asortir(im).begin();
      
      int numero = 0; // car ce n'est pas un tableau, cf. utilisation d'EnteteView
      for (il=glob_elem_ddl_retenu.begin();il != ilfin;il++)
       {Ddl_enum_etendu& ddlEtendu = (*il); // pour simplifier
        ostream *sorti; 
        // def de l'entete
        if (ddlEtendu.Nom_vide())
           { sorti = &(entreePrinc.Sort_resultat_Gmsh(Nom_ddl(ddlEtendu.Enum())+"_pti"));
             EnteteView(*sorti,incre,Nom_ddl(ddlEtendu.Enum()),numero);}
        else   
           { sorti = &(entreePrinc.Sort_resultat_Gmsh(ddlEtendu.Nom()+"_pti"));
             EnteteView(*sorti,incre,ddlEtendu.Nom(),numero);};
        ostream& sort = *sorti;      
        // -- sortie des grandeurs
        // on balaie les maillages
        
        for (int im =1; im <= nbmail; im++)
         {// on ne continue que si le ddl est à sortir
          if (*(t_indic_sortie(im)))
          	{int numMail = tab_mail(im);
             int nbmaxelem = lesMail->Nombre_element(numMail);
             int dcaN = mailInitial->DecalNumNoeud(numMail);
             for (int numElem = 1; numElem <= nbmaxelem; numElem++)
          	   { Element& elem  = lesMail->Element_LesMaille(numMail,numElem); // récup de l'élément
                Tableau<Noeud *>& t_n = elem.Tab_noeud();
                int num_elem_gmsh = t_Egmsh(im)(numElem);  // numéro de classement du type d'élément gmsh
                // maintenant on sort en fonction de  d'élément
   // ***** a complèter pour les éléments quadratiques incomplet et les autres non possibles *****            
                sort << "\n" << tabScalVecTensGmsh.scalar_pourView(num_elem_gmsh)<< "(";
                // on considère le nombre de noeuds de la sortie gmsh, et non celui de l'élément (qui peut-être
                // plus grand dans le cas d'un sfe, ou plus petit dans le cas d'un quadratique incomplet !)
                int nbNmax = tGmshHer(num_elem_gmsh).Taille(); //t_n.Taille();
                for (int ino=1;ino<=nbNmax;ino++) // ino = numéro gmsh
                { int num_her = tGmshHer(num_elem_gmsh)(ino); // --> num HZpp
                  int num_N = t_n(num_her)->Num_noeud()+dcaN; // num global
                  SortieUseUneCoordonnee(incre,sort,(ino == nbNmax),num_N);
                };
                // maintenant les grandeurs
                for (int ino=1;ino<nbNmax;ino++) // sortie des grandeurs sauf la dernière
                  {int num_her = tGmshHer(num_elem_gmsh)(ino); // --> num HZpp
                   sort << t_n(num_her)->DdlEtendue(ddlEtendu).ConstValeur() <<",";
                  };
                // puis la dernière valeur  
                int num_her_max = tGmshHer(num_elem_gmsh)(nbNmax); // --> num HZpp
                sort << t_n(num_her_max)->DdlEtendue(ddlEtendu).ConstValeur() <<"};";
          	   };
          	};
         };
        // fin de la view
        sort << "\n }; "; 
        // mise à jour des pointeurs de choix
        for (int im =1; im <= nbmail; im++)
           t_indic_sortie(im)++;
       }; //--// fin de la boucle sur les enum
     }; //--// fin du test d'existance d'énum à sortir venant d'un transfert aux noeuds des grandeurs aux pt d'integ

     // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
     // c) cas des types évoluées venant d'un transfert aux noeuds des grandeurs aux pt d'integ
     //    on ne sort que les incréments différents de 0, car pour l'incrément 0 pas de grandeurs licites aux pt integ
     if ((glob_elem_evol_retenu.size() != 0) && (incre != 0))
     {// on utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
      // maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
      List_io < TypeQuelconque >::iterator il,ilfin=glob_elem_evol_retenu.end();
      Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
      for (int im =1; im <= nbmail; im++)
         t_indic_sortie(im)=t_g_elem_evoluee_asortir(im).begin();
     
      for (il=glob_elem_evol_retenu.begin();il != ilfin;il++)
       {TypeQuelconque& typ = (*il); // pour simplifier
        ostream &sort = entreePrinc.Sort_resultat_Gmsh((typ.EnuTypeQuelconque().NomPlein())+"_evolue_pti");
        // -- choix entre grandeur simple ou complexe
        EnumTypeGrandeur enugrandeur = typ.EnuTypeGrandeur();
        EnumType2Niveau  enuStructure = typ.Const_Grandeur_pointee()->Type_structure_grandeurAssocie();
        switch (enuStructure)
         { case TYPE_SIMPLE: 
          	{ // appel directe de la routine adoc
          	  int numero = 0;
              SortirUneViewTypeQuelconque_old_format(sort,typ.EnuTypeQuelconque(),enuStructure,numero
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
          	  break;                       
          	}
           case TABLEAU_T:
          	{ // dans le cas d'un tableau on boucle sur les éléments du tableau
          	  switch (enugrandeur)
              { case TENSEURHH:
                 {Tab_Grandeur_TenseurHH& tab_tensHH =  *((Tab_Grandeur_TenseurHH*) typ.Const_Grandeur_pointee());
                  int taille = tab_tensHH.Taille();
                  // on boucle, et on sort  chaque tenseur
                  for (int i=1;i<=taille;i++)
                      SortirUneViewTypeQuelconque_old_format(sort,typ.EnuTypeQuelconque(),enuStructure,i
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
                  break; 
                 }
                case SCALAIRE: case SCALAIRE_ENTIER: case SCALAIRE_DOUBLE: 
                 {Tab_Grandeur_scalaire_double& tab_Gdouble =  *((Tab_Grandeur_scalaire_double*) typ.Const_Grandeur_pointee());
                  int taille = tab_Gdouble.Taille();
                  // on boucle, et on sort  chaque scalaire
                  for (int i=1;i<=taille;i++)
                      SortirUneViewTypeQuelconque_old_format(sort,typ.EnuTypeQuelconque(),enuStructure,i
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
                  break; 
                  }
                default:
                   cout << "\n attention : cas de sortie de grandeur tableau non implantee (mais il suffit de le demander !!) "; 
                   typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
                   cout << "\n EcritureAuxNoeuds_ancien_format::EcritureAuxNoeuds(... ";    
              };//-- fin du  switch (enugrandeur)
              break;
          	}
           default:            
             cout << "\n attention : cas de sortie de grandeur de type secondaire " << NomType2Niveau(enuStructure) 
                  << " non implantee (mais il suffit de le demander !!) "; 
             typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
             cout << "\n EcritureAuxNoeuds_ancien_format::EcritureAuxNoeuds(... ";    
         }; 

        // mise à jour des pointeurs de choix
        for (int im =1; im <= nbmail; im++)
           t_indic_sortie(im)++;
          	
       }; //--// fin de la boucle sur les enum
     }; //--// fin du test d'existance de type évolué venant d'un transfert aux noeuds des grandeurs aux pt d'integ

     // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
     // d) cas des types particuliers aux elements venant d'un transfert aux noeuds
     //    on ne sort que les incréments différents de 0, car pour l'incrément 0 pas de grandeurs licites aux pt integ
     if ((glob_elem_Parti_retenu.size() != 0) && (incre != 0))
     {// on utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
      // maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
      List_io < TypeQuelconque >::iterator il,ilfin=glob_elem_Parti_retenu.end();
      Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
      for (int im =1; im <= nbmail; im++)
         t_indic_sortie(im)=t_g_elem_typeParti_asortir(im).begin();
     
      for (il=glob_elem_Parti_retenu.begin();il != ilfin;il++)
       {TypeQuelconque& typ = (*il); // pour simplifier
        ostream &sort = entreePrinc.Sort_resultat_Gmsh((typ.EnuTypeQuelconque().NomPlein())+"_particulier_pti");
        // -- choix entre grandeur simple ou complexe
        EnumTypeGrandeur enugrandeur = typ.EnuTypeGrandeur();
        EnumType2Niveau  enuStructure = typ.Const_Grandeur_pointee()->Type_structure_grandeurAssocie();
        switch (enuStructure)
         { case TYPE_SIMPLE: 
          	{ // appel directe de la routine adoc
          	  int numero = 0;
              SortirUneViewTypeQuelconque_old_format(sort,typ.EnuTypeQuelconque(),enuStructure,numero
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
          	  break;                       
          	}
           case TABLEAU_T:
          	{ // dans le cas d'un tableau on boucle sur les éléments du tableau
          	  switch (enugrandeur)
              { case TENSEURHH:
                 {Tab_Grandeur_TenseurHH& tab_tensHH =  *((Tab_Grandeur_TenseurHH*) typ.Const_Grandeur_pointee());
                  int taille = tab_tensHH.Taille();
                  // on boucle, et on sort  chaque tenseur
                  for (int i=1;i<=taille;i++)
                     SortirUneViewTypeQuelconque_old_format(sort,typ.EnuTypeQuelconque(),enuStructure,i
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
                  break; 
                 }
                case SCALAIRE: case SCALAIRE_ENTIER: case SCALAIRE_DOUBLE: 
                 {Tab_Grandeur_scalaire_double& tab_Gdouble =  *((Tab_Grandeur_scalaire_double*) typ.Const_Grandeur_pointee());
                  int taille = tab_Gdouble.Taille();
                  // on boucle, et on sort  chaque scalaire
                  for (int i=1;i<=taille;i++)
                     SortirUneViewTypeQuelconque_old_format(sort,typ.EnuTypeQuelconque(),enuStructure,i
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
                  break; 
                  }
                default:
                   cout << "\n attention : cas de sortie de grandeur tableau non implantee (mais il suffit de le demander !!) "; 
                   typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
                   cout << "\n EcritureAuxNoeuds_ancien_format::EcritureAuxNoeuds(... ";    
              };//-- fin du  switch (enugrandeur)
              break;
          	}
           default:            
             cout << "\n attention : cas de sortie de grandeur de type secondaire " << NomType2Niveau(enuStructure) 
                  << " non implantee (mais il suffit de le demander !!) "; 
             typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
             cout << "\n EcritureAuxNoeuds_ancien_format::EcritureAuxNoeuds(... ";    
         }; 
          	
        // mise à jour des pointeurs de choix
        for (int im =1; im <= nbmail; im++)
           t_indic_sortie(im)++;

       }; //--// fin de la boucle sur les enum
     }; //--// fin du test d'existance de type évolué venant d'un transfert aux noeuds des grandeurs aux pt d'integ

   }; //-- fin du cas if (atraiter)

};