// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL  : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.

#include "Choix_grandeurs_maple.h"
#include "CharUtil.h"
#include "ReferenceNE.h"
#include "ReferencePtiAF.h"

#include <iomanip>
#include <limits>

// ------------------------------------------------ méthodes protégées --------------------------------------
// entrée du choix de ddl principaux aux noeuds
void Choix_grandeurs_maple::Entree_grandeur_principale_aux_noeuds(string& rep)
  { // cas de grandeurs aux noeuds, on boucle sur les maillages
    int dim = ParaGlob::Dimension();
    // on récupère la liste des maillages à visualiser
    const list <int>& list_mail = choix_mail->List_choisit();
    list<int>::const_iterator ilm,ilmfin=list_mail.end();
    int taille_list_maille = list_mail.size();
    if (list_mail.size() == 0)
      { cout << "\n aucun maillage n'est definit ! , il faut commencer par definir les maillages pour"
             << " lesquels on veut une sortie ";
        return;
       };      
     // on balaie les différents maillages
     for (ilm = list_mail.begin();ilm!=ilmfin;ilm++)
       {int n_mail = abs(*ilm); // numéro du maillage  
        // -- boucle sur les maillages
        // affichage du nom du maillages s'il y en a plusieurs
        if (taille_list_maille > 1)
          cout << "\n ======>>>>>   maillage : " << lesMail->NomMaillage(n_mail);
        // on affiche la liste actuelle des grandeurs si elle n'est pas vide
        if ((tabnoeud_type_ddl_retenu(n_mail)).size())
          { cout << "\n liste des grandeurs actuellement a sortir:   ";  
            List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabnoeud_type_ddl_retenu(n_mail)).end();
            for (iet=(tabnoeud_type_ddl_retenu(n_mail)).begin();iet!=ietfin;iet++)
                cout << (*iet) << " " ;
            }
        // on affiche les différentes grandeurs possibles
        cout << "\n maillage nb : " << n_mail ;
        cout << "\n la liste des grandeurs disponibles est la suivante : ";
        List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabnoeud_type_ddl(n_mail)).end();
        for (iet=(tabnoeud_type_ddl(n_mail)).begin();iet!=ietfin;iet++)
               cout << (*iet) << " " ;
               //      if ((*iet).Nom_vide()) cout << Nom_ddl((*iet).Enum()) << " "; else  cout << (*iet).Nom() << " ";
        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 type de sortie de ddl retenue                         (rep : ts)         "
             << "\n                                       (pour terminer tapez : fin (ou f)) ";
        rep = "";
        while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
           { cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
             if (rep == "to")
             // cas de toutes les grandeurs sans les réactions
             {List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddl(n_mail).end();
              for (ite = tabnoeud_type_ddl(n_mail).begin();ite != itefin; ite++)
                if ( !Ddl_reaction((*ite).Enum()))
                      tabnoeud_type_ddl_retenu(n_mail).push_back(*ite);
              tabnoeud_type_ddl_retenu(n_mail).sort(); // on ordonne
              tabnoeud_type_ddl_retenu(n_mail).unique();// on supprime les doublons                           
              }  
             else if (rep == "tr")
             // cas de toutes les grandeurs avec les réactions
             {List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddl(n_mail).end();
              for (ite = tabnoeud_type_ddl(n_mail).begin();ite != itefin; ite++)
                      tabnoeud_type_ddl_retenu(n_mail).push_back(*ite);
              tabnoeud_type_ddl_retenu(n_mail).sort(); // on ordonne
              tabnoeud_type_ddl_retenu(n_mail).unique();// on supprime les doublons                           
             }
             else if (ExisteEnum_ddl(rep))
              { // on vérifie qu'il appartiend à la liste des ddl proposés
                Enum_ddl enume=Id_nom_ddl (rep);
                Ddl_enum_etendu enu_etendu(enume);
                if (Ddl_enum_etendu::Existe_dans_la_liste(tabnoeud_type_ddl(n_mail),enu_etendu))
                    { (tabnoeud_type_ddl_retenu(n_mail)).push_back(enu_etendu);
                      tabnoeud_type_ddl_retenu(n_mail).sort(); // on ordonne
                      (tabnoeud_type_ddl_retenu(n_mail)).unique(); // supprime le doublon si nécessaire
                     }
                else     
                  cout << " erreur de choix de ddl, celui choisit n'appartient pas a la liste propose";
              }
             else if (rep == "ef") 
              { // on efface la liste
                (tabnoeud_type_ddl_retenu(n_mail)).clear();
               }
             else if (rep == "ts") 
              { cout << "\n actuellement type_sortie_ddl_retenue= " << type_sortie_ddl_retenue << "\n";
                cout << "\n sortie des grandeurs a t (par defaut) : (rep: 0)"
                     << "\n sortie des grandeurs entre t et 0     : (rep: 1)"
                     << "\n sortie des grandeurs a 0 et a t       : (rep: 2)"
                     << "\n laisser tel-quel                      : (rep: f)\n";
                string reep="";
                reep = lect_return_defaut(false,"f");
                if (reep == "0") {type_sortie_ddl_retenue=0;}
                else if (reep == "1") {type_sortie_ddl_retenue=1;}
                else if (reep == "2") {type_sortie_ddl_retenue=2;}
                cout << "\n nouvelle valeur: type_sortie_ddl_retenue= " << type_sortie_ddl_retenue << "\n";
               }
             else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
              cout << " erreur de syntaxe dans le ddl! recommencez ";
           };
                 
        // choix du ou des noeuds, on affiche la liste actuelle
        if ((tab_num_noeud(n_mail)).size())
         { cout << "\n liste actuelle de noeud:   ";
           List_io <int>::iterator ieint,ieintfin = tab_num_noeud(n_mail).end();
           for (ieint=tab_num_noeud(n_mail).begin();ieint!=ieintfin;ieint++)
             cout << *ieint << " ";
           cout << endl;  
          }
        if ((nomDeRef(n_mail)).size() != 0)
         { cout << "\n liste actuelle de reference de noeuds:   ";
           List_io <string >::iterator ieint1,ieintfin1 = (nomDeRef(n_mail)).end();
           for (ieint1=(nomDeRef(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
             cout << *ieint1 << " ";
           cout << endl;  
          }
          
        // questions  
        cout << "\n choix du ou des noeuds ou l'on veut la visualisation "
             << "\n le reperage d'un noeuds peut se faire de differentes manieres :" 
             << "\n par son numero dans le maillage          ->                 (choix : 1)"
             << "\n par ses coordonnees, meme approximatives ->                 (choix : 2)"
             << "\n par une reference de liste de noeuds     ->                 (choix : 3)"
             << "\n donnez pour chaque noeud le type de choix puis le numero               "
             << "\n ou les cordonnees                                                      "
             << "\n effacer la liste actuelle de noeuds                         (rep : ef) "                     
             << "\n effacer la liste actuelle des references de noeuds          (rep : efref) " 
             << "\n afficher la liste des references de noeuds existants        (rep : affref) "                    
             << "\n                                                (pour finir tapez : fin (ou f))";
        rep = "";
        while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
         { cout << "\n choix ? ";rep = lect_return_defaut(false,"f");
           bool verif = true; // pour la vérification du numéro du noeud
           int nu=0 ; // le numéro de noeud
           if (rep == "1")
             { cout << " numero ? "; rep = lect_return_defaut(false,"f"); nu = ChangeEntier(rep);
               }
           else if (rep =="2")
             { Coordonnee xi(dim);
               cout << "\n coordonnee ("<<dim<<" nombre(s)) ? ";
               for(int j=1;j<=dim;j++) cin >> xi(j);
               std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
               cout << "\n les coordonnees sont a:  t = 0 ou t ou tdt (repondre 0 ou t ou tdt) ?";
               rep  = lect_chaine();
               // recherche du noeud le plus proche
               if (rep == "0")        nu = lesMail->Noeud_le_plus_proche_0(xi,n_mail);
               else if (rep == "t")   nu = lesMail->Noeud_le_plus_proche_t(xi,n_mail);  
               else if (rep == "tdt") nu = lesMail->Noeud_le_plus_proche_tdt(xi,n_mail);
               else
                 { cout << "\n erreur de syntaxe, on attendait 0 ou t ou tdt ! ";verif = false;};
               cout << "\n noeud le plus proche nb= " << nu; verif = true;
              }    
           else if (rep =="3")
             { string nom_ref;
               cout << "\n nom de la reference ? ";nom_ref= lect_chaine();
               // vérif que la référence existe
               if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 1))
                 { cout << "\n erreur de nom donne (** "<< nom_ref << " **)  ne correspond pas a une reference de noeud correcte ";}
               else // on enregistre
                 { nomDeRef(n_mail).push_back(nom_ref);
                   nomDeRef(n_mail).sort(); // on ordonne
                   nomDeRef(n_mail).unique();// on supprime les doublons                         
                 };
               verif = false; // pour ne pas enregistrer de numéro dans la liste de noeud car ici c'est 
                              // la liste de référence de noeud qui est en cause       
              }    
          else if (rep == "ef") 
            { // on efface la liste des noeuds
              (tab_num_noeud(n_mail)).clear();
               verif = false;                                                                 
             }
          else if (rep == "efref") 
            { // on efface la liste des références de noeuds
              (nomDeRef(n_mail)).clear(); 
              verif = false;                                                                
             }
          else if (rep == "affref") 
            { // affichage de la liste des références enregistrées dans les maillages
              cout << "\n liste des references de noeuds ";
              if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
              const Reference* reff =NULL; bool prempass = true;
              do { 
                 if (prempass)
                   { reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
                 else
                   { reff = lesRef->Reference_suivante();} // récup de la ref courante  
                 // sortie de la ref si c'est le bon maillage, et si c'est une ref de noeud
                 if (reff != NULL)
                    if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 1)) cout << reff->Nom() << " ";
                 prempass = false; 
                  } while (reff != NULL);
               verif = false;    
             }
          else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
             { cout << " erreur de syntaxe on attendait 1 ou 2 ! recommencez ";verif = false;};
           // vérif que le numéro est acceptable et enregistrement
           if ((nu>0)&&(nu<=lesMail->Nombre_noeud(n_mail))) 
            { // on vérifie que les ddls à sortir sont bien présent pour ce noeud
              List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabnoeud_type_ddl_retenu(n_mail).end();
              for (ienu = tabnoeud_type_ddl_retenu(n_mail).begin();ienu!=ienufin;ienu++)
                {if ( (!(lesMail->Noeud_LesMaille(n_mail,nu).Existe_ici((*ienu).Enum())))  // cas où le ddl principal n'existe pas
                     && (!(lesMail->Noeud_LesMaille(n_mail,nu).Existe_ici_ddlEtendu((*ienu))))) // cas où le ddl étendu n'existe pas
                  {cout << "\n attention le ddl " << Nom_ddl((*ienu).Enum()) << " n'existe pas pour le noeud " 
                        << nu << " du maillage " << n_mail 
                        << "\n il y aura 0 en sortie ! ";
                   verif = true;     
                   } 
                 } 
               }            
           if ((verif)&&((Minuscules(rep) != "fin") && (Minuscules(rep) != "f")))  
             { // enregistrement
               tab_num_noeud(n_mail).push_back(nu);
               tab_num_noeud(n_mail).sort(); // on ordonne
               tab_num_noeud(n_mail).unique();// on supprime les doublons                         
              } 
         }// -- fin de la boucle infini sur l'entrée de numéro de noeud                     
       }// -- fin de la boucle sur les maillages
     }; // -- fin du cas des ddl principaux aux noeuds

// entrée du choix de ddl étendus secondaires aux noeuds
void Choix_grandeurs_maple::Entree_grandeur_etendue_secondaire_aux_noeuds(string& rep)
  { // cas de grandeurs aux noeuds, on boucle sur les maillages
    int dim = ParaGlob::Dimension();
    // on récupère la liste des maillages à visualiser
    const list <int>& list_mail = choix_mail->List_choisit();
    list<int>::const_iterator ilm,ilmfin=list_mail.end();
    int taille_list_maille = list_mail.size();
    if (list_mail.size() == 0)
      { cout << "\n aucun maillage n'est definit ! , il faut commencer par definir les maillages pour"
             << " lesquels on veut une sortie ";
        return;
       };      
    // on balaie les différents maillages
    for (ilm = list_mail.begin();ilm!=ilmfin;ilm++)
     {int n_mail = abs(*ilm); // numéro du maillage  
      // dans le cas où aucune grandeur particulière sont défini on passe
      if ( (tabnoeud_type_ddlEtendu(n_mail)).size() == 0)
        { cout << "\n aucune grandeur etendue n'est definit, donc aucune proposition ";}
      else
       {// affichage du nom du maillages s'il y en a plusieurs
        rep = ""; // init
        while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
         {if (taille_list_maille > 1)
            cout << "\n ======>>>>>   maillage : " << lesMail->NomMaillage(n_mail);
          // on affiche la liste actuelle des grandeurs si elle n'est pas vide
          if ((tabnoeud_type_ddlEtendu_retenu(n_mail)).size())
            { cout << "\n liste des grandeurs actuellement a sortir:   ";  
              List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabnoeud_type_ddlEtendu_retenu(n_mail)).end();
              for (iet=(tabnoeud_type_ddlEtendu_retenu(n_mail)).begin();iet!=ietfin;iet++)
                cout << (*iet) << " " ;
            };
          // on affiche les différentes grandeurs possibles
          cout << "\n maillage nb : " << n_mail ;
          cout << "\n la liste des grandeurs disponibles est la suivante : ";
          List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabnoeud_type_ddlEtendu(n_mail)).end();
          for (iet=(tabnoeud_type_ddlEtendu(n_mail)).begin();iet!=ietfin;iet++)
               cout << (*iet) << " " ;
          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 = "";
          cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
          if (rep == "to")
             // cas de toutes les grandeurs sans les réactions
             {List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddlEtendu(n_mail).end();
              for (ite = tabnoeud_type_ddlEtendu(n_mail).begin();ite != itefin; ite++)
                if ( !Ddl_reaction((*ite).Enum()))
                      tabnoeud_type_ddlEtendu_retenu(n_mail).push_back(*ite);
              tabnoeud_type_ddlEtendu_retenu(n_mail).sort(); // on ordonne
              tabnoeud_type_ddlEtendu_retenu(n_mail).unique();// on supprime les doublons
              }  
          else if (rep == "tr")
             // cas de toutes les grandeurs avec les réactions
             {List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddlEtendu(n_mail).end();
              for (ite = tabnoeud_type_ddlEtendu(n_mail).begin();ite != itefin; ite++)
                      tabnoeud_type_ddlEtendu_retenu(n_mail).push_back(*ite);
              tabnoeud_type_ddlEtendu_retenu(n_mail).sort(); // on ordonne
              tabnoeud_type_ddlEtendu_retenu(n_mail).unique();// on supprime les doublons
              }  
          else if (Ddl_enum_etendu::VerifExistence(rep))
              { // on vérifie qu'il appartiend à la liste des ddl étendus proposés
                Ddl_enum_etendu enu_etendu(rep);
                if (Ddl_enum_etendu::Existe_dans_la_liste(tabnoeud_type_ddlEtendu(n_mail),enu_etendu))
                    { (tabnoeud_type_ddlEtendu_retenu(n_mail)).push_back(enu_etendu);
                      tabnoeud_type_ddlEtendu_retenu(n_mail).sort(); // on ordonne
                      (tabnoeud_type_ddlEtendu_retenu(n_mail)).unique(); // supprime le doublon si nécessaire
                     }
                else     
                  cout << " erreur de choix de ddl, celui choisit n'appartient pas a la liste propose";
               }
          else if (rep == "ef") 
              { // on efface la liste
                (tabnoeud_type_ddlEtendu_retenu(n_mail)).clear();
               }
          else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
              cout << " erreur de syntaxe dans le ddl! recommencez ";
         };
        // maintenant si la liste de ddl étendu  est vide on s'arrête sinon on choisit éventuellement des noeuds
        if ( (tabnoeud_type_ddlEtendu_retenu(n_mail)).size() != 0)
             { Choix_noeud_a_retenir(n_mail,tabnoeud_type_ddlEtendu_retenu(n_mail)); }
        else
             { cout << "\n aucune grandeur enregistree ! pour le maillage " << n_mail <<"\n "; };
       };
     };// -- fin de la boucle sur les maillages
  }; // -- fin du cas des ddl étendus secondaires aux noeuds
// entrée du choix de cas de grandeurs particulières aux noeuds
void Choix_grandeurs_maple::Entree_grandeur_TypeQuelconque_secondaire_aux_noeuds(string& rep)
  { // cas de grandeurs particulières aux noeuds, on boucle sur les maillages
    int dim = ParaGlob::Dimension();
    // on récupère la liste des maillages à visualiser
    const list <int>& list_mail = choix_mail->List_choisit();
    list<int>::const_iterator ilm,ilmfin=list_mail.end();
    int taille_list_maille = list_mail.size();
    if (list_mail.size() == 0)
      { cout << "\n aucun maillage n'est definit ! , il faut commencer par definir les maillages pour"
             << " lesquels on veut une sortie ";
        return;
      };             
    // on balaie les différents maillages
    for (ilm = list_mail.begin();ilm!=ilmfin;ilm++)
      {int n_mail = abs(*ilm); // numéro du maillage
       // dans le cas où aucune grandeur particulière sont défini on passe
       if (   ((tabnoeud_TypeQuelconque(n_mail)).size() == 0)
           && (listeVecGlobbal.size() == 0))
        { cout << "\n aucune grandeur particuliere n'est definit, donc aucune proposition ";}
       else
        { // def d'une liste de travail, pour vérifier que tous les grandeurs particuliers sont relatives
          // à un même point d'intégration
          List_io < Ddl_enum_etendu > li_ddl; 
          // on affiche la liste actuelle des grandeurs enregistrées
          if ((tabnoeud_TypeQuelconque_retenu(n_mail)).size())
             { cout << "\n liste des grandeurs particulieres actuellement a sortir:   ";  
               List_io < TypeQuelconque >::iterator iet,ietfin = (tabnoeud_TypeQuelconque_retenu(n_mail)).end();
               for (iet=(tabnoeud_TypeQuelconque_retenu(n_mail)).begin();iet!=ietfin;iet++)
                 cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
               cout << endl;  
             };
          // on affiche les différentes grandeurs possibles
          cout << "\n maillage nb : " << n_mail ;
          cout << "\n la liste des grandeurs particulieres disponibles est la suivante : ";
          // tout d'abord celles venant du maillage
          {List_io < TypeQuelconque >::iterator iet,ietfin = (tabnoeud_TypeQuelconque(n_mail)).end();
           for (iet=(tabnoeud_TypeQuelconque(n_mail)).begin();iet!=ietfin;iet++)
                     cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
          };
          // puis celles venant de l'algorithme
          {List_io < TypeQuelconque >::iterator iet,ietfin = listeVecGlobbal.end();
           List_io<TypeQuelconque>& tpg = (tabnoeud_TypeQuelconque(n_mail));
           for (iet=listeVecGlobbal.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()) ;
               };
          };
          cout << "\n";
          cout << "\n grandeurs que vous voulez visualiser                         (rep : grandeurs?)"
               << "\n effacer la liste actuelle                                    (rep : ef)         "
               << "\n toutes les grandeurs :                                       (rep : to)         "
               << "\n                                               (pour terminer tapez : fin (ou f))";
          rep = "";
          while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
             { cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
               // -- cas de toutes les grandeurs
               if (rep == "to")
                {// tout d'abord celles venant du maillage
                 {List_io<TypeQuelconque>& tpg_ret = (tabnoeud_TypeQuelconque_retenu(n_mail)); // pour simplifier
                  List_io<TypeQuelconque>& tpg = (tabnoeud_TypeQuelconque(n_mail)); // pour simplifier
                  List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
                  for (ite = tabnoeud_TypeQuelconque(n_mail).begin();ite != itefin; ite++)
                      if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
                        { tpg_ret.push_back(*ite);};
                 };
                 // puis celles venant de l'algorithme
                 {List_io<TypeQuelconque>& tpg_ret = (tabnoeud_TypeQuelconque_retenu(n_mail)); // pour simplifier
                  List_io<TypeQuelconque>& tpg = listeVecGlobbal; // pour simplifier
                  List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
                  for (ite = listeVecGlobbal.begin();ite != itefin; ite++)
                      if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
                        { tpg_ret.push_back(*ite);
                          listeVecGlobbal_retenu.push_back(*ite); // sert pour ajouter les conteneurs aux noeuds
                        };
                  // on sort un message pour indiquer que les grandeurs globales ne seront
                  // disponible qu'au fil du calcul
                  {cout << "\n ---- attention, les grandeurs suivantes ne sont disponibles qu'au fil du calcul ----";
                   List_io < TypeQuelconque >::iterator iet,ietfin = listeVecGlobbal.end();
                   for (iet=listeVecGlobbal.begin();iet!=ietfin;iet++)
                        cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
                  };
                 };
                }  
               // -- cas d'une grandeur particulière
               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_TypeQuelconque_retenu(n_mail)); // pour simplifier
                  List_io<TypeQuelconque>& tpg = (tabnoeud_TypeQuelconque(n_mail)); // 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_TypeQuelconque_retenu(n_mail)); // pour simplifier
                  List_io<TypeQuelconque>& tpg = listeVecGlobbal; // 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);
                        listeVecGlobbal_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 ";};
                }
               // -- cas où on veut effacer la liste
               else if (rep == "ef") 
                {(tabnoeud_TypeQuelconque_retenu(n_mail)).clear();
                 listeVecGlobbal_retenu.clear();
                 }
               // -- cas fin
               else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                cout << " erreur de syntaxe  recommencez ";
             };
          // affichage des infos actuellement enregistrées
          if ( (tabnoeud_TypeQuelconque_retenu(n_mail)).size() != 0)
            { cout << "\n liste des grandeurs particulieres enregistrees:   ";  
              List_io < TypeQuelconque >::iterator iet,ietfin = (tabnoeud_TypeQuelconque_retenu(n_mail)).end();
              for (iet=(tabnoeud_TypeQuelconque_retenu(n_mail)).begin();iet!=ietfin;iet++)
                  cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
              cout << endl;  
            }
          else
            { cout << "\n aucune grandeur enregistree ! \n "; };
          // maintenant si la liste de grandeurs quelconques  est vide on s'arrête sinon on choisit éventuellement des noeuds
          if ( (tabnoeud_type_ddlEtendu_retenu(n_mail)).size() != 0)
             { Choix_noeud_a_retenir(n_mail,tabnoeud_type_ddlEtendu_retenu(n_mail)); }
          else
             { cout << "\n aucune grandeur enregistree ! pour le maillage " << n_mail <<"\n "; };
        }; //-- fin du choix sur le fait qu'il existe ou non des grandeurs particulières pour le maillage
      }; //-- fin de la boucle sur les maillages          
  }; // -- fin du cas des grandeurs particulières aux noeuds

// entrée du choix d'une grandeur aux éléments
void Choix_grandeurs_maple::Entree_grandeur_aux_elements(string& rep)
  { // cas de grandeurs aux éléments, on boucle sur les maillages
    int dim = ParaGlob::Dimension();
    // on récupère la liste des maillages à visualiser
    const list <int>& list_mail = choix_mail->List_choisit();
    list<int>::const_iterator ilm,ilmfin=list_mail.end();
    int taille_list_maille = list_mail.size();
    if (list_mail.size() == 0)
      { cout << "\n aucun maillage n'est definit ! , il faut commencer par definir les maillages pour"
             << " lesquels on veut une sortie ";
        return;
       };      
     // on balaie les différents maillages
     for (ilm = list_mail.begin();ilm!=ilmfin;ilm++)
       {  int n_mail = abs(*ilm); // numéro du maillage
//    int taille_list_maille = tabelement_type_ddl.Taille();
//    for (int n_mail=1;n_mail<=taille_list_maille;n_mail++)
               // on affiche la liste actuelle
                if ((tabelement_type_ddl_retenu(n_mail)).size())
                 { cout << "\n liste actuelle des element a sortir en info:   ";
                   List_io <int>::iterator ieint,ieintfin = tab_num_element(n_mail).end();
                   for (ieint=tab_num_element(n_mail).begin();ieint!=ieintfin;ieint++)
                     cout << *ieint << " ";
                   cout << "\n liste des grandeurs actuellement a sortir:   ";  
                   List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabelement_type_ddl_retenu(n_mail)).end();
                   for (iet=(tabelement_type_ddl_retenu(n_mail)).begin();iet!=ietfin;iet++)
                     cout << (*iet) << " " ;
             //        if ((*iet).Nom_vide()) cout << Nom_ddl((*iet).Enum()) << " "; else  cout << (*iet).Nom() << " ";
                   cout << endl;  
                  }
                // on affiche les différentes grandeurs possibles
                cout << "\n maillage nb : " << n_mail ;
                cout << "\n la liste des grandeurs disponibles est la suivante : ";
                List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabelement_type_ddl(n_mail)).end();
                for (iet=(tabelement_type_ddl(n_mail)).begin();iet!=ietfin;iet++)
                     cout << (*iet) << " " ;
           //          if ((*iet).Nom_vide()) cout << Nom_ddl((*iet).Enum()) << " "; else  cout << (*iet).Nom() << " ";
                cout << "\n grandeurs que vous voulez visualiser                    ( rep : grandeurs?)"
                     << "\n REMARQUE : il faut donner uniquement un jeux de ddl                        "
                     << "\n def au meme point d'integration (contraintes/def                           "
                     << "\n ou (exclusif) erreur ou ...)                                               "
                     << "\n effacer la liste actuelle                                (rep : ef)        "
                     << "\n                                          (pour terminer tapez : fin (ou f))";
                rep = "";
                while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                 { cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
                   if (rep == "to")
                    // cas de toutes les grandeurs
                    {List_io<Ddl_enum_etendu>::iterator ite,itefin = tabelement_type_ddl(n_mail).end();
                     for (ite = tabelement_type_ddl(n_mail).begin();ite != itefin; ite++)
                       tabelement_type_ddl_retenu(n_mail).push_back(*ite);
                     }  
                   else if (Ddl_enum_etendu::VerifExistence(rep))
                     // on vérifie que cette grandeur existe 
                     // enregistrement
                     {  Ddl_enum_etendu a = Ddl_enum_etendu::RecupDdl_enum_etendu(rep);
                        (tabelement_type_ddl_retenu(n_mail)).push_back(a);
                        (tabelement_type_ddl_retenu(n_mail)).sort(); // on ordonne, pour qu'unique fonctionne
                        (tabelement_type_ddl_retenu(n_mail)).unique(); // supprime le doublon si nécessaire
                     }
                   else if (rep == "ef") 
                    { // on efface la liste
                      (tabelement_type_ddl_retenu(n_mail)).clear();
                     }
                   else if (((Minuscules(rep) == "fin") || (Minuscules(rep) == "f")) 
                         && ( (tabelement_type_ddl_retenu(n_mail)).size()==0))
                     { rep = "-"; cout << " \n *** ERREUR: vous devez definir au moins une grandeur a visualiser !!";} 
                   else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                    cout << " erreur de syntaxe dans le ddl! recommencez ";
                  }
                // maintenant si la liste de grandeur quelconque est vide on s'arrête sinon on choisit les éléments
                if ( (tabelement_type_ddl_retenu(n_mail)).size() != 0)
                     { Choix_element_a_retenir(n_mail,tabelement_type_ddl_retenu(n_mail)); }
                else
                     { cout << "\n aucune grandeur enregistree ! \n "; };     
                       
               } // -- fin de la boucle sur les maillages pour les éléments
       };
        
    // entrée du choix d'une grandeur particulières (diff des ddl génériques) aux éléments
void Choix_grandeurs_maple::Entree_grandeur_particuliere_aux_elements(string& rep)
  { // cas de grandeurs particulières aux éléments, on boucle sur les maillages
    int dim = ParaGlob::Dimension();
    // on récupère la liste des maillages à visualiser
    const list <int>& list_mail = choix_mail->List_choisit();
    list<int>::const_iterator ilm,ilmfin=list_mail.end();
    int taille_list_maille = list_mail.size();
    if (list_mail.size() == 0)
      { cout << "\n aucun maillage n'est definit ! , il faut commencer par definir les maillages pour"
             << " lesquels on veut une sortie ";
        return;
       };             
     // on balaie les différents maillages
     for (ilm = list_mail.begin();ilm!=ilmfin;ilm++)
      {int n_mail = abs(*ilm); // numéro du maillage 
       // dans le cas où aucune grandeur particulière sont défini on passe
       if ( (tabelement_typeParti(n_mail)).size() == 0)
        { cout << "\n aucune grandeur particuliere n'est definit, donc aucune proposition ";}
       else
        { // def d'une liste de travail, pour vérifier que tous les grandeurs particuliers sont relatives
          // à un même point d'intégration
          List_io < Ddl_enum_etendu > li_ddl; 
          // on affiche la liste actuelle
          if ((tabelement_typeParti_retenu(n_mail)).size())
                 { cout << "\n liste actuelle des element a sortir en info:   ";
                   List_io <int>::iterator ieint,ieintfin = tab_num_element(n_mail).end();
                   for (ieint=tab_num_element(n_mail).begin();ieint!=ieintfin;ieint++)
                     cout << (*ieint) << " ";
                   cout << "\n liste des grandeurs particulieres actuellement a sortir:   ";  
                   List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_typeParti_retenu(n_mail)).end();
                   for (iet=(tabelement_typeParti_retenu(n_mail)).begin();iet!=ietfin;iet++)
                     cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
                   cout << endl;  
                  }
          // on affiche les différentes grandeurs possibles
          cout << "\n maillage nb : " << n_mail ;
          cout << "\n la liste des grandeurs particulieres disponibles est la suivante : ";
          List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_typeParti(n_mail)).end();
          for (iet=(tabelement_typeParti(n_mail)).begin();iet!=ietfin;iet++)
                     cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
          cout << "\n";            
          cout << "\n grandeurs que vous voulez visualiser                         ( rep : grandeurs?)"
               << "\n REMARQUE : il faut donner uniquement un jeu de grandeurs                        "
               << "\n definies  au meme point d'integration                                           "
               << "\n effacer la liste actuelle                                    (rep : ef)         "
               << "\n toutes les grandeurs :                                       (rep : to)         "
               << "\n                                               (pour terminer tapez : fin (ou f))";
          rep = "";
          while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                 { cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
                   if (rep == "to")
                    // cas de toutes les grandeurs
                    {List_io<TypeQuelconque>& tpg_ret = (tabelement_typeParti_retenu(n_mail)); // pour simplifier
                     List_io<TypeQuelconque>& tpg = (tabelement_typeParti(n_mail)); // pour simplifier
                     List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
                     for (ite = tabelement_typeParti(n_mail).begin();ite != itefin; ite++)
                          if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
                            { tpg_ret.push_back(*ite);
                              // on enregistre également le ddl associé qui définit le point d'integ où est calculé la grandeur
                              // particulière
                              li_ddl.push_back(Ddl_enum_etendu((*ite).Enum()));
                             }; 
                     }  
                   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
                       List_io<TypeQuelconque>& tpg_ret = (tabelement_typeParti_retenu(n_mail)); // pour simplifier
                       List_io<TypeQuelconque>& tpg = (tabelement_typeParti(n_mail)); // 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);
                              // on enregistre également le ddl associé qui définit le point d'integ où est calculé la grandeur
                              // particulière
                              li_ddl.push_back(Ddl_enum_etendu((*il).Enum()));
                             }; 
                         }
                       else
                        { cout << "\n erreur, grandeur non disponible !, recommencez ";};
                     }
                   else if (rep == "ef") 
                    { // on efface la liste
                      (tabelement_typeParti_retenu(n_mail)).clear();
                     }
                   else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                    cout << " erreur de syntaxe  recommencez ";
                  };
          // maintenant si la liste de grandeur quelconque est vide on s'arrête sinon on choisit les éléments
          if ( (tabelement_typeParti_retenu(n_mail)).size() != 0)
               { cout << "\n liste des grandeurs particulieres enregistrees:   ";  
                 List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_typeParti_retenu(n_mail)).end();
                 for (iet=(tabelement_typeParti_retenu(n_mail)).begin();iet!=ietfin;iet++)
                     cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
                 cout << endl;  
                 Choix_element_a_retenir(n_mail,li_ddl); 
                }
          else
             { cout << "\n aucune grandeur enregistree ! \n "; };     
          }; //-- fin du choix sur le fait qu'il existe ou non des grandeurs particulières pour le maillage           
        }; //-- fin de la boucle sur les maillages          
   };
           
    // entrée du choix d'une grandeur évoluées (tensorielles) aux éléments
void Choix_grandeurs_maple::Entree_grandeur_tensorielle_aux_elements(string& rep)
  { // cas de grandeurs tensorielles aux éléments, on boucle sur les maillages
    int dim = ParaGlob::Dimension();
    // on récupère la liste des maillages à visualiser
    const list <int>& list_mail = choix_mail->List_choisit();
    list<int>::const_iterator ilm,ilmfin=list_mail.end();
    int taille_list_maille = list_mail.size();
    if (list_mail.size() == 0)
      { cout << "\n aucun maillage n'est definit ! , il faut commencer par definir les maillages pour"
             << " lesquels on veut une sortie ";
        return;
       };             
     // on balaie les différents maillages
     for (ilm = list_mail.begin();ilm!=ilmfin;ilm++)
      {int n_mail = abs(*ilm); // numéro du maillage 
       // dans le cas où aucune grandeur particulière sont défini on passe
       if ( (tabelement_evoluee(n_mail)).size() == 0)
        { cout << "\n aucune grandeur tensorielle n'est definit, donc aucune proposition ";}
       else
        { // def d'une liste de travail, pour vérifier que tous les grandeurs évoluées sont relatives
          // à un même point d'intégration
          List_io < Ddl_enum_etendu > li_ddl; 
          // on affiche la liste actuelle
          if ((tabelement_evoluee_retenu(n_mail)).size())
                 { cout << "\n liste actuelle des element a sortir en info:   ";
                   List_io <int>::iterator ieint,ieintfin = tab_num_element(n_mail).end();
                   for (ieint=tab_num_element(n_mail).begin();ieint!=ieintfin;ieint++)
                     cout << (*ieint) << " ";
                   cout << "\n liste des grandeurs tensorielles actuellement a sortir: (attention: peuvent ne pas etre definies)  ";
                   List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_evoluee_retenu(n_mail)).end();
                   for (iet=(tabelement_evoluee_retenu(n_mail)).begin();iet!=ietfin;iet++)
                     cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
                   cout << endl;  
                  }
          // on affiche les différentes grandeurs possibles
          cout << "\n maillage nb : " << n_mail ;
          cout << "\n la liste des grandeurs tensorielles disponibles est la suivante : (attention: peuvent ne pas etre definies)";
          List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_evoluee(n_mail)).end();
          for (iet=(tabelement_evoluee(n_mail)).begin();iet!=ietfin;iet++)
                  cout << "\n" <<  ((*iet).EnuTypeQuelconque().NomPlein()) ;
          cout << "\n";
          cout << "\n grandeurs que vous voulez visualiser                         ( rep : grandeurs?)"
               << "\n REMARQUE : il faut donner uniquement un jeu de grandeurs                        "
               << "\n defini      au meme point d'integration                                         "
               << "\n effacer la liste actuelle                                    (rep : ef)         "
               << "\n toutes les grandeurs :                                       (rep : to)         "
               << "\n                                               (pour terminer tapez : fin (ou f))";
          rep = "";
          while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                 { cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
                   if (rep == "to")
                    // cas de toutes les grandeurs
                    {List_io<TypeQuelconque>& tpg_ret = (tabelement_evoluee_retenu(n_mail)); // pour simplifier
                     List_io<TypeQuelconque>& tpg = (tabelement_evoluee(n_mail)); // pour simplifier
                     List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
                     for (ite = tabelement_evoluee(n_mail).begin();ite != itefin; ite++)
                          if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
                            { tpg_ret.push_back(*ite);
                              // on enregistre également le ddl associé qui définit le point d'integ où est calculé la grandeur
                              // évoluées
                              li_ddl.push_back(Ddl_enum_etendu((*ite).Enum()));
                             }; 
                     }  
                   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
                       List_io<TypeQuelconque>& tpg_ret = (tabelement_evoluee_retenu(n_mail)); // pour simplifier
                       List_io<TypeQuelconque>& tpg = (tabelement_evoluee(n_mail)); // 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);
                              // on enregistre également le ddl associé qui définit le point d'integ où est calculé la grandeur
                              // évoluées
                              li_ddl.push_back(Ddl_enum_etendu((*il).Enum()));
                             }; 
                         }
                       else
                        { cout << "\n erreur, grandeur non disponible !, recommencez ";};
                     }
                   else if (rep == "ef") 
                    { // on efface la liste
                      (tabelement_evoluee_retenu(n_mail)).clear();
                     }
                   else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                    cout << " erreur de syntaxe  recommencez ";
                  };
          // maintenant si la liste de grandeur quelconque est vide on s'arrête sinon on choisit les éléments
          if ( (tabelement_evoluee_retenu(n_mail)).size() != 0)
               { cout << "\n liste des grandeurs tensorielles enregistrees:   ";
                 List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_evoluee_retenu(n_mail)).end();
                 for (iet=(tabelement_evoluee_retenu(n_mail)).begin();iet!=ietfin;iet++)
                     cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
                 cout << endl;  
                 Choix_element_a_retenir(n_mail,li_ddl); 
                }
          else
             { cout << "\n aucune grandeur enregistree ! \n "; };     
          }; //-- fin du choix sur le fait qu'il existe ou non des grandeurs évoluées pour le maillage
        }; //-- fin de la boucle sur les maillages          
   };
   
// entrée du choix d'une grandeur quelconque aux faces d'éléments
void Choix_grandeurs_maple::Entree_grandeur_quelconque_aux_faces_element(string& rep)
{ // cas de grandeurs quelconques aux faces des éléments, on boucle sur les maillages
  int dim = ParaGlob::Dimension();
  // on récupère la liste des maillages à visualiser
  const list <int>& list_mail = choix_mail->List_choisit();
  list<int>::const_iterator ilm,ilmfin=list_mail.end();
  int taille_list_maille = list_mail.size();
  if (list_mail.size() == 0)
    { cout << "\n aucun maillage n'est definit ! , il faut commencer par definir les maillages pour"
           << " lesquels on veut une sortie ";
      return;
    };
  // on balaie les différents maillages
  for (ilm = list_mail.begin();ilm!=ilmfin;ilm++)
    {int n_mail = abs(*ilm); // numéro du maillage
     // dans le cas où aucune grandeur particulière sont défini on passe
     if ( (tab_F_element_TypeQuelconque(n_mail)).size() == 0)
      { cout << "\n aucune grandeur quelconque n'est definit aux faces d'element, donc aucune proposition ";}
     else
      { // def de la liste de travail qui contient les grandeurs à visualiser,
        // sert également pour vérifier que tous les grandeurs quelconques sont relatives
        // à un même point d'intégration
        List_io < EnumTypeQuelconque > li_enu_quelconque;
        // on affiche la liste actuelle
        if ((tab_F_element_TypeQuelconque_retenu(n_mail)).size())
               { cout << "\n liste actuelle des faces element a sortir en info: < (num_ele, num_face) > ";
                 List_io <int>::iterator ieint,ieintfin = tab_num_F_element(n_mail).end();
                 List_io <int>::iterator ifint = tab_num_F(n_mail).begin();
                 for (ieint=tab_num_F_element(n_mail).begin();ieint!=ieintfin;ieint++,ifint++)
                   cout << " (" << (*ieint) << ", "<<(*ifint)<<") ";
                 cout << "\n liste des grandeurs quelconques actuellement a sortir:   ";
                 List_io < TypeQuelconque >::iterator iet,ietfin = (tab_F_element_TypeQuelconque_retenu(n_mail)).end();
                 for (iet=(tab_F_element_TypeQuelconque_retenu(n_mail)).begin();iet!=ietfin;iet++)
                   cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
                 cout << endl;
                }
        // on affiche les différentes grandeurs possibles
        cout << "\n maillage nb : " << n_mail ;
        cout << "\n la liste des grandeurs quelconque disponibles aux faces d'element est la suivante : ";
        {List_io < TypeQuelconque >::iterator iet,ietfin = (tab_F_element_TypeQuelconque(n_mail)).end();
         for (iet=(tab_F_element_TypeQuelconque(n_mail)).begin();iet!=ietfin;iet++)
                   cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
        }
        cout << "\n";
        cout << "\n grandeurs que vous voulez visualiser                         ( rep : grandeurs?)"
             << "\n REMARQUE : il faut donner uniquement un jeu de grandeurs                        "
             << "\n definies  au meme point d'integration                                           "
             << "\n effacer la liste actuelle                                    (rep : ef)         "
             << "\n toutes les grandeurs :                                       (rep : to)         "
             << "\n                                               (pour terminer tapez : fin (ou f))";
        rep = "";
        while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
               { cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
                 if (rep == "to")
                  // cas de toutes les grandeurs
                  {List_io<TypeQuelconque>& tpg_ret = (tab_F_element_TypeQuelconque_retenu(n_mail)); // pour simplifier
                   List_io<TypeQuelconque>& tpg = (tab_F_element_TypeQuelconque(n_mail)); // pour simplifier
                   List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
                   for (ite = tab_F_element_TypeQuelconque(n_mail).begin();ite != itefin; ite++)
                        if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
                          { tpg_ret.push_back(*ite);
                            // on enregistre également l'enum quelconque associé qui définit le point d'integ où est calculé la grandeur
                            li_enu_quelconque.push_back((*ite).EnuTypeQuelconque().EnumTQ());
                          };
                  }
                 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
                     List_io<TypeQuelconque>& tpg_ret = (tab_F_element_TypeQuelconque_retenu(n_mail)); // pour simplifier
                     List_io<TypeQuelconque>& tpg = (tab_F_element_TypeQuelconque(n_mail)); // 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);
                            // on enregistre également l'enum quelconque associé qui définit le point d'integ où est calculé la grandeur
                            li_enu_quelconque.push_back((*il).EnuTypeQuelconque().EnumTQ());
                           };
                       }
                     else
                      { cout << "\n erreur, grandeur non disponible !, recommencez ";};
                   }
                 else if (rep == "ef")
                  { // on efface la liste
                    (tab_F_element_TypeQuelconque_retenu(n_mail)).clear();
                   }
                 else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                  cout << " erreur de syntaxe  recommencez ";
                };
        // maintenant si la liste de grandeur quelconque est vide on s'arrête sinon on choisit les faces d'élément
        if ( (tab_F_element_TypeQuelconque_retenu(n_mail)).size() != 0)
             { cout << "\n liste des grandeurs particulieres enregistrees:   ";
               List_io < TypeQuelconque >::iterator iet,ietfin = (tab_F_element_TypeQuelconque_retenu(n_mail)).end();
               for (iet=(tab_F_element_TypeQuelconque_retenu(n_mail)).begin();iet!=ietfin;iet++)
                   cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
               cout << endl;
               Choix_faces_element_a_retenir(n_mail,li_enu_quelconque);
              }
        else
           { cout << "\n aucune grandeur enregistree ! \n "; };
        }; //-- fin du choix sur le fait qu'il existe ou non des grandeurs particulières pour le maillage
      }; //-- fin de la boucle sur les maillages
 };

// entrée du choix d'une grandeur quelconque aux arêtes d'éléments
void Choix_grandeurs_maple::Entree_grandeur_quelconque_aux_aretes_element(string& rep)
{ // cas de grandeurs quelconques aux arêtes des éléments, on boucle sur les maillages
 int dim = ParaGlob::Dimension();
 // on récupère la liste des maillages à visualiser
 const list <int>& list_mail = choix_mail->List_choisit();
 list<int>::const_iterator ilm,ilmfin=list_mail.end();
 int taille_list_maille = list_mail.size();
 if (list_mail.size() == 0)
   { cout << "\n aucun maillage n'est definit ! , il faut commencer par definir les maillages pour"
          << " lesquels on veut une sortie ";
     return;
   };
 // on balaie les différents maillages
 for (ilm = list_mail.begin();ilm!=ilmfin;ilm++)
   {int n_mail = abs(*ilm); // numéro du maillage
    // dans le cas où aucune grandeur particulière sont défini on passe
    if ( (tab_A_element_TypeQuelconque(n_mail)).size() == 0)
     { cout << "\n aucune grandeur quelconque n'est definit aux aretes d'element, donc aucune proposition ";}
    else
     { // def de la liste de travail qui contient les grandeurs à visualiser,
       // sert également pour vérifier que tous les grandeurs quelconques sont relatives
       // à un même point d'intégration
       List_io < EnumTypeQuelconque > li_enu_quelconque;
       // on affiche la liste actuelle
       if ((tab_A_element_TypeQuelconque_retenu(n_mail)).size())
              { cout << "\n liste actuelle des aretes element a sortir en info: < (num_ele, num_arete) > ";
                List_io <int>::iterator ieint,ieintfin = tab_num_A_element(n_mail).end();
                List_io <int>::iterator ifint = tab_num_A(n_mail).begin();
                for (ieint=tab_num_A_element(n_mail).begin();ieint!=ieintfin;ieint++,ifint++)
                  cout << " (" << (*ieint) << ", "<<(*ifint)<<") ";
                cout << "\n liste des grandeurs quelconques actuellement a sortir:   ";
                List_io < TypeQuelconque >::iterator iet,ietfin = (tab_A_element_TypeQuelconque_retenu(n_mail)).end();
                for (iet=(tab_A_element_TypeQuelconque_retenu(n_mail)).begin();iet!=ietfin;iet++)
                  cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
                cout << endl;
               }
       // on affiche les différentes grandeurs possibles
       cout << "\n maillage nb : " << n_mail ;
       cout << "\n la liste des grandeurs quelconque disponibles aux aretes d'element est la suivante : ";
       List_io < TypeQuelconque >::iterator iet,ietfin = (tab_A_element_TypeQuelconque(n_mail)).end();
       for (iet=(tab_A_element_TypeQuelconque(n_mail)).begin();iet!=ietfin;iet++)
                  cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
       cout << "\n";
       cout << "\n grandeurs que vous voulez visualiser                         ( rep : grandeurs?)"
            << "\n REMARQUE : il faut donner uniquement un jeu de grandeurs                        "
            << "\n definies  au meme point d'integration                                           "
            << "\n effacer la liste actuelle                                    (rep : ef)         "
            << "\n toutes les grandeurs :                                       (rep : to)         "
            << "\n                                               (pour terminer tapez : fin (ou f))";
       rep = "";
       while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
              { cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
                if (rep == "to")
                 // cas de toutes les grandeurs
                 {List_io<TypeQuelconque>& tpg_ret = (tab_A_element_TypeQuelconque_retenu(n_mail)); // pour simplifier
                  List_io<TypeQuelconque>& tpg = (tab_A_element_TypeQuelconque(n_mail)); // pour simplifier
                  List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
                  for (ite = tab_A_element_TypeQuelconque(n_mail).begin();ite != itefin; ite++)
                       if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
                         { tpg_ret.push_back(*ite);
                           // on enregistre également l'enum quelconque associé qui définit le point d'integ où est calculé la grandeur
                           li_enu_quelconque.push_back((*ite).EnuTypeQuelconque().EnumTQ());
                         };
                 }
                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
                    List_io<TypeQuelconque>& tpg_ret = (tab_A_element_TypeQuelconque_retenu(n_mail)); // pour simplifier
                    List_io<TypeQuelconque>& tpg = (tab_A_element_TypeQuelconque(n_mail)); // 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);
                           // on enregistre également l'enum quelconque associé qui définit le point d'integ où est calculé la grandeur
                           li_enu_quelconque.push_back((*il).EnuTypeQuelconque().EnumTQ());
                          };
                      }
                    else
                     { cout << "\n erreur, grandeur non disponible !, recommencez ";};
                  }
                else if (rep == "ef")
                 { // on efface la liste
                   (tab_A_element_TypeQuelconque_retenu(n_mail)).clear();
                  }
                else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                 cout << " erreur de syntaxe  recommencez ";
               };
       // maintenant si la liste de grandeur quelconque est vide on s'arrête sinon on choisit les arêtes élément
       if ( (tab_A_element_TypeQuelconque_retenu(n_mail)).size() != 0)
            { cout << "\n liste des grandeurs particulieres enregistrees:   ";
              List_io < TypeQuelconque >::iterator iet,ietfin = (tab_A_element_TypeQuelconque_retenu(n_mail)).end();
              for (iet=(tab_A_element_TypeQuelconque_retenu(n_mail)).begin();iet!=ietfin;iet++)
                  cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
              cout << endl;
              Choix_aretes_element_a_retenir(n_mail,li_enu_quelconque);
             }
       else
          { cout << "\n aucune grandeur enregistree ! \n "; };
       }; //-- fin du choix sur le fait qu'il existe ou non des grandeurs particulières pour le maillage
     }; //-- fin de la boucle sur les maillages
};

// choix des éléments
void Choix_grandeurs_maple::Choix_element_a_retenir(int n_mail,List_io < Ddl_enum_etendu >& li_ddl)
{ 
   // def de grandeur globale
   int dim = ParaGlob::Dimension();
   // on récupère la liste des maillages à visualiser
   const list <int>& list_mail = choix_mail->List_choisit();
   list<int>::const_iterator ilm,ilmfin=list_mail.end();
   int taille_list_maille = list_mail.size();

   // choix du ou des elements, on affiche la liste actuelle si elle est non nulle
   if (tab_num_element(n_mail).size())
     {cout << "\n liste actuelle des element:   ";
      List_io <int>::iterator ieint,ieintfin = tab_num_element(n_mail).end();
      for (ieint=tab_num_element(n_mail).begin();ieint!=ieintfin;ieint++)
                      cout << *ieint << " ";
      };
   cout <<endl;  
   // cas des références d'éléments  
   if ((nomDeRef_E(n_mail)).size() != 0)
                  { cout << "\n liste actuelle de reference d'elements:  (ref et num integ) ";
                    List_io <BlocScal >::iterator ieint1,ieintfin1 = (nomDeRef_E(n_mail)).end();
                    for (ieint1=(nomDeRef_E(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
                      cout << (*ieint1).NomRef() << " "<< (int) ((*ieint1).Val()) << " ";
                    cout << endl;  
                   }
   // cas des références de point d'intégration d'éléments  
   if ((nomDeRef_ptinteg(n_mail)).size() != 0)
                  { cout << "\n liste actuelle de reference de pt d'integration d'elements:  (ref) ";
                    List_io <string >::iterator ieint1,ieintfin1 = (nomDeRef_ptinteg(n_mail)).end();
                    for (ieint1=(nomDeRef_ptinteg(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
                      cout << (*ieint1) << " ";
                    cout << endl;  
                   }
   cout              << "\n choix de la position sur le ou les elements ou l'on veut la visualisation        "
                     << "\n le reperage  peut se faire de differentes manieres :                              "
                     << "\n par un  numero d'element dans le maillage + un ou plusieurs                       "
                     << "\n numero(s)  de pt d'integration (au sens classique)                  -> (choix : 1)"
                     << "\n par des coordonnees d'un point (interne !!), meme approximatives                  "
                     << "\n la grandeur affichee sera a un point le plus proche ou elle existe  -> (choix : 2)"
                     << "\n par une reference de liste d'element (avec 1 ou tous les pti)       -> (choix : 3)"
                     << "\n (dans ce dernier cas il faut que tous les elements soient de meme type)           "
                     << "\n par une reference de liste de point d'integration d'element         -> (choix : 4)"
                     << "\n donnez le type de choix puis les infos correspondantes                            "
                     << "\n effacer la liste actuelle                                           ->  (rep : ef) "
                     << "\n effacer la liste actuelle des references d'elements                 ->  (rep : efref) " 
                     << "\n afficher la liste des references d'elements existants               ->  (rep : affref) "                    
                     << "\n effacer la liste actuelle des references de pt integ d'element      ->  (rep : efrefpti) " 
                     << "\n afficher la liste des references de pt integ d'elements existants   ->  (rep : affrefpti) "                    
                     << "\n                                                             (tapez fin pour finir(ou f))";
   string rep = "";
   // -- début boucle choix position sur element
   while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f")) 
         { cout << "\n choix ? ";rep = lect_return_defaut(false,"f");
           if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f")) break;
           // def du conteneur des numéros que l'on cherche
           // comme on peut en définir plusieurs d'un coup (par exemple tous les pti d'un élément) on utilise une liste
           list <Maillage::NBelemEtptInteg> list_nut; // à chaque passage elle est initialisée et donc vide au début
           Maillage::NBelemEtptInteg nut; // idem, initialisé à chaque passage
           bool verif = true; // pour la vérification des numéros
           if (rep == "1")
             { cout << " numero d'element ? "; rep = lect_chaine(); nut.nbElem = ChangeEntier(rep);
               cout << " numero du point d'integration (ou -1 pour tous les pti de l'element) ? ";
               rep = lect_chaine(); nut.nbPtInteg = ChangeEntier(rep);
               if (nut.nbPtInteg != -1)
                {list_nut.push_back(nut);} // cas d'un seul pti
               else // cas de tous les pti
                {// on commence par tester si l'élément existe vraiment
                 if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
                  {if (nut.nbElem < 0)
                     { cout << "\n le numero d'element doit etre superieur a 0 !!!";verif = false;};
                   if (nut.nbElem > lesMail->Nombre_element(n_mail))
                     { cout << "\n chois non valide, le numero d'element doit etre inferieur ou egal"
                            << "   au nombre total d'element du maillage !!!";verif = false;
                     };
                  }
                 else // sinon c'est ok, on continue au niveau des pti
                  {Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
                   // maintenant on va vérifier que tous les ddl correspondent aux mêmes nombre de pti
                   // on récupère le nb de pti pour le premier ddl retenu
                   List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
                   ite = li_ddl.begin();
                   int nbpti = 0; // init
                   bool veriflocal = true;
                   if (ite == li_ddl.end()) {veriflocal = false;} // la liste est vide on ne peut pas aller plus loin
                   else
                    {nbpti = ele.NbPtInteg((*ite).Enum());
                     for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
                       // boucle sur les ddl retenus
                       for (ite = li_ddl.begin();ite != itefin; ite++)
                        { // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                          if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                           { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                  << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                  << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                             cout << "\n une raison possible est qu'il y a des elements avec un nombre different de "
                                  << "points d'integration : cas non permis actuellement (se plaindre !! ) ";
                             veriflocal = false;
                           };
                        }; //-- fin de la boucle sur les ddl retenus
                    };
                   
                   // si tout est ok arrivée ici on enregistre
                   if (veriflocal)
                    { for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
                        list_nut.push_back(nut);
                    }
                   else // sinon on averti que c'est mauvais
                    {verif = false;};
                  };
                };
             }
           else if (rep == "2")
             { Coordonnee xi(dim);
               cout << "\n coordonnee ("<<dim<<" nombre(s)) ? ";
               for(int j=1;j<=dim;j++) cin >> xi(j); 
               std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
               cout << "\n les coordonnees sont a:  t = 0 ou t ou tdt (repondre 0 ou t ou tdt) ? ";
               rep = lect_chaine();
               bool rep_exploitable = true; Enum_dure enu_temps;
               if (rep == "0")
                  enu_temps = TEMPS_0;
               else if (rep == "t")   
                  enu_temps = TEMPS_t;
               else if (rep == "tdt") 
                   enu_temps = TEMPS_tdt;
               else
                 { cout << "\n erreur de syntaxe, on attendait 0 t ou tdt ";verif = false;
                   rep_exploitable = false;
                 };
               if (rep_exploitable)    
                 {nut = lesMail->Element_le_plus_proche(enu_temps,li_ddl,xi,n_mail);
                  if (nut.nbElem == 0) // cas où l'on ne trouve pas d'élément
                   { cout << "\n pas d'element qui contiend ce point, pour les ddl et le temps " 
                          << rep << "  recommencez ! "; verif = false; 
                    }
                  else if ( nut.nbPtInteg < 0)
                   { cout << "\n il n'est pas possible de trouver un seul point d'integration pour "
                          << " tous les ddl que vous avez choisi, le mieux est de recommencer avec "
                          << " des ddl de meme type c-a-d par exemple contrainte ou erreur, mais "
                          << " pas les deux en meme temps car ils n'utilisent pas le meme systeme de "
                          << " points d'integration !! ";
                          verif = false;
                   }
                  else  
                   { cout << "\n element contenant le point nb= " << nut.nbElem 
                          << " et le numero d'ordre le plus proche " 
                          << nut.nbPtInteg << " de coordonnee a t: " ;
                     List_io<Ddl_enum_etendu>::iterator ienu=li_ddl.begin();
                     bool erreur=false; // ici on n'en tiend pas compte car déjà testé     
                     Coordonnee ncor = 
                         lesMail->Element_LesMaille(n_mail,nut.nbElem).CoordPtInteg
                                                                       (TEMPS_t,(*ienu).Enum(),nut.nbPtInteg,erreur);
                     for (int ic=1;ic<=ncor.Dimension();ic++) cout <<  ncor(ic) << " ";
                     // le choix est a priori ok, on enregistre
                     list_nut.push_back(nut);
                   };
                 };
             }
           else if (rep == "3")
             { string nom_ref;
               cout << "\n nom de la reference ? ";
               nom_ref= lect_chaine();
               // vérif que la référence existe
               if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 2))
                 { cout << "\n erreur de nom (** "<< nom_ref << " **)  donne ne correspond pas a une reference d'element correcte ";}
               else 
                 { // choix du point d'intégration, ici on ne va pas utiliser la liste list_nut, mais une liste particulière
                   string repo;
                   cout << " numero d'un point d'integration ou: -1 pour tous les pti ? ";
                   repo = lect_chaine(); nut.nbPtInteg = ChangeEntier(repo);
                   if (nut.nbPtInteg != -1) // cas d'un seul pti
                    {// on vérifie que ce point d'intégration est valide pour tous les éléments de la référence
                     bool veriflocal = true;
                     List_io <BlocScal >::iterator idl,idlfin= nomDeRef_E(n_mail).end();
                     List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
                     // boucle sur les ddl retenus
                     for (ite = li_ddl.begin();ite != itefin; ite++)
                      { // recup de la reference correspondant au mot cle
                        const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                        const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
                        int taillen=reff.Taille(); // nombre d'éléments dans la référence
                        for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                         { nut.nbElem = reff.Numero(ielem);
                           // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                           if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                            { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                   << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                   << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                              veriflocal = false;
                             };
                          } //-- fin de la boucle sur les éléments de la référence   
                      }; //-- fin de la boucle sur les ddl retenus
                     // on enregistre si la vérification a été ok
                     if (veriflocal)
                       { nomDeRef_E(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
                         nomDeRef_E(n_mail).sort(); // on ordonne
                         nomDeRef_E(n_mail).unique();// on supprime les doublons 
                       };
                    }
                   else  // cas de tous les pti
                    { // il faut d'abord que l'on vérifie que tous les pti pour tous les éléments sont valides
                      // .. on commence par tester si un premier élément existe vraiment et si oui, on récupère le nb de pti associé
                      bool veriflocal = true;
                      int nbpti = 0; // init
                      { // on encapsule pour pas de redondance de nom
                        const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                        const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
                        int taillen=reff.Taille(); // nombre d'éléments dans la référence
                        if (taillen < 1) {veriflocal = false;} // cas d'une ref vide, on ne peut pas aller plus loin
                        else
                         {nut.nbElem = reff.Numero(1);
                          if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
                           {if (nut.nbElem < 0)
                              { cout << "\n le numero d'element doit etre superieur a 0 !!!";verif = false;};
                            if (nut.nbElem > lesMail->Nombre_element(n_mail))
                              { cout << "\n chois non valide, le numero d'element doit etre inferieur ou egal "
                                     << "   au nombre total d'element du maillage !!!";verif = false;
                              };
                           }
                          else // sinon c'est ok, on continue au niveau des pti
                           {Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
                            List_io<Ddl_enum_etendu>::iterator ite = li_ddl.begin();
                            if (ite == li_ddl.end()) {veriflocal = false;} // la liste est vide on ne peut pas aller plus loin
                            else {nbpti = ele.NbPtInteg((*ite).Enum());};
                           };
                         };
                      };
                      // .. puis on balaie l'ensemble des éléments et l'ensemble des pti
                      if (veriflocal)
                        {List_io <BlocScal >::iterator idl,idlfin= nomDeRef_E(n_mail).end();
                         List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
                         // boucle sur les ddl retenus
                         for (ite = li_ddl.begin();ite != itefin; ite++)
                          { // recup de la reference correspondant au mot cle
                            const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                            const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
                            int taillen=reff.Taille(); // nombre d'éléments dans la référence
                            for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                             { nut.nbElem = reff.Numero(ielem);
                               for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
                                 // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                                 if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                                  { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                         << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                         << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                                    veriflocal = false;
                                    break;
                                  };
                                if (!veriflocal) break;
                              } //-- fin de la boucle sur les éléments de la référence   
                            if (!veriflocal) break;
                          }; //-- fin de la boucle sur les ddl retenus
                        };
                      // arrivée ici, si tout est ok on enregistre
                      if (veriflocal)
                        for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
                          { nomDeRef_E(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
                            nomDeRef_E(n_mail).sort(); // on ordonne
                            nomDeRef_E(n_mail).unique();// on supprime les doublons 
                          };
                    };
                 }; // fin du choix du point d'intégration et de l'enregistrement
               verif = false; // pour ne pas enregistrer de numéro dans la liste directe d'element car ici c'est 
                              // la liste de référence de référence d'éléments qui est en cause       
             }
           else if (rep == "4")
             { string nom_ref;
               cout << "\n nom de la reference ? ";nom_ref= lect_chaine();
               // vérif que la référence existe
               if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 6))
                 { cout << "\n erreur de nom (** "<< nom_ref << " **)  donne ne correspond pas a une reference de point d'integration "
                        << " d'element correcte ";}
               else 
                 { // on vérifie que le choix est valide 
                   bool veriflocal = true;
                   List_io <string >::iterator idl,idlfin= nomDeRef_ptinteg(n_mail).end();
                   List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
                   // boucle sur les ddl retenus
                   for (ite = li_ddl.begin();ite != itefin; ite++)
                    { // recup de la reference correspondant au mot cle
                      const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                      const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'élément
                      int taillen=reff.Taille(); // nombre d'éléments dans la référence
                      for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                       { nut.nbElem = reff.NumeroElem(ielem);
                         nut.nbPtInteg = reff.NumeroFA(ielem);
                         // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                         if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                          { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                 << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                 << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                            veriflocal = false;
                           };
                        } //-- fin de la boucle sur les éléments de la référence   
                     } //-- fin de la boucle sur les ddl retenus 
                   // on enregistre si la vérification a été ok
                   if (veriflocal)
                     { nomDeRef_ptinteg(n_mail).push_back(nom_ref);
                       nomDeRef_ptinteg(n_mail).sort(); // on ordonne
                       nomDeRef_ptinteg(n_mail).unique();// on supprime les doublons 
                     };
                 }; // fin du choix du point d'intégration et de l'enregistrement
               verif = false; // pour ne pas enregistrer de numéro dans la liste directe d'element car ici c'est 
                              // la liste de référence de référence d'éléments qui est en cause       
              }    
           else if (rep == "ef")
            { // on efface les deux listes
              (tab_num_element(n_mail)).clear();                                                                 
              (tab_num_integ(n_mail)).clear();
              verif = false;                                                                 
            }
           else if (rep == "efref") 
            { // on efface la liste des références d'éléments et la liste de pt d'integ associée
              (nomDeRef_E(n_mail)).clear(); 
              verif = false;                                                                
            }
           else if (rep == "affref") 
            { // affichage de la liste des références d'éléments enregistrées dans les maillages
              cout << "\n liste des references d'elements ";
              if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
              const Reference* reff =NULL; bool prempass = true;
              do { 
                 if (prempass)
                   { reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
                 else
                   { reff = lesRef->Reference_suivante();} // récup de la ref courante  
                 // sortie de la ref si c'est le bon maillage, et si c'est une ref d'élément
                 if (reff != NULL)
                    if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 2)) cout << reff->Nom() << " ";
                 prempass = false; 
                  } while (reff != NULL);
               verif = false;    
            }
           else if (rep == "efrefpti") 
            { // on efface la liste des références de pt d'integ d'éléments 
              (nomDeRef_ptinteg(n_mail)).clear(); 
              verif = false;                                                                
            }
           else if (rep == "affrefpti")
            { // affichage de la liste des références de pti enregistrées dans les maillages
              cout << "\n liste des references de pt integ d'elements ";
              if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
              const Reference* reff =NULL; bool prempass = true;
              do { 
                 if (prempass)
                   { reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
                 else
                   { reff = lesRef->Reference_suivante();} // récup de la ref courante  
                 // sortie de la ref si c'est le bon maillage, et si c'est une ref d'élément
                 if (reff != NULL)
                    if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 6)) cout << reff->Nom() << " ";
                 prempass = false; 
                  } while (reff != NULL);
               verif = false;    
            }
           else
            { cout << "\n reponse non valide, recommencez " << endl;
            };
           // vérification des numéros d'éléments
           if (verif)
            { // on balaie les numéros de la liste
              list <Maillage::NBelemEtptInteg>::iterator i_list_nut,i_list_nut_fin = list_nut.end();
              for (i_list_nut=list_nut.begin();i_list_nut != i_list_nut_fin;i_list_nut++)
               { nut = (*i_list_nut); // par simplicité
                 if (nut.nbElem < 0)
                   { cout << "\n le numero d'element doit etre superieur a 0 !!!";verif = false;};   
                  if (nut.nbElem > lesMail->Nombre_element(n_mail))
                   { cout << "\n chois non valide, le numero d'element doit etre inferieur ou egal"
                          << "   au nombre total d'element du maillage !!!";verif = false;
                    };
               };
            };
           // .. vérification des numéros de pti
           //   tout d'abord les numéros négatifs
           if (verif)   
            { // on balaie les numéros de la liste
              list <Maillage::NBelemEtptInteg>::iterator i_list_nut,i_list_nut_fin = list_nut.end();
              for (i_list_nut=list_nut.begin();i_list_nut != i_list_nut_fin;i_list_nut++)
               { nut = (*i_list_nut); // par simplicité
                 if (nut.nbPtInteg < 0)
                  { cout << "\n le numero du point d'integration doit etre superieur a 0 !!!";verif = false;};
               };
            };
           //  puis vérif que le pt d'integ existe
           // on récupère l'élément géométrique qui correspond aux ddl
           if (verif)   
            { // on balaie les numéros de la liste
              list <Maillage::NBelemEtptInteg>::iterator i_list_nut,i_list_nut_fin = list_nut.end();
              for (i_list_nut=list_nut.begin();i_list_nut != i_list_nut_fin;i_list_nut++)
               { nut = (*i_list_nut); // par simplicité
                 List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
                 for (ite = li_ddl.begin();ite != itefin; ite++)
                   { // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                     if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                       { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                              << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                              << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                         verif = false;
                       };
                   };
               };
            };
           // enregistrement si tout est ok       
           if ((verif)&&((Minuscules(rep) != "fin") && (Minuscules(rep) != "f")))  
              { // on balaie les numéros de la liste
                list <Maillage::NBelemEtptInteg>::iterator i_list_nut,i_list_nut_fin = list_nut.end();
                for (i_list_nut=list_nut.begin();i_list_nut != i_list_nut_fin;i_list_nut++)
                 { nut = (*i_list_nut); // par simplicité
                   // si le groupe (élément, nb  point d'intégration) n'est pas actuellement enregistré, on l'enregistre
                   // on boucle sur les datas déjà enregistrés
                   bool a_enregistrer=true;
                   List_io <int>::iterator ilelem,ilinteg,ilelemfin=tab_num_element(n_mail).end();
                   ilinteg = tab_num_integ(n_mail).begin();
                   for (ilelem=tab_num_element(n_mail).begin();ilelem != ilelemfin;ilelem++,ilinteg++)
                     if ((nut.nbElem==(*ilelem))&&(nut.nbPtInteg==(*ilinteg)))
                        a_enregistrer = false;
                   if (a_enregistrer)  
                      { tab_num_element(n_mail).push_back(nut.nbElem);
                        tab_num_integ(n_mail).push_back(nut.nbPtInteg);
                      };
                 };
   //             if (  (find(tab_num_element(n_mail).begin(),tab_num_element(n_mail).end(),nut.nbElem)
   //                    == tab_num_element(n_mail).end())
   //                && (find(tab_num_integ(n_mail).begin(),tab_num_integ(n_mail).end(),nut.nbPtInteg) 
   //                    == tab_num_integ(n_mail).end()))    
   //                { tab_num_element(n_mail).push_back(nut.nbElem);
   //                  tab_num_integ(n_mail).push_back(nut.nbPtInteg);
   //                 }; 
              };
         };  // -- fin boucle choix position sur element

 };
// choix des faces d'éléments
void Choix_grandeurs_maple::Choix_faces_element_a_retenir(int n_mail,List_io < EnumTypeQuelconque >& li_enu_quelc)
{
  // def de grandeur globale
  int dim = ParaGlob::Dimension();
  // on récupère la liste des maillages à visualiser
  const list <int>& list_mail = choix_mail->List_choisit();
  list<int>::const_iterator ilm,ilmfin=list_mail.end();
  int taille_list_maille = list_mail.size();

  // choix du ou des faces d'elements, on affiche la liste actuelle si elle est non nulle
  if (tab_num_F_element(n_mail).size())
    { cout << "\n liste actuelle des faces element a sortir en info: < (num_ele, num_face) > ";
      List_io <int>::iterator ieint,ieintfin = tab_num_F_element(n_mail).end();
      List_io <int>::iterator ifint = tab_num_F(n_mail).begin();
      for (ieint=tab_num_F_element(n_mail).begin();ieint!=ieintfin;ieint++,ifint++)
        cout << " (" << (*ieint) << ", "<<(*ifint)<<") ";
      cout << endl;
     }
  // cas des références de faces d'élément
  if ((nomDeRef_F_E(n_mail)).size() != 0)
     { cout << "\n liste actuelle de reference de faces d'element:  (ref et num integ) ";
       List_io <BlocScal >::iterator ieint1,ieintfin1 = (nomDeRef_F_E(n_mail)).end();
       for (ieint1=(nomDeRef_F_E(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
         cout << (*ieint1).NomRef() << " "<< (int) ((*ieint1).Val()) << " ";
       cout << endl;
     };
  // cas des références de point d'intégration de faces d'élément
  if ((nomDeRef_F_ptinteg(n_mail)).size() != 0)
     { cout << "\n liste actuelle de reference de pt d'integration de faces d'element:  (ref) ";
       List_io <string >::iterator ieint1,ieintfin1 = (nomDeRef_F_ptinteg(n_mail)).end();
       for (ieint1=(nomDeRef_F_ptinteg(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
         cout << (*ieint1) << " ";
       cout << endl;
     };
  cout              << "\n --- choix de la position sur le ou les faces ou l'on veut la visualisation     "
                    << "\n le reperage  peut se faire de differentes manieres :                              "
                    << "\n par 2 numeros (element, face) dans le maillage + un ou plusieurs                  "
                    << "\n numero(s)  de pt d'integration (au sens classique)                      -> (choix : 1)"
//                    << "\n par des coordonnees d'un point (interne !!), meme approximatives                  "
//                    << "\n la grandeur affichee sera a un point le plus proche ou elle existe      -> (choix : 2)"
                    << "\n par une reference de liste de faces d'element (avec 1 ou tous les pti)  -> (choix : 3)"
                    << "\n (dans ce dernier cas il faut que toutes les faces soient de meme type)  "
                    << "\n par une reference de liste de point d'integration de faces d'element    -> (choix : 4)"
                    << "\n ---> donnez le type de choix puis les infos correspondantes <---        "
                    << "\n effacer la liste actuelle de faces d'element                            ->  (rep : efF) "
                    << "\n effacer la liste actuelle des references de faces d'element             ->  (rep : efrefF) "
                    << "\n afficher la liste des references de faces d'element existantes          ->  (rep : affrefF) "
                    << "\n effacer la liste actuelle des references de pti de faces d'element      ->  (rep : efrefFpti) "
                    << "\n afficher la liste des references de pti de faces d'element existantes   ->  (rep : affrefFpti) "
                    << "\n                                                             (tapez fin pour finir(ou f))";
  string rep = "";
  // -- début boucle choix
  while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
    { cout << "\n choix ? ";rep = lect_return_defaut(false,"f");
      if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f")) break;
      // def du conteneur des numéros que l'on cherche
      // comme on peut en définir plusieurs d'un coup (par exemple tous les pti d'une face) on utilise une liste
      list <Maillage::NBelemFAEtptInteg> list_nut; // à chaque passage elle est initialisée et donc vide au début
      Maillage::NBelemFAEtptInteg nut; // idem, initialisé à chaque passage
      bool verif = true; // pour la vérification des numéros
      if (rep == "1")
        { cout << " numero d'element ? "; rep = lect_chaine(); nut.nbElem = ChangeEntier(rep);
          cout << " numero de face ? "; rep = lect_chaine(); nut.nbFA = ChangeEntier(rep);
          cout << " numero du point d'integration (ou -1 pour tous les pti de l'element) ? ";
          rep = lect_chaine(); nut.nbPtInteg = ChangeEntier(rep);
          if (nut.nbPtInteg != -1)
           {list_nut.push_back(nut);} // cas d'un seul pti
          else // cas de tous les pti
           {// on commence par tester si l'élément existe vraiment
            if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
             {if (nut.nbElem < 0)
                { cout << "\n le numero d'element doit etre superieur a 0 !!!";verif = false;};
              if (nut.nbElem > lesMail->Nombre_element(n_mail))
                { cout << "\n chois non valide, le numero d'element doit etre inferieur ou egal"
                       << "   au nombre total d'element du maillage !!!";verif = false;
                };
             }
            else // sinon c'est ok pour l'élément, on continue au niveau de la face et des pti
             {Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
              int nbpti=0; // init
              // test si l'élément face existe
              if (!ele.SurfExiste(nut.nbFA))
               {cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                     << " du maillage "<< n_mail
                     << " !!!" << flush ;
                verif = false;
               }
              else
               {const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
                nbpti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
               };
              // si tout est ok arrivée ici on enregistre
              if (verif)
               { for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
                   list_nut.push_back(nut);
               }
              else // sinon on averti que c'est mauvais
               {verif = false;};
             };
           };
        }
      else if (rep == "3")
        { string nom_ref;
          cout << "\n nom de la reference de faces ? ";
          nom_ref= lect_chaine();
          // vérif que la référence existe
          if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 3))
            { cout << "\n erreur de nom (** "<< nom_ref << " **)  donne ne correspond pas a une reference de faces d'element correcte ";}
          else
            // choix du point d'intégration, ici on ne va pas utiliser la liste list_nut, mais une liste particulière
            { string repo;
              cout << " numero d'un point d'integration ou: -1 pour tous les pti ? ";
              repo = lect_chaine(); nut.nbPtInteg = ChangeEntier(repo);
              if (nut.nbPtInteg != -1) // cas d'un seul pti
               {// on vérifie que ce point d'intégration est valide pour toutes les faces de la référence
                bool veriflocal = true;
                List_io <BlocScal >::iterator idl,idlfin= nomDeRef_F_E(n_mail).end();
                
                // recup de la reference correspondant au mot cle
                const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de faces d'élément
                int taillen=reff.Taille(); // nombre d'éléments dans la référence
                for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                 { nut.nbElem = reff.NumeroElem(ielem);
                   nut.nbFA  = reff.NumeroFA(ielem);
                   Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
                   // test si l'élément face existe
                   if (!ele.SurfExiste(nut.nbFA))
                    {cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                          << " du maillage "<< n_mail
                          << " ceci pour la reference " << reff.Nom()
                          << " !!!" << flush ;
                     veriflocal = false;
                    }
                   else
                    {const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
                     int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
                     // vérification que le  point d'intégration est possible
                     if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
                      { cout << "\n le numero de pti " << nut.nbPtInteg
                             << " n'est pas valide  "
                             << " pour la face " << nut.nbFA << "pour l'element "
                             << nut.nbElem << " du maillage " << n_mail
                             << ", car la face ne comporte que " << max_pti << " pti possible(s) "
                             << " !!!! " << flush;
                        veriflocal = false;
                      };
                    };
                 }; //-- fin de la boucle sur les éléments de la référence


                // --- on enregistre si la vérification a été ok
                if (veriflocal)
                  { nomDeRef_F_E(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
                    nomDeRef_F_E(n_mail).sort(); // on ordonne
                    nomDeRef_F_E(n_mail).unique();// on supprime les doublons
                  };
               }
              else  // cas de tous les pti
               { // il faut d'abord que l'on vérifie que tous les pti pour tous les faces d'élément sont valides
                 // .. on commence par tester si une première face d'élément existe vraiment et si oui, on récupère le nb de pti associé
                 bool veriflocal = true;
                 int nbpti = 0; // init-> ensuite sera == au nombre de pti pour chaque élément
                 { // on encapsule pour pas de redondance de nom
                   const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                   const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de face d'élément
                   int taillen=reff.Taille(); // nombre d'éléments dans la référence
                   if (taillen < 1) {veriflocal = false;} // cas d'une ref vide, on ne peut pas aller plus loin
                   else
                    {nut.nbElem = reff.NumeroElem(1);
                     nut.nbFA = reff.NumeroFA(1);
                     if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
                      {if (nut.nbElem < 0)
                         { cout << "\n le numero d'element (ici"<<nut.nbElem<<") doit etre superieur a 0 !!!";};
                       if (nut.nbElem > lesMail->Nombre_element(n_mail))
                         { cout << "\n chois non valide, le numero d'element (ici"<<nut.nbElem<<") doit etre inferieur ou egal "
                                << "   au nombre total d'element du maillage ("<<lesMail->Nombre_element(n_mail)<<") !!!";
                         };
                       veriflocal = false;
                      }
                     else // sinon c'est ok, on continue au niveau des pti
                      {Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
                       // test si l'élément face existe
                       if (!ele.SurfExiste(nut.nbFA))
                        {cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                              << " du maillage "<< n_mail
                              << " ceci pour la reference " << reff.Nom()
                              << " !!!" << flush ;
                         veriflocal = false;
                        }
                       else
                        {const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
                         int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
                         List_io < TypeQuelconque >& li_quelc = tab_F_element_TypeQuelconque_retenu(n_mail);
                         // on regarde si  listes ne sont pas toutes vides
                         if ((li_quelc.empty())&&(li_enu_quelc.empty()))
                           {// toutes les listes sont vides, on ne pourra pas aller plus loin
                            cout << "\n pas encore de grandeurs choisies !! ";
                            veriflocal = false;
                           }
                         else // sinon on peut continuer
                           {nbpti = max_pti;};
                        };
                      }
                    };
                 };
                 // .. puis on balaie l'ensemble des éléments et l'ensemble des pti
                 if (veriflocal)
                   {List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_F_E_SM(n_mail).end();
                
                    // --- cas des types quelconques aux faces d'éléments
                    {List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelc.end();
                     // boucle sur les grandeurs retenus
                     for (ite = li_enu_quelc.begin();ite != itefin; ite++)
                      { // recup de la reference correspondant au mot cle
                        const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                        const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de faces d'élément
                        int taillen=reff.Taille(); // nombre d'éléments dans la référence
                        for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                         { nut.nbElem = reff.NumeroElem(ielem);
                           nut.nbFA = reff.NumeroFA(ielem);
                           Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
                           if (!ele.SurfExiste(nut.nbFA))
                            {cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                  << " du maillage "<< n_mail
                                  << " ceci pour la reference " << reff.Nom()
                                  << " !!!" << flush ;
                             veriflocal = false;break;
                            }
                           else
                            {const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
                             int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
                             
                             // vérification que l'on a le même nombre de pti
                             if (max_pti != nbpti)
                              { cout << "\n ---> traitement de la reference: "<<refi.Nom()<<" : ";
                                cout << "\n la face "<<nut.nbFA<<" de l'element "<<nut.nbElem << " du maillage " << n_mail
                                     << " contient "<<max_pti<< " pti , alors qu'il en faudrait: "<<nbpti
                                     << "\n les faces sont donc differentes, on ne peut pas utiliser cette reference !! "
                                     << flush;
                                veriflocal = false;
                              };
                             if (!veriflocal) break;
                            };
                         }; //-- fin de la boucle sur les éléments de la référence
                        if (!veriflocal) break;
                      }; //-- fin de la boucle sur les ddl retenus
                    };
                   };
                
                 // arrivée ici, si tout est ok on enregistre
                 if (veriflocal)
                     { nut.nbPtInteg = -1;
                       nomDeRef_F_E(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
                       nomDeRef_F_E(n_mail).sort(); // on ordonne
                       nomDeRef_F_E(n_mail).unique();// on supprime les doublons
                     };
               };
            }; // fin du choix du point d'intégration et de l'enregistrement
          verif = false; // pour ne pas enregistrer de numéro dans la liste directe d'element car ici c'est
                         // la liste de référence de référence de faces d'élément qui est en cause
        }
      else if (rep == "4")
        { string nom_ref;
          cout << "\n nom de la reference ? ";nom_ref= lect_chaine();
          // vérif que la référence existe
          if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 7))
            { cout << "\n erreur de nom (** "<< nom_ref << " **)  donne ne correspond pas a une reference de point d'integration "
                   << " de faces d'element correcte ";}
          else
            { // on vérifie que le choix est valide
              bool veriflocal = true;
              // --- cas des types quelconques aux éléments
              {List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelc.end();
               // boucle sur les grandeurs retenus
               for (ite = li_enu_quelc.begin();ite != itefin; ite++)
                { // recup de la reference correspondant au mot cle
                  const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                  const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref de pti de faces d'élément
                  int taillen=reff.Taille(); // nombre d'éléments dans la référence
                  for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                   { nut.nbElem = reff.NumeroElem(ielem);
                     nut.nbFA = reff.NumeroFA(ielem);
                     nut.nbPtInteg = reff.NumeroPti(ielem);
                     
                     Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
                     if (!ele.SurfExiste(nut.nbFA))
                      {cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                            << " du maillage "<< n_mail
                            << " ceci pour la reference " << reff.Nom()
                            << " !!!" << flush ;
                       veriflocal = false;
                      }
                     else
                      {const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
                       int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
                       // vérification que le  point d'intégration est possible
                       if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
                        { cout << "\n le numero de pti " << nut.nbPtInteg
                               << " pour la grandeur  " << NomTypeQuelconque((*ite)) << " n'est pas valide  "
                               << " pour la face " << nut.nbFA << "pour l'element "
                               << nut.nbElem << " du maillage " << n_mail
                               << ", car la face ne comporte que " << max_pti << " pti possible(s) "
                               << " !!!! " << flush;
                          veriflocal = false;
                        };
                       };
                   }; //-- fin de la boucle sur les éléments de la référence
                }; //-- fin de la boucle sur les grandeurs retenus
              };
             
              // on enregistre si la vérification a été ok
              if (veriflocal)
                { nomDeRef_F_ptinteg(n_mail).push_back(nom_ref);
                  nomDeRef_F_ptinteg(n_mail).sort(); // on ordonne
                  nomDeRef_F_ptinteg(n_mail).unique();// on supprime les doublons
                };
            }; // fin de la vérification
          verif = false; // pour ne pas enregistrer de numéro dans la liste directe d'element car ici c'est
                             // la liste de référence de référence d'éléments qui est en cause
        }
      else if (rep == "efF")
        { // on efface les 3 listes
          (tab_num_F_element(n_mail)).clear();
          (tab_num_F(n_mail)).clear();
          (tab_num_F_integ(n_mail)).clear();
          verif = false;
        }
      else if (rep == "efrefF")
        { // on efface la liste des références d'éléments et la liste de pt d'integ associée
          (nomDeRef_F_E(n_mail)).clear();
          verif = false;
        }
      else if (rep == "affrefF")
        { // affichage de la liste des références d'éléments enregistrées dans les maillages
          cout << "\n liste des references de face d'elements ";
          if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
          const Reference* reff =NULL; bool prempass = true;
          do {
               if (prempass)
                 { reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
               else
                 { reff = lesRef->Reference_suivante();} // récup de la ref courante
               // sortie de la ref si c'est le bon maillage, et si c'est une ref de faces d'élément
               if (reff != NULL)
                  if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 3)) cout << reff->Nom() << " ";
               prempass = false;
             } while (reff != NULL);
         verif = false;
        }
      else if (rep == "efrefFpti")
        { // on efface la liste des références de pt d'integ d'éléments
          (nomDeRef_F_ptinteg(n_mail)).clear();
          verif = false;
        }
      else if (rep == "affrefFpti")
        { // affichage de la liste des références de pti enregistrées dans les maillages
          cout << "\n liste des references de pt integ de faces d'elements ";
          if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
          const Reference* reff =NULL; bool prempass = true;
          do {
               if (prempass)
                 { reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
               else
                 { reff = lesRef->Reference_suivante();} // récup de la ref courante
               // sortie de la ref si c'est le bon maillage, et si c'est une ref de faces d'élément
               if (reff != NULL)
                  if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 7)) cout << reff->Nom() << " ";
               prempass = false;
             } while (reff != NULL);
          verif = false;
        }
      else
        { cout << "\n reponse non valide, recommencez " << endl;
        };
          
      // enregistrement si tout est ok
      if ((verif)&&((Minuscules(rep) != "fin") && (Minuscules(rep) != "f")))
         { // on balaie les numéros de la liste
           list <Maillage::NBelemFAEtptInteg>::iterator i_list_nut,i_list_nut_fin = list_nut.end();
           for (i_list_nut=list_nut.begin();i_list_nut != i_list_nut_fin;i_list_nut++)
            { nut = (*i_list_nut); // par simplicité
              // si le groupe (élément, face et nb  point d'intégration) n'est pas actuellement enregistré, on l'enregistre
              // on boucle sur les datas déjà enregistrés
              bool a_enregistrer=true;
              List_io <int>::iterator ilelem,iliface,ilinteg,ilelemfin=tab_num_F_element(n_mail).end();
              ilinteg = tab_num_F_integ(n_mail).begin();
              iliface = tab_num_F(n_mail).begin();
              for (ilelem=tab_num_F_element(n_mail).begin();ilelem != ilelemfin;ilelem++,iliface++,ilinteg++)
                if ((nut.nbElem==(*ilelem))&&(nut.nbFA==(*iliface))&&(nut.nbPtInteg==(*ilinteg)))
                   a_enregistrer = false;
              if (a_enregistrer)
                 { tab_num_F_element(n_mail).push_back(nut.nbElem);
                   tab_num_F(n_mail).push_back(nut.nbFA);
                   tab_num_F_integ(n_mail).push_back(nut.nbPtInteg);
                 };
            };
         };
    };  // -- fin boucle choix position sur element

};
// choix des arête d'éléments
void Choix_grandeurs_maple::Choix_aretes_element_a_retenir(int n_mail,List_io < EnumTypeQuelconque >& li_enu_quelc)
{
  // def de grandeur globale
  int dim = ParaGlob::Dimension();
  // on récupère la liste des maillages à visualiser
  const list <int>& list_mail = choix_mail->List_choisit();
  list<int>::const_iterator ilm,ilmfin=list_mail.end();
  int taille_list_maille = list_mail.size();

  // choix du ou des arêtes d'elements, on affiche la liste actuelle si elle est non nulle
  if (tab_num_A_element(n_mail).size())
    { cout << "\n liste actuelle des aretes d'element a sortir en info: < (num_ele, num_arete) > ";
      List_io <int>::iterator ieint,ieintfin = tab_num_A_element(n_mail).end();
      List_io <int>::iterator ifint = tab_num_A(n_mail).begin();
      for (ieint=tab_num_A_element(n_mail).begin();ieint!=ieintfin;ieint++,ifint++)
        cout << " (" << (*ieint) << ", "<<(*ifint)<<") ";
      cout << endl;
     }
  // cas des références d'arêtes d'élément
  if ((nomDeRef_A_E(n_mail)).size() != 0)
     { cout << "\n liste actuelle de reference d'aretes d'element:  (ref et num integ) ";
       List_io <BlocScal >::iterator ieint1,ieintfin1 = (nomDeRef_A_E(n_mail)).end();
       for (ieint1=(nomDeRef_A_E(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
         cout << (*ieint1).NomRef() << " "<< (int) ((*ieint1).Val()) << " ";
       cout << endl;
     };
  // cas des références de point d'intégration d'arêtes d'élément
  if ((nomDeRef_A_ptinteg(n_mail)).size() != 0)
     { cout << "\n liste actuelle de reference de pt d'integration d'arete d'element:  (ref) ";
       List_io <string >::iterator ieint1,ieintfin1 = (nomDeRef_A_ptinteg(n_mail)).end();
       for (ieint1=(nomDeRef_A_ptinteg(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
         cout << (*ieint1) << " ";
       cout << endl;
     };
  cout              << "\n --- choix de la position sur le ou les aretes ou l'on veut la visualisation     "
                    << "\n le reperage  peut se faire de differentes manieres :                              "
                    << "\n par 2 numeros (element, arete) dans le maillage + un ou plusieurs                  "
                    << "\n numero(s)  de pt d'integration (au sens classique)                      -> (choix : 1)"
//                    << "\n par des coordonnees d'un point (interne !!), meme approximatives                  "
//                    << "\n la grandeur affichee sera a un point le plus proche ou elle existe      -> (choix : 2)"
                    << "\n par une reference de liste d'arete d'element (avec 1 ou tous les pti)  -> (choix : 3)"
                    << "\n (dans ce dernier cas il faut que toutes les aretes soient de meme type)  "
                    << "\n par une reference de liste de point d'integration d'aretes d'element    -> (choix : 4)"
                    << "\n ---> donnez le type de choix puis les infos correspondantes <---        "
                    << "\n effacer la liste actuelle d'aretes d'element                            ->  (rep : efA) "
                    << "\n effacer la liste actuelle des references d'aretes d'element             ->  (rep : efrefA) "
                    << "\n afficher la liste des references d'aretes d'element existantes          ->  (rep : affrefA) "
                    << "\n effacer la liste actuelle des references de pti d'aretes d'element      ->  (rep : efrefApti) "
                    << "\n afficher la liste des references de pti d'aretes d'element existantes   ->  (rep : affrefApti) "
                    << "\n                                                             (tapez fin pour finir(ou f))";
  string rep = "";
  // -- début boucle choix
  while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
    { cout << "\n choix ? ";rep = lect_return_defaut(false,"f");
      if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f")) break;
      // def du conteneur des numéros que l'on cherche
      // comme on peut en définir plusieurs d'un coup (par exemple tous les pti d'une arête on utilise une liste
      list <Maillage::NBelemFAEtptInteg> list_nut; // à chaque passage elle est initialisée et donc vide au début
      Maillage::NBelemFAEtptInteg nut; // idem, initialisé à chaque passage
      bool verif = true; // pour la vérification des numéros
      if (rep == "1")
        { cout << " numero d'element ? "; rep = lect_chaine(); nut.nbElem = ChangeEntier(rep);
          cout << " numero de l'arete ? "; rep = lect_chaine(); nut.nbFA = ChangeEntier(rep);
          cout << " numero du point d'integration (ou -1 pour tous les pti de l'element) ? ";
          rep = lect_chaine(); nut.nbPtInteg = ChangeEntier(rep);
          if (nut.nbPtInteg != -1)
           {list_nut.push_back(nut);} // cas d'un seul pti
          else // cas de tous les pti
           {// on commence par tester si l'élément existe vraiment
            if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
             {if (nut.nbElem < 0)
                { cout << "\n le numero d'element doit etre superieur a 0 !!!";verif = false;};
              if (nut.nbElem > lesMail->Nombre_element(n_mail))
                { cout << "\n chois non valide, le numero d'element doit etre inferieur ou egal"
                       << "   au nombre total d'element du maillage !!!";verif = false;
                };
             }
            else // sinon c'est ok pour l'élément, on continue au niveau de l'arête et des pti
             {Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
              int nbpti=0; // init
              // test si l'élément arête existe
              if (!ele.SurfExiste(nut.nbFA))
               {cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                     << " du maillage "<< n_mail
                     << " !!!" << flush ;
                verif = false;
               }
              else
               {const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
                nbpti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
               };
              // si tout est ok arrivée ici on enregistre
              if (verif)
               { for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
                   list_nut.push_back(nut);
               }
              else // sinon on averti que c'est mauvais
               {verif = false;};
             };
           };
        }
      else if (rep == "3")
        { string nom_ref;
          cout << "\n nom de la reference d'aretes ? ";
          nom_ref= lect_chaine();
          // vérif que la référence existe
          if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 3))
            { cout << "\n erreur de nom (** "<< nom_ref << " **)  donne ne correspond pas a une reference d'aretes d'element correcte ";}
          else
            // choix du point d'intégration, ici on ne va pas utiliser la liste list_nut, mais une liste particulière
            { string repo;
              cout << " numero d'un point d'integration ou: -1 pour tous les pti ? ";
              repo = lect_chaine(); nut.nbPtInteg = ChangeEntier(repo);
              if (nut.nbPtInteg != -1) // cas d'un seul pti
               {// on vérifie que ce point d'intégration est valide pour toutes les arêtes de la référence
                bool veriflocal = true;
                List_io <BlocScal >::iterator idl,idlfin= nomDeRef_A_E(n_mail).end();
                
                // recup de la reference correspondant au mot cle
                const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'élément
                int taillen=reff.Taille(); // nombre d'éléments dans la référence
                for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                 { nut.nbElem = reff.NumeroElem(ielem);
                   nut.nbFA  = reff.NumeroFA(ielem);
                   Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
                   // test si l'élément arête existe
                   if (!ele.SurfExiste(nut.nbFA))
                    {cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                          << " du maillage "<< n_mail
                          << " ceci pour la reference " << reff.Nom()
                          << " !!!" << flush ;
                     veriflocal = false;
                    }
                   else
                    {const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
                     int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
                     // vérification que le  point d'intégration est possible
                     if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
                      { cout << "\n le numero de pti " << nut.nbPtInteg
                             << " n'est pas valide  "
                             << " pour l'arete " << nut.nbFA << "pour l'element "
                             << nut.nbElem << " du maillage " << n_mail
                             << ", car l'arete ne comporte que " << max_pti << " pti possible(s) "
                             << " !!!! " << flush;
                        veriflocal = false;
                      };
                    };
                 }; //-- fin de la boucle sur les éléments de la référence


                // --- on enregistre si la vérification a été ok
                if (veriflocal)
                  { nomDeRef_A_E(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
                    nomDeRef_A_E(n_mail).sort(); // on ordonne
                    nomDeRef_A_E(n_mail).unique();// on supprime les doublons
                  };
               }
              else  // cas de tous les pti
               { // il faut d'abord que l'on vérifie que tous les pti pour toutes les arêtes d'élément sont valides
                 // .. on commence par tester si une première arête d'élément existe vraiment et si oui, on récupère le nb de pti associé
                 bool veriflocal = true;
                 int nbpti = 0; // init-> ensuite sera == au nombre de pti pour chaque élément
                 { // on encapsule pour pas de redondance de nom
                   const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                   const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'élément
                   int taillen=reff.Taille(); // nombre d'éléments dans la référence
                   if (taillen < 1) {veriflocal = false;} // cas d'une ref vide, on ne peut pas aller plus loin
                   else
                    {nut.nbElem = reff.NumeroElem(1);
                     nut.nbFA = reff.NumeroFA(1);
                     if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
                      {if (nut.nbElem < 0)
                         { cout << "\n le numero d'element (ici"<<nut.nbElem<<") doit etre superieur a 0 !!!";};
                       if (nut.nbElem > lesMail->Nombre_element(n_mail))
                         { cout << "\n chois non valide, le numero d'element (ici"<<nut.nbElem<<") doit etre inferieur ou egal "
                                << "   au nombre total d'element du maillage ("<<lesMail->Nombre_element(n_mail)<<") !!!";
                         };
                       veriflocal = false;
                      }
                     else // sinon c'est ok, on continue au niveau des pti
                      {Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
                       // test si l'élément arête existe
                       if (!ele.SurfExiste(nut.nbFA))
                        {cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                              << " du maillage "<< n_mail
                              << " ceci pour la reference " << reff.Nom()
                              << " !!!" << flush ;
                         veriflocal = false;
                        }
                       else
                        {const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
                         int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
                         List_io < TypeQuelconque >& li_quelc = tab_A_element_TypeQuelconque_retenu(n_mail);
                         // on regarde si  listes ne sont pas toutes vides
                         if ((li_quelc.empty())&&(li_enu_quelc.empty()))
                           {// toutes les listes sont vides, on ne pourra pas aller plus loin
                            cout << "\n pas encore de grandeurs choisies !! ";
                            veriflocal = false;
                           }
                         else // sinon on peut continuer
                           {nbpti = max_pti;};
                        };
                      }
                    };
                 };
                 // .. puis on balaie l'ensemble des éléments et l'ensemble des pti
                 if (veriflocal)
                   {List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_A_E_SM(n_mail).end();
                
                    // --- cas des types quelconques aux arêtes d'éléments
                    {List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelc.end();
                     // boucle sur les grandeurs retenus
                     for (ite = li_enu_quelc.begin();ite != itefin; ite++)
                      { // recup de la reference correspondant au mot cle
                        const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                        const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'élément
                        int taillen=reff.Taille(); // nombre d'éléments dans la référence
                        for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                         { nut.nbElem = reff.NumeroElem(ielem);
                           nut.nbFA = reff.NumeroFA(ielem);
                           Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
                           if (!ele.SurfExiste(nut.nbFA))
                            {cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                  << " du maillage "<< n_mail
                                  << " ceci pour la reference " << reff.Nom()
                                  << " !!!" << flush ;
                             veriflocal = false;break;
                            }
                           else
                            {const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
                             int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
                             
                             // vérification que l'on a le même nombre de pti
                             if (max_pti != nbpti)
                              { cout << "\n ---> traitement de la reference: "<<refi.Nom()<<" : ";
                                cout << "\n l'arete "<<nut.nbFA<<" de l'element "<<nut.nbElem << " du maillage " << n_mail
                                     << " contient "<<max_pti<< " pti , alors qu'il en faudrait: "<<nbpti
                                     << "\n les aretes sont donc differentes, on ne peut pas utiliser cette reference !! "
                                     << flush;
                                veriflocal = false;
                              };
                             if (!veriflocal) break;
                            };
                         }; //-- fin de la boucle sur les éléments de la référence
                        if (!veriflocal) break;
                      }; //-- fin de la boucle sur les ddl retenus
                    };
                   };
                
                 // arrivée ici, si tout est ok on enregistre
                 if (veriflocal)
                     { nut.nbPtInteg = -1;
                       nomDeRef_A_E(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
                       nomDeRef_A_E(n_mail).sort(); // on ordonne
                       nomDeRef_A_E(n_mail).unique();// on supprime les doublons
                     };
               };
            }; // fin du choix du point d'intégration et de l'enregistrement
          verif = false; // pour ne pas enregistrer de numéro dans la liste directe d'element car ici c'est
                         // la liste de référence d'arêtes d'élément qui est en cause
        }
      else if (rep == "4")
        { string nom_ref;
          cout << "\n nom de la reference ? ";nom_ref= lect_chaine();
          // vérif que la référence existe
          if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 7))
            { cout << "\n erreur de nom (** "<< nom_ref << " **)  donne ne correspond pas a une reference de point d'integration "
                   << " d'aretes d'element correcte ";}
          else
            { // on vérifie que le choix est valide
              bool veriflocal = true;
              // --- cas des types quelconques aux éléments
              {List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelc.end();
               // boucle sur les grandeurs retenus
               for (ite = li_enu_quelc.begin();ite != itefin; ite++)
                { // recup de la reference correspondant au mot cle
                  const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                  const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref de pti d'arêtes d'élément
                  int taillen=reff.Taille(); // nombre d'éléments dans la référence
                  for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                   { nut.nbElem = reff.NumeroElem(ielem);
                     nut.nbFA = reff.NumeroFA(ielem);
                     nut.nbPtInteg = reff.NumeroPti(ielem);
                     
                     Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
                     if (!ele.SurfExiste(nut.nbFA))
                      {cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                            << " du maillage "<< n_mail
                            << " ceci pour la reference " << reff.Nom()
                            << " !!!" << flush ;
                       veriflocal = false;
                      }
                     else
                      {const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
                       int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
                       // vérification que le  point d'intégration est possible
                       if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
                        { cout << "\n le numero de pti " << nut.nbPtInteg
                               << " pour la grandeur  " << NomTypeQuelconque((*ite)) << " n'est pas valide  "
                               << " pour l'arete " << nut.nbFA << "pour l'element "
                               << nut.nbElem << " du maillage " << n_mail
                               << ", car l'arete ne comporte que " << max_pti << " pti possible(s) "
                               << " !!!! " << flush;
                          veriflocal = false;
                        };
                       };
                   }; //-- fin de la boucle sur les éléments de la référence
                }; //-- fin de la boucle sur les grandeurs retenus
              };
             
              // on enregistre si la vérification a été ok
              if (veriflocal)
                { nomDeRef_A_ptinteg(n_mail).push_back(nom_ref);
                  nomDeRef_A_ptinteg(n_mail).sort(); // on ordonne
                  nomDeRef_A_ptinteg(n_mail).unique();// on supprime les doublons
                };
            }; // fin de la vérification
          verif = false; // pour ne pas enregistrer de numéro dans la liste directe d'element car ici c'est
                             // la liste de référence de référence d'éléments qui est en cause
        }
      else if (rep == "efA")
        { // on efface les 3 listes
          (tab_num_A_element(n_mail)).clear();
          (tab_num_A(n_mail)).clear();
          (tab_num_A_integ(n_mail)).clear();
          verif = false;
        }
      else if (rep == "efrefA")
        { // on efface la liste des références d'éléments et la liste de pt d'integ associée
          (nomDeRef_A_E(n_mail)).clear();
          verif = false;
        }
      else if (rep == "affrefA")
        { // affichage de la liste des références d'éléments enregistrées dans les maillages
          cout << "\n liste des references d'aretes d'element ";
          if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
          const Reference* reff =NULL; bool prempass = true;
          do {
               if (prempass)
                 { reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
               else
                 { reff = lesRef->Reference_suivante();} // récup de la ref courante
               // sortie de la ref si c'est le bon maillage, et si c'est une ref d'arêtes d'élément
               if (reff != NULL)
                  if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 3)) cout << reff->Nom() << " ";
               prempass = false;
             } while (reff != NULL);
         verif = false;
        }
      else if (rep == "efrefApti")
        { // on efface la liste des références de pt d'integ d'éléments
          (nomDeRef_A_ptinteg(n_mail)).clear();
          verif = false;
        }
      else if (rep == "affrefpti")
        { // affichage de la liste des références de pti enregistrées dans les maillages
          cout << "\n liste des references de pt integ d'aretes d'elements ";
          if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
          const Reference* reff =NULL; bool prempass = true;
          do {
               if (prempass)
                 { reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
               else
                 { reff = lesRef->Reference_suivante();} // récup de la ref courante
               // sortie de la ref si c'est le bon maillage, et si c'est une ref d'arêtes d'élément
               if (reff != NULL)
                  if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 7)) cout << reff->Nom() << " ";
               prempass = false;
             } while (reff != NULL);
          verif = false;
        }
      else
        { cout << "\n reponse non valide, recommencez " << endl;
        };
          
      // enregistrement si tout est ok
      if ((verif)&&((Minuscules(rep) != "fin") && (Minuscules(rep) != "f")))
         { // on balaie les numéros de la liste
           list <Maillage::NBelemFAEtptInteg>::iterator i_list_nut,i_list_nut_fin = list_nut.end();
           for (i_list_nut=list_nut.begin();i_list_nut != i_list_nut_fin;i_list_nut++)
            { nut = (*i_list_nut); // par simplicité
              // si le groupe (élément, arête et nb  point d'intégration) n'est pas actuellement enregistré, on l'enregistre
              // on boucle sur les datas déjà enregistrés
              bool a_enregistrer=true;
              List_io <int>::iterator ilelem,iliAre,ilinteg,ilelemfin=tab_num_A_element(n_mail).end();
              ilinteg = tab_num_A_integ(n_mail).begin();
              iliAre = tab_num_A(n_mail).begin();
              for (ilelem=tab_num_A_element(n_mail).begin();ilelem != ilelemfin;ilelem++,iliAre++,ilinteg++)
                if ((nut.nbElem==(*ilelem))&&(nut.nbFA==(*iliAre))&&(nut.nbPtInteg==(*ilinteg)))
                   a_enregistrer = false;
              if (a_enregistrer)
                 { tab_num_A_element(n_mail).push_back(nut.nbElem);
                   tab_num_A(n_mail).push_back(nut.nbFA);
                   tab_num_A_integ(n_mail).push_back(nut.nbPtInteg);
                 };
            };
         };
    };  // -- fin boucle choix position sur element

};

// choix des noeud
void Choix_grandeurs_maple::Choix_noeud_a_retenir(int n_mail,List_io < Ddl_enum_etendu >& li_ddl)
{ // def de grandeur globale
  int dim = ParaGlob::Dimension();
  string rep="";
  while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
   { // choix du ou des noeuds, on affiche la liste actuelle
     if ((tab_num_noeud(n_mail)).size())
      { cout << "\n liste actuelle de noeud:   ";
        List_io <int>::iterator ieint,ieintfin = tab_num_noeud(n_mail).end();
        for (ieint=tab_num_noeud(n_mail).begin();ieint!=ieintfin;ieint++)
          cout << *ieint << " ";
        cout << endl;  
      };
     if ((nomDeRef(n_mail)).size() != 0)
      { cout << "\n liste actuelle de reference de noeuds:   ";
        List_io <string >::iterator ieint1,ieintfin1 = (nomDeRef(n_mail)).end();
        for (ieint1=(nomDeRef(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
          cout << *ieint1 << " ";
        cout << endl;  
      };
          
     // questions  
     cout << "\n choix du ou des noeuds ou l'on veut la visualisation "
          << "\n le reperage d'un noeuds peut se faire de differentes manieres :" 
          << "\n par son numero dans le maillage          ->                 (choix : 1)"
          << "\n par ses coordonnees, meme approximatives ->                 (choix : 2)"
          << "\n par une reference de liste de noeuds     ->                 (choix : 3)"
          << "\n donnez pour chaque noeud le type de choix puis le numero               "
          << "\n ou les cordonnees                                                      "
          << "\n effacer la liste actuelle de noeuds                         (rep : ef) "                     
          << "\n effacer la liste actuelle des references de noeuds          (rep : efref) " 
          << "\n afficher la liste des references de noeuds existants        (rep : affref) "                    
          << "\n                                                (pour finir tapez : fin (ou f))";
     rep = "";
     cout << "\n choix ? ";rep = lect_return_defaut(false,"f");
     bool verif = true; // pour la vérification du numéro du noeud
     int nu ; // le numéro de noeud
     if (rep == "1")
       { cout << " numero ? "; rep = lect_chaine(); nu = ChangeEntier(rep);
       }
     else if (rep =="2")
       { Coordonnee xi(dim);
         cout << "\n coordonnee ("<<dim<<" nombre(s)) ? ";
         for(int j=1;j<=dim;j++) cin >> xi(j);
         std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
         cout << "\n les coordonnees sont a:  t = 0 ou t ou tdt (repondre 0 ou t ou tdt) ?";
         rep = lect_chaine();
         // recherche du noeud le plus proche
         if (rep == "0")        nu = lesMail->Noeud_le_plus_proche_0(xi,n_mail);
         else if (rep == "t")   nu = lesMail->Noeud_le_plus_proche_t(xi,n_mail);  
         else if (rep == "tdt") nu = lesMail->Noeud_le_plus_proche_tdt(xi,n_mail);
         else
           { cout << "\n erreur de syntaxe, on attendait 0 ou t ou tdt ! ";verif = false;};
         cout << "\n noeud le plus proche nb= " << nu; verif = true;
        }    
     else if (rep =="3")
       { string nom_ref;
         cout << "\n nom de la reference ? ";nom_ref= lect_chaine();
         // vérif que la référence existe
         if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 1))
           { cout << "\n erreur de nom donne (** "<< nom_ref << " **)  ne correspond pas a une reference de noeud correcte ";}
         else // on enregistre
           { nomDeRef(n_mail).push_back(nom_ref);
             nomDeRef(n_mail).sort(); // on ordonne
             nomDeRef(n_mail).unique();// on supprime les doublons                         
           };
         verif = false; // pour ne pas enregistrer de numéro dans la liste de noeud car ici c'est 
                        // la liste de référence de noeud qui est en cause       
       }    
     else if (rep == "ef") 
       { // on efface la liste des noeuds
         (tab_num_noeud(n_mail)).clear();
          verif = false;                                                                 
       }
     else if (rep == "efref") 
       { // on efface la liste des références de noeuds
         (nomDeRef(n_mail)).clear(); 
         verif = false;                                                                
       }
     else if (rep == "affref") 
       { // affichage de la liste des références enregistrées dans les maillages
         cout << "\n liste des references de noeuds ";
         cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
         const Reference* reff =NULL; bool prempass = true;
         do{ 
            if (prempass)
              { reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
            else
              { reff = lesRef->Reference_suivante();} // récup de la ref courante  
            // sortie de la ref si c'est le bon maillage, et si c'est une ref de noeud
            if (reff != NULL)
               if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 1)) cout << reff->Nom() << " ";
            prempass = false; 
           } while (reff != NULL);
          verif = false;    
       }
     else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
       { cout << " erreur de syntaxe on attendait 1 ou 2 ! recommencez ";verif = false;};
     // vérif que le numéro est acceptable et enregistrement
     if ((nu>0)&&(nu<=lesMail->Nombre_noeud(n_mail))) 
       { // on vérifie que les ddls à sortir sont bien présent pour ce noeud
         List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabnoeud_type_ddl_retenu(n_mail).end();
         for (ienu = tabnoeud_type_ddl_retenu(n_mail).begin();ienu!=ienufin;ienu++)
           {if ( (!(lesMail->Noeud_LesMaille(n_mail,nu).Existe_ici((*ienu).Enum())))  // cas où le ddl principal n'existe pas
                && (!(lesMail->Noeud_LesMaille(n_mail,nu).Existe_ici_ddlEtendu((*ienu))))) // cas où le ddl étendu n'existe pas
             {cout << "\n attention le ddl " << Nom_ddl((*ienu).Enum()) << " n'existe pas pour le noeud " 
                   << nu << " du maillage " << n_mail 
                   << "\n il y aura 0 en sortie ! ";
              verif = true;     
              } 
            } 
       };
     if ((verif)&&((Minuscules(rep) != "fin") && (Minuscules(rep) != "f")))  
       { // enregistrement
         tab_num_noeud(n_mail).push_back(nu);
         tab_num_noeud(n_mail).sort(); // on ordonne
         tab_num_noeud(n_mail).unique();// on supprime les doublons                         
       };
   }// -- fin de la boucle infini sur l'entrée de numéro de noeud   
};

// entrée du choix de grandeurs globals
void Choix_grandeurs_maple::Entree_grandeur_gobal(string& rep)
  { rep = "";
    while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
      { if (list_grandeur_global.size() != 0)
         { // on utilise directement Paraglob
           ParaGlob::param->Affiche_GrandeurGlobal(cout);
//           cout << "\n liste des grandeurs globales disponibles en sortie:\n >>> ";
//           List_io <string>::iterator jeint,jeintfin = list_grandeur_global.end();
//           for (jeint=list_grandeur_global.begin();jeint!=jeintfin;jeint++)
//                 cout << *jeint << " ";
           // il faut que l'on remette à jour les grandeurs globales car elles peuvent avoir été abondées
           // pendant le calcul ex: Iteration, compteur divers ...
           // comme on est en interactif le cout cpu a moins d'importance
           ParaGlob::param->Recup_list_GrandeurGlobal(list_grandeur_global);

           if (  list_grand_global_retenu.size() != 0)
             {cout << "\n liste des grandeurs actuellement a sortir:\n  <<<:   ";  
              List_io <string>::iterator jeint,jeintfin = list_grand_global_retenu.end();              jeintfin = list_grand_global_retenu.end();
              for (jeint=list_grand_global_retenu.begin();jeint!=jeintfin;jeint++)
                      cout << *jeint << " ";
              }        
           cout << endl;  
         }
        cout << "\n grandeurs que vous voulez visualiser    (rep grandeurs?)"
             << "\n toutes les grandeurs (rep par defaut)   (rep : to) "
             << "\n effacer la liste actuelle               (rep : ef) "
             << "\n                                         (pour terminer tapez : fin (ou f) ) ";
        cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
        if (rep == "to")
           // cas de toutes les grandeurs
           list_grand_global_retenu = list_grandeur_global;
 //       else if (find(list_grandeur_global.begin(),list_grandeur_global.end(),rep) != list_grandeur_global.end())
        else if (    (find(list_grandeur_global.begin(),list_grandeur_global.end(),rep)
                         != list_grandeur_global.end())
                  || (ParaGlob::param->GrandeurGlobal(rep) != NULL)
                )
           list_grand_global_retenu.push_back(rep);
        else if (rep == "ef")
           list_grand_global_retenu.erase(list_grand_global_retenu.begin(),list_grand_global_retenu.end());
        else if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f"))  
           {cout << "\n liste des grandeurs enregistrees :   ";  
            List_io <string>::iterator jfint,jfintfin = list_grand_global_retenu.end();
            for (jfint=list_grand_global_retenu.begin();jfint!=jfintfin;jfint++)
                    cout << *jfint << " ";
            cout << "\n";        
            }        
        else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
           cout << " erreur de syntaxe dans le ddl! recommencez ";
       }
   };

// entrée du choix des torseurs de réaction
void Choix_grandeurs_maple::Entree_torseurs_reaction(string& rep)
{ int nbmail = tab_list_torseur_condLim.Taille();
  // on boucle sur les maillages
  bool aucunesortie = true; // pour mettre un message si aucun torseur n'est dispo
  for (int imail = 1; imail <= nbmail; imail++)
   { rep = "";
     List_io <String_et_entier >& list_torseur_condLim = tab_list_torseur_condLim(imail);
     List_io <String_et_entier >& list_torseur_condLim_retenu = tab_list_torseur_condLim_retenu(imail);
     if (list_torseur_condLim.size() != 0) 
      { aucunesortie=false;
        while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
         { cout << "\n ---- maillage: " << lesMail->NomMaillage(imail);
           cout << "\n liste des ref de torseur de reaction disponibles:\n >>> ";
           List_io <String_et_entier>::iterator jeint,jeintfin = list_torseur_condLim.end();
           for (jeint=list_torseur_condLim.begin();jeint!=jeintfin;jeint++)
                 cout << (*jeint).nom << " ";
           if (  list_torseur_condLim_retenu.size() != 0)                     
            {cout << "\n liste des ref de torseur actuellement a sortir:\n  <<<:   ";  
             List_io <String_et_entier>::iterator intfin = list_torseur_condLim_retenu.end();
             for (jeint=list_torseur_condLim_retenu.begin();jeint!=intfin;jeint++)
                cout << (*jeint).nom << " ";  
             }        
           cout << endl;  
           cout << "\n ref  que vous voulez visualiser    (rep grandeurs?)"
                << "\n toutes les ref (rep par defaut)         (rep : to) "
                << "\n effacer la liste actuelle               (rep : ef) "
                << "\n                                         (pour terminer tapez : fin (ou f) ) ";
           cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
           // on regarde si la ref est bonne
           bool choix_valide = false;
           for (jeint=list_torseur_condLim.begin();jeint!=jeintfin;jeint++)
            { if ((*jeint).nom == rep)
            	{ list_torseur_condLim_retenu.push_back(*jeint);
                  choix_valide = true;
                  break;
            	};
            };
           if (!choix_valide) 
           	{if (rep == "to")
                // cas de toutes les grandeurs
                list_torseur_condLim_retenu = list_torseur_condLim;
             else if (rep == "ef")
                list_torseur_condLim_retenu.erase(list_torseur_condLim_retenu.begin(),list_torseur_condLim_retenu.end());
             else if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f"))  
                {cout << "\n liste des grandeurs enregistrees :   ";  
                 List_io <String_et_entier>::iterator intfin = list_torseur_condLim_retenu.end();
                 for (jeint=list_torseur_condLim_retenu.begin();jeint!=intfin;jeint++)
                    cout << (*jeint).nom << " ";  
                 cout << "\n";        
                 }        
             else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                cout << " erreur de syntaxe dans le ddl! recommencez ";
           	}; // -- fin du test choix_valide
        }; // -- fin du while
      }; //-- fin du test sur la taille de la liste 
   }; //-- fin de la boucle sur les maillages
   // sortie éventuelle d'un message
   if (aucunesortie)
     cout << "\n ??? il n'y a aucun torseur de reaction a sortir ???? ";    
};

// dans le cas d'une animation, il n'y a pas de sortie directe mais la création de listes qui sont transmises
// à animation_maple
void Choix_grandeurs_maple::Construction_liste_pour_animation
                                 (int numMail ,LesMaillages * lesMail,Charge* charge)
 {List_io <DeuxDoubles> liste_sortie; // la liste à sortir
  // on balaie la liste des grandeurs a visualiser, dans le cas ou l'on trouve la bonne grandeur on 
  // sauvegarde dans la liste à sortir
  if (type_xi)
    { // --------- cas des grandeurs aux noeuds ------------
      List_io<int>::iterator inoeud,inoeudfin=tab_num_noeud(numMail).end();
      // on crée une liste intermédiaire qui contient tous les noeuds à sortir, 
      List_io <int> tab_total_noeud = tab_num_noeud(numMail); // tout d'abord récup de la liste de noeuds
      // puis les références de listes de noeuds
      List_io <string >::iterator idl,idlfin= nomDeRef(numMail).end();
      for (idl=nomDeRef(numMail).begin();idl!=idlfin;idl++)
        { // recup de la reference correspondant au mot cle
          const Reference& refi = lesRef->Trouve(*idl,numMail);
          const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref de noeud
          int taillen=reff.Taille();
          for (int inoeu=1;inoeu<=taillen;inoeu++)  // on boucle et enregistre les noeuds
            tab_total_noeud.push_back(reff.Numero(inoeu));
         }
      inoeudfin=tab_total_noeud.end(); 
      // maintenant on affiche les infos pour la liste totale de noeuds   
      for (inoeud = tab_total_noeud.begin();inoeud!=inoeudfin;inoeud++)
       { // la grandeurs en x1
         bool asortir = true; double valx_a_sortir;
          // on regarde si la grandeur existe
          if (!lesMail->Noeud_LesMaille(numMail,*inoeud).Existe_ici((x1).Enum())) 
             { asortir=false;
         #ifdef MISE_AU_POINT
               cout << "\n attention la grandeur " << Nom_ddl((x1).Enum()) << " n'est pas disponible, on mais 0 a la place";
         #endif
             }
         if ((asortir) && (!accroi_x1)) // cas où l'on sort la grandeur
            {if (charge->Temps_courant() == 0.) {valx_a_sortir = lesMail->Noeud_LesMaille(numMail,*inoeud).Valeur_0((x1).Enum());}
             else {valx_a_sortir = lesMail->Noeud_LesMaille(numMail,*inoeud).Valeur_t((x1).Enum());} 
             }
         else if ((asortir) && (accroi_x1)) // cas où l'on sort la variation entre 0 et t de la grandeur
            {if (charge->Temps_courant() == 0.) {valx_a_sortir = 0.;}
             else { double val_init = lesMail->Noeud_LesMaille(numMail,*inoeud).Valeur_0((x1).Enum());
                    valx_a_sortir = lesMail->Noeud_LesMaille(numMail,*inoeud).Valeur_t((x1).Enum()) - val_init;} 
             }    
         else {valx_a_sortir = 0.;}
         // la grandeurs en x2
         asortir = true; double valy_a_sortir;
          // on regarde si la grandeur existe
          if (!lesMail->Noeud_LesMaille(numMail,*inoeud).Existe_ici((x2).Enum())) 
             { asortir=false;
         #ifdef MISE_AU_POINT
               cout << "\n attention la grandeur " << Nom_ddl((x2).Enum()) << " n'est pas disponible, on mais 0 a la place";
         #endif
             };
         if ((asortir) && (!accroi_x2)) // cas où l'on sort la grandeur
            {if (charge->Temps_courant() == 0.) {valy_a_sortir = lesMail->Noeud_LesMaille(numMail,*inoeud).Valeur_0((x2).Enum());}
             else {valy_a_sortir = lesMail->Noeud_LesMaille(numMail,*inoeud).Valeur_t((x2).Enum());} 
             }
         else if ((asortir) && (accroi_x2)) // cas où l'on sort la variation entre 0 et t de la grandeur
            {if (charge->Temps_courant() == 0.) {valy_a_sortir = 0.;}
             else { double val_init = lesMail->Noeud_LesMaille(numMail,*inoeud).Valeur_0((x2).Enum());
                    valy_a_sortir = lesMail->Noeud_LesMaille(numMail,*inoeud).Valeur_t((x2).Enum()) - val_init;} 
             }    
         else {valy_a_sortir = 0.;}
         // enregistrement  
         liste_sortie.push_back(DeuxDoubles(valx_a_sortir,valy_a_sortir));  
       }
     } //-- fin des grandeurs pour un noeud
  else
   { // --------- cas des grandeurs aux éléments ------------
      List_io<int>::iterator ielement,ielementfin=tab_num_element(numMail).end();     
      // on crée une liste intermédiaire qui contient tous les éléments et point d'integ à sortir, 
      List_io <int> tab_total_elem = tab_num_element(numMail); // tout d'abord récup de la liste des éléments
      List_io <int> tab_total_ptint = tab_num_integ(numMail); // et les points d'intégration correspondant      
      // puis les références de listes d'éléments
      {List_io <BlocScal>::iterator idl,idlfin= nomDeRef_E(numMail).end();
       for (idl=nomDeRef_E(numMail).begin();idl!=idlfin;idl++)
        { // recup de la reference correspondant au mot cle
          const Reference& refi = lesRef->Trouve((*idl).NomRef(),numMail);
          const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'éléments
          int taillen=reff.Taille(); // nombre d'éléments dans la liste
          for (int ielem=1;ielem<=taillen;ielem++)  // on boucle et enregistre les elements et le point
            {tab_total_elem.push_back(reff.Numero(ielem));  // d'intégration
             tab_total_ptint.push_back((int) ((*idl).Val()));          // associé (le même pour toute la référence)
             }
         };
      }; // encapsulage
      // puis les références de listes de points d'intégration d'éléments
      {List_io <string>::iterator ids,idsfin= nomDeRef_ptinteg(numMail).end();
       for (ids=nomDeRef_ptinteg(numMail).begin();ids!=idsfin;ids++)
        { // recup de la reference correspondant au mot cle
          const Reference& refi = lesRef->Trouve((*ids),numMail);
          const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de pt d'integ
          int taillen=reff.Taille(); // nombre d'éléments dans la liste
          for (int ielem=1;ielem<=taillen;ielem++)  // on boucle et enregistre les elements et le point
            {tab_total_elem.push_back(reff.NumeroElem(ielem));  // d'intégration
             tab_total_ptint.push_back(reff.NumeroFA(ielem));          // associé (le même pour toute la référence)
             }
         }
      }; // encapsulé
      ielementfin=tab_total_elem.end();
      // dans le cas où il s'agit de ddl
      if (ddl_etpas_TQ_1 && ddl_etpas_TQ_2)
       {// on crée une liste intermédiaire pour stocker x1 et x2 , ceci pour l'appel de   "Valeur_a_diff_temps "  
        List_io < Ddl_enum_etendu > x1x2; x1x2.push_back(x1); x1x2.push_back(x2);      
        // maintenant on affiche les infos pour la liste totale d'éléments
        List_io <int>::iterator iptinteg = tab_total_ptint.begin();  
        for (ielement = tab_total_elem.begin();ielement!=ielementfin;ielement++,iptinteg++)
         { // les grandeurs
           Tableau <double> tab= 
                lesMail->Element_LesMaille(numMail,*ielement).Valeur_a_diff_temps(absolue,TEMPS_tdt,x1x2,*iptinteg);
           // enregistrement
           liste_sortie.push_back(DeuxDoubles(tab(1),tab(2))); 
          }
        }
      else // cas où x ou y sont des grandeurs particulières
       {// on crée une liste intermédiaire pour stocker x1 ou x2 , ceci pour l'appel de   "Valeur_a_diff_temps "  
        List_io < Ddl_enum_etendu > x1x2; List_io<TypeQuelconque> lix1x2;
        if (ddl_etpas_TQ_1) {x1x2.push_back(x1);} else {lix1x2.push_back(xx1);};
        if (ddl_etpas_TQ_2) {x1x2.push_back(x2);} else {lix1x2.push_back(xx1);};
        List_io<TypeQuelconque>::iterator ilix1x2 = lix1x2.begin();
        List_io<TypeQuelconque>::iterator ilix1x2_fin = ilix1x2;ilix1x2_fin++;
        // maintenant on affiche les infos pour la liste totale d'éléments
        List_io <int>::iterator iptinteg = tab_total_ptint.begin(); 
        if ( ddl_etpas_TQ_1 & !ddl_etpas_TQ_2)
         { // cas où la première grandeur est ddl et la seconde particulière
           for (ielement = tab_total_elem.begin();ielement!=ielementfin;ielement++,iptinteg++)
            { // les grandeurs de type enum
             Tableau <double> tab= 
                lesMail->Element_LesMaille(numMail,*ielement).Valeur_a_diff_temps(absolue,TEMPS_tdt,x1x2,*iptinteg);
             // les grandeurs particulières     
             lesMail->Element_LesMaille(numMail,*ielement).Grandeur_particuliere(absolue,lix1x2,*iptinteg);
             // enregistrement
             double val2= (*ilix1x2).GrandeurNumOrdre(nb_ordre_2);
             liste_sortie.push_back(DeuxDoubles(tab(1),val2)); 
            }
         }
        else  if ( !ddl_etpas_TQ_1 & ddl_etpas_TQ_2)
         { // cas où la première grandeur est particulière et la seconde ddl
           for (ielement = tab_total_elem.begin();ielement!=ielementfin;ielement++,iptinteg++)
            { // les grandeurs de type enum
             Tableau <double> tab= 
                lesMail->Element_LesMaille(numMail,*ielement).Valeur_a_diff_temps(absolue,TEMPS_tdt,x1x2,*iptinteg);
             // les grandeurs particulières     
             lesMail->Element_LesMaille(numMail,*ielement).Grandeur_particuliere(absolue,lix1x2,*iptinteg);
             // enregistrement
             double val1= (*ilix1x2).GrandeurNumOrdre (nb_ordre_1);
             liste_sortie.push_back(DeuxDoubles(val1,tab(1))); 
            }
         }
        else  // sinon les deux grandeurs sont particulière
         { for (ielement = tab_total_elem.begin();ielement!=ielementfin;ielement++,iptinteg++)
            {// les grandeurs particulières     
             lesMail->Element_LesMaille(numMail,*ielement).Grandeur_particuliere(absolue,lix1x2,*iptinteg);
             // enregistrement
             double val1= (*ilix1x2).GrandeurNumOrdre(nb_ordre_1);
             double val2= (*ilix1x2_fin).GrandeurNumOrdre(nb_ordre_2);
             liste_sortie.push_back(DeuxDoubles(val1,val2)); 
            }
         };
        }; //-- fin du cas où il y a au moins une grandeur particulière 
     }; // fin du else sur les grandeurs aux éléments
  // ajout de la  courbe à l'animation 
  animation_maple->Ajout_courbe(liste_sortie);                      
};
   
// entrée du choix de l'utilisation sur le style de sortie
void Choix_grandeurs_maple::Style_de_sortie(string& rep)
{rep = ""; // init
 while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
   {// on expliques les différentes possibles possibles
    cout << "\n differents choix possibles                                     "
         << "\n sortie avec standart automatique                               (rep : st)"
         << "\n forcer l'ecriture sur une ligne unix pour chaque increment     (rep : ul)"
         << "\n tenseur en absolue                                             (rep : ab)"
         << "\n tenseur dans un repere le plus ad hoc                          (rep : ad)"
         << "\n aide                                                           (rep :  ?)"
         << "\n  pas de changement et retour                           (rep : fin (ou f)) ";
    cout << "\n ( valeur actuelle du choix: "; 
    if (style_de_sortie==0) {cout << " st )\n";} else {cout << " ul )\n";};
    rep = "";
    cout << "\n choix ? ";rep = lect_return_defaut(false,"f");
    if (rep == "st") { style_de_sortie = 0;}
    else if (rep == "ul")  { style_de_sortie = 1;}
    else if (rep == "ab")  { absolue = 1;}
    else if (rep == "ad")  { absolue = 0;}
    else if (rep == "?")
     { cout << "\n dans le cas d'une sortie standart automatique, chaque increment est sortie sur une ligne"
            << " unix, sauf dans le cas ou un seul increment est en sortie. Dans ce dernier cas,"
            << "  les informations sont decoupees par defaut, par exemple selon: une ligne = un noeud , "
            << "  et le temps n'est pas indique. Dans certain cas cette modification automatique de format"
            << " n'est pas interressante (par exemple pour les sorties au fil du calcul), il est alors possible"
            << " de forcer une sortie globale de l'increment sur une seule ligne meme dans le cas d'un seul increment"
            << " c'est l'option ul. "
            << " \n concernant la sortie des tenseurs: par defaut les tenseurs sont exprimes dans le repere "
            << " absolu. Dans le cas de coque par exemple, il est plus interessant d'exprimer les tenseurs "
            << " dans un repere tangent a l'element (repere ad hoc) "
            ;
       }
    else
     { cout << "\n erreur de syntaxe, recommencez ! ";};
   };
}; 
 
// vérification des listes de pt d'integ et d'éléments relativement au grandeur à sortir
void Choix_grandeurs_maple::VerifListes()
{   // on vérifie que les grandeurs principale de type enum étendue que l'on veut sortir sont possible
    // par contre pas de vérif pour les grandeurs quelconques
    int nb_maillage = tabelement_type_ddl.Taille();
    // def d'un conteneur de travail
    Maillage::NBelemEtptInteg nut; 
    for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
	  {
         List_io<Ddl_enum_etendu>::iterator ienufin=tabelement_type_ddl_retenu(n_mail).end();
         List_io<Ddl_enum_etendu>::iterator ienu_deb=tabelement_type_ddl_retenu(n_mail).begin();
         List_io<Ddl_enum_etendu>::iterator ienu;
         
	     // 1) liste d'éléments
	     {List_io <BlocScal>::iterator idl,idlfin= nomDeRef_E(n_mail).end();
          for (idl=nomDeRef_E(n_mail).begin();idl!=idlfin;idl++)
           { // recup de la reference correspondant au mot cle
             const Reference& refi = lesRef->Trouve((*idl).NomRef(),n_mail);
             const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'éléments
             int taillen=reff.Taille(); // nombre d'éléments dans la liste
             for (int ielem=1;ielem<=taillen;ielem++)  // on boucle et on test
               {
                 // boucle sur les ddl retenus
                 for (ienu = ienu_deb;ienu != ienufin; ienu++)
                   { nut.nbElem = reff.Numero(ielem);
                     nut.nbPtInteg = (int) ((*idl).Val());
                     // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                     if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ienu).Enum())))
                         { cout << "\n warning : le numero " << nut.nbPtInteg << " de numero d'ordre "
                                << " pour le ddl " << Nom_ddl((*ienu).Enum()) << " n'est pas valide  pour l'element "
                                << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                          };
                   }; // fin de la boucle sur les ddl retenus
               };//-- fin de la boucle sur les éléments de la référence   
           }; //-- fin de la boucle sur les références d'éléments 
	     };// fin encapsulage

	     // 2) liste de points d'intégrations d'éléments
	     {List_io <string>::iterator idl,idlfin= nomDeRef_ptinteg(n_mail).end();
          for (idl=nomDeRef_ptinteg(n_mail).begin();idl!=idlfin;idl++)
           { // recup de la reference correspondant au mot cle
             const Reference& refi = lesRef->Trouve((*idl),n_mail);
             const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'éléments
             int taillen=reff.Taille(); // nombre d'éléments dans la liste
             for (int ielem=1;ielem<=taillen;ielem++)  // on boucle et on test
               {
                 // boucle sur les ddl retenus
                 for (ienu = ienu_deb;ienu != ienufin; ienu++)
                   { nut.nbElem = reff.NumeroElem(ielem);
                     nut.nbPtInteg = reff.NumeroFA(ielem);
                     // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                     if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ienu).Enum())))
                         { cout << "\n warning : le numero " << nut.nbPtInteg << " de numero d'ordre "
                                << " pour le ddl " << Nom_ddl((*ienu).Enum()) << " n'est pas valide  pour l'element "
                                << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                          };
                   }; // fin de la boucle sur les ddl retenus
               };//-- fin de la boucle sur les éléments de la référence   
           }; //-- fin de la boucle sur les références d'éléments 
	     };// fin encapsulage
	  }; // fin de la boucle sur les maillages
		
	};
   
	 // utilitaire de sortie d'entête pour les noeuds:
void Choix_grandeurs_maple::Sortie_entete_noeud_unitaire(list<int>::const_iterator imail,ostream & sort, int& num_col)
   { // on sort la position des xyz
	    switch (ParaGlob::Dimension())
 	    {case 1: sort << " ["<<num_col<<"]X "; num_col++; break;
 	     case 2: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y " ;num_col+=2; break;
 	     case 3: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y "<< " ["<<num_col+2<<"]Z ";num_col+=3; break;
 	    };
     // les positions de chaque grandeurs
     //  --- les ddl principaux ----
     {List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabnoeud_type_ddl_retenu(*imail).end();
      for (ienu = tabnoeud_type_ddl_retenu(*imail).begin();ienu!=ienufin;ienu++)
       { switch (type_sortie_ddl_retenue)
         { case 0: sort << " ["<<num_col<<"]"<< (*ienu).Nom_plein() << " ";num_col++;break;
           case 1: sort << " ["<<num_col<<"]"<< ("delta_0_t_"+string((*ienu).Nom_plein())) << " ";num_col++;break;
           case 2: sort << " ["<<num_col<<"]"<< (string((*ienu).Nom_plein())+"_0")<<" "
                        << " ["<<num_col+1<<"]"<< (*ienu).Nom_plein() << " ";num_col+=2; break;
         };
         
       };
     };
     //  --- les ddl étendus ----
     {List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabnoeud_type_ddlEtendu_retenu(*imail).end();
      for (ienu = tabnoeud_type_ddlEtendu_retenu(*imail).begin();ienu!=ienufin;ienu++)
       { sort << " ["<<num_col<<"]"<< (*ienu).Nom_plein() << " ";num_col++; };
     };
     //  --- les grandeurs quelconques ---
     {List_io<TypeQuelconque>::iterator iquefin=tabnoeud_TypeQuelconque_retenu(*imail).end();
      List_io<TypeQuelconque>::iterator ique,ique_deb=tabnoeud_TypeQuelconque_retenu(*imail).begin();
      for (ique = ique_deb;ique != iquefin;ique++)
        {(*ique).Ecriture_entete_grandeur(sort);
         sort << " ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"]"; // l'étendue des colonnes
         num_col += (*ique).NbMaxiNumeroOrdre();
         sort << "\n#     ";
        };
     };
    
     sort << " ;\n# ";
   };

	 // utilitaire de sortie d'entête pour les éléments:
void Choix_grandeurs_maple::Sortie_entete_element_unitaire(list<int>::const_iterator imail,ostream & sort, int& num_col, bool & temps_deja_affiche)
{
    // a) les Ddl_enum_etendu
    List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabelement_type_ddl_retenu(*imail).end();
    List_io<Ddl_enum_etendu>::iterator ienu_deb=tabelement_type_ddl_retenu(*imail).begin();
    if (ienu_deb !=  ienufin) // c'est a dire: cas où existe une grandeur
    { // on sort la position des xyz du point d'intégration
	     if (!temps_deja_affiche) num_col++; // on passe l'affichage du temps si besoin
      temps_deja_affiche=true;
      switch (ParaGlob::Dimension())
	      {case 1: sort << " ["<<num_col<<"]X "; num_col++; break;
	       case 2: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y " ;num_col+=2; break;
	       case 3: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y "<< " ["<<num_col+2<<"]Z ";num_col+=3; break;
	      };
      // les positions de chaque grandeurs
      for (ienu = tabelement_type_ddl_retenu(*imail).begin();ienu!=ienufin;ienu++,num_col++)
        sort << "  ["<<num_col<<"]"<< (*ienu) << " ";
    };
   {// maintenant les grandeurs particulières
    List_io<TypeQuelconque>::iterator iquefin=tabelement_typeParti_retenu(*imail).end();
    List_io<TypeQuelconque>::iterator ique,ique_deb=tabelement_typeParti_retenu(*imail).begin();
    if (ique_deb !=  iquefin) // c'est a dire: cas où existe une grandeur
    { // on sort la position des xyz du point d'intégration
      sort << "\n#                       ";
		    if (!temps_deja_affiche) num_col++; // on passe l'affichage du temps si on ne l'a pas déjà passé
      switch (ParaGlob::Dimension())
	      {case 1: sort << " ["<<num_col<<"]X "; num_col++; break;
	       case 2: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y " ;num_col+=2; break;
	       case 3: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y "<< " ["<<num_col+2<<"]Z ";num_col+=3; break;
	      };
      sort << "\n#     ";
      // puis l'intervalle des grandeurs
      for (ique = tabelement_typeParti_retenu(*imail).begin();ique!=iquefin;ique++)
        {(*ique).Ecriture_entete_grandeur(sort);
         sort << " ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"]"; // l'étendue des colonnes
         num_col += (*ique).NbMaxiNumeroOrdre();
         sort << "\n#     ";
        };
	   };
   }; // fin encapsulage pour les grandeurs particulières
 
   {// maintenant les grandeurs évoluées
    List_io<TypeQuelconque>::iterator iquefin=tabelement_evoluee_retenu(*imail).end();
    List_io<TypeQuelconque>::iterator ique,ique_deb=tabelement_evoluee_retenu(*imail).begin();
    if (ique_deb !=  iquefin) // c'est a dire: cas où existe une grandeur
    { // on sort la position des xyz du point d'intégration
      sort << "\n#                       ";
      if (!temps_deja_affiche)
        {num_col++; // on passe l'affichage du temps si on ne l'a pas déjà passé
         temps_deja_affiche=true;
        };
      switch (ParaGlob::Dimension())
	      {case 1: sort << " ["<<num_col<<"]X "; num_col++; break;
	       case 2: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y " ;num_col+=2; break;
	       case 3: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y "<< " ["<<num_col+2<<"]Z ";num_col+=3; break;
	      };
      sort << "\n#     ";
      // puis l'intervalle des grandeurs
      for (ique = tabelement_evoluee_retenu(*imail).begin();ique!=iquefin;ique++)
        {(*ique).Ecriture_entete_grandeur(sort);
         sort << " ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"]"; // l'étendue des colonnes
         num_col += (*ique).NbMaxiNumeroOrdre();
         sort << "\n#     ";
        };
	   };
   }; // fin encapsulage pour les grandeurs évoluées
    sort << "\n# ";
};

// utilitaire de sortie d'entête pour les faces d'élément:
void Choix_grandeurs_maple::Sortie_entete_face_element_unitaire(list<int>::const_iterator imail,ostream & sort, int& num_col, bool & temps_deja_affiche)
{
   {// cas des grandeurs quelconques
    List_io<TypeQuelconque>::iterator iquefin=tab_F_element_TypeQuelconque_retenu(*imail).end();
    List_io<TypeQuelconque>::iterator ique,ique_deb=tab_F_element_TypeQuelconque_retenu(*imail).begin();
    if (ique_deb !=  iquefin) // c'est a dire: cas où existe une grandeur
    { // on sort la position des xyz du point d'intégration
      sort << "\n#                       ";
      if (!temps_deja_affiche)
        {num_col++; // on passe l'affichage du temps si on ne l'a pas déjà passé
         temps_deja_affiche=true;
        };
      switch (ParaGlob::Dimension())
       {case 1: sort << " ["<<num_col<<"]X "; num_col++; break;
        case 2: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y " ;num_col+=2; break;
        case 3: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y "<< " ["<<num_col+2<<"]Z ";num_col+=3; break;
       };
      sort << "\n#     ";
      // puis l'intervalle des grandeurs
      for (ique = tab_F_element_TypeQuelconque_retenu(*imail).begin();ique!=iquefin;ique++)
        {(*ique).Ecriture_entete_grandeur(sort);
         sort << " ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"]"; // l'étendue des colonnes
         num_col += (*ique).NbMaxiNumeroOrdre();
         sort << "\n#     ";
        };
    };
   }; // fin encapsulage pour les grandeurs quelconques
   sort << "\n# ";
};
// utilitaire de sortie d'entête pour les arêtes d'élément:
void Choix_grandeurs_maple::Sortie_entete_arete_element_unitaire(list<int>::const_iterator imail,ostream & sort, int& num_col, bool & temps_deja_affiche)
{
   {// cas des grandeurs quelconques
    List_io<TypeQuelconque>::iterator iquefin=tab_A_element_TypeQuelconque_retenu(*imail).end();
    List_io<TypeQuelconque>::iterator ique,ique_deb=tab_A_element_TypeQuelconque_retenu(*imail).begin();
    if (ique_deb !=  iquefin) // c'est a dire: cas où existe une grandeur
    { // on sort la position des xyz du point d'intégration
      sort << "\n#                       ";
      if (!temps_deja_affiche)
        {num_col++; // on passe l'affichage du temps si on ne l'a pas déjà passé
         temps_deja_affiche=true;
        };
      switch (ParaGlob::Dimension())
       {case 1: sort << " ["<<num_col<<"]X "; num_col++; break;
        case 2: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y " ;num_col+=2; break;
        case 3: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y "<< " ["<<num_col+2<<"]Z ";num_col+=3; break;
       };
      sort << "\n#     ";
      // puis l'intervalle des grandeurs
      for (ique = tab_A_element_TypeQuelconque_retenu(*imail).begin();ique!=iquefin;ique++)
        {(*ique).Ecriture_entete_grandeur(sort);
         sort << " ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"]"; // l'étendue des colonnes
         num_col += (*ique).NbMaxiNumeroOrdre();
         sort << "\n#     ";
        };
    };
   }; // fin encapsulage pour les grandeurs quelconques
   sort << "\n# ";
};