// 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_Gid.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"

    // CONSTRUCTEURS :
// par defaut
Isovaleurs_Gid::Isovaleurs_Gid () :
   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)
   ,ddlSurY_1D(true),transfert_au_noeud(false),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)
   ,absolue(true),li_glob_restreinte_TQ()
     { for (int i=1; i<=2; i++) tab_quelconque(i)=NULL;};
       
    // constructeur de copie 
Isovaleurs_Gid::Isovaleurs_Gid (const Isovaleurs_Gid& 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()
   ,ddlSurY_1D(ord.ddlSurY_1D)
   ,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(),tabelement_evoluee_retenu()
   ,tabelement_typeParti(),tabelement_typeParti_retenu()
   ,mailInitial(ord.mailInitial),lesMail(ord.lesMail)
   ,transfert_au_noeud(ord.transfert_au_noeud),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)
   ,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_Gid::~Isovaleurs_Gid () 
     {  };  
    
    // 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_Gid::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
  int nbdigit = ParaGlob::NbdigdoGR();
  // visualisation du maillage pointé si actif
  ostream &sort = entreePrinc.Sort_resultat_Gid();
  int dim = ParaGlob::Dimension();
  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,sort); 
        // %% cas des noeuds %% on initialise les différentes listes internes qui globalisent tous les maillages
        GlobalisationListSurTousLesMaillagesPourLesNoeuds();
        InitPremierIncrExecutionTransfertAuxNoeuds(); // init pour les transferts aux noeuds
        // --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)
            { // 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 la sortie aux pt integ, on peut avoir du transfert aux noeuds
     //     qui ensuite sera traité pour la visualisation par les noeuds
     // -------------------------------------------------------------------------------------------------
     EcritureAuxPtInteg(tab_mail,lesMail,sort,incre);    
     // -------------------------------------------------------
     //  II - traitement des degrés de libertés aux noeuds 
     // -------------------------------------------------------
     EcritureAuxNoeuds(tab_mail,lesMail,sort,incre);
   }; //-- 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_Gid::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, pas de transferts aux noeuds "
          << "\n (3) parametres generaux "
          << "\n (4) choix grandeurs aux noeuds "
          << "\n (5) choix grandeurs scalaires aux pts integ "
          << "\n (6) choix grandeurs tensorielles aux pts integ "
          << "\n (7) choix grandeurs particulieres aux pts integ "
          << "\n (8) transferts aux noeuds de grandeurs existantes aux points d'integration "
          << "\n (9) annuler le transferts aux noeuds de grandeurs existantes aux points d'integration "
          << "\n (10) ddl etendu aux noeuds "
          << "\n (11) 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) transfer from integration points to nodes for defined values  "
          << "\n (9) remove transfer (8) "
          << "\n (10) extended dof at nodes "
          << "\n (11) 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");
             }  
          else if ((num >= 3)&&(num<=11))
           { 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 8:  // "transferts aux noeuds de grandeurs existantes aux points d'integration"
                  {transfert_au_noeud = true;
                   VerificationTransfertPossible(); 
                   break;}
                case 9:  // "transferts aux noeuds de grandeurs existantes aux points d'integration"
                  {transfert_au_noeud = false; 
                   break;}
                case 3:  //"definition des parametres generaux"
                { ParametresGeneraux(" "); break;}
                case 10:  // "choix des isovaleurs ddl étendus aux noeuds"
                 {ChoixIsovaleur_ddl_etendu_noeud(" ");
                  break;}
                case 11:  // "choix des isovaleurs quelconque aux noeuds"
                 {ChoixIsovaleur_evoluee_noeud(" ");
                  break;}
               }
             } 
          else { cout << "\n Erreur on attendait un entier entre 3 et 11 !!, "
                      << "\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);
   // vérification que le transfert peut se faire (pas de doublon de grandeurs)
   VerificationTransfertPossible();
   // 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);
   };
  };
            
// 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_Gid::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_Gid::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
    tabnoeud_type_ddl = lesMail->Les_type_de_ddl_par_noeud(absolue);
    tabelement_type_ddl = lesMail->Les_type_de_ddl_par_element(absolue);
    // idem mais sous forme de grandeurs évoluées
    tabnoeud_type_ddlEtendu = lesMail->Les_type_de_ddl_etendu_par_noeud(absolue);
    tabnoeud_evoluee.Change_taille(0);
    tabnoeud_evoluee = lesMail->Les_type_de_TypeQuelconque_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
    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
    int nb_maillage = tabnoeud_type_ddl.Taille();
    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
          }
       // 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_Gid::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_Gid")!=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 transfert_au_noeud_sav = transfert_au_noeud;
      // essaie de lecture
      try 
        { string nom,nom1; 
          (*entreePrinc.entCVisu)  >> nom ;
          if (nom != "debut_isovaleur_Gid")
            { 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_Gid "
                   << " on ne tiens pas compte  des parametres fournis !! ";
              }
          else
           { // appel de l'ordre de la classe mère
             OrdreVisu::Lect_para_OrdreVisu_general(entreePrinc);
             // puis lecture des parametres propres
             // transfert aux noeuds
             if (strstr(entreePrinc.tablcarCVisu,"transfert_aux_noeuds")!=NULL)
              { (*entreePrinc.entCVisu) >> nom >> transfert_au_noeud;
                entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
               };
             int nb_maillage = lesMail->NbMaillage(); int imail; 
             while (strstr(entreePrinc.tablcarCVisu,"fin_isovaleur_Gid")==NULL)
              { (*entreePrinc.entCVisu) >> imail; // lecture du numero de maillage
                if (imail > nb_maillage) // 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 trop grand !! nombre lu " << imail 
                         << " alors que nb_maillage enregistre: " << nb_maillage ;
                    cout << "\n Isovaleurs_Gid::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);
                     List_io <bool>& choix_v_dd = choix_var_ddl(imail);
                     List_io <bool>::iterator ichoixdd;
                     lis_sor.clear();choix_v_dd.clear();
                     string nom2;
                     // lecture de la liste demandée
                     int compteur=0; // pour éviter une boucle infinie
                     while (compteur < 1000000)
                       { (*entreePrinc.entCVisu) >> nom >> nom2; compteur++;
                         if (nom != "fin_tableau_ddl_aux_noeuds")
                           { lis_sor.push_back(Ddl_enum_etendu(nom));
                             choix_v_dd.push_back(ChangeEntier(nom2));
                            }
                         else break;
                        }
                     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
                    };

                // ---- 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.erase(lis_sor.begin(),lis_sor.end());
                     // 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")
                           { lis_sor.push_back(Ddl_enum_etendu(nom));}
                         else break;
                        }
                     entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                    }
                // ---- 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.erase(tpg_ret.begin(),tpg_ret.end());
                       // 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
                               // 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.erase(tpg_ret.begin(),tpg_ret.end());
                       // 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")
                             { 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
                               // 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
                      }
                 }// -- fin du while sur les maillages 
             entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
            } // -- fin du if then else sur "debut_isovaleur_Gid"       
         } // -- 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;
          transfert_au_noeud = transfert_au_noeud_sav;
          if (ParaGlob::NiveauImpression() >= 4)     
             cout  << "\n Isovaleurs_Gid::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);
  // vérification que le transfert peut se faire (pas de doublon de grandeurs)
  VerificationTransfertPossible();

  // 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);
  };

      
      
  };

// écriture des paramètres de l'ordre dans un flux
void Isovaleurs_Gid::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_Gid         # mot cle de debut des parametres pour les isovaleurs"; 
   // appel de l'ordre de la classe mère
   OrdreVisu::Ecrit_para_OrdreVisu_general(entreePrinc);
   // puis les paramètres
   // transfert aux noeuds
   sort << "\n transfert_aux_noeuds " << transfert_au_noeud 
        << " # =1 indique que toutes les valeurs definis aux pt d'integ sont transferees"   
        << " \n #  egalement aux noeuds, =0 pas de transfert aux noeuds";   
   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 ddl aux noeuds a visualiser
      sort << "\n #   tableau de (ddl + 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 ";
      int nb_mail = tabnoeud_type_ddl_retenu.Taille();
      sort << "\n debut_tableau_ddl_aux_noeuds " ;
      List_io < Ddl_enum_etendu >::iterator ild,ildfin = tabnoeud_type_ddl_retenu(imail).end();
      List_io <bool>::iterator ilbo=choix_var_ddl(imail).begin();
      for (ild=tabnoeud_type_ddl_retenu(imail).begin();ild!=ildfin;ild++,ilbo++)
         { sort << (*ild) << " " << (*ilbo) << " ";};
      sort << " fin_tableau_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
      sort << "\n #   tableau de ddl aux elements a visualiser, un par maillage";
      sort << "\n debut_tableau_ddl_aux_elements " ;
      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_Gid         # mot cle de fin des parametres pour les isovaleurs \n"; 
  };

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

// choix de l'isovaleur à visualiser calculée à partir des noeuds
void Isovaleurs_Gid::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 à true 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.erase(choix_v_ddl.begin(),choix_v_ddl.end()); // 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 visualiser "
               << "\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);
          if (rep == "to")
           // cas de toutes les grandeurs sans les réactions
           {List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddl(imail).end();
            // on nettoie les listes avant chargement
            (tabnoeud_type_ddl_retenu(imail)).clear();
            choix_var_ddl(imail).clear();
            // puis on enregistre
            for (ite = tabnoeud_type_ddl(imail).begin();ite != itefin; ite++)
              if ( !Ddl_reaction((*ite).Enum()))
               {tabnoeud_type_ddl_retenu(imail).push_back(*ite);
                // -- choix var ou pas: on encapsule car on utilise des mêmes noms de variables
                { bool choix_var_valide=false;
                  while (!choix_var_valide)
                    {try
                      { cout << "\n valeur du ddl " << (*ite).Nom_plein()
                             << " ou variation entre t=0 et t (rep 1 ou 0 ) ? \n"
                             << "\n reponse ?  ";
                        string rap = lect_chaine();
                        if (rap == "1") {choix_var_ddl(imail).push_back(true);choix_var_valide=true;}
                        else if (rap == "0") {choix_var_ddl(imail).push_back(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 de la variation ou non des ddl !!, "
                              << "\n redonnez une bonne valeur";
                         choix_var_valide=false;
                      }
                    }; //-- fin du while
                };
               };
            tabnoeud_type_ddl_retenu(imail).sort(); // on ordonne
            tabnoeud_type_ddl_retenu(imail).unique();// on supprime les doublons                           
            choix_valide=false;
            }  
          else if (rep == "tr")
           // cas de toutes les grandeurs avec les réactions
           {List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddl(imail).end();
            // on nettoie les listes avant chargement
            (tabnoeud_type_ddl_retenu(imail)).clear();
            choix_var_ddl(imail).clear();
            // puis on enregistre
            for (ite = tabnoeud_type_ddl(imail).begin();ite != itefin; ite++)
             {tabnoeud_type_ddl_retenu(imail).push_back(*ite);
              // -- choix var ou pas: on encapsule car on utilise des mêmes noms de variables
              { bool choix_var_valide=false;
                while (!choix_var_valide)
                  {try
                    { cout << "\n valeur du ddl " << (*ite).Nom_plein()
                           << " ou variation entre t=0 et t (rep 1 ou 0 ) ? \n"
                           << "\n reponse ?  ";
                      string rap = lect_chaine();
                      if (rap == "1") {choix_var_ddl(imail).push_back(true);choix_var_valide=true;}
                      else if (rap == "0") {choix_var_ddl(imail).push_back(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 de la variation ou non des ddl !!, "
                            << "\n redonnez une bonne valeur";
                       choix_var_valide=false;
                    }
                  }; //-- fin du while
              };
             };
            tabnoeud_type_ddl_retenu(imail).sort(); // on ordonne
            tabnoeud_type_ddl_retenu(imail).unique();// on supprime les doublons                           
            choix_valide=false;
            }  
          else if (rep == "ef") 
           {// on efface la liste
            (tabnoeud_type_ddl_retenu(imail)).clear();
             choix_var_ddl(imail).clear();
            choix_valide=false;
           };

          bool deplace_ou_valeur_a_demander = false; // pour la gestion
          // 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
            { Enum_ddl enum_d = Id_nom_ddl(rep.c_str());
              Ddl_enum_etendu ddl_enu_etendue(enum_d);
              // 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))
                 {// 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 ((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)));
                         case 2: tabnoeud_type_ddl_retenu(imail).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)));
                       	};
                  	}
                  else // cas d'une grandeur scalaire simple
                  	{ tabnoeud_type_ddl_retenu(imail).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)
                { bool choix_var_valide=false;
                  while (!choix_var_valide)
                      {try
                       { cout << "\n valeur du ddl 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(true);choix_var_valide=true;}
                         else if (rep == "0") {choix_var_ddl(imail).push_back(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 de la variation ou non des ddl !!, "
                                << "\n redonnez une bonne valeur";
                           choix_var_valide=false;
                         }
                       }; //-- fin du second while
                };
             };

          }
        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 
      tabnoeud_type_ddl_retenu(imail).sort(); // on ordonne
      tabnoeud_type_ddl_retenu(imail).unique();// on supprime les doublons                           
     }//-- fin de la boucle sur les maillages   
  };
  
// choix de l'isovaleur à visualiser calculée à partir des ddl etendu aux noeuds
void Isovaleurs_Gid::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 (...)// 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_Gid::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_Gid::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) aux pt 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).erase(tabelement_type_ddl_retenu(imail).begin(),
                      tabelement_type_ddl_retenu(imail).end());
              }
          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
void Isovaleurs_Gid::ExeOrdrePremierIncrement(const Tableau <int>& tab_mail,LesMaillages * lesMail,ostream &sort)
{   // pour simplifier
    int nbdigit = ParaGlob::NbdigdoGR();
    int dim = ParaGlob::Dimension();
    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.erase(li_P_gauss_total.begin(),li_P_gauss_total.end());
    // idem pour map_gauss_base
    map_gauss_base.erase(map_gauss_base.begin(),map_gauss_base.end());
    map_gauss_basePQ.erase(map_gauss_basePQ.begin(),map_gauss_basePQ.end());
    map_gauss_baseEVol.erase(map_gauss_baseEVol.begin(),map_gauss_baseEVol.end());
    
    // --- 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_Gid::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_Gid::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_Gid::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_Gid::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  
               // écriture de l'entête
               sort << "\n \n    #  definition des positions de points de gauss : maillage: " 
                    << lesMail->NomMaillage(numMail) << "\n";
               // 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_Gid::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
               
               // écriture des infos     
               sort << "\n GaussPoints \""<< nom_pt_integ_sous_maillage <<  "\" ";
//cout << "\n GaussPoints \""<< nom_pt_integ_sous_maillage <<  "\" " << endl;  /// pour debug
               // définition du type d'élément
               sort << "Elemtype " ;
               bool naturel=true; // indique si oui ou non les pt de gauss sont idem gid
               int nb_integ=ele.NbPtInteg(*iddle); // récup du nombre de pt d'integ
               // cas particulier des plaques et coques
   	           Enum_PiPoCo typeele = ele.PoutrePlaqueCoque() ;
   	           if ((typeele == COQUE) || (typeele == PLAQUE))  
   	             nb_integ = ele.NbPtIntegSurface(*iddle); // on récupère les pt d'integ de surface
               
   	           switch ((*ipos).id_geom)
   	            {// def du type d'élément et du sous_maillage Gid associé
   	             case TRIANGLE :{sort << "Triangle \""; 
   	                             if ((nb_integ!=1)&&(nb_integ!=3)&&(nb_integ!=6)) naturel = false;
   	                             break;}
   	             case TRIA_AXI :{sort << "Triangle \""; 
   	                             if ((nb_integ!=1)&&(nb_integ!=3)&&(nb_integ!=6)) naturel = false;
   	                             break;}
   		            case QUADRANGLE : {sort << "Quadrilateral \""; 
   	                                if ((nb_integ!=1)&&(nb_integ!=4)&&(nb_integ!=9)) naturel = false;
   	                                break;}
   	             case QUAD_AXI :{sort << "Quadrilateral \""; 
   	                             if ((nb_integ!=1)&&(nb_integ!=4)&&(nb_integ!=9)) naturel = false;
   	                             break;}
   		            case TETRAEDRE : {sort << "Tetrahedra \""; 
   	                               if (nb_integ!=4) naturel = false;
   	                               break;}
     		          case HEXAEDRE :{sort << "Hexahedra \""; 
   	                             if ((nb_integ!=8)&&(nb_integ!=27)) naturel = false;
   	                             break;}
   		            case POUT :{sort << "Linear \""; break;}
   		            case POINT : {sort << "Point \""; break;}
     		          case PENTAEDRE : // gid ne gère pas les pentaèdres, on sort donc des hexaèdres avec deux lignes confondues
     		            { sort << "Hexahedra \"";
     		              // ici dans tous les cas, la position des points d'intégration n'est pas naturelle 
   	                 naturel = false;
   	                 cout << "\n warning : la sortie GID aux pt d'integ pour les pentaedres n'est pas correcte pour l'instant, mais la valeur"
   	                      << " aux noeuds est correcte\n";
   	                 break;}
   		            default :
   		  	            cout << "\nErreur : cas d'element non traite par Gid !" << Nom_geom((*ipos).id_geom) 
   			                   << " **********  attention, le fichier de sortie isovaleur ne sera pas exploitable !!!\n";
   	            };
    	          sort << lesMail->NomMaillage(numMail) << "_" << ism << "\" ";
    	          if ((*ipos).id_geom == POUT) sort << "\n Nodes not included "; // cas particulier des éléments barres
               sort << "\n   Number Of Gauss Points: " << nb_integ ; //ele.NbPtInteg(*iddle);
               // test si on peut utiliser ou non les pts de gauss de Gid
               if (naturel)
   	            // cas simple
   	            {sort  << "\n   Natural Coordinates: Internal ";}
   	           else
   	            // cas où l'on donne les pt d'integ
   	            {sort  << "\n   Natural Coordinates: Given ";
   	             // écriture des points d'integration
   	             Enum_PiPoCo typeele = ele.PoutrePlaqueCoque() ;
   	             if ( typeele == NON_PoutrePlaqueCoque)
   	              { // cas d'éléments classique
   	                int nb_pt_gauss = ele.NbPtInteg(*iddle); 
   	                for (int ipg=1;ipg<=nb_pt_gauss;ipg++)
   	                  {sort << "\n  ";
   	                   ele.ElementGeometrie(*iddle).CoorPtInteg(ipg).Affiche(sort,ParaGlob::NbdigdoGR());
   	                   };
   	              }
   	             else // cas de poutre plaque ou coque
   	              { switch (typeele)
   	              	 { case COQUE :
   	              	 	{ int nb_pt_gauss = ele.NbPtIntegSurface(*iddle); // on récupère les pt d'integ de surface
   	                      for (int ipg=1;ipg<=nb_pt_gauss;ipg++)
   	                        {sort << "\n  ";
   	                         ele.ElementGeometrieSurface(*iddle)->CoorPtInteg(ipg).Affiche(sort,ParaGlob::NbdigdoGR());
   	                        };
   	                      break;  
   	              	 	}
   	              	   default:
   	              	     cout << " \n cas non pris en compte : element " << Nom_Enum_PiPoCo(typeele);
   	              	     ele.Affiche(1);
   	              	 };
   	              };
   	             };
   	           // fin     
   	           sort  << "\n End gausspoints \n";
              }; //-- 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
/*  	    list < P_gauss >::iterator lip,lipfin=li_P_gauss_total.end();
   	    tab_point_enum.Change_taille(nombre_maxi_de_type_de_ddl); // utile uniquement au premier maillage
   	    for (lip= li_P_gauss_total.begin();lip!=lipfin;lip++)
   	      tab_point_enum((*lip).enu)=&(*lip);  */
   	    // 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 isoGid " <<  (*((*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.erase(map_gauss_tab_baseEVol.begin(),map_gauss_tab_baseEVol.end());
    map_gauss_tab_basePQ.erase(map_gauss_tab_basePQ.begin(),map_gauss_tab_basePQ.end());
    // 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();
//           // on regarde s'il s'agit d'une poutre plaque ou coque, si oui on change le nb de pt d'integ
//	       Enum_PiPoCo enu_pipoco = ele.PoutrePlaqueCoque();
//	       if ((enu_pipoco == PLAQUE)||(enu_pipoco == COQUE))
//	       	{// dans ce cas il faut tenir compte des différentes couches de pt d'integ
//	       	 // comme il s'agit de pt d'integ classique, on prend SIG11 qui est le ddl banal
//	       	 nb_ptinteg = ele.NbPtIntegSurface(SIG11) * ele.NbPtIntegEpaiss(SIG11);
//	       	};
           // 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 isoGid " <<  (*((*map_gauss_basePQ[nom].begin()).Grandeur_pointee())) << endl; // débug
 //          cout << "\n debug de isoGid " <<  (*((*map_gauss_tab_basePQ[nom](1).begin()).Grandeur_pointee())) << endl; // débug	          
       	          
          }
       };
     };
      
};

// écriture des grandeurs aux points d'intégration
void Isovaleurs_Gid::EcritureAuxPtInteg(const Tableau <int>& tab_mail,LesMaillages * lesMail
                           ,ostream &sort,int incre)
{ // dans le cas où l'on transfert aux noeuds, on initialise les compteurs    
  if (transfert_au_noeud)
     lesMail->InitUpdateAuNoeud(glob_elem_ddl_retenu,tab_quelconque,cas_transfert);
  int nbmail = tab_mail.Taille();
  int dim = ParaGlob::Dimension();
  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 
         // récup de la liste de noms de sous maillage
         const  List_io <string>& li_nom_sous_mesh 
                                = (mailInitial->Tab_listes_nom_sousMaillage())(numMail);
         // on récupère le décalage de numéros d'éléments
         int decal_ele=mailInitial->DecalNumElement(numMail); // pour simplifier
         // 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]);
   //              cout << "\n debug de isoGid " <<  (*((*map_gauss_tab_basePQ[gauss_enCours.nom_groupe_pt_integ](1).begin()).Grandeur_pointee())) << endl; // débug	          
   //              cout << "\n debug de isoGid " <<  (*(  (*(lidsorPQ->begin())).Grandeur_pointee())) << endl; // débug	          
   //               cout << "\n debug de isoGid " <<  (*((*map_gauss_basePQ[nom].begin()).Grandeur_pointee())) << endl; // débug	          
                };
              // écriture de l'entête de groupe
              sort << "\n ResultGroup  \"calcul_mecanique\" " << incre << " OnGaussPoints  \"" 
                   << gauss_enCours.nom_groupe_pt_integ << "\" ";
              // maintenant on décrit les différentes entitées définis aux points d'intégrations
              // c-1 ----- tout d'abord les ddl étendues donc des grandeurs scalaires ------
              // on définie les iterators pour balaier tous les types quelconques pour les grandeurs scalaires
              List_io < Ddl_enum_etendu >::iterator li,li_end,li_deb;
              
              if (lidsor!=NULL) 
                {li_end = (*lidsor).end();li_deb = (*lidsor).begin();
                 for (li=li_deb;li!=li_end;li++)
                  { //  on sauvegarde en scalaire
                    sort << "\n ResultDescription \"";
                    if (!((*li).Nom_vide())) {sort << (*li).Nom() <<"_"<< numMail << "\" Scalar ";}
                    else {sort << Nom_ddl((*li).Enum()) <<"_"<< numMail << "\" Scalar "; };
                  };
                };
              // c-2 ----- les types tensorielles c-a-d évoluées  ------
              bool drap_noeud = false; // drapeau pour indiquer que l'on sort des grandeurs aux pt integ
              // on définie les iterators pour balaier tous les types quelconques pour les grandeurs tensorielles
              List_io < TypeQuelconque >::iterator ieve,ieve_end,ieve_deb;
              if (lidsorEV!=NULL) 
                {ieve_end = lidsorEV->end();ieve_deb = lidsorEV->begin();
                 for(ieve=ieve_deb;ieve!=ieve_end;ieve++)
                  { //  on sauvegarde en fonction du type et de la dimension des grandeurs
                    this->EnteteSortieIsovaleurs_G_Quelconque(sort,(*ieve),drap_noeud);
                  };
                };
              // c-3 ----- les types quelconques : idem types évolués  ------
              // on définie les iterators pour balaier tous les types quelconques pour les grandeurs particulières
              List_io < TypeQuelconque >::iterator ique,ique_end,ique_deb;
              if (lidsorPQ!=NULL) 
                {ique_end = lidsorPQ->end();ique_deb = lidsorPQ->begin();
                 for(ique=ique_deb;ique!=ique_end;ique++)
                  { //  on sauvegarde en fonction du type et de la dimension des grandeurs
                    this->EnteteSortieIsovaleurs_G_Quelconque(sort,(*ique),drap_noeud);
                  };
                };
              // maintenant on écrit les grandeurs associés
              sort << "\n \n Values ";           
              // on balaie tous les éléments du sous_maillage
              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);
                   sort << "\n" << ele.Num_elt_const() + decal_ele << " " ; // le numéro d'élément                	          
                   // définition de la numérotation indirecte des numéros de points d'intégration naturels
                   // lorsque la numérotation de Gid est différente de celle d'Herezh++
                   int nb_pt_gauss = gauss_enCours.elemgeom->Nbi(); // récup du nombre de pt d'integ
                   
                   Tableau <int> ind(nb_pt_gauss);	bool indirecte=false;  // ind(i) = le nb de HZ du i de Gid 
                   // dimensionnement des tableaux de sortie
                   tab_val.Change_taille(nb_pt_gauss); 
                         
                   switch (ele.Id_geometrie())
                    { case TRIANGLE : case TRIA_AXI:
                       {if (nb_pt_gauss==3) {indirecte=true; ind(2)= 1; ind(3)=2; ind(1)=3;}
                        else if (nb_pt_gauss==6) {indirecte=true; ind(5)= 1; ind(6)=2; ind(4)=3;
                                                          ind(1)= 4; ind(2)=5; ind(3)=6;};
                        break;
                       }
                      case QUADRANGLE :  case QUAD_AXI:
                       {if (nb_pt_gauss==4) {indirecte=true; ind(1)= 1; ind(2)=2; ind(3)=4; ind(4)=3;}
                        else if (nb_pt_gauss==9) {indirecte=true; ind(1)= 1; ind(5)=2; ind(2)=3; ind(8)=4;
                                                          ind(9)= 5; ind(6)=6; ind(4)=7; ind(7)=8; ind(3)=9;};
                        break;
                       }
                      case TETRAEDRE :
                       {if (nb_pt_gauss==4) {indirecte=true; ind(1)= 1; ind(4)=2; ind(3)=3; ind(2)=4;};
                        break;
                       }
                      case HEXAEDRE :
                        {if (nb_pt_gauss==8) {indirecte=true; ind(7)= 1; ind(3)=2; ind(6)=3; ind(2)=4;
                                                           ind(8)= 5; ind(4)=6; ind(5)=7; ind(1)=8;}
                         else if (nb_pt_gauss==27) {indirecte=true; ind(1)= 1; ind(9)=2; ind(2)=3; ind(12)=4;
                         ind(21)= 5; ind(10)=6; ind(4)=7; ind(11)=8; ind(3)= 9; ind(13)=10; ind(22)=11; ind(14)=12;
                         ind(25)= 13; ind(27)=14; ind(23)=15; ind(16)=16; ind(24)= 17; ind(15)=18; ind(5)=19; ind(17)=20;                                  
                         ind(6)= 21; ind(20)=22; ind(26)=23; ind(18)=24; ind(8)= 25; ind(19)=26; ind(7)=27; }
                         break;
                        }
                      case PENTAEDRE : // on le passe pour éviter un affichage d'erreur,
                       // mais ici la sortie au point d'integ n'est pas bonne, il faut utiliser uniquement les valeurs
                       // transferrées aux noeuds (il y a avant un affichage d'un warning !!)
                          {break;}
                      default :
// a priori il n'y a pas d'erreur si on passe ici, cela veut simplement dire que la numérotation des pti est identique
// entre herezh et gid...
//                        cout << "\nErreur : cas d'element non traite par Gid !" << Nom_geom(ele.Id_geometrie())
//                             << " **********  attention, le fichier de sortie ne sera pas exploitable !!!\n";
                           break;
                    };
   
                   // on balaie le nombre de pt d'integ
                   for (int nb_pt=1;nb_pt<=nb_pt_gauss;nb_pt++)
                    { int iptinteg;bool sortie_retour_a_la_ligne=false;
                      if (indirecte) {iptinteg=ind(nb_pt);} else {iptinteg=nb_pt;};
                      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);
                         int tabtaille = tab.Taille();
                         for (int k=1;k<= tabtaille;k++)
                             sort << setprecision(ParaGlob::NbdigdoGR()) <<  tab(k) << " ";
                         if (nb_pt < nb_pt_gauss) sortie_retour_a_la_ligne=true;
                         };
                      // 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
                      if (lidsorEV != NULL) 
                        {List_io < TypeQuelconque > & listsorEVduPtInteg = (*tablidsorEV)(iptinteg);
                         ele.ValTensorielle_a_diff_temps(absolue,TEMPS_tdt,listsorEVduPtInteg,iptinteg);
                         // sortie
                         ieve_end = listsorEVduPtInteg.end();
                         for (ieve=listsorEVduPtInteg.begin();ieve!=ieve_end;ieve++) 
                           this->SortieGrandeursQuelconque(sort,(*ieve));
                         if (nb_pt < nb_pt_gauss) sortie_retour_a_la_ligne=true;
                        };
                      // 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);
                         // sortie
                         ique_end = listsorPQduPtInteg.end();
                         for (ique=listsorPQduPtInteg.begin();ique!=ique_end;ique++) 
                           this->SortieGrandeursQuelconque(sort,(*ique));
                         if (nb_pt < nb_pt_gauss) sortie_retour_a_la_ligne=true;
                        };
                      // passage à la ligne si nécessaire
                      if (sortie_retour_a_la_ligne)  sort << "\n   ";
                     }; //-- fin de boucle sur les pt de gauss
                   // dans le cas où il y a un transert aux noeuds   
                   if (transfert_au_noeud)
                       {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_Gid::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  
              sort << "\n End Values \n";
             }; //-- 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
  // dans le cas où l'on a fait un transfert aux noeuds on effectue la dernière étape
  if (transfert_au_noeud)
     lesMail->FinTransfertPtIntegAuNoeud(glob_elem_ddl_retenu,tab_quelconque,cas_transfert);
		
};
  
// écriture des grandeurs aux noeuds
void Isovaleurs_Gid::EcritureAuxNoeuds(const Tableau <int>& tab_mail,LesMaillages * lesMail
                                       ,ostream &sort,int incre)
{ // pour simplifier
  int nbmail = tab_mail.Taille();
  int dim = ParaGlob::Dimension();
  // 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 ou un transfert aux noeuds
  bool atraiter = false;
  if (transfert_au_noeud)
      {if (glob_noe_ddl_retenu.size() != 0)  atraiter = true;
       if (glob_noeud_ddl_etendu_retenu.size() != 0) atraiter = true;
       if (glob_noeud_evol_retenu.size() != 0) atraiter = true;
       if (glob_elem_ddl_retenu.size() != 0)  atraiter = true;
       if (glob_elem_evol_retenu.size() != 0)  atraiter = true;
       if (glob_elem_Parti_retenu.size() != 0)  atraiter = true;
      }
  else
      {if (glob_noe_ddl_retenu.size() != 0)  atraiter = true;
       if (glob_noeud_ddl_etendu_retenu.size() != 0) atraiter = true;
       if (glob_noeud_evol_retenu.size() != 0) atraiter = true;
      };
  //---------- traitement de l'entête -----------------
  if (atraiter)   
   {// écriture de l'entête de groupe dans un premier passage
    sort << "\n ResultGroup  \"calcul_mecanique\" " << incre << " OnNodes ";
    // les grandeurs a sortir sont globalisées sur tous les maillage
    // maintenant on décrit les différentes entitées définis aux noeuds
    // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    // a) cas des ddl initiaux définis aux noeuds
    // **(3mars2016) je retire l'incrément 0 qui est bancal, car ne représente pas l'état initial de la structure
    if ((glob_noe_ddl_retenu.size() != 0)&& (incre != 0))
    {//--// on fait un bloc d'isolement
      List_io < Ddl_enum_etendu >::iterator ili,ilideb,ilifin=glob_noe_ddl_retenu.end();
      List_io < Ddl_enum_etendu >::iterator yly;
      ilideb = glob_noe_ddl_retenu.begin();
      int sortie_de_vecteur_en_cours = 0;
      for(ili=ilideb;ili!=ilifin;ili++)
         { // on regarde si le ddl est de type vecteur ou coordonnées car Gid peut en faire un traitement particulier
           EnumTypeGrandeur type_grandeur = (*ili).TypeDeGrandeur();
           // on regarde si l'on est en train de sortir un vecteur (ne marche pas au premier passage)
           if ((sortie_de_vecteur_en_cours < dim) && (sortie_de_vecteur_en_cours >= 1))
            {if (!((*ili).Nom_vide())) {sort << " \"" << (*ili).Nom() << "\" "; }
    //        !!!!! il faut gérer les différentes composantes comme pour les ddl purs
             else 
               {Enum_ddl ddl = (*ili).Enum(); // récup du ddl 
                sort << " \"" << Nom_ddl(Enum_ddl(ddl)) << "\"  "; 
                if ((dim == 2)&&(sortie_de_vecteur_en_cours==1)) // cas où il faut ajouter des ddl vides
                  sort << " \"" << Nom_ddl(Enum_ddl(ddl+1)) << "\"  " ;
               }; 
             sortie_de_vecteur_en_cours++;
             }
           // sinon on regarde s'il s'agit d'un premier passage de vecteur   
           else if ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE) 
              || (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH))
            { // c'est un vecteur ou coordonnées, on vérifie que toutes les grandeurs fonctions de la dimension
              // sont présentes
              sortie_de_vecteur_en_cours = 0; // réinitialisation au cas où l'on suit un précédent vecteur
              // comme les ddl sont ordonnées, cela signifie que l'on est en train de tester le premier si
              // toutes les composantes sont présentes
              Enum_ddl pr_ddl = PremierDdlFamille((*ili).Enum()); // récup du premier ddl
              bool present=true; // a priori tous les ddl sont présents
              // on considère que tous les ddl sont ordonnées
              yly = ili; // récup de la position du premier ddl
              for (int i=1;i<=dim;i++,yly++) 
                {if ((Enum_ddl(pr_ddl+i-1) != (*yly).Enum())||((yly==ilifin)&&(i!=dim))) 
                   {present=false;break;};};
              if (present)
               {// cas d'un type vecteur avec dim coordonnees, on sauvegarde en coordonnées
                sort << "\n ResultDescription \"" << (*ili).NomGenerique()  << "\" Vector "
                     << "\n  ComponentNames ";
                // on sort la première composante     
                if (!((*ili).Nom_vide())) {sort << " \"" << (*ili).Nom() << "\" "; }
                else 
                  { Enum_ddl ddl = (*ili).Enum(); // récup du ddl
                    sort << " \"" << Nom_ddl(ddl) << "\"  ";
                    if (dim == 1) // cas où il faut ajouter des ddl vides
                      sort << " \"" << Nom_ddl(Enum_ddl(ddl+1)) << "\"  \"" 
                                    << Nom_ddl(Enum_ddl(ddl+2)) << "\"  ";
                    };
                if (dim != 1)  {sortie_de_vecteur_en_cours++;}
                else {sortie_de_vecteur_en_cours=0;}
                }
              else
               {// cas d'un vecteur incomplet, on sauvegarde en scalaire
                sort << "\n ResultDescription \"";
                if (!((*ili).Nom_vide())) {sort << (*ili).Nom()  << "\" Scalar ";}
                else {sort << Nom_ddl((*ili).Enum())  << "\" Scalar "; };
                };    
             }
           // cas où on est sûr que ce n'est pas un vecteur, on traite tout comme des scalaires typés   
           else     
            {//  on sauvegarde en scalaire
             sort << "\n ResultDescription \"";
             if (!((*ili).Nom_vide())) {sort << (*ili).Nom()  << "\" Scalar ";}
             else {sort << Nom_ddl((*ili).Enum())  << "\" Scalar "; };
             };    
         }; // fin de la boucle sur les ddl
    }; //--// fin du  bloc d'isolement
    
    // a-1) cas des ddl étendues définis aux noeuds
    // **(3mars2016) je retire l'incrément 0 qui est bancal, car ne représente pas l'état initial de la structure
    if ((glob_noeud_ddl_etendu_retenu.size() != 0) && (incre != 0))
     {//--// on fait un bloc d'isolement
       List_io < Ddl_enum_etendu >::iterator ili,ilideb,ilifin=glob_noeud_ddl_etendu_retenu.end();
       List_io < Ddl_enum_etendu >::iterator yly;
       ilideb = glob_noeud_ddl_etendu_retenu.begin();
       int sortie_de_vecteur_en_cours = 0;
       for(ili=ilideb;ili!=ilifin;ili++)
          { // on regarde si le ddl est de type vecteur ou coordonnées car Gid peut en faire un traitement particulier
            EnumTypeGrandeur type_grandeur = (*ili).TypeDeGrandeur();
            // on regarde si l'on est en train de sortir un vecteur (ne marche pas au premier passage)
            if ((sortie_de_vecteur_en_cours < dim) && (sortie_de_vecteur_en_cours >= 1))
             {if (!((*ili).Nom_vide())) {sort << " \"" << (*ili).Nom() << "\" "; }
     //        !!!!! il faut gérer les différentes composantes comme pour les ddl purs
              else
                {Enum_ddl ddl = (*ili).Enum(); // récup du ddl
                 sort << " \"" << Nom_ddl(Enum_ddl(ddl)) << "\"  ";
                 if ((dim == 2)&&(sortie_de_vecteur_en_cours==1)) // cas où il faut ajouter des ddl vides
                   sort << " \"" << Nom_ddl(Enum_ddl(ddl+1)) << "\"  " ;
                };
              sortie_de_vecteur_en_cours++;
              }
            // sinon on regarde s'il s'agit d'un premier passage de vecteur
            else if ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE)
               || (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH))
             { // c'est un vecteur ou coordonnées, on vérifie que toutes les grandeurs fonctions de la dimension
               // sont présentes
               sortie_de_vecteur_en_cours = 0; // réinitialisation au cas où l'on suit un précédent vecteur
               // comme les ddl sont ordonnées, cela signifie que l'on est en train de tester le premier si
               // toutes les composantes sont présentes
               Enum_ddl pr_ddl = PremierDdlFamille((*ili).Enum()); // récup du premier ddl
               bool present=true; // a priori tous les ddl sont présents
               // on considère que tous les ddl sont ordonnées
               yly = ili; // récup de la position du premier ddl
               for (int i=1;i<=dim;i++,yly++)
                 {if ((Enum_ddl(pr_ddl+i-1) != (*yly).Enum())||((yly==ilifin)&&(i!=dim)))
                    {present=false;break;};};
               if (present)
                {// cas d'un type vecteur avec dim coordonnees, on sauvegarde en coordonnées
                 sort << "\n ResultDescription \"" << (*ili).NomGenerique()  << "\" Vector "
                      << "\n  ComponentNames ";
                 // on sort la première composante
                 if (!((*ili).Nom_vide())) {sort << " \"" << (*ili).Nom() << "\" "; }
                 else
                   { Enum_ddl ddl = (*ili).Enum(); // récup du ddl
                     sort << " \"" << Nom_ddl(ddl) << "\"  ";
                     if (dim == 1) // cas où il faut ajouter des ddl vides
                       sort << " \"" << Nom_ddl(Enum_ddl(ddl+1)) << "\"  \""
                                     << Nom_ddl(Enum_ddl(ddl+2)) << "\"  ";
                     };
                 if (dim != 1)  {sortie_de_vecteur_en_cours++;}
                 else {sortie_de_vecteur_en_cours=0;}
                 }
               else
                {// cas d'un vecteur incomplet, on sauvegarde en scalaire
                 sort << "\n ResultDescription \"";
                 if (!((*ili).Nom_vide())) {sort << (*ili).Nom()  << "\" Scalar ";}
                 else {sort << Nom_ddl((*ili).Enum())  << "\" Scalar "; };
                 };
              }
            // cas où on est sûr que ce n'est pas un vecteur, on traite tout comme des scalaires typés
            else
             {//  on sauvegarde en scalaire
              sort << "\n ResultDescription \"";
              if (!((*ili).Nom_vide())) {sort << (*ili).Nom()  << "\" Scalar ";}
              else {sort << Nom_ddl((*ili).Enum())  << "\" Scalar "; };
              };
          }; // fin de la boucle sur les ddl
     }; //--// fin du  bloc d'isolement

    // a-2) cas des types évoluées définis aux noeuds
    // **(3mars2016) je retire l'incrément 0 qui est bancal, car ne représente pas l'état initial de la structure
    bool drap_noeud = true; // drapeau pour indiquer que l'on sort des grandeurs aux noeuds
    if ((glob_noeud_evol_retenu.size() != 0) && (incre != 0))
     {//--// on fait un bloc d'isolement
       List_io < TypeQuelconque >::iterator ili,ilideb,ilifin=glob_noeud_evol_retenu.end();
       List_io < TypeQuelconque >::iterator yly;
       ilideb = glob_noeud_evol_retenu.begin();
       int sortie_de_vecteur_en_cours = 0;
       for(ili=ilideb;ili!=ilifin;ili++)
          { //  on sauvegarde en fonction du type et de la dimension des grandeurs
            this->EnteteSortieIsovaleurs_G_Quelconque(sort,(*ili),drap_noeud);
          }; // fin de la boucle sur les grandeurs quelconques
     }; //--// fin du  bloc d'isolement
    
    // ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    // b) cas des ddl venant d'un transfert aux noeuds des grandeurs aux pt d'integ
    if ((glob_elem_ddl_retenu.size() != 0)  && (incre != 0))
    { //--// on fait un bloc d'isolement
      List_io < Ddl_enum_etendu >::iterator ili,ilideb,ilifin=glob_elem_ddl_retenu.end();
      List_io < Ddl_enum_etendu >::iterator yly;
      ilideb = glob_elem_ddl_retenu.begin();
      int sortie_de_vecteur_en_cours = 0;
      for(ili=ilideb;ili!=ilifin;ili++)
         { //  on traite tout comme des scalaires typés   
           sort << "\n ResultDescription \"";
           if (!((*ili).Nom_vide())) {sort << (*ili).Nom()  << "\" Scalar ";}
           else {sort << Nom_ddl((*ili).Enum())  << "\" Scalar "; };
         }; // fin de la boucle sur les ddl
    }; //--// fin du  bloc d'isolement
    
    // ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    // c) cas des types évoluées venant d'un transfert aux noeuds des grandeurs aux pt d'integ
    if ((glob_elem_evol_retenu.size() != 0)  && (incre != 0))
    { //--// on fait un bloc d'isolement
      List_io < TypeQuelconque >::iterator ili,ilideb,ilifin=glob_elem_evol_retenu.end();
      ilideb = glob_elem_evol_retenu.begin();
      for(ili=ilideb;ili!=ilifin;ili++)
         { //  on sauvegarde en fonction du type et de la dimension des grandeurs
           this->EnteteSortieIsovaleurs_G_Quelconque(sort,(*ili),drap_noeud);
          }; 
/*         { // on considère que c'est systématique une suite de scalaires
           int nb_scalaire = (*ili).NbMaxiNumeroOrdre();
           // def du nom générique de la grandeur à sortir
           string nom(NomTypeQuelconque((*ili).EnuTypeQuelconque()));
           // on va sortir le nom générique suivie d'un numéro
           for (int insca=1;insca<=nb_scalaire;insca++)
            {//  on sauvegarde en scalaire
             sort << "\n ResultDescription \"";
             sort << nom <<insca  << "\" Scalar ";
             };    
         }; // fin de la boucle sur les ddl */
    }; //--// fin du  bloc d'isolement
    // ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    // d) cas des types particuliers aux elements venant d'un transfert aux noeuds
    if ((glob_elem_Parti_retenu.size() != 0)  && (incre != 0))
    { //--// on fait un bloc d'isolement
      List_io < TypeQuelconque >::iterator ili,ilideb,ilifin=glob_elem_Parti_retenu.end();
      ilideb = glob_elem_Parti_retenu.begin();
      for(ili=ilideb;ili!=ilifin;ili++)
         { //  on sauvegarde en fonction du type et de la dimension des grandeurs
           this->EnteteSortieIsovaleurs_G_Quelconque(sort,(*ili),drap_noeud);
          }; 
   /*      { // on considère que c'est systématique une suite de scalaires
           int nb_scalaire = (*ili).NbMaxiNumeroOrdre();
           // def du nom générique de la grandeur à sortir
           string nom(NomTypeQuelconque_court((*ili).EnuTypeQuelconque()));
           // on va sortir le nom générique suivie d'un numéro
           for (int insca=1;insca<=nb_scalaire;insca++)
            {//  on sauvegarde en scalaire
             sort << "\n ResultDescription \"";
             sort << nom <<insca  << "\" Scalar ";
             };    
         }; // fin de la boucle sur les ddl  */
    }; //--// fin du  bloc d'isolement
  //---------- fin du traitement de l'entête -----------------    

  // maintenant on écrit les grandeurs associés
  sort << "\n \n Values ";
  for (int im=1;im<=nbmail;im++)  // on boucle sur les maillages
    {int numMail=tab_mail(im);
     //   ....... pour simplifier ...........
     // .. pour les ddl  aux noeuds 
     List_io < bool >& g_noeud_ddl_asortir = t_g_noeud_ddl_asortir(numMail);
     // .. les ddl étendu aux noeuds
     List_io < bool >& g_noeud_ddl_etendu_asortir = t_g_noeud_ddl_etendu_asortir(numMail);
     // .. les grandeurs quelconques aux noeuds
     List_io < bool >& g_noeud_evoluee_asortir = t_g_noeud_evoluee_asortir(numMail);
     // .. pour les ddl venant d'un transfert aux noeuds des grandeurs aux pt d'integ
     List_io < bool >& g_elem_ddl_asortir = t_g_elem_ddl_asortir(numMail);
     // .. pour les types évoluées venant d'un transfert aux noeuds des grandeurs aux pt d'integ
     List_io < bool >& g_elem_evoluee_asortir = t_g_elem_evoluee_asortir(numMail);
     // .. pour les types particuliers aux elements venant d'un transfert aux noeuds
     List_io < bool >& g_elem_typeParti_asortir = t_g_elem_typeParti_asortir(numMail);

     // on balaie tous les noeuds du maillage
     // on récupère le décalage de numéros
     int decal_noe=mailInitial->DecalNumNoeud(numMail); // pour simplifier
     List_io <bool>&  choix_var_ddl_unMail = choix_var_ddl(numMail);
     List_io <bool>::iterator itb,itest;
     // cas des ddl étendu
     List_io < Ddl_enum_etendu >::iterator ili,ilideb,ilifin;
     List_io < Ddl_enum_etendu >::iterator yly;
     // cas des grandeurs quelconques
     List_io < TypeQuelconque >::iterator ibi,ibideb,ibifin;
     
     int nbmaxinoeud = lesMail->Nombre_noeud(numMail);
     for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++) 
       { // recup du noeud
         Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
         sort << "\n" << noe.Num_noeud() + decal_noe << " " ;
         // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
         // a) cas des ddl initiaux définis aux noeuds
         if ((glob_noe_ddl_retenu.size() != 0) && (incre != 0))
         {//--// on fait un bloc d'isolement
          ilifin=glob_noe_ddl_retenu.end();
          ilideb = glob_noe_ddl_retenu.begin();
          // recup des  valeur de ddl
          itb=choix_var_ddl_unMail.begin(); // init de la liste d'indicateur de var
          Enum_ddl enu_type_famille = PremierDdlFamille((*ilideb).Enum()); // la première famille
          EnumTypeGrandeur type_grandeur = (*ilideb).TypeDeGrandeur(); // le premier type de grandeur
          bool cas_vecteur=false;
          if ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE) 
            || (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH))
              cas_vecteur=true; // signale que l'on sort un vecteur qui est "le" cas particulier

          itest=g_noeud_ddl_asortir.begin(); // pour le test de sortie pour le maillage en question
          for(ili=ilideb;ili!=ilifin;ili++,itb++,itest++)
             {Enum_ddl enu = (*ili).Enum();
              // on regarde si l'on a changé de famille
              if (!Meme_famille(enu_type_famille,enu))
              	{if (cas_vecteur)
              	  // on a changé de famille, on complète avec des zéros si c'est un vecteur
                 {switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
                  { case 1: { sort << "  0.   "; if (ddlSurY_1D) {break;};}
                    case 2: sort << "  0.   ";
                   };
                 }; // sinon on ne fait rien
                // on initialise pour la suite
                enu_type_famille = PremierDdlFamille(enu);   
                type_grandeur = (*ili).TypeDeGrandeur();                 
                if ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE) 
                   || (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH))
                     cas_vecteur=true; // signale que l'on sort un vecteur qui est "le" cas particulier
              	};
              // si la grandeur existe et que l'on doit la sortir pour ce maillage (cf. itest) on la sort sinon on sort 0.
              double val_ddl=0.;
              if ((noe.Existe_ici(enu)) && (*itest) ) 
                {val_ddl = noe.Valeur_tdt(enu); // la valeur actuelle
                 if ((*itb))
                    val_ddl -= noe.Valeur_0(enu);
                };
              if ((dim == 1) && ddlSurY_1D)
                   sort << "    0.     ";// cas où on veut sortir sur y et non sur x les ddl 
              // enregistrement de la valeur
              sort << setw (ParaGlob::NbdigdoGR()) << val_ddl << " ";              
             };
             
            // traitement pour la dernière série de ddl, dans le cas d'un vecteur
            if (cas_vecteur)  
              switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
                  { case 1: { sort << "  0.   "; if (ddlSurY_1D) {break;};}
                    case 2: sort << "  0.   ";
                   };             
          }; //--// fin du  bloc d'isolement pour les ddl initiaux définis aux noeuds
         // a-1) cas des ddl étendues définis aux noeuds
         if ((glob_noeud_ddl_etendu_retenu.size() != 0) && (incre != 0))
          {//--// on fait un bloc d'isolement
           ilifin=glob_noeud_ddl_etendu_retenu.end();
           ilideb = glob_noeud_ddl_etendu_retenu.begin();
           // recup des  valeur de ddl
           itb=choix_var_ddl_unMail.begin(); // init de la liste d'indicateur de var
           Enum_ddl enu_type_famille = PremierDdlFamille((*ilideb).Enum()); // la première famille
           EnumTypeGrandeur type_grandeur = (*ilideb).TypeDeGrandeur(); // le premier type de grandeur
           bool cas_vecteur=false;
           if ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE)
             || (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH))
               cas_vecteur=true; // signale que l'on sort un vecteur qui est "le" cas particulier

           itest=g_noeud_ddl_asortir.begin(); // pour le test de sortie pour le maillage en question
           for(ili=ilideb;ili!=ilifin;ili++,itb++,itest++)
              {Enum_ddl enu = (*ili).Enum();
               // on regarde si l'on a changé de famille
               if (!Meme_famille(enu_type_famille,enu))
                {if (cas_vecteur)
                  // on a changé de famille, on complète avec des zéros si c'est un vecteur
                  {switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
                   { case 1: { sort << "  0.   "; if (ddlSurY_1D) {break;};}
                     case 2: sort << "  0.   ";
                    };
                  }; // sinon on ne fait rien
                 // on initialise pour la suite
                 enu_type_famille = PremierDdlFamille(enu);
                 type_grandeur = (*ili).TypeDeGrandeur();
                 if ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE)
                    || (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH))
                      cas_vecteur=true; // signale que l'on sort un vecteur qui est "le" cas particulier
                };
               // si la grandeur existe et que l'on doit la sortir pour ce maillage (cf. itest) on la sort sinon on sort 0.
               double val_ddl=0.;
               if ((noe.Existe_ici(enu)) && (*itest) )
                 {val_ddl = noe.Valeur_tdt(enu); // la valeur actuelle
                  if ((*itb))
                     val_ddl -= noe.Valeur_0(enu);
                 };
               if ((dim == 1) && ddlSurY_1D)
                    sort << "    0.     ";// cas où on veut sortir sur y et non sur x les ddl
               // enregistrement de la valeur
               sort << setw (ParaGlob::NbdigdoGR()) << val_ddl << " ";
              };
              
             // traitement pour la dernière série de ddl, dans le cas d'un vecteur
             if (cas_vecteur)
               switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
                   { case 1: { sort << "  0.   "; if (ddlSurY_1D) {break;};}
                     case 2: sort << "  0.   ";
                    };
           }; //--// fin du  bloc d'isolement pour les ddl étendus définis aux noeuds
         // a-2) cas des types évoluées définis aux noeuds
         if ((glob_noeud_evol_retenu.size() != 0) && (incre != 0))
          { //--// on fait un bloc d'isolement
            ibifin=glob_noeud_evol_retenu.end();
            ibideb = glob_noeud_evol_retenu.begin();
            // recup des  valeur de ddl
            itest=g_noeud_evoluee_asortir.begin(); // pour le test de sortie pour le maillage en question
            for(ibi=ibideb;ibi!=ibifin;ibi++,itest++)
             {// si la grandeur existe et que l'on doit la sortir pour ce maillage (cf. itest) on la sort sinon on sort 0.
              TypeQuelconque_enum_etendu enu = (*ibi).EnuTypeQuelconque();
              const TypeQuelconque* tq = NULL;
              bool existe = noe.Existe_ici(enu);
              if (existe) {tq = &(noe.Grandeur_quelconque(enu));};
              // on sort les grandeurs
              if ((*itest) * existe)
                  { this->SortieGrandeursQuelconque(sort,(*tq));}
              else // si ça n'existe pas au noeud on sort des 0, normalement (*ibi) ne sert que pour le type
                   // donc est initialisée à 0, on s'en sert comme conteneur nul
                  { this->SortieGrandeursQuelconque(sort,(*ibi));};
             };
          }; //--// fin du  bloc d'isolement pour les types évoluées

         // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
         // b) cas des ddl venant d'un transfert aux noeuds des grandeurs aux pt d'integ
         if ((glob_elem_ddl_retenu.size() != 0) && (incre != 0))
          { //--// on fait un bloc d'isolement
            ilifin=glob_elem_ddl_retenu.end();
            ilideb = glob_elem_ddl_retenu.begin();
            // recup des  valeur de ddl
            itest=g_elem_ddl_asortir.begin(); // pour le test de sortie pour le maillage en question
            for(ili=ilideb;ili!=ilifin;ili++,itest++)
             {// si la grandeur existe et que l'on doit la sortir pour ce maillage (cf. itest) on la sort sinon on sort 0.
              if ((dim == 1) && ddlSurY_1D)
                   sort << "    0.     ";// cas où on veut sortir sur y et non sur x les ddl 
              // enregistrement de la valeur
              if ((noe.Existe_ici_ddlEtendu(*ili)) && (*itest) ) 
                    {sort << setw (ParaGlob::NbdigdoGR()) << noe.DdlEtendue(*ili).ConstValeur() << " "; }
              else  {sort << "    0.     "; };             	
             }; 
          }; //--// fin du  bloc d'isolement pour les ddl 
                 //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
         if ((glob_elem_evol_retenu.size() != 0) && (incre != 0))
          { //--// on fait un bloc d'isolement
            ibifin=glob_elem_evol_retenu.end();
            ibideb = glob_elem_evol_retenu.begin();
            // recup des  valeur de ddl
            itest=g_elem_evoluee_asortir.begin(); // pour le test de sortie pour le maillage en question
            for(ibi=ibideb;ibi!=ibifin;ibi++,itest++)
             {// si la grandeur existe et que l'on doit la sortir pour ce maillage (cf. itest) on la sort sinon on sort 0.
              TypeQuelconque_enum_etendu enu = (*ibi).EnuTypeQuelconque();
              const TypeQuelconque* tq = NULL;
              bool existe = noe.Existe_ici(enu);
              if (existe) {tq = &(noe.Grandeur_quelconque(enu));};
              // on sort les grandeurs
              if ((*itest) * existe)
                  { this->SortieGrandeursQuelconque(sort,(*tq));}
              else // si ça n'existe pas au noeud on sort des 0, normalement (*ibi) ne sert que pour le type
                   // donc est initialisée à 0, on s'en sert comme conteneur nul 
                  { this->SortieGrandeursQuelconque(sort,(*ibi));};
             };
   /*          {// si la grandeur existe et que l'on doit la sortir pour ce maillage (cf. itest) on la sort sinon on sort 0.
              // on considère que c'est systématique une suite de scalaires
              int nb_scalaire = (*ibi).NbMaxiNumeroOrdre();
              TypeQuelconque_enum_etendu enu = (*ibi).EnuTypeQuelconque();
              const TypeQuelconque* tq = NULL;
              bool existe = noe.Existe_ici(enu);
              if (existe) {tq = &(noe.Grandeur_quelconque(enu));};
              // on boucle sur tous les scalaires
              if ((*itest) * existe)
               {for (int insca=1;insca<=nb_scalaire;insca++)
                  { sort << setw (ParaGlob::NbdigdoGR())  << tq->GrandeurNumOrdre(insca) << " ";}
               }
              else  
                  { for (int insca=1;insca<=nb_scalaire;insca++) sort << "    0.     ";};
             }; */
          }; //--// fin du  bloc d'isolement pour les types évoluées 
                 // 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
         if ((glob_elem_Parti_retenu.size() != 0) && (incre != 0))
          { //--// on fait un bloc d'isolement
            ibifin=glob_elem_Parti_retenu.end();
            ibideb = glob_elem_Parti_retenu.begin();
            itest=g_elem_typeParti_asortir.begin(); // pour le test de sortie pour le maillage en question
            for(ibi=ibideb;ibi!=ibifin;ibi++,itest++)
             {TypeQuelconque_enum_etendu enu = (*ibi).EnuTypeQuelconque();
              const TypeQuelconque* tq = NULL;
              bool existe = noe.Existe_ici(enu);
              if (existe) {tq = &(noe.Grandeur_quelconque(enu));};
              // on sort les grandeurs
              if ((*itest) * existe)
                  { this->SortieGrandeursQuelconque(sort,(*tq));}
              else // si ça n'existe pas au noeud on sort des 0, normalement (*ibi) ne sert que pour le type
                   // donc est initialisée à 0, on s'en sert comme conteneur nul 
                  { this->SortieGrandeursQuelconque(sort,(*ibi));};
             };
/*             {// on considère que c'est systématique une suite de scalaires
              int nb_scalaire = (*ibi).NbMaxiNumeroOrdre();
              TypeQuelconque_enum_etendu enu = (*ibi).EnuTypeQuelconque();
              const TypeQuelconque* tq = NULL;
              bool existe = noe.Existe_ici(enu);
              if (existe) {tq = &(noe.Grandeur_quelconque(enu));};
              // on sort les grandeurs
              if ((*itest) * existe)
               {for (int insca=1;insca<=nb_scalaire;insca++)
                  { sort << setw (ParaGlob::NbdigdoGR())  << tq->GrandeurNumOrdre(insca) << " ";}
               }
              else  
                  { for (int insca=1;insca<=nb_scalaire;insca++) sort << "    0.     ";};
             };*/
          }; //--// fin du  bloc d'isolement pour les types particuliers 
                 // aux elements venant d'un transfert aux noeuds
       }; //fin boucle sur noeud
    }; //-- fin de la boucle sur les maillages
  sort << "\n End Values \n";
   }; //-- fin du cas if (atraiter)

};