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

#include "Choix_grandeurs_maple.h"
#include "CharUtil.h"
#include "ReferenceNE.h"
#include "ReferencePtiAF.h"
#include "ParaGlob.h"
#include <iomanip>
#include "TypeQuelconqueParticulier.h"

/*
// -> face d'éléments
Tableau <List_io < TypeQuelconque > > tab_F_element_TypeQuelconque; // TypeQuelconque aux faces d'elements possibles à visualiser
Tableau <List_io < TypeQuelconque > > tab_F_element_TypeQuelconque_retenu; // TypeQuelconque aux faces d'elements  à visualiser
Tableau <List_io < TypeQuelconque > > tab_F_element_TypeQuelconque_retenu_pourSM; // idem pour somme, moy etc. sur une ref

// -> arête d'éléments
Tableau <List_io < TypeQuelconque > > tab_A_element_TypeQuelconque; // TypeQuelconque aux arêtes d'elements possibles à visualiser
Tableau <List_io < TypeQuelconque > > tab_A_element_TypeQuelconque_retenu; // TypeQuelconque aux arête d'elements  à visualiser
Tableau <List_io < TypeQuelconque > > tab_A_element_TypeQuelconque_retenu_pourSM; // idem pour somme, moy etc. sur une ref

Tableau <List_io <BlocScal> > tab_nomDeRef_F_E_SM; // list de nom de références de faces d'élément et de point d'intégration associé
Tableau <List_io <string> > tab_nomDeRef_F_ptinteg_SM; // list de nom de références de pt d'integ de faces d'éléments

Tableau <List_io <BlocScal> > tab_nomDeRef_A_E_SM; // list de nom de références d'arêtes d'élément et de point d'intégration associé
Tableau <List_io <string> > tab_nomDeRef_A_ptinteg_SM; // list de nom de références de pt d'integ d'arêtes d'élément

// -> les pti de face d'éléments
Tableau <List_io <int> > tab_num_F_element; // liste des éléments à visualiser
Tableau <List_io <int> > tab_num_F; // liste des num de face ou arêtes d'éléments à visualiser
Tableau <List_io <int> > tab_num_F_integ; // liste des numéros de point d'integration à visualiser associé à tab_num_F_element
Tableau <List_io <BlocScal> > nomDeRef_F_E; // list de nom de références face  d'éléments associés
Tableau <List_io <string> > nomDeRef_F_ptinteg; // list de nom de références de pt d'integ de face d'éléments

// -> les pti d'arête d'éléments
Tableau <List_io <int> > tab_num_A_element; // liste des éléments à visualiser
Tableau <List_io <int> > tab_num_A; // liste des num d'arêtes d'éléments à visualiser
Tableau <List_io <int> > tab_num_A_integ; // liste des numéros de point d'integration à visualiser associé à tab_num_A_element
Tableau <List_io <BlocScal> > nomDeRef_A_E; // list de nom de références d'arête d'éléments  associé
Tableau <List_io <string> > nomDeRef_A_ptinteg; // list de nom de références de pt d'integ d'arête d'éléments
*/


    // CONSTRUCTEURS :
// par defaut
Choix_grandeurs_maple::Choix_grandeurs_maple () : 
   OrdreVisu("...................................choix grandeurs" // de 15 à 65
             ,"choix des grandeurs a visualiser","cg")
   ,tabnoeud_type_ddl(),tabnoeud_type_ddl_retenu(),type_sortie_ddl_retenue(0)
   ,tabnoeud_type_ddlEtendu(),tabnoeud_type_ddlEtendu_retenu()
   ,tabnoeud_TypeQuelconque(),tabnoeud_TypeQuelconque_retenu()
   ,lesMail(NULL),lesRef(NULL),nomDeRef(),nomDeRef_E(),nomDeRef_ptinteg()
   // -> les pti de face d'éléments
   ,tab_num_F_element(),tab_num_F(),tab_num_F_integ()
   ,nomDeRef_F_E(),nomDeRef_F_ptinteg()
   ,tab_F_element_TypeQuelconque(),tab_F_element_TypeQuelconque_retenu()
   // -> les pti d'arête d'éléments
   ,tab_num_A_element(),tab_num_A(),tab_num_A_integ()
   ,nomDeRef_A_E(),nomDeRef_A_ptinteg()
   ,tab_A_element_TypeQuelconque(),tab_A_element_TypeQuelconque_retenu()

   ,tabelement_type_ddl(),tabelement_type_ddl_retenu()
   ,tabelement_typeParti(),tabelement_typeParti_retenu()
   ,tabelement_evoluee(),tabelement_evoluee_retenu()
   ,tab_num_noeud(),tab_num_element(),tab_num_integ()
   ,list_grandeur_global(),list_grand_global_retenu()
   ,listeVecGlobbal(),listeVecGlobbal_retenu()
   ,tab_list_torseur_condLim(),tab_list_torseur_condLim_retenu()
   ,x1(),x2(),accroi_x1(false),accroi_x2(true),type_xi(true)
   ,xx1(),xx2(),ddl_etpas_TQ_1(1),ddl_etpas_TQ_2(1),nb_ordre_1(1),nb_ordre_2(1)
   ,animation_maple(NULL),choix_mail(NULL),style_de_sortie(1) 
	  ,der_numero_mail(0),absolue(false)
    // --- pour les sorties concernant les sommes et moyennes etc. relativement à des références
   ,tab_nomDeRef_SM(),tab_nomDeRef_E_SM(),tab_nomDeRef_ptinteg_SM() // noeuds et éléments
   ,tab_nomDeRef_F_E_SM(),tab_nomDeRef_F_ptinteg_SM() // faces d'éléments
   ,tab_nomDeRef_A_E_SM(),tab_nomDeRef_A_ptinteg_SM() // arêtes d'éléments

   ,tabnoeud_type_ddl_retenu_pourSM()
   ,tabnoeud_type_ddlEtendu_retenu_pourSM(),tabnoeud_TypeQuelconque_retenu_pourSM()
   ,tabelement_type_ddl_retenu_pourSM(),tabelement_typeParti_retenu_pourSM()
   ,tabelement_evoluee_retenu_pourSM()
   ,tab_F_element_TypeQuelconque_retenu_pourSM()  // face d'éléments
   ,tab_A_element_TypeQuelconque_retenu_pourSM()  // arêtes d'éléments

     {if (ParaGlob::Anglais()) 
	       OrdreVisu::changeLibelle("..............................choice of quantities" // de 15 à 65
                                 ," choice of the quantities for visualisation ","cg");	  
	    }; 
     
     // constructeur de copie 
Choix_grandeurs_maple::Choix_grandeurs_maple (const Choix_grandeurs_maple& ord) :
    OrdreVisu(ord)
    ,tabnoeud_type_ddl(ord.tabnoeud_type_ddl)
    ,tabnoeud_type_ddl_retenu(ord.tabnoeud_type_ddl_retenu)
    ,type_sortie_ddl_retenue(ord.type_sortie_ddl_retenue)
    ,tabnoeud_type_ddlEtendu(ord.tabnoeud_type_ddlEtendu)
    ,tabnoeud_type_ddlEtendu_retenu(ord.tabnoeud_type_ddlEtendu_retenu)
    ,tabnoeud_TypeQuelconque(ord.tabnoeud_TypeQuelconque)
    ,tabnoeud_TypeQuelconque_retenu(ord.tabnoeud_TypeQuelconque_retenu)
    ,lesMail(ord.lesMail),lesRef(ord.lesRef),nomDeRef(ord.nomDeRef)
    ,nomDeRef_E(ord.nomDeRef_E),nomDeRef_ptinteg(ord.nomDeRef_ptinteg)
    // -> les pti de face d'éléments
    ,tab_num_F_element(ord.tab_num_F_element)
    ,tab_num_F(ord.tab_num_F),tab_num_F_integ(ord.tab_num_F_integ)
    ,nomDeRef_F_E(ord.nomDeRef_F_E),nomDeRef_F_ptinteg(ord.nomDeRef_F_ptinteg)
    ,tab_F_element_TypeQuelconque(ord.tab_F_element_TypeQuelconque)
    ,tab_F_element_TypeQuelconque_retenu(ord.tab_F_element_TypeQuelconque_retenu)

    // -> les pti d'arête d'éléments
    ,tab_num_A_element(ord.tab_num_A_element)
    ,tab_num_A(ord.tab_num_A),tab_num_A_integ(ord.tab_num_A_integ)
    ,nomDeRef_A_E(ord.nomDeRef_A_E),nomDeRef_A_ptinteg(ord.nomDeRef_A_ptinteg)
    ,tab_A_element_TypeQuelconque(ord.tab_A_element_TypeQuelconque)
    ,tab_A_element_TypeQuelconque_retenu(ord.tab_A_element_TypeQuelconque_retenu)

    ,tabelement_type_ddl(ord.tabelement_type_ddl)
    ,tabelement_type_ddl_retenu(ord.tabelement_type_ddl_retenu)
    ,tabelement_typeParti(ord.tabelement_typeParti)
    ,tabelement_typeParti_retenu(ord.tabelement_typeParti_retenu)
    ,tabelement_evoluee(ord.tabelement_evoluee)
    ,tabelement_evoluee_retenu(ord.tabelement_evoluee_retenu)
    ,tab_num_noeud(ord.tab_num_noeud),tab_num_element(ord.tab_num_element)
    ,tab_num_integ(ord.tab_num_integ)
    ,list_grandeur_global(ord.list_grandeur_global)
    ,list_grand_global_retenu(ord.list_grand_global_retenu)
    ,listeVecGlobbal(ord.listeVecGlobbal),listeVecGlobbal_retenu(ord.listeVecGlobbal_retenu)
    ,tab_list_torseur_condLim(ord.tab_list_torseur_condLim)
    ,tab_list_torseur_condLim_retenu(ord.tab_list_torseur_condLim_retenu) 
    ,x1(ord.x1),x2(ord.x2),accroi_x1(ord.accroi_x1),accroi_x2(ord.accroi_x2)
    ,type_xi(ord.type_xi) 
    ,xx1(ord.xx1),xx2(ord.xx2),ddl_etpas_TQ_1(ord.ddl_etpas_TQ_1),ddl_etpas_TQ_2(ord.ddl_etpas_TQ_2)
    ,nb_ordre_1(ord.nb_ordre_1),nb_ordre_2(ord.nb_ordre_2)
    ,animation_maple(ord.animation_maple),choix_mail(ord.choix_mail),style_de_sortie(ord.style_de_sortie) 
	   ,der_numero_mail(ord.der_numero_mail),absolue(ord.absolue)
    // --- pour les sorties concernant les sommes et moyennes etc. relativement à des références
    ,tab_nomDeRef_SM(ord.tab_nomDeRef_SM)
    ,tab_nomDeRef_E_SM(ord.tab_nomDeRef_E_SM)
    ,tab_nomDeRef_ptinteg_SM(ord.tab_nomDeRef_ptinteg_SM)
    
    ,tab_nomDeRef_F_E_SM(ord.tab_nomDeRef_F_E_SM) // faces d'éléments
    ,tab_nomDeRef_F_ptinteg_SM(ord.tab_nomDeRef_F_ptinteg_SM) // faces d'éléments
    ,tab_nomDeRef_A_E_SM(ord.tab_nomDeRef_A_E_SM) // arêtes d'éléments
    ,tab_nomDeRef_A_ptinteg_SM(ord.tab_nomDeRef_A_ptinteg_SM) // arêtes d'éléments

    ,tabnoeud_type_ddl_retenu_pourSM(ord.tabnoeud_type_ddl_retenu_pourSM)
    ,tabnoeud_type_ddlEtendu_retenu_pourSM(ord.tabnoeud_type_ddlEtendu_retenu_pourSM)
    ,tabnoeud_TypeQuelconque_retenu_pourSM(ord.tabnoeud_TypeQuelconque_retenu_pourSM)
    ,tabelement_type_ddl_retenu_pourSM(ord.tabelement_type_ddl_retenu_pourSM)
    ,tabelement_typeParti_retenu_pourSM(ord.tabelement_typeParti_retenu_pourSM)
    ,tabelement_evoluee_retenu_pourSM(ord.tabelement_evoluee_retenu_pourSM)
    ,tab_F_element_TypeQuelconque_retenu_pourSM(ord.tab_F_element_TypeQuelconque_retenu_pourSM)  // face d'éléments
    ,tab_A_element_TypeQuelconque_retenu_pourSM(ord.tab_A_element_TypeQuelconque_retenu_pourSM)  // arêtes d'éléments
      {};
               
    // DESTRUCTEUR :
Choix_grandeurs_maple::~Choix_grandeurs_maple () 
     {};  
    
    // METHODES PUBLIQUES :
    
// initialisation : permet d'initialiser les différents paramètres de l'ordre
// lors d'un premier passage des différents incréments
// en virtuelle, a priori est défini si nécessaire dans les classes dérivées
void Choix_grandeurs_maple::Initialisation(ParaGlob * paraGlob,LesMaillages * lesmail,LesReferences* lesRefer
                      ,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage,Charge* charge
                      ,LesCondLim* lesCondLim,LesContacts* lesContacts
                      ,Resultats* resultats,EnumTypeIncre type_incre,int incre
                      ,const map < string, const double * , std::less <string> >& listeVarGlob
                      ,const List_io < TypeQuelconque >& listeVecGlob
                      ,bool fil_calcul) 
   {
     // récupération de la liste des vecteurs globaux
     listeVecGlobbal = listeVecGlob;
     // initialisation de la liste des différentes isovaleurs possibles
     Init_liste_grandeurs(lesmail,lesCondLim,lesContacts,fil_calcul);
     // récup de l'adresse des maillages
     lesMail = lesmail;
    
     // récup de la liste de référence
     lesRef = lesRefer;
     //appel de l'ordre d'initialisation de la classe mère
     OrdreVisu::Initialisation(paraGlob,lesMail,lesRef,lesLoisDeComp,diversStockage,charge
                      ,lesCondLim,lesContacts,resultats,type_incre,incre
                      ,listeVarGlob,listeVecGlob,fil_calcul);
     // récupération de la liste des grandeurs globales
     map < string, const double * , std::less <string> >::const_iterator il,ilfin= listeVarGlob.end();
     for (il=listeVarGlob.begin();il != ilfin; il++)
       { // on rempli si ce n'est pas déjà présent
         if (find(list_grandeur_global.begin(),list_grandeur_global.end(),(*il).first) == list_grandeur_global.end())
                 list_grandeur_global.push_back((*il).first);
        };
     // récupération de la liste des torseurs de réaction
     tab_list_torseur_condLim = lesCondLim->TabListTorseurReaction(*lesmail);
     // on redimensionne la liste de sortie au cas où
     tab_list_torseur_condLim_retenu.Change_taille(tab_list_torseur_condLim.Taille());
     // init par defaut
     Ddl_enum_etendu x; x1 = x; x2 = x; accroi_x1 = false; accroi_x2 = true; type_xi = true;                        
   };
   
// execution de l'ordre
// tab_mail : donne les numéros de maillage concerné
// incre : numéro d'incrément qui en cours
// type_incre : indique si c'est le premier le dernier ou l'incrément courant a visualiser ou pas
// animation : indique si l'on est en animation ou pas
// unseul_incre : indique si oui ou non il y a un seul increment à visualiser
void Choix_grandeurs_maple::ExeOrdre(ParaGlob * ,const Tableau <int>& tab_mail  ,LesMaillages * lesMail,bool unseul_incre,LesReferences*
                      ,LesLoisDeComp* ,DiversStockage*,Charge* charge,LesCondLim* lesCondLim
                      ,LesContacts* lesContacts,Resultats*,UtilLecture & entreePrinc,OrdreVisu::EnumTypeIncre type_incre ,int
                      ,bool animation,const map < string,const  double * , std::less <string> >& listeVarGlob
                      ,const List_io < TypeQuelconque >& listeVecGlob)
 {// pour simplifier
  int nbdigit = ParaGlob::NbdigdoGR();
  int nbmail = tab_mail.Taille();
  int dima = ParaGlob::Dimension();
  // visualisation du maillage pointé si actif
  if ((actif) && animation)
    {// 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
     for (int i=1;i<=nbmail;i++)
        Construction_liste_pour_animation(tab_mail(i),lesMail,charge);
     return;
    }
  else if (actif)
    { // cas du premier passage , pour les contacts on définit aux noeuds les conteneurs ad hoc
      // 14 oct 2016 je commente la suite car je ne sais pas si c'est ici ou dans initialisation qu'il faut
      // intervenir (cf. pense bête) 
//      if (type_incre == PREMIER_INCRE)
//       { // initialisation de la liste de grandeurs qui sont effectivement gérées par le contact
//         List_io<TypeQuelconque> list_gere_par_lesContacts
//                = lesContacts->Init_list_grandeur_contact_a_sortir(tabnoeud_TypeQuelconque_retenu);
//         // maintenant on ajoute les conteneurs ah hoc
//         List_io < Ddl_enum_etendu > vide; // ne sert à rien ici car vide
//         Tableau <List_io < TypeQuelconque > * > tabQ(2); // tableau transitoire
//         tabQ(1) = &list_gere_par_lesContacts; tabQ(2)= NULL; // init
//         lesMail->AjoutConteneurAuNoeud(vide,tabQ);
//       };
    
      ostream &sort = entreePrinc.Sort_princ_maple();
      // on statue que les sorties seront de type affichage scientifique
      sort.setf(ios::scientific);
      // on balaie la liste des grandeurs a visualiser, toutes les données sont sur une même ligne
      // sauf s'il y a un seul incrément
      // --- tout d'abord les grandeurs globales
      if (list_grand_global_retenu.size() != 0)
       { List_io <string>::iterator jeint,jeintfin = list_grand_global_retenu.end();
         sort << setprecision(nbdigit) << charge->Temps_courant() << " "; // le temps courant donc à tdt
         for (jeint=list_grand_global_retenu.begin();jeint!=jeintfin;jeint++)
          { // récup de la grandeur
            map < string,const  double * , std::less <string> >::const_iterator jei = listeVarGlob.find(*jeint);
            if (jei != listeVarGlob.end())
              {sort << setprecision(nbdigit) <<  (*((*jei).second)) << " ";}
            else
             {// on essaie alors au niveau des adressages directement avec un string
              const void * pointe = ParaGlob::param->GrandeurGlobal(*jeint);
              // si cela n'a pas fonctionné on essaie avec l'énuméré
              if ((pointe == NULL)
                  && EstUneGrandeurGlobale(*jeint)
                 )
                pointe = ParaGlob::param->GrandeurGlobal(Id_nom_GrandeurGlobale(*jeint) );
              if (pointe != NULL)
               {TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
                switch(gr_quelc->Grandeur_pointee()->Type_structure_grandeurAssocie())
                 { case  TYPE_SIMPLE:
                    { switch(gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere())
                       {case PARTICULIER_SCALAIRE_ENTIER:
                          {Grandeur_scalaire_entier& gr
                             = *((Grandeur_scalaire_entier*) gr_quelc->Grandeur_pointee()); // pour simplifier
                           sort << setprecision(nbdigit) <<  *(gr.ConteneurEntier())<< " ";
                           break;
                          }
                        case PARTICULIER_SCALAIRE_DOUBLE:
                          {Grandeur_scalaire_double& gr
                             = *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
                           sort << setprecision(nbdigit) <<  *(gr.ConteneurDouble())<< " ";
                           break;
                          }
                        case PARTICULIER_DDL_ETENDU:
                          {Grandeur_Ddl_etendu& gr
                             = *((Grandeur_Ddl_etendu*) gr_quelc->Grandeur_pointee()); // pour simplifier
                           sort << setprecision(nbdigit) <<  (gr.GrandeurNumOrdre(1))<< " ";
                           break;
                          }
                        case PARTICULIER_VECTEUR_NOMMER:
                          {Grandeur_Vecteur_Nommer& gr
                             = *((Grandeur_Vecteur_Nommer*) gr_quelc->Grandeur_pointee()); // pour simplifier
                           Vecteur& V = gr.ConteneurVecteur();
                           int taille = V.Taille();
                           for (int i=1;i<=taille;i++)
                              sort << setprecision(nbdigit) <<  V(i)<< " ";
                           break;
                          }
                        case PARTICULIER_VECTEUR:
                          {Grandeur_Vecteur& gr
                             = *((Grandeur_Vecteur*) gr_quelc->Grandeur_pointee()); // pour simplifier
                           Vecteur* V = gr.ConteneurVecteur();
                           int taille = V->Taille();
                           for (int i=1;i<=taille;i++)
                              sort << setprecision(nbdigit) <<  (*V)(i)<< " ";
                           break;
                          }
                        default:
                          {cout << "\n erreur en sortant la grandeur globale: " << (*jeint) << " on met 0 a la place ";}
                       }
                     break;
                   }
                 default:
                    {cout << "\n erreur en sortant la grandeur globale: " << (*jeint) << " on met 0 a la place ";};
                };
               }
              else
                {if (ParaGlob::Francais())
                      {cout << "\n erreur en sortant la grandeur globale: " << (*jeint) << " on met 0 a la place ";}
                 else {cout << "\n error for outputting the global quantity : " << (*jeint) << " the output will be 0  ";};
       
                 sort << setprecision(nbdigit) <<  0. << " ";
                 if (ParaGlob::NiveauImpression() >= 4)
                   cout << "\n Choix_grandeurs_maple::ExeOrdre(....)";
                };
             };
          };
       }; //-- fin des grandeurs globales
      // --- puis les torseurs de reaction 
      int nb_maillage = tab_list_torseur_condLim_retenu.Taille();
      for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
       { // pour simplifier
         List_io <String_et_entier >& list_torseur_condLim_retenu = tab_list_torseur_condLim_retenu(n_mail);
         // écriture du temps que si il y a des torseurs et que l'on n'est pas avec un seul incrément
         // sinon on écrit le temps également en commentaire
         // à moins que le style de sortie force une sortie sur une seule ligne
         if ((list_torseur_condLim_retenu.size() != 0) && ((!unseul_incre) || (style_de_sortie==1)))
           { sort << setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
         else if (list_torseur_condLim_retenu.size() != 0)
           // ici on écrit une fois le temps en commentaire
           { sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
         // maintenant on sort les torseurs
         List_io <String_et_entier>::iterator jfint,jfintfin = list_torseur_condLim_retenu.end();
         for (jfint=list_torseur_condLim_retenu.begin();jfint!=jfintfin;jfint++)
       	  { int indice = (*jfint).n;
	           lesCondLim->Torseur_de_reaction(indice).resultante.Affiche(sort,nbdigit);
            int dim = dima;
            // dans le cas axi c'est comme en 2D pour les torseurs
            if (ParaGlob::AxiSymetrie()) dim--;
	           switch (dim)
	      	    { case 1: break; // pas de moment en dimension 1
	      	      case 2: sort << setprecision(nbdigit)  // la première composante est le moment
	      	                   << lesCondLim->Torseur_de_reaction(indice).moment(1) << " ";
	      	              break;
	      	      case 3: lesCondLim->Torseur_de_reaction(indice).moment.Affiche(sort,nbdigit);
	      	              break;
	      	    };
	           // s'il n'y a qu'un seul incrément on met un retour à la ligne
            if ((unseul_incre) && (style_de_sortie==0)) sort << "\n";  
       	  };
       };
      // --- puis les grandeurs sommes, moyennes, maxi etc.
      // sortie pour les  ref N
      Sortie_somme_moy_N(sort,charge,unseul_incre);
      // sortie pour les  ref E
      Sortie_somme_moy_E(sort,charge,unseul_incre);
      // sortie pour les  ref de face E
      Sortie_somme_moy_face_E(sort,charge,unseul_incre);
      // sortie pour les  ref d'arete E
      Sortie_somme_moy_arete_E(sort,charge,unseul_incre);

      // --- puis les grandeurs aux noeuds 
      nb_maillage = tabnoeud_type_ddl.Taille();
      for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
       {List_io<int>::iterator inoeud,inoeudfin=tab_num_noeud(n_mail).end();
        // on crée une liste intermédiaire qui contient tous les noeuds à sortir, 
        List_io <int> tab_total_noeud = tab_num_noeud(n_mail); // 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(n_mail).end();
        for (idl=nomDeRef(n_mail).begin();idl!=idlfin;idl++)
         { // recup de la reference correspondant au mot cle
           const Reference& refi = lesRef->Trouve(*idl,n_mail);
           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();      
        // écriture du temps que si il y a des noeuds et que l'on n'est pas avec un seul incrément
        // sinon on écrit le temps également en commentaire
        // à moins que le style de sortie force une sortie sur une seule ligne
        if ((tab_total_noeud.begin() != inoeudfin) && ((!unseul_incre) || (style_de_sortie==1)))
          { sort << setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
        else if (tab_total_noeud.begin() != inoeudfin)
          // ici on écrit une fois le temps en commentaire
          { sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
        // maintenant on affiche les infos pour la liste totale de noeuds   
        for (inoeud = tab_total_noeud.begin();inoeud!=inoeudfin;inoeud++)
         { Noeud& noe=lesMail->Noeud_LesMaille(n_mail,*inoeud);
           Coordonnee ncor = noe.Coord0();  // par défaut dans le cas où les coordonnées à t n'existent pas
           if (noe.ExisteCoord2()) { ncor = noe.Coord2() ;} // cas normal:   coordonnées du noeud à tdt
           else if (noe.ExisteCoord1()) { ncor = noe.Coord1() ;}; // cas les coordonnées à tdt n'existent pas mais que celles à t existent
           for (int ic=1;ic<=ncor.Dimension();ic++) sort << setprecision(nbdigit) << ncor(ic) << " ";
          
           // .... sortie des ddl principaux .....
           {List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabnoeud_type_ddl_retenu(n_mail).end();
//debug
//if ((*inoeud)==1)
//  noe.Affiche();
//fin debug
            switch(type_sortie_ddl_retenue)
            { case 0: // cas où on ne sort que la grandeur
               for (ienu = tabnoeud_type_ddl_retenu(n_mail).begin();ienu!=ienufin;ienu++)
                { bool asortir = true; double val_a_sortir=0.; 
					             if (!noe.Existe_ici((*ienu).Enum()))
                     { asortir=false; 
	                #ifdef MISE_AU_POINT  // on regarde si la grandeur existe
					                 if (ParaGlob::NiveauImpression() >= 2)
						                   {if (ParaGlob::Francais())
                           {cout << "\n attention la grandeur " << (*ienu).Nom_plein() << " n'est pas disponible, on met 0 a la place";}
							                   else 
                           {cout << "\n Warning the quantity  " << (*ienu).Nom_plein() << " is not available, the output will be 0 ";};
                         };
                 #endif
						               };
                 if (asortir)  // puis la valeur finale de la grandeur
                  { if (charge->Temps_courant() == 0.) {val_a_sortir = noe.Valeur_0((*ienu).Enum());}
                    else if (noe.Tdt())                {val_a_sortir = noe.Valeur_tdt((*ienu).Enum());}
						              else                               {val_a_sortir = noe.Valeur_t((*ienu).Enum());};
                  };
                 sort << setprecision(nbdigit) << val_a_sortir << " ";
                };
               break; 
              case 1: // cas où on ne sort que la variation de la grandeur entre 0 et tdt ou t
               for (ienu = tabnoeud_type_ddl_retenu(n_mail).begin();ienu!=ienufin;ienu++)
                { bool asortir = true; double val_a_sortir=0.;
                  if (!noe.Existe_ici((*ienu).Enum()))
                   { asortir=false; 
                #ifdef MISE_AU_POINT  // on regarde si la grandeur existe
						               if (ParaGlob::NiveauImpression() >= 2)
						                 {if (ParaGlob::Francais())
                         {cout << "\n attention la grandeur " << (*ienu).Nom_plein() << " n'est pas disponible, on met 0 a la place";}
							                 else 
                         {cout << "\n Warning the quantity  " << (*ienu).Nom_plein() << " is not available, the output will be 0 ";};
                       };
                #endif
                   };
                  if (asortir)  // puis la valeur finale de la grandeur
                   { if (charge->Temps_courant() == 0.) {val_a_sortir = 0.;}
                     else if (noe.Tdt())                {val_a_sortir = noe.Valeur_tdt((*ienu).Enum())-noe.Valeur_0((*ienu).Enum());}
                     else                               {val_a_sortir = noe.Valeur_t((*ienu).Enum())-noe.Valeur_0((*ienu).Enum());};
					              };
                  sort << setprecision(nbdigit) << val_a_sortir << " ";
                };
               break; 
              case 2: // cas où on  sort les grandeurs à 0 et à tdt ou t
               for (ienu = tabnoeud_type_ddl_retenu(n_mail).begin();ienu!=ienufin;ienu++)
                { bool asortir = true; double val_a_sortir=0.;double val_init=0.;
                  if (!noe.Existe_ici((*ienu).Enum()))
                   { asortir=false; 
                #ifdef MISE_AU_POINT  // on regarde si la grandeur existe
						               if (ParaGlob::Francais())
                      {cout << "\n attention la grandeur " << (*ienu).Nom_plein() << " n'est pas disponible, on met 0 a la place";}
						               else 
                      {cout << "\n Warning the quantity  " << (*ienu).Nom_plein() << " is not available, the output will be 0 ";};
                #endif
						             }
                  if (asortir)  // puis la valeur finale de la grandeur
                   { if (charge->Temps_courant() == 0.)
                         {val_init = val_a_sortir = noe.Valeur_0((*ienu).Enum());}
                     else if (noe.Tdt())
                      {val_a_sortir = noe.Valeur_tdt((*ienu).Enum());
                       val_init = noe.Valeur_0((*ienu).Enum());}
                     else
                      {val_a_sortir = noe.Valeur_t((*ienu).Enum());
                       val_init = noe.Valeur_0((*ienu).Enum());};
					              };
                  sort << setprecision(nbdigit) << val_init << " "<< val_a_sortir << " ";
                };
               break;
            }; // fin du switch sur type_sortie_ddl_retenue
           };
          
           // .... sortie des ddl étendus .....
           {List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabnoeud_type_ddlEtendu_retenu(n_mail).end();
            for (ienu = tabnoeud_type_ddlEtendu_retenu(n_mail).begin();ienu!=ienufin;ienu++)
               {double val_a_sortir=0.; 
                #ifdef MISE_AU_POINT  // on regarde si la grandeur existe
                 if (!noe.Existe_ici_ddlEtendu((*ienu))) 
                   { if (ParaGlob::NiveauImpression() >= 2)
						                 {if (ParaGlob::Francais())
                         {cout << "\n attention la grandeur " << (*ienu).Nom_plein() << " n'est pas disponible, on met 0 a la place";}
							                 else 
                         {cout << "\n Warning the quantity  " << (*ienu).Nom_plein() << " is not available, the output will be 0 ";};
                       };
						             }
                #endif
                 if (noe.Existe_ici_ddlEtendu((*ienu))) {val_a_sortir = noe.DdlEtendue(*ienu).ConstValeur();}
                 sort << setprecision(nbdigit) << val_a_sortir << " ";
               };
           };
          
           // .... sortie des grandeurs quelconque aux noeud .....
           {List_io<TypeQuelconque>::iterator ienu,ienufin=tabnoeud_TypeQuelconque_retenu(n_mail).end();
            for (ienu = tabnoeud_TypeQuelconque_retenu(n_mail).begin();ienu!=ienufin;ienu++)
              { // récup de l'énuméré
                TypeQuelconque_enum_etendu enuq = (*ienu).EnuTypeQuelconque();
                #ifdef MISE_AU_POINT  // on regarde si la grandeur existe
                 if (!noe.Existe_ici(enuq))
                   { if (ParaGlob::NiveauImpression() >= 2)
						                 {if (ParaGlob::Francais())
                         {cout << "\n attention la grandeur " << (enuq.NomPlein()) << " n'est pas disponible, on met 0 a la place";}
							                 else 
                         {cout << "\n Warning the quantity  " << (enuq.NomPlein()) << " is not available, the output will be 0 ";};
                       };
						             }
                #endif
                if (noe.Existe_ici(enuq))
                 { const TypeQuelconque& grand_quelconque_noe = noe.Grandeur_quelconque(enuq);
                   grand_quelconque_noe.Grandeur_brut(sort,ParaGlob::NbdigdoGR());
                 }
                else
                 {// dans le cas où la grandeur n'existe pas on sort des 0
                  int nb_val = (*ienu).NbMaxiNumeroOrdre();
                  for (int j=1;j<= nb_val;j++)
                    sort << " 0  ";
                 };
               };
           };
          
           // s'il n'y a qu'un seul incrément on met un retour à la ligne
           if ((unseul_incre) && (style_de_sortie==0)) sort << "\n";  
         };
       };
     
      // --- puis les grandeurs aux éléments
      nb_maillage = tabelement_type_ddl.Taille();
      for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
       { List_io<int>::iterator ielement,ielementfin=tab_num_element(n_mail).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(n_mail); // tout d'abord récup de la liste des éléments
         List_io <int> tab_total_ptint = tab_num_integ(n_mail); // 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(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 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)
             };
          };
        }; // encapsulé
        
         // ---- puis les références de listes de points d'intégration d'éléments
        {
         {List_io <string>::iterator ids,idsfin= nomDeRef_ptinteg(n_mail).end();
          for (ids=nomDeRef_ptinteg(n_mail).begin();ids!=idsfin;ids++)
           { // recup de la reference correspondant au mot cle
             const Reference& refi = lesRef->Trouve((*ids),n_mail);
             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();      
         // écriture du temps que s 'il y a des éléments  et que l'on n'est pas avec un seul incrément
         // sinon on écrit le temps également en commentaire
         // à moins que le style de sortie force une sortie sur une seule ligne
         if ((tab_total_elem.begin() != ielementfin)  && ((!unseul_incre) || (style_de_sortie==1)))
           {sort << setw(3) // minimum sur 3 caractères
                << setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
         else if (tab_total_elem.begin() != ielementfin)
           // ici on écrit une fois le temps en commentaire
           {sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
         // maintenant on affiche les infos pour la liste totale d'éléments
         //   cout << " \n liste de pt integ " << tab_total_ptint;         // pour le débug
     
         List_io <int>::iterator iptinteg = tab_total_ptint.begin();  
         for (ielement = tab_total_elem.begin();ielement!=ielementfin;ielement++,iptinteg++)
          { // a) on s'occupe des Ddl_enum_etendu       
            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();
            if (ienu_deb !=  ienufin) // c'est a dire: cas où existe une grandeur
             { // coordonnées du point d'integ où sont données les grandeurs, systématiquement à tdt
               bool erreur=false; // ici on n'en tiend pas compte car déjà testé
               Coordonnee ncor = lesMail->Element_LesMaille(n_mail,*ielement).CoordPtInteg(TEMPS_tdt,(*ienu_deb).Enum(),*iptinteg,erreur);
               for (int ic=1;ic<=ncor.Dimension();ic++) sort << setprecision(nbdigit) << ncor(ic) << " ";
               // puis les grandeurs
               Tableau <double> tab= 
               lesMail->Element_LesMaille(n_mail,*ielement).Valeur_a_diff_temps(absolue,TEMPS_tdt,tabelement_type_ddl_retenu(n_mail),*iptinteg);
               int tabtaille = tab.Taille();
               for (int k=1;k<= tabtaille;k++)
                    sort << setprecision(nbdigit) << (double) tab(k) << " ";
             };        
            // b) on s'occupe des données particulières de type quelconque        
            List_io<TypeQuelconque>::iterator iquefin=tabelement_typeParti_retenu(n_mail).end();
            List_io<TypeQuelconque>::iterator ique,ique_deb=tabelement_typeParti_retenu(n_mail).begin();
            if (ique_deb !=  iquefin) // c'est a dire: cas où existe une grandeur
             { // coordonnées du point d'integ où sont données les grandeurs, systématiquement à tdt
               bool erreur=false; // ici on n'en tiend pas compte car déjà testé
               Coordonnee ncor = lesMail->Element_LesMaille(n_mail,*ielement).CoordPtInteg(TEMPS_tdt,(*ique_deb).Enum(),*iptinteg,erreur);
               for (int ic=1;ic<=ncor.Dimension();ic++) 
                 sort << setw(nbdigit)  << setprecision(nbdigit) << ncor(ic) << " ";
               // puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
               lesMail->Element_LesMaille(n_mail,*ielement).Grandeur_particuliere(absolue,tabelement_typeParti_retenu(n_mail),*iptinteg);
               // sortie
               for (ique=ique_deb;ique!=iquefin;ique++) (*ique).Grandeur_brut(sort,ParaGlob::NbdigdoGR());
             }; 
            // c) on s'occupe des données évoluées de type quelconque
            List_io<TypeQuelconque>::iterator jquefin=tabelement_evoluee_retenu(n_mail).end();
            List_io<TypeQuelconque>::iterator jque,jque_deb=tabelement_evoluee_retenu(n_mail).begin();
            if (jque_deb !=  jquefin) // c'est a dire: cas où existe une grandeur
             { // coordonnées du point d'integ où sont données les grandeurs, systématiquement à tdt
               bool erreur=false; // ici on n'en tiend pas compte car déjà testé
               Coordonnee ncor = lesMail->Element_LesMaille(n_mail,*ielement).CoordPtInteg(TEMPS_tdt,(*jque_deb).Enum(),*iptinteg,erreur);
               for (int ic=1;ic<=ncor.Dimension();ic++) 
                 sort << setw(nbdigit)  << setprecision(nbdigit) << ncor(ic) << " ";
               // puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
               lesMail->Element_LesMaille(n_mail,*ielement).ValTensorielle_a_diff_temps
                                 (absolue,TEMPS_tdt,tabelement_evoluee_retenu(n_mail),*iptinteg);
               // sortie
               for (jque=jque_deb;jque!=jquefin;jque++) (*jque).Grandeur_brut(sort,ParaGlob::NbdigdoGR());
             }; 
            // s'il n'y a qu'un seul incrément on met un retour à la ligne
            if ((unseul_incre) && (style_de_sortie==0)) sort << "\n";              
          };
        };
       };
       
      // --- puis les grandeurs aux faces d'éléments
      nb_maillage = tab_F_element_TypeQuelconque.Taille();
      for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
       { List_io<int>::iterator ielement,ielementfin=tab_num_F_element(n_mail).end();
         // on crée une liste intermédiaire qui contient toutes les faces éléments et point d'integ à sortir,
         List_io <int> tab_total_elem = tab_num_F_element(n_mail); // tout d'abord récup de la liste des éléments
         List_io <int> tab_total_face = tab_num_F(n_mail); // les numéros de face
         List_io <int> tab_total_ptint = tab_num_F_integ(n_mail); // et les points d'intégration correspondant
         // puis les références de listes de faces d'élément
         {List_io <BlocScal>::iterator idl,idlfin= nomDeRef_F_E(n_mail).end();
          for (idl=nomDeRef_F_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 ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de faces d'élément
             int taillen=reff.Taille(); // nombre d'éléments dans la liste
             for (int ielem=1;ielem<=taillen;ielem++)  // on boucle et enregistre les elements, face et le point
              { tab_total_elem.push_back(reff.NumeroElem(ielem));  // d'intégration
                tab_total_face.push_back(reff.NumeroFA(ielem));
                tab_total_ptint.push_back((int) ((*idl).Val()));          // associé (le même pour toute la référence)
              };
           };
         };
          
         // ---- puis les références de listes de points d'intégration de faces d'élément
         {List_io <string>::iterator ids,idsfin= nomDeRef_F_ptinteg(n_mail).end();
          for (ids=nomDeRef_F_ptinteg(n_mail).begin();ids!=idsfin;ids++)
           { // recup de la reference correspondant au mot cle
             const Reference& refi = lesRef->Trouve((*ids),n_mail);
             const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref de pt d'integ
             int taillen=reff.Taille(); // nombre faces d'élément dans la liste
             for (int ielem=1;ielem<=taillen;ielem++)  // on boucle et enregistre les
              { tab_total_elem.push_back(reff.NumeroElem(ielem));  // éléments
                tab_total_face.push_back(reff.NumeroFA(ielem));    // faces
                tab_total_ptint.push_back(reff.NumeroPti(ielem));  // ptis associés (le même pour toute la référence)
              };
           };
         }; // encapsulé
         
         ielementfin=tab_total_elem.end();
         // écriture du temps que s 'il y a des éléments  et que l'on n'est pas avec un seul incrément
         // sinon on écrit le temps également en commentaire
         // à moins que le style de sortie force une sortie sur une seule ligne
         if ((tab_total_elem.begin() != ielementfin)  && ((!unseul_incre) || (style_de_sortie==1)))
           {sort << setw(3) // minimum sur 3 caractères
                << setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
         else if (tab_total_elem.begin() != ielementfin)
           // ici on écrit une fois le temps en commentaire
           {sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
         // maintenant on affiche les infos pour la liste totale d'éléments
         //   cout << " \n liste de pt integ " << tab_total_ptint;         // pour le débug
       
         List_io <int>::iterator iptinteg = tab_total_ptint.begin();
         List_io <int>::iterator iptface = tab_total_face.begin();
         for (ielement = tab_total_elem.begin();ielement!=ielementfin;ielement++,iptinteg++,iptface++)
          { //  on s'occupe des données  de type quelconque
            List_io<TypeQuelconque>::iterator iquefin=tab_F_element_TypeQuelconque_retenu(n_mail).end();
            List_io<TypeQuelconque>::iterator ique,ique_deb=tab_F_element_TypeQuelconque_retenu(n_mail).begin();
            if (ique_deb !=  iquefin) // c'est a dire: cas où existe une grandeur
             { // coordonnées du point d'integ où sont données les grandeurs, systématiquement à tdt
               bool erreur=false;
               Coordonnee ncor = lesMail->Element_LesMaille(n_mail,*ielement).CoordPtIntFace(*iptface,TEMPS_tdt,*iptinteg,erreur);
               #ifdef MISE_AU_POINT
                 if ((ParaGlob::NiveauImpression() > 0)&& erreur)
                  { cout << "\n *** attention, les coordonnees du pti " << *iptinteg << " de la face " << *iptface
                         << " de l'element " << *ielement << " du maillage " << n_mail
                         << " n'est pas disponible "
                         << " peut etre que la face n'est pas utilisee ?? "<< endl;
                   }
               #endif
               for (int ic=1;ic<=ncor.Dimension();ic++)
                 sort << setw(nbdigit)  << setprecision(nbdigit) << ncor(ic) << " ";
               // puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
               lesMail->Element_LesMaille(n_mail,*ielement).Grandeur_particuliere_face(absolue,tab_F_element_TypeQuelconque_retenu(n_mail),*iptface,*iptinteg);
               // sortie
               for (ique=ique_deb;ique!=iquefin;ique++) (*ique).Grandeur_brut(sort,ParaGlob::NbdigdoGR());
             };
            // s'il n'y a qu'un seul incrément on met un retour à la ligne
            if ((unseul_incre) && (style_de_sortie==0)) sort << "\n";
          };
       };
      
     // --- puis les grandeurs aux arêtes d'élément
     nb_maillage = tab_A_element_TypeQuelconque.Taille();
     for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
      { List_io<int>::iterator ielement,ielementfin=tab_num_A_element(n_mail).end();
        // on crée une liste intermédiaire qui contient toutes les arêtes élément et point d'integ à sortir,
        List_io <int> tab_total_elem = tab_num_A_element(n_mail); // tout d'abord récup de la liste des éléments
        List_io <int> tab_total_arete = tab_num_A(n_mail); // les numéros d'arêtes
        List_io <int> tab_total_ptint = tab_num_A_integ(n_mail); // et les points d'intégration correspondant
        // puis les références de listes d'arêtes d'élément
        {List_io <BlocScal>::iterator idl,idlfin= nomDeRef_A_E(n_mail).end();
         for (idl=nomDeRef_A_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 ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'élément
            int taillen=reff.Taille(); // nombre d'éléments dans la liste
            for (int ielem=1;ielem<=taillen;ielem++)  // on boucle et enregistre les elements, arete et le point
             { tab_total_elem.push_back(reff.NumeroElem(ielem));  // d'intégration
               tab_total_arete.push_back(reff.NumeroFA(ielem));
               tab_total_ptint.push_back((int) ((*idl).Val()));          // associé (le même pour toute la référence)
             };
          };
        };
         
        // ---- puis les références de listes de points d'intégration d'arêtes d'élément
        {List_io <string>::iterator ids,idsfin= nomDeRef_A_ptinteg(n_mail).end();
         for (ids=nomDeRef_A_ptinteg(n_mail).begin();ids!=idsfin;ids++)
          { // recup de la reference correspondant au mot cle
            const Reference& refi = lesRef->Trouve((*ids),n_mail);
            const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref de pt d'integ
            int taillen=reff.Taille(); // nombre faces d'élément dans la liste
            for (int ielem=1;ielem<=taillen;ielem++)  // on boucle et enregistre les
             { tab_total_elem.push_back(reff.NumeroElem(ielem));  // éléments
               tab_total_arete.push_back(reff.NumeroFA(ielem));    // arêtes
               tab_total_ptint.push_back(reff.NumeroPti(ielem));  // ptis associés (le même pour toute la référence)
             };
          };
        }; // encapsulé
        
        ielementfin=tab_total_elem.end();
        // écriture du temps que s 'il y a des éléments  et que l'on n'est pas avec un seul incrément
        // sinon on écrit le temps également en commentaire
        // à moins que le style de sortie force une sortie sur une seule ligne
        if ((tab_total_elem.begin() != ielementfin)  && ((!unseul_incre) || (style_de_sortie==1)))
          {sort << setw(3) // minimum sur 3 caractères
               << setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
        else if (tab_total_elem.begin() != ielementfin)
          // ici on écrit une fois le temps en commentaire
          {sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
        // maintenant on affiche les infos pour la liste totale d'éléments
        //   cout << " \n liste de pt integ " << tab_total_ptint;         // pour le débug
      
        List_io <int>::iterator iptinteg = tab_total_ptint.begin();
        List_io <int>::iterator iptarete = tab_total_arete.begin();
        for (ielement = tab_total_elem.begin();ielement!=ielementfin;ielement++,iptinteg++)
         { //  on s'occupe des données  de type quelconque
           List_io<TypeQuelconque>::iterator iquefin=tab_A_element_TypeQuelconque_retenu(n_mail).end();
           List_io<TypeQuelconque>::iterator ique,ique_deb=tab_A_element_TypeQuelconque_retenu(n_mail).begin();
           if (ique_deb !=  iquefin) // c'est a dire: cas où existe une grandeur
            { // coordonnées du point d'integ où sont données les grandeurs, systématiquement à tdt
              bool erreur=false;
              Coordonnee ncor = lesMail->Element_LesMaille(n_mail,*ielement).CoordPtIntArete(*iptarete,TEMPS_tdt,*iptinteg,erreur);
              #ifdef MISE_AU_POINT
                if ((ParaGlob::NiveauImpression() > 0)&& erreur)
                 { cout << "\n *** attention, les coordonnees du pti " << *iptinteg << " de l'arete " << *iptarete
                        << " de l'element " << *ielement << " du maillage " << n_mail
                        << " n'est pas disponible "
                        << " peut etre que l'arete n'est pas utilisee ?? "<< endl;
                  }
              #endif
              for (int ic=1;ic<=ncor.Dimension();ic++)
                sort << setw(nbdigit)  << setprecision(nbdigit) << ncor(ic) << " ";
              // puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
              lesMail->Element_LesMaille(n_mail,*ielement).Grandeur_particuliere_arete(absolue,tab_A_element_TypeQuelconque_retenu(n_mail),*iptarete,*iptinteg);
              // sortie
              for (ique=ique_deb;ique!=iquefin;ique++) (*ique).Grandeur_brut(sort,ParaGlob::NbdigdoGR());
            };
           // s'il n'y a qu'un seul incrément on met un retour à la ligne
           if ((unseul_incre) && (style_de_sortie==0)) sort << "\n";
         };
      };
       
    };

 };

// choix de l'ordre, cet méthode peut entraîner la demande d'informations
// supplémentaires si nécessaire. qui sont ensuite gérer par la classe elle même
void Choix_grandeurs_maple::ChoixOrdre()
   { // demande de précision
     //int dim = ParaGlob::Dimension();
     bool choix_valide = false;
     while (!choix_valide)
      { // premier choix : grandeurs aux noeuds et/ou aux éléments 
        if (ParaGlob::Francais())
         {cout << "\n grandeurs globales                   -> rep : glo "
               << "\n torseurs de reactions                -> rep : tre "
               << "\n moyenne, maxi, mini etc. sur ref N   -> rep : smN "
               << "\n moyenne, maxi, mini etc. sur ref E   -> rep : smE "
               << "\n moyenne, maxi, mini etc. ref face E  -> rep : smFE "
               << "\n moyenne, maxi, mini etc. ref arete E -> rep : smAE "
               << "\n ddl aux noeuds                       -> rep : noe ?"
               << "\n ddl etendu aux noeuds                -> rep : net ?"
               << "\n grandeur particuliere aux noeuds     -> rep : nop ?"
               << "\n grandeurs generique aux elements     -> rep : ele "
               << "\n grandeurs particulieres aux elements -> rep : elp "
               << "\n grandeurs tensorielles aux elements  -> rep : elt "
               << "\n grandeurs aux faces d'elements       -> rep : elF "
               << "\n grandeurs aux aretes d'elements      -> rep : elA "
               << "\n style de sortie                      -> rep : sty "
               << "\n  pour accepter la valeur par defaut  -> rep : o   "
               << "\n  pour arreter les questions          -> rep : fin (ou f) ";
			      }
		      else
		       {cout << "\n global quantities                    -> rep : glo "
               << "\n reaction  wrench                     -> rep : tre "  // on dit aussi screws pour les torseurs en général
               << "\n average, maxi, mini etc. for ref N   -> rep : smN "
               << "\n average, maxi, mini etc. for ref E   -> rep : smE "
               << "\n average, maxi, mini etc. ref facet E -> rep : smFE "
               << "\n average, maxi, mini etc. ref edge E  -> rep : smAE "
               << "\n main dof at nodes   (default)        -> rep : noe "    // mais pour le torseur : force et moment c'est wrench
               << "\n secondary extend dof at nodes        -> rep : net "
               << "\n specific dof at nodes                -> rep : nop "
               << "\n classical quantities at elements     -> rep : ele "
               << "\n specific  quantities at elements     -> rep : elp "
               << "\n tensorial values from  elements      -> rep : elt "
               << "\n values from facets of elements       -> rep : elF "
               << "\n values from edges of elements        -> rep : elA "
               << "\n style of output                      -> rep : sty "
               << "\n  for taking the default value        -> rep : o   "
               << "\n  for stopping the questions          -> rep : fin (ou f) "; 
			      };

        string rep;
        if (ParaGlob::Francais())
         {cout << "\n reponse ? ";}else {cout << "\n answer ? ";}
        rep = lect_return_defaut(false,"f");
        if ((rep == "o") || (rep == "noe"))
          { // cas de grandeurs aux noeuds,
            Entree_grandeur_principale_aux_noeuds(rep);          
          } // -- fin du cas des grandeurs aux noeuds
        else if (rep == "net")
          { // cas de grandeurs étendus secondaires aux noeuds
            Entree_grandeur_etendue_secondaire_aux_noeuds(rep);          
          } // -- fin du cas des grandeurs  étendus secondaires aux noeuds
        else if (rep == "nop")
          { // cas de grandeurs particuliére aux noeuds
            Entree_grandeur_TypeQuelconque_secondaire_aux_noeuds(rep);          
          } // -- fin du cas des grandeurs  particulières aux noeuds
        else if (rep == "ele")
          { // cas de grandeurs génériques aux éléments, 
            Entree_grandeur_aux_elements(rep);
          } // -- fin du cas génériques des éléments
        else if (rep == "elp")
          { // cas de grandeurs particulières aux éléments, 
            Entree_grandeur_particuliere_aux_elements(rep);
          } // -- fin du cas des éléments
        else if (rep == "elt")
          { // cas de grandeurs tensorielles aux éléments,
            Entree_grandeur_tensorielle_aux_elements(rep);
          } // -- fin du cas des éléments
       else if (rep == "elF")
         { // cas de grandeurs aux faces d'éléments,
           Entree_grandeur_quelconque_aux_faces_element(rep);
         } // -- fin du cas des faces aux éléments
       else if (rep == "elA")
         { // cas de grandeurs aux arêtes  d'éléments,
           Entree_grandeur_quelconque_aux_aretes_element(rep);
         } // -- fin du cas des arêtes d'éléments
        else if (rep == "glo")
          {// cas de la sortie de grandeurs globales qui sont gérées au niveau de l'algorithme: par exemple les énergies
           Entree_grandeur_gobal(rep);
          }
        else if (rep == "tre")
          {// cas de la sortie des torseurs de réaction
           Entree_torseurs_reaction(rep);
          }
        else if (rep == "smN")
          {// cas du choix pour les moyennes sommes etc. sur ref N
           Entree_somme_moy_N(rep);
          }
        else if (rep == "smE")
          {// cas du choix pour les moyennes sommes etc. sur ref E
           Entree_somme_moy_E(rep);
          }
       else if (rep == "smFE")
         {// cas du choix pour les moyennes sommes etc. sur ref de face E
          Entree_somme_moy_F_E(rep);
         }
       else if (rep == "smAE")
         {// cas du choix pour les moyennes sommes etc. sur ref d'arêtes  E
          Entree_somme_moy_A_E(rep);
         }
        else if (rep == "sty")
          {// entrée du choix de l'utilisation sur le style de sortie
           Style_de_sortie(rep);
          }
        else if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f"))
          choix_valide = true;   
        else
          if (ParaGlob::Francais()) {cout << "\n choix non valide, recommencez !";}
			     else {cout << "\n the choice is not valide, starts again ! ";};
      }; // -- fin de la boucle infinie sur le choix noeud/élément ou arrêt
     // on introduit certains conteneurs internes des maillages si besoin est en fonction
     // des choix de l'utilisateurs: utiles uniquement pour certaines grandeurs
     lesMail->Intro_Conteneurs_internes_noeud_relier_auto_autres_grandeur(tabnoeud_TypeQuelconque_retenu);

     // appel de la méthode de la classe mère
     OrdreVisu::ChoixOrdre();    
   };

                       
// initialisation de la liste des différentes isovaleurs possibles
void Choix_grandeurs_maple::Init_liste_grandeurs(LesMaillages * lesMail,LesCondLim*
                  ,LesContacts* lesContacts,bool fil_calcul)
{
 
  // on n'initialise que si on n'est pas au fil du calcul
  if (!fil_calcul)
    { // cas des contacts: a priori il n'y a que des grandeurs définies aux noeuds
      // on définit des conteneurs ad hoc aux noeud
      int nb_maillage = lesMail->NbMaillage();
      {List_io<TypeQuelconque> liste_inter = lesContacts->ListeGrandeurs_particulieres(absolue);
       // on abonde donc le tableau précédent et ceci pour chaque maillage
       // de plus on définie éventuellement les conteneurs aux noeuds
       List_io < Ddl_enum_etendu > li1; // liste vide pour l'appel de AjoutConteneurAuNoeud
       Tableau <List_io < TypeQuelconque > * > tabQ(2); tabQ(1)=&liste_inter;tabQ(2)=NULL;
       for (int i=1;i<=nb_maillage;i++)
         lesMail->AjoutConteneurAuNoeud(li1,tabQ); // ajout éventuel de conteneur
      };

      // récupération des ddl présents dans les maillages aux noeuds
      tabnoeud_type_ddl = lesMail->Les_type_de_ddl_par_noeud(absolue);
      tabnoeud_type_ddlEtendu = lesMail->Les_type_de_ddl_etendu_par_noeud(absolue);
      // attention **** pour les grandeurs quelconques, il faudrait d'abord effacer les listes, dans dans l'opération
      // d'affectation, car il faut exactement les mêmes types de chaque coté du = , ce qui peut ne pas être le cas
      // si d'un appel à l'autre, la liste à changée, ce qui est le cas pour des grandeurs qui
      // apparaissent pendant le calcul, il y aura un pb donc il faut surveiller ce point !!
     
      tabnoeud_TypeQuelconque.Change_taille(0);
      tabnoeud_TypeQuelconque = lesMail->Les_type_de_TypeQuelconque_par_noeud(absolue);

      tabelement_type_ddl = lesMail->Les_type_de_ddl_par_element(absolue);
      tabelement_typeParti = lesMail->Les_type_de_donnees_particulieres_par_element(absolue);
      // idem mais sous forme de grandeurs évoluées
      tabelement_evoluee.Change_taille(0);
      tabelement_evoluee = lesMail->Les_type_de_donnees_evolues_internes_par_element(absolue);
      
      // pour les faces et arêtes
      tab_F_element_TypeQuelconque = lesMail->Les_type_de_donnees_evolues_internes_par_face_element(absolue);
      tab_A_element_TypeQuelconque = lesMail->Les_type_de_donnees_evolues_internes_par_arete_element(absolue);

      // initialisation des tableaux, si c'est déjà fait, ne fait rien
      if (tabnoeud_type_ddl_retenu.Taille() == 0)
           { //int nb_maillage = tabnoeud_type_ddl.Taille();
             tabnoeud_type_ddl_retenu.Change_taille(nb_maillage);// initialisation
             tabnoeud_type_ddlEtendu_retenu.Change_taille(nb_maillage);// initialisation
             tabnoeud_TypeQuelconque_retenu.Change_taille(nb_maillage);
             tab_num_noeud.Change_taille(nb_maillage);// initialisation
             nomDeRef.Change_taille(nb_maillage); // init
             nomDeRef_E.Change_taille(nb_maillage); // init
             nomDeRef_ptinteg.Change_taille(nb_maillage); // init
             // pour les ref de face d'éléments
             tab_num_F_element.Change_taille(nb_maillage);
             tab_num_F.Change_taille(nb_maillage);
             tab_num_F_integ.Change_taille(nb_maillage);
             nomDeRef_F_E.Change_taille(nb_maillage);
             nomDeRef_F_ptinteg.Change_taille(nb_maillage);
             // pour les ref d'arête d'éléments
             tab_num_A_element.Change_taille(nb_maillage);
             tab_num_A.Change_taille(nb_maillage);
             tab_num_A_integ.Change_taille(nb_maillage);
             nomDeRef_A_E.Change_taille(nb_maillage);
             nomDeRef_A_ptinteg.Change_taille(nb_maillage);

             tabelement_type_ddl_retenu.Change_taille(nb_maillage);// initialisation
             tabelement_typeParti_retenu.Change_taille(nb_maillage);// initialisation
             tabelement_evoluee_retenu.Change_taille(nb_maillage);// initialisation
             tab_num_element.Change_taille(nb_maillage);// initialisation
             tab_num_integ.Change_taille(nb_maillage);// initialisation
             // pour les faces et arêtes
             tab_F_element_TypeQuelconque.Change_taille(nb_maillage);
             tab_F_element_TypeQuelconque_retenu.Change_taille(nb_maillage);
             tab_A_element_TypeQuelconque.Change_taille(nb_maillage);
             tab_A_element_TypeQuelconque_retenu.Change_taille(nb_maillage);
             
             // --- pour les sorties concernant les sommes et moyennes etc. relativement à des références
             tab_nomDeRef_SM.Change_taille(nb_maillage);
             tab_nomDeRef_E_SM.Change_taille(nb_maillage);
             tab_nomDeRef_ptinteg_SM.Change_taille(nb_maillage);
             // faces d'éléments
             tab_nomDeRef_F_E_SM.Change_taille(nb_maillage);tab_nomDeRef_F_ptinteg_SM.Change_taille(nb_maillage);
             tab_F_element_TypeQuelconque_retenu_pourSM.Change_taille(nb_maillage);
             // arêtes d'éléments
             tab_nomDeRef_A_E_SM.Change_taille(nb_maillage);tab_nomDeRef_A_ptinteg_SM.Change_taille(nb_maillage);
             tab_A_element_TypeQuelconque_retenu_pourSM.Change_taille(nb_maillage);

             tabnoeud_type_ddl_retenu_pourSM.Change_taille(nb_maillage);
             tabnoeud_type_ddlEtendu_retenu_pourSM.Change_taille(nb_maillage);
             tabnoeud_TypeQuelconque_retenu_pourSM.Change_taille(nb_maillage);
             tabelement_type_ddl_retenu_pourSM.Change_taille(nb_maillage);
             tabelement_typeParti_retenu_pourSM.Change_taille(nb_maillage);
             tabelement_evoluee_retenu_pourSM.Change_taille(nb_maillage);
           };
    };// fin du cas différent du fil du calcul
};
                            
    
// écriture des informations d'entête, renseigne sur les infos du fichier, ceci
// pour permettre l'exploitation par le programme en maple
// en entrée : list_mail = la liste des maillages à visualiser 
void Choix_grandeurs_maple::Entete_fichier_maple(const list<int>& list_mail,ostream & sort)
{if (!(animation_maple->Actif()))
  {// le détails des grandeurs
   if (ParaGlob::Francais())
    {sort << "\n # entete des donnees : informations gererales: on trouve successivement: ";
     sort << "\n # >>  le nombre de grandeurs globales (peut etre nul) suivi des identificateurs "
          << "\n #                  precedes du numero de colonne entre crochet"
          << "\n # >> le nombre de maillages m, et dimension de l'espace de travail "
          << "\n # puis pour chaque  maillage, "
          << "\n # >> le nombre de torseurs de reaction (peut etre nul), le nombre total de reel qui va etre ecrit "
          << "\n # correspondant aux composantes des torseurs, puis les noms de ref associee suivi des positions "
          << "\n # des composantes entre crochet accolees a un identificateur: R pour reaction, M pour moment "

          << "\n # ensuite pour les moyennes, sommes, maxi etc. calculees sur des references de noeuds "
          << "\n # >> le nombre de ref de noeuds, nombre total de grandeurs associees "
          << "\n # puis pour chaque maillage "
          << "\n # le numero de maillage puis pour chaque reference de noeuds"
          << "\n # le nom de la reference, le nombre de noeud de la ref, le nombre de grandeurs qui vont etre ecrites "
          << "\n # puis entre crochet la position suivi de la signification de chaque grandeur "
          << "\n #  "
          << "\n # ensuite pour les moyennes, sommes, maxi etc. calculees sur des references d'elements ou de pti"
          << "\n # >> le nombre de ref d'element+ref de pti, nombre total de grandeurs associees "
          << "\n # puis pour chaque maillage "
          << "\n # le numero de maillage puis pour chaque reference d'element et de pti"
          << "\n # le nom de la reference, le nombre d'element de la ref, le nombre de grandeurs qui vont etre ecrites "
          << "\n # puis entre crochet la position suivi de la signification de chaque grandeur "
          << "\n #  "

          << "\n # ensuite pour les moyennes, sommes, maxi etc. calculees sur des references de faces d'element ou de pti"
          << "\n # >> le nombre de ref de face + ref de pti de face, nombre total de grandeurs associees "
          << "\n # puis pour chaque maillage "
          << "\n # le numero de maillage puis pour chaque reference de face et de pti de face "
          << "\n # le nom de la reference, le nombre de face de la ref, le nombre de grandeurs qui vont etre ecrites "
          << "\n # puis entre crochet la position suivi de la signification de chaque grandeur "
          << "\n #  "

          << "\n # ensuite pour les moyennes, sommes, maxi etc. calculees sur des references d'arete d'element ou de pti"
          << "\n # >> le nombre de ref d'arete + ref de pti d'arete, nombre total de grandeurs associees "
          << "\n # puis pour chaque maillage "
          << "\n # le numero de maillage puis pour chaque reference d'arete et de pti d'arete "
          << "\n # le nom de la reference, le nombre d'arete de la ref, le nombre de grandeurs qui vont etre ecrites "
          << "\n # puis entre crochet la position suivi de la signification de chaque grandeur "
          << "\n #  "

          << "\n # puis pour chaque maillage "
          << "\n # >> le nombre de noeud n (peut etre nul) ou il y a des grandeurs en sortie , "
          << "\n # puis le nombre des grandeurs p1 correspondantes, la position entre crochet des coordonnees "
          << "\n #  et enfin l'idendificateur de ces grandeurs(p1 chaines de caractere) "
          << "\n #  precedes du numero de colonne correspondant entre crochet"
          << "\n # puis pour chaque  maillage "
          << "\n # >> le nombre de couples element-pt_integ (peut etre nulle) ou il y a des grandeurs en sortie , "
          << "\n # les grandeurs aux elements sont decomposees en 2 listes: la premiere de quantite P2 correspondant " 
          << "\n # a des grandeurs generiques, la seconde de quantite P3 corresponds aux grandeurs specifiques, " 
          << "\n # on trouve donc a la suite du nombre d'element: le nombre P2, suivi de P2 identificateurs de ddl"
          << "\n # chacun precedes du numero de colonne entre crochet"
          << "\n # puis le nombre P3, suivi de P3 identificateurs+categorie+type (chaines de caracteres),"
          << "\n #   suivi entre crochet, de la plage des numeros de colonnes, correspondant "
          << "\n # chacun sur une ligne differentes "
          
          << "\n # puis pour chaque  maillage "
          << "\n # >> le nombre de triplets element-nb_face-pt_integ (peut etre nulle) ou il y a des grandeurs en sortie , "
          << "\n # puis le nombre grandeurs, suivi des identificateurs+categorie+type (chaines de caracteres),"
          << "\n #   suivi entre crochet, de la plage des numeros de colonnes, correspondant "
          << "\n # chacun sur une ligne differentes "
          << "\n # puis pour chaque  maillage "
          << "\n # >> le nombre de triplets element-nb_arete-pt_integ (peut etre nulle) ou il y a des grandeurs en sortie , "
          << "\n # puis le nombre grandeurs, suivi des identificateurs+categorie+type (chaines de caracteres),"
          << "\n #   suivi entre crochet, de la plage des numeros de colonnes, correspondant "
          << "\n # chacun sur une ligne differentes "

          << "\n # ==== NB: pour les grandeurs specifique tensorielle: exemple d'ordre en 2D: "
          << "\n # tenseur symetrique, A(1,1) A(2,1) A(2,2),  non symetrique A(1,1) A(1,2) A(2,1) A(2,2)"
          << "\n # en 3D c'est: tenseur symetrique, A(1,1) A(2,1) A(2,2) A(3,1) A(3,2) A(3,3) "
          << "\n #                   non symetrique A(1,1) A(1,2) A(2,1) A(2,2) A(2,3) A(3,1) A(3,2) A(3,3) "
          << "\n # ** dans le cas ou il n'y a qu'un seul increment en sortie, pour les grandeurs aux noeuds et aux elements, "
          << "\n # ** les informations peuvent etre decoupees  selon: une ligne = un noeud, et le temps n'est pas indique "
          << "\n # ** ( cf: parametre_style_de_sortie = 0) \n";
	   }
   else
    {sort << "\n # The heading of the data : general informations: we will find successively: ";
     sort << "\n # >>  the number of global values  (can be zero), followed by identifiers "
          << "\n #                  preceded  by the corresponding column number, surrounded by brackets "
          << "\n # >> the number of mesh  m, and the dimension of the working space  "
          << "\n # then for each mesh, "
          << "\n # >> the numer of reaction wrench (can be zero), the total number of real, which will be writen  "
          << "\n # it correspond to the wrench components, then the names of the associated references, followed by the positions "
          << "\n # of the components surrounded by brackets and the identifiers: R for the reaction vector, M for the torque  "
          << "\n # then for each mesh "
          << "\n # >> the number of nodes  n (can be zero) where there are output values , "
          << "\n # then the number of corresponding values  p1 , the position between bracket of the components  "
          << "\n #  and finally the identifier of these quantities (p1 strings) "
          << "\n #  preceded by their column number between brackets"
          << "\n # then for each mesh  "
          << "\n # >> the number of couples element-integretion-point  (can be zero) where there are output values , "
          << "\n # the values at elements are composed by  two lists : the first one, of P2 quantities, corresponds  " 
          << "\n # to generic quantities , the second, of P3 quantities, corresponds to specific quantities, " 
          << "\n # so, we find after the number of element : the number P2, followed by  P2 identifiers of dof"
          << "\n # each is preceded by a column number between brackets "
          << "\n # then the number P3, followed by P3 identifiers+category+type  (string),"
          << "\n #   followed, between brackets, of the corresponding range of column numbers "
          << "\n # each on a different line  "
          << "\n # ==== NB: for second order tensor specific values: for instance in 2D, the order of componants is: "
          << "\n # for symetric tensor, A(1,1) A(2,1) A(2,2),  for non symetric A(1,1) A(1,2) A(2,1) A(2,2)"
          << "\n # in 3D it is: symetric tensor, A(1,1) A(2,1) A(2,2) A(3,1) A(3,2) A(3,3) "
          << "\n #              non symetric A(1,1) A(1,2) A(2,1) A(2,2) A(2,3) A(3,1) A(3,2) A(3,3) "
          << "\n # ** in the case of only one output increment, for values at nodes and at elements, "
          << "\n # ** the informations can be presented as: one line  = one node, and the time is not indicated  "
          << "\n # ** (parametre_style_de_sortie = 0) \n";
    };
     // ---- grandeur globales
   if (ParaGlob::Francais())
    {  sort << "\n#====================================================================";
       sort << "\n#||     recapitulatif des differentes grandeurs par colonne        ||";
       sort << "\n#====================================================================";
       sort << "\n#----------------------------------  grandeur globales ------------------------------------";
       sort << "\n#" << list_grand_global_retenu.size() << " (nombre de grandeurs globales) ";
    }
   else
    {  sort << "\n#====================================================================";
       sort << "\n#||     global checkup of the output quantities by column          ||";
       sort << "\n#====================================================================";
       sort << "\n#----------------------------------  global quantities ------------------------------------";
       sort << "\n#" << list_grand_global_retenu.size() << " (number of global quantities ) ";
	   };
   List_io <string >::iterator ilg,ilgfin=list_grand_global_retenu.end();
   int num_col=1 ; // le numéro des colonnes, la première colonne = temps, donc la première grandeur est en col 2   
   if (list_grand_global_retenu.size() != 0) 
      num_col++; // on passe l'affichage du temps 
   for (ilg=list_grand_global_retenu.begin();ilg != ilgfin; ilg++)//,num_col++)
       {sort << " ["<<num_col<<"]" << (*ilg) ;
        // soit c'est une grandeur scalaire soit une grandeur vectorielle !! il faut que l'on teste
        // récup de la grandeur
        const void * pointe = NULL; // init
        if (EstUneGrandeurGlobale(*ilg))
          {Enum_GrandeurGlobale idGR = Id_nom_GrandeurGlobale(*ilg);
           pointe = ParaGlob::param->GrandeurGlobal(idGR);
          };
        if (pointe == NULL)
         {// on essaie alors au niveau des adressages directement avec un string
          pointe = ParaGlob::param->GrandeurGlobal(*ilg);
         };
        if (pointe != NULL)
           {TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
//// --- debug
//cout << "\n debug Choix_grandeurs_maple::Entete_fichier_maple(..."
//     << "\n Type_enumGrandeurParticuliere= "
//     << NomTypeQuelParticulier(gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere())
//     << "\n Type_structure_grandeurAssocie= "
//     << NomType2Niveau(gr_quelc->Grandeur_pointee()->Type_structure_grandeurAssocie())
//     << flush;
//           
//// ---- fin debug

            switch(gr_quelc->Grandeur_pointee()->Type_structure_grandeurAssocie())
             { case  TYPE_SIMPLE: // pour les grandeurs globales a priori que des types simples
                { switch(gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere())
                   {case PARTICULIER_SCALAIRE_ENTIER: case PARTICULIER_SCALAIRE_DOUBLE:
                    case PARTICULIER_DDL_ETENDU:
                      {num_col++; break;}
                    case PARTICULIER_VECTEUR_NOMMER:
                      {Grandeur_Vecteur_Nommer& gr
                         = *((Grandeur_Vecteur_Nommer*) gr_quelc->Grandeur_pointee()); // pour simplifier
                       Vecteur& V = gr.ConteneurVecteur();
                       int taille = V.Taille();
                       num_col += taille;
                       break;
                      }
                    case PARTICULIER_VECTEUR:
                      {Grandeur_Vecteur& gr
                         = *((Grandeur_Vecteur*) gr_quelc->Grandeur_pointee()); // pour simplifier
                       Vecteur* V = gr.ConteneurVecteur();
                       int taille = V->Taille();
                       num_col += taille;
                       break;
                      }
                    default:
                      {cout << "\n erreur en sortant la grandeur globale: " << (*ilg) << " on met 0 a la place ";}
                   }
                 break;
               }
             default:
                {cout << "\n erreur en sortant la grandeur globale: " << (*ilg) << " on met 0 a la place ";};
            };
           }
        else
            {if (ParaGlob::Francais())
                  {cout << "\n erreur en sortant la grandeur globale: " << (*ilg) << " on met 0 a la place ";}
             else {cout << "\n error for outputting the global quantity : " << (*ilg) << " the output will be 0  ";
                   if (ParaGlob::NiveauImpression() >= 4)
                      cout << "\n Choix_grandeurs_maple::Entete_fichier_maple(....)";
                  };
            };
       
       };
   // ----- maillage et dimension    
   if (ParaGlob::Francais())
    {	sort << "\n#----------------------------------  maillage et dimension --------------------------------";
      sort << "\n#" << list_mail.size() << " " << ParaGlob::Dimension() << "  (nombre de maillages et dimension) " ;
      // --- cas des torseurs de réaction
	     sort << "\n#----------------------------------  torseurs de reactions --------------------------------";
	   }
	  else
    {	sort << "\n#----------------------------------  mesh and dimension  ----------------------------------";
      sort << "\n#" << list_mail.size() << " " << ParaGlob::Dimension() << "  (number of mesh and dimension) " ;
      // --- cas des torseurs de réaction
	     sort << "\n#----------------------------------  reaction wrench --------------------------------------";
	   };
   int nb_maillage = tab_list_torseur_condLim_retenu.Taille();
   for (int n_mail = 1; n_mail<= nb_maillage; n_mail++)
	   {  if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
       else {sort << "\n# mesh_" << n_mail << " : "; };
       List_io <String_et_entier >& list_torseur_condLim_retenu = tab_list_torseur_condLim_retenu(n_mail);
       sort << list_torseur_condLim_retenu.size() << " ";
       // le nombre de réel correspondant
       switch (ParaGlob::Dimension())
       	{case 1: sort << list_torseur_condLim_retenu.size() << " "; break;
       	 case 2: sort << 3 * list_torseur_condLim_retenu.size() << " "; break;
       	 case 3: sort << 6 * list_torseur_condLim_retenu.size() << " "; break;
       	};
		     if (ParaGlob::Francais())
         {sort << "  (nombre de torseurs et nombre total de grandeurs associees) ";	}
		     else
         {sort << "  (number of wrench and global number of associated values ) ";	}
//       if ((list_torseur_condLim_retenu.size() != 0)&&(tab_list_torseur_condLim_retenu.Taille()>1))
//		      {if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
//         else {sort << "\n# mesh_" << n_mail << " : "; };
//        }
		     sort << "\n# ";
       if (list_torseur_condLim_retenu.size() != 0) 
            num_col++; // on passe l'affichage du temps 
       // puis les ref
       List_io <String_et_entier>::iterator jeint,jeintfin = list_torseur_condLim_retenu.end();
       for (jeint=list_torseur_condLim_retenu.begin();jeint!=jeintfin;jeint++)
          { sort << (*jeint).nom << " ";
            int dim = ParaGlob::Dimension(); if (ParaGlob::AxiSymetrie()) dim--;
            switch (dim)
       	     {case 1: sort << " ["<<num_col<<"]Rx "; num_col++; break;
       	      case 2: sort << " ["<<num_col<<"]Rx " << " ["<<num_col+1<<"]Ry "<< " ["<<num_col+2<<"]Mz " ;num_col+=3; break;
       	      case 3: sort << " ["<<num_col<<"]Rx " << " ["<<num_col+1<<"]Ry "<< " ["<<num_col+2<<"]Rz "
       	                   << " ["<<num_col+3<<"]Mx "<< " ["<<num_col+4<<"]My "<< " ["<<num_col+5<<"]Mz " ;num_col+=6; break;
       	     };
            sort << ";\n# ";
          };
   	};
   // --- cas des grandeurs sommes, moyennes, maxi etc. pour les références de noeuds ---
   list<int>::const_iterator imail,imailfin=list_mail.end();
	  if (ParaGlob::Francais()) {sort << "\n#-------- moyenne, somme, maxi etc. de grandeurs aux noeuds pour des ref ---------------";}
	  else                      {sort << "\n#--------- average, sum, maxi etc. of values at nodes for ref  ------------------";}
   // sortie de l'entete pour les moyennes sommes etc. sur ref N
   Sortie_entete_somme_moy_N(sort,num_col);
   // --- cas des grandeurs sommes, moyennes, maxi etc. pour les références d'éléments ---
	  if (ParaGlob::Francais()) {sort << "\n#-------- moyenne, somme, maxi etc. de grandeurs aux elements pour des ref ---------------";}
	  else                      {sort << "\n#--------- average, sum, maxi etc. of values at element for ref  ------------------";}
   // sortie de l'entete pour les moyennes sommes etc. sur ref E
   Sortie_entete_somme_moy_E(sort,num_col);

   // --- cas des grandeurs sommes, moyennes, maxi etc. pour les références de faces d'élément ---
   if (ParaGlob::Francais()) {sort << "\n#-------- moyenne, somme, maxi etc. de grandeurs aux faces d'elements pour des ref ---------------";}
   else                      {sort << "\n#--------- average, sum, maxi etc. of values at element facets for ref  ------------------";}
   // sortie de l'entete pour les moyennes sommes etc. sur ref face E
   Sortie_entete_somme_moy_face_E(sort,num_col);

   // --- cas des grandeurs sommes, moyennes, maxi etc. pour les références d'arêtes d'élément ---
   if (ParaGlob::Francais()) {sort << "\n#-------- moyenne, somme, maxi etc. de grandeurs aux aretes d'element pour des ref ---------------";}
   else                      {sort << "\n#--------- average, sum, maxi etc. of values at element edges for ref  ------------------";}
   // sortie de l'entete pour les moyennes sommes etc. sur ref face E
   Sortie_entete_somme_moy_arete_E(sort,num_col);

   // --- cas des noeuds
	  if (ParaGlob::Francais()) {sort << "\n#----------------------------------  grandeurs aux noeuds  --------------------------------";}
	  else                      {sort << "\n#--------------------------------------  values at nodes   --------------------------------";}
   for (imail = list_mail.begin();imail!=imailfin;imail++)
     { // on calcul le nombre total de noeud: en incluant les noeuds des liste
       int nombre_noeud = tab_num_noeud(*imail).size(); // d'abord les noeuds
       // puis les références de listes de noeuds
       List_io <string >::iterator idl,idlfin= nomDeRef(*imail).end();
       for (idl=nomDeRef(*imail).begin();idl!=idlfin;idl++)
        { // recup de la reference correspondant au mot cle
          const Reference& refi = lesRef->Trouve(*idl,*imail);
          const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref de noeud
          nombre_noeud+=reff.Taille();
        };

       // affichage
       if (nombre_noeud != 0) // on n'écrit que s'il y a des noeuds 
        {sort << "\n#" << nombre_noeud << " " ;
         // on calcul le nombre de grandeurs à sortir en fonction de type_sortie_ddl_retenue
         int nb_type_ddl_retenu = tabnoeud_type_ddl_retenu(*imail).size();
         int nb_type_ddlEtendu_retenu = tabnoeud_type_ddlEtendu_retenu(*imail).size();
         // pour les types quelconques il faut faire un petit calcul pour savoir combien de grandeurs scalaires il y a
         int nb_noe_TypeQuelconque_ret = 0; // init
         { 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++)
             nb_noe_TypeQuelconque_ret += (*ique).NbMaxiNumeroOrdre();
         };
         
         switch (type_sortie_ddl_retenue)
         	{ case 0: sort << nb_type_ddl_retenu + nb_type_ddlEtendu_retenu + nb_noe_TypeQuelconque_ret << " ";break;
         	  case 1: sort << nb_type_ddl_retenu + nb_type_ddlEtendu_retenu + nb_noe_TypeQuelconque_ret << " ";break;
         	  case 2: sort << 2*nb_type_ddl_retenu + nb_type_ddlEtendu_retenu + nb_noe_TypeQuelconque_ret << " ";break;
         	};
			      if (ParaGlob::Francais()) {sort << "  (nombre de noeuds, nombre total de grandeurs associees) ";	}
			      else                      {sort << "  (number of nodes, total number of associated quatities) ";	};  
         if (nombre_noeud != 0) 	
          { num_col++; // on passe l'affichage du temps
			         if (list_mail.size() > 1)
		           { if (ParaGlob::Francais()) {sort << "\n# maillage_" << *imail << " : ";}
				           else                      {sort << "\n# mesh_" << *imail << " : ";};
             };
			         sort << "\n# ";

			         // on sort tout d'abord les noeuds identifiés par un numéro seulement 
			        {List_io<int>::iterator inoeud,inoeudfin=tab_num_noeud(*imail).end();
			         for (inoeud = tab_num_noeud(*imail).begin(); inoeud != inoeudfin; inoeud++)
             { if (ParaGlob::Francais()) {sort << "noeud_"<<(*inoeud)<<" ";}
			            else                      {sort << "node_"<<(*inoeud)<<" ";};
				           Sortie_entete_noeud_unitaire(imail,sort,num_col);
             }; //-- fin de la boucle sur les noeuds seuls
			        }; 
			         // on sort maintenant les noeuds qui font partie d'une référence
            List_io <string >::iterator idl,idlfin= nomDeRef(*imail).end();
            for (idl=nomDeRef(*imail).begin();idl!=idlfin;idl++)
             { // recup de la reference correspondant au mot cle
               const Reference& refi = lesRef->Trouve(*idl,*imail);
               const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref de noeud
               int taillen=reff.Taille();
				           sort << " reference " << reff.Nom() <<" : ";
               for (int inoeu=1;inoeu<=taillen;inoeu++)  // on boucle 
                { // on sort la position des xyz
			               if (ParaGlob::Francais()) {sort << "noeud_"<<reff.Numero(inoeu)<<" ";}
				              else                      {sort << "node_"<<reff.Numero(inoeu)<<" ";};
				              Sortie_entete_noeud_unitaire(imail,sort,num_col);
				            }; // fin de la boucle sur les noeuds de la référence
             }; // fin de la boucle sur les référence
			  
          };
        }
       else
        {if (ParaGlob::Francais()) 
		        { sort << "\n# maillage_" << *imail << " : "
                 << 0 << " " << 0 <<  "  (nombre de noeuds, nombre total de grandeurs associees) ";}
			      else
          { sort << "\n# maillage_" << *imail << " : "
                 << 0 << " " << 0 <<  "  (number of nodes, total number of associated quantities) ";};
			     };
       // sauvegarde du nombre maxi de maillage à visualiser pour l'exécution
       der_numero_mail = *imail; // seul le dernier numéro est sauvegardé               
     };

   // -----  les éléments
	  if (ParaGlob::Francais()) 
	     {sort << "\n#----------------------------------  grandeurs aux elements  ------------------------------";}
	  else {sort << "\n#---------------------------------------  values at elements  ------------------------------";}	  
   for (imail = list_mail.begin();imail!=imailfin;imail++)     
     { // on calcul le nombre total d'élément: en incluant les éléments des listes
       int nombre_element = tab_num_element(*imail).size(); // d'abord les éléments unitaires
       // puis les références de listes d'élément
       {List_io <BlocScal >::iterator idl,idlfin= nomDeRef_E(*imail).end();
        for (idl=nomDeRef_E(*imail).begin();idl!=idlfin;idl++)
         {// recup de la reference correspondant au mot cle
          const Reference& refi = lesRef->Trouve((*idl).NomRef(),*imail);
          const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
          nombre_element+=reff.Taille();
         };
       }; // encapsulage
       // puis les références de listes de points d'intégration d'élément
       {List_io <string >::iterator ids,idsfin= nomDeRef_ptinteg(*imail).end();
        for (ids=nomDeRef_ptinteg(*imail).begin();ids!=idsfin;ids++)
        { // recup de la reference correspondant au mot cle
          const Reference& refi = lesRef->Trouve(*ids,*imail);
          const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'élément
          nombre_element+=reff.Taille();
        };
       }; // encapsulage
       // affichage
       if (nombre_element != 0) // on n'écrit que s'il y a des éléments à sortir
        {sort << "\n#" << nombre_element << " " << tabelement_type_ddl_retenu(*imail).size() << " " 
              <<  tabelement_typeParti_retenu(*imail).size()
              <<  tabelement_evoluee_retenu(*imail).size()  << "   ";
	        if (ParaGlob::Francais()) 
	           {sort << "  (nombre total d'elements, nombre totale de grandeurs associees, nombre de grandeurs particulieres"
                  << ", nombre de grandeurs tensorielles)  ";}
			      else {sort << "  (total number of elements, total number of associated quantities, number of specific quantities"
                    << " number of tensorial values ) ";};

         if (nombre_element != 0)
          {bool temps_deja_affiche = false;
			        if (list_mail.size() > 1)
				        {if (ParaGlob::Francais()) {sort << "\n# maillage_" << *imail << " : ";}
				         else                      {sort << "\n# mesh_" << *imail << " : ";};
            };
			        sort << "\n# ";
			        // affichage des éléments identifié uniquement pas un numéro
           List_io <int> tab_elem = tab_num_element(*imail); // tout d'abord récup de la liste des éléments
           List_io <int> tab_ptint = tab_num_integ(*imail); // et les points d'intégration correspondant      
           int nb_element = tab_elem.size(); // d'abord les éléments unitaires
			        List_io <int>::iterator i_elem = tab_elem.begin();  
			        List_io <int>::iterator i_ptint = tab_ptint.begin();  
           for (int ine = 1;ine<= nb_element; ine++,i_elem++,i_ptint++)
			         { sort << "element_"<<*i_elem<<" pt_integ_"<<*i_ptint << ": ";
				          Sortie_entete_element_unitaire(imail,sort,num_col,temps_deja_affiche);
			         };
			        // puis les listes d'éléments par référence	  
           {List_io <BlocScal>::iterator idl,idlfin= nomDeRef_E(*imail).end();
            for (idl=nomDeRef_E(*imail).begin();idl!=idlfin;idl++)
             { // recup de la reference correspondant au mot cle
               const Reference& refi = lesRef->Trouve((*idl).NomRef(),*imail);
               const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'éléments
				           sort << " reference " << reff.Nom() <<" : ";
               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
					           { sort << "element_"<<reff.Numero(ielem)<<" pt_integ_"<<((int) ((*idl).Val())) << ": ";
				              Sortie_entete_element_unitaire(imail,sort,num_col,temps_deja_affiche);
					           };
				         };
           }; // encapsulé
           // puis les références de listes de points d'intégration d'éléments
           {List_io <string>::iterator ids,idsfin= nomDeRef_ptinteg(*imail).end();
            for (ids=nomDeRef_ptinteg(*imail).begin();ids!=idsfin;ids++)
             { // recup de la reference correspondant au mot cle
               const Reference& refi = lesRef->Trouve((*ids),*imail);
               const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de pt d'integ
				           sort << " reference " << reff.Nom() <<" : ";
               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
					            { sort << "element_"<<reff.NumeroElem(ielem)<<" pt_integ_"<<reff.NumeroFA(ielem) << ": ";
				               Sortie_entete_element_unitaire(imail,sort,num_col,temps_deja_affiche);
					            };
             };
           }; // encapsulé
			  
          };
         sort << "\n#     ";
        }
       else
        { if (ParaGlob::Francais())
            {sort << "\n# maillage_" << *imail << " : " << 0 << " " << 0
                  << "  (nombre total d'elements, nombre totale de grandeurs associees) ";
            }
          else
            {sort << "\n# mesh_" << *imail << " : " << 0 << " " << 0
                  << "  (total number of elements, total number of associated quantities) ";
            };
        };
     };

   // -----  les faces d'éléments
   if (ParaGlob::Francais())
      {sort << "\n#----------------------------------  grandeurs aux faces d'elements  ------------------------------";}
   else {sort << "\n#---------------------------------------  values at facet of elements  ------------------------------";}
   for (imail = list_mail.begin();imail!=imailfin;imail++)
     { // on calcul le nombre total de faces d'élément: en incluant les éléments des listes
       int nombre_face = tab_num_F_element(*imail).size(); // d'abord les éléments unitaires
       // puis les références de listes de face d'élément
       {List_io <BlocScal >::iterator idl,idlfin= nomDeRef_F_E(*imail).end();
        for (idl=nomDeRef_F_E(*imail).begin();idl!=idlfin;idl++)
         {// recup de la reference correspondant au mot cle
          const Reference& refi = lesRef->Trouve((*idl).NomRef(),*imail);
          const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref ad hoc
          nombre_face+=reff.Taille();
         };
       }; // encapsulage
       // puis les références de listes de points d'intégration de face d'élément
       {List_io <string >::iterator ids,idsfin= nomDeRef_F_ptinteg(*imail).end();
        for (ids=nomDeRef_F_ptinteg(*imail).begin();ids!=idsfin;ids++)
        { // recup de la reference correspondant au mot cle
          const Reference& refi = lesRef->Trouve(*ids,*imail);
          const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref d'élément
          nombre_face+=reff.Taille();
        };
       }; // encapsulage
       // affichage
       if (ParaGlob::Francais()) {sort << "\n# maillage_" << *imail << " : "; }
       else {sort << "\n# mesh_" << *imail << " : "; };
       if (nombre_face != 0) // on n'écrit que s'il y a des éléments à sortir
        {sort << nombre_face << " " << tab_F_element_TypeQuelconque_retenu(*imail).size() << "   ";
         if (ParaGlob::Francais())
            {sort << "  (nombre total de faces d'element, nombre totale de grandeurs associees  ";}
         else {sort << "  (total number of element facets, total number of associated quantities ";};

         if (nombre_face != 0)
          {bool temps_deja_affiche = false;
//           if (list_mail.size() > 1)
//            {if (ParaGlob::Francais()) {sort << "\n# maillage_" << *imail << " : ";}
//             else                      {sort << "\n# mesh_" << *imail << " : ";};
//            };
           sort << "\n# ";
           // affichage des éléments identifié uniquement pas un numéro
           List_io <int> tab_elem = tab_num_F_element(*imail); // tout d'abord récup de la liste des éléments
           List_io <int> tab_face_elem = tab_num_F(*imail); // liste des faces d'élément
           List_io <int> tab_ptint = tab_num_F_integ(*imail); // et les points d'intégration correspondant
           int nb_element = tab_elem.size(); // d'abord les éléments unitaires
           List_io <int>::iterator i_elem = tab_elem.begin();
           List_io <int>::iterator i_F_elem = tab_face_elem.begin();
           List_io <int>::iterator i_ptint = tab_ptint.begin();
           for (int ine = 1;ine<= nb_element; ine++,i_elem++,i_F_elem++,i_ptint++)
            { sort << "element_"<<*i_elem << " face_"<<*i_F_elem <<" pt_integ_"<<*i_ptint << ": ";
              Sortie_entete_face_element_unitaire(imail,sort,num_col,temps_deja_affiche);
            };
           // puis les listes d'éléments par référence
           {List_io <BlocScal>::iterator idl,idlfin= nomDeRef_F_E(*imail).end();
            for (idl=nomDeRef_F_E(*imail).begin();idl!=idlfin;idl++)
             { // recup de la reference correspondant au mot cle
               const Reference& refi = lesRef->Trouve((*idl).NomRef(),*imail);
               const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de faces d'éléments
               sort << " reference " << reff.Nom() <<" : ";
               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
                { sort << "element_"<<reff.NumeroElem(ielem) << " face_"<< reff.NumeroFA(ielem)
                       <<" pt_integ_"<<((int) ((*idl).Val())) << ": ";
                  Sortie_entete_face_element_unitaire(imail,sort,num_col,temps_deja_affiche);
                };
             };
           }; // encapsulé
           // puis les références de listes de points d'intégration d'éléments
           {List_io <string>::iterator ids,idsfin= nomDeRef_F_ptinteg(*imail).end();
            for (ids=nomDeRef_F_ptinteg(*imail).begin();ids!=idsfin;ids++)
             { // recup de la reference correspondant au mot cle
               const Reference& refi = lesRef->Trouve((*ids),*imail);
               const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref de pt d'integ
               sort << " reference " << reff.Nom() <<" : ";
               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
                 { sort << "element_"<<reff.NumeroElem(ielem)
                        << " face_"<< reff.NumeroFA(ielem)
                        <<" pt_integ_"<<reff.NumeroPti(ielem) << ": ";
                   Sortie_entete_face_element_unitaire(imail,sort,num_col,temps_deja_affiche);
                 };
             };
           }; // encapsulé
     
          };
         sort << "\n#     ";
        }
       else
        {sort << "\n#" << 0 << " " << 0 << "  (nombre total de faces d'elements, nombre totale de grandeurs associees) ";
        };
     };

   // -----  les arêtes d'éléments
   if (ParaGlob::Francais())
      {sort << "\n#----------------------------------  grandeurs aux aretes d'elements  ------------------------------";}
   else {sort << "\n#---------------------------------------  values at edge of elements  ------------------------------";}
   for (imail = list_mail.begin();imail!=imailfin;imail++)
     { // on calcul le nombre total d'arêtes  d'élément: en incluant les éléments des listes
       int nombre_element = tab_num_A_element(*imail).size(); // d'abord les éléments unitaires
       // puis les références de listes d'arêtes d'élément
       {List_io <BlocScal >::iterator idl,idlfin= nomDeRef_A_E(*imail).end();
        for (idl=nomDeRef_A_E(*imail).begin();idl!=idlfin;idl++)
         {// recup de la reference correspondant au mot cle
          const Reference& refi = lesRef->Trouve((*idl).NomRef(),*imail);
          const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref ad hoc
          nombre_element+=reff.Taille();
         };
       }; // encapsulage
       // puis les références de listes de points d'intégration d'arêtes d'élément
       {List_io <string >::iterator ids,idsfin= nomDeRef_A_ptinteg(*imail).end();
        for (ids=nomDeRef_A_ptinteg(*imail).begin();ids!=idsfin;ids++)
        { // recup de la reference correspondant au mot cle
          const Reference& refi = lesRef->Trouve(*ids,*imail);
          const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref d'élément
          nombre_element+=reff.Taille();
        };
       }; // encapsulage
       // affichage
       if (ParaGlob::Francais()) {sort << "\n# maillage_" << *imail << " : "; }
       else {sort << "\n# mesh_" << *imail << " : "; };
       if (nombre_element != 0) // on n'écrit que s'il y a des éléments à sortir
        {sort << nombre_element << " " << tab_A_element_TypeQuelconque_retenu(*imail).size() << "   ";
         if (ParaGlob::Francais())
            {sort << "  (nombre total d'aretes d'element, nombre totale de grandeurs associees  ";}
         else {sort << "  (total number of edge of elements, total number of associated quantities ";};

         if (nombre_element != 0)
          {bool temps_deja_affiche = false;
//           if (list_mail.size() > 1)
//            {if (ParaGlob::Francais()) {sort << "\n# maillage_" << *imail << " : ";}
//             else                      {sort << "\n# mesh_" << *imail << " : ";};
//            };
           sort << "\n# ";
           // affichage des éléments identifié uniquement pas un numéro
           List_io <int> tab_elem = tab_num_A_element(*imail); // tout d'abord récup de la liste des éléments
           List_io <int> tab_face_elem = tab_num_A(*imail); // liste des arêtes d'élément
           List_io <int> tab_ptint = tab_num_A_integ(*imail); // et les points d'intégration correspondant
           int nb_element = tab_elem.size(); // d'abord les éléments unitaires
           List_io <int>::iterator i_elem = tab_elem.begin();
           List_io <int>::iterator i_A_elem = tab_face_elem.begin();
           List_io <int>::iterator i_ptint = tab_ptint.begin();
           for (int ine = 1;ine<= nb_element; ine++,i_elem++,i_A_elem++,i_ptint++)
            { sort << "element_"<<*i_elem << " arete_"<<*i_A_elem <<" pt_integ_"<<*i_ptint << ": ";
              Sortie_entete_arete_element_unitaire(imail,sort,num_col,temps_deja_affiche);
            };
           // puis les listes d'éléments par référence
           {List_io <BlocScal>::iterator idl,idlfin= nomDeRef_A_E(*imail).end();
            for (idl=nomDeRef_A_E(*imail).begin();idl!=idlfin;idl++)
             { // recup de la reference correspondant au mot cle
               const Reference& refi = lesRef->Trouve((*idl).NomRef(),*imail);
               const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'éléments
               sort << " reference " << reff.Nom() <<" : ";
               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
                { sort << "element_"<<reff.NumeroElem(ielem) << " arete_"<< reff.NumeroFA(ielem)
                       <<" pt_integ_"<<((int) ((*idl).Val())) << ": ";
                  Sortie_entete_arete_element_unitaire(imail,sort,num_col,temps_deja_affiche);
                };
             };
           }; // encapsulé
           // puis les références de listes de points d'intégration d'éléments
           {List_io <string>::iterator ids,idsfin= nomDeRef_A_ptinteg(*imail).end();
            for (ids=nomDeRef_A_ptinteg(*imail).begin();ids!=idsfin;ids++)
             { // recup de la reference correspondant au mot cle
               const Reference& refi = lesRef->Trouve((*ids),*imail);
               const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref de pt d'integ
               sort << " reference " << reff.Nom() <<" : ";
               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
                 { sort << "element_"<<reff.NumeroElem(ielem)
                        << " arete_"<< reff.NumeroFA(ielem)
                        <<" pt_integ_"<<reff.NumeroPti(ielem) << ": ";
                   Sortie_entete_arete_element_unitaire(imail,sort,num_col,temps_deja_affiche);
                 };
             };
           }; // encapsulé
     
          };
         sort << "\n#     ";
        }
       else
        {sort << "\n#" << 0 << " " << 0 << "  (nombre total d'aretes d'elements, nombre totale de grandeurs associees) ";
        };
     };




	if (ParaGlob::Francais())
	 { sort << "\n#====================================================================";
      sort << "\n#||          fin du recapitulatif des differentes grandeurs        ||";
      sort << "\n#====================================================================";
      // explication de la structuration des datas qui vont suivre        
      sort << "\n \n # ensuite les donnees sont organisees sur differentes lignes, chaques lignes correspondant "
           << "\n # a un calcul (par exemple un pas de temps), sur chaque ligne il y a m enregistrement, chacun "
           << "\n # correspondant a un maillage. On trouve pour chaque enregistrement successivement : "
           << "\n # s'il y a des grandeurs globales: le temps puis les grandeurs globales, "
           << "\n # puis s'il y a des torseurs de reaction : "
           << "\n # de nouveau le temps, les composantes de la resultante puis les composantes du moments " 
           << "\n # donc en 1D -> 1 reels (resultante), en 2D -> 3 reels (resultante 2, moment 1) et en 3D 6 reels " 
           << "\n # puis s'il y a des grandeurs aux noeuds: de nouveau le temps " 
           << "\n # les coordonnees a t du premier  noeud suivi des p1 grandeurs correspondant au premier noeud"
           << "\n # puis les coordonnees du second noeud, les p1 grandeurs etc. pour tous les noeuds"   
           << "\n # puis s'il y a des grandeur aux elements: "
           << "\n # le temps, puis les coordonnees a t du point d'integration d'un element (pour les grandeurs generiques) "
           << "\n # suivi des p2 grandeurs correspondantes  puis les coordonnees a t du point d'integration  "
           << "\n # correspondant aux grandeurs specifiques  suivi des p3 grandeurs correspondantes "
   
           << "\n # puis les coordonnees d'un second  point d'integration d'un element, les p2 grandeurs  "
           << "\n #  etc. pour tous les points d'integration - element "   
           << "\n \n ";
    }
   else 	 
	 { sort << "\n#====================================================================";
      sort << "\n#||    end of the global checkup of the output quantities          ||";
      sort << "\n#====================================================================";
      // explication de la structuration des datas qui vont suivre        
      sort << "\n \n # then the data are organised on different lines, each lines corresponds   "
           << "\n # to a calculus (for instance a step of time), on each line there are m recordings, each of them"
           << "\n # corresponding to a mesh. We will find successively, for each recording:  "
           << "\n # if there are global quantities: the time then the global data, "
           << "\n # then if the are wrench of reaction : "
           << "\n # again the time, the components of the reaction vector, then the component of the reaction torque " 
           << "\n # so in  1D -> 1 real (vector), in 2D -> 3 reels (vector 2, torque 1) and in 3D 6 reals " 
           << "\n # then if there are data at nodes, again the time  " 
           << "\n # the coordinates at t for the first node followed by the  p1 data corresponding to this first node "
           << "\n # then the coordinate for the second node, the p1 values etc. for all the nodes "   
           << "\n # then, if there are quantities at elements: "
           << "\n # again the time, the coordinates at t, for an integration point of the element (for the generic quantities) "
           << "\n # followed by the p2 corresponding values, then, the coordinates at t of the integration point "
           << "\n # corresponding to the specific quantities (if there is) followed by the  p3 corresponding values "
           << "\n # then the coordinates of the second integration point of an element, the  p2 corresponding values  "
           << "\n #  etc. for all the integration points of element  "   
           << "\n \n ";
     }
  }
 else
  { // cas d'une animation
   if (ParaGlob::Francais()) 
	   {sort << "\n # les donnees en sortie sont: en x ";
     if (accroi_x1) sort <<" variation de "; 
     sort  << x1 << " en y " ; 
     if (accroi_x2) sort <<" variation de "; 
     sort << x2;
     if (type_xi)
       // il s'agit de grandeurs aux noeuds
      {sort << "\n # il s'agit de grandeurs aux noeuds";}
     else
       // il s'agit de grandeurs aux éléments
      {sort << "\n # il s'agit de grandeurs aux elements";}    
	   }
   else	
	   {sort << "\n # the output values are: for x ";
     if (accroi_x1) sort <<" variation of "; 
     sort  << x1 << " for y " ; 
     if (accroi_x2) sort <<" variation of "; 
     sort << x2;
     if (type_xi)
       // il s'agit de grandeurs aux noeuds
      {sort << "\n # they are values at nodes ";}
     else
       // il s'agit de grandeurs aux éléments
      {sort << "\n # they are values at elements";}    
	   };
   // maillage et dimension    
   sort << "\n # nb_maillage= " << list_mail.size() << " dimension= " << ParaGlob::Dimension();
   //  numéros des maillages
   list<int>::const_iterator imail,imailfin=list_mail.end();
   for (imail = list_mail.begin();imail!=imailfin;imail++)
     sort << "\n # Numero_de_maillage: " << (*imail) << " ";
   sort << "\n \n ";
  }	          
};
    
// demande de choix d'uniquement 2 grandeurs à visualiser: aux noeuds ou (exclusif) aux éléments
// retourne un booléen indiquant si l'opération est un succes ou pas
bool Choix_grandeurs_maple::Choix_deux_grandeurs(int num_mail)
   { // affichage du maillage à considérer
     cout << "\n ----- cas du maillage num: " << num_mail;
     // tout d'abord on regarde s'il y a au moins une grandeur à visualiser
     if (    (tabnoeud_type_ddl_retenu(num_mail).size() == 0) 
          && (tabnoeud_type_ddlEtendu_retenu(num_mail).size()==0) 
          && (tabnoeud_TypeQuelconque_retenu(num_mail).size()==0) 
          && (tabelement_type_ddl_retenu(num_mail).size()==0) 
          && (tabelement_typeParti_retenu(num_mail).size()==0)
         )
      { cout << "\n pour l'instant aucune grandeur aux noeuds ou aux elements ne sont definit,"
             << " il faut en definir deux au minimum (une pour x et une pour y) \n";
        return false;
      };
     string rep; 
     // ensuite on affiche les possibilités
     // choix dans tous les cas de x2, et par la même occasion de type_xi qui dit si les grandeurs sont aux 
     // noeuds ou aux éléments: 
     bool choix_valide = false;
     while (!choix_valide)
          {cout << "\n ------- choix de la grandeur en ordonnee ----------"
                << "\n  ddl aux noeuds                           -> rep : noe ?"
                << "\n  ddl etendu aux noeuds                    -> rep : net ?"
                << "\n  grandeur particuliere aux noeuds         -> rep : nop ?"
                << "\n  ou grandeurs aux elements(generique)     -> rep : ele ?"
                << "\n  ou grandeurs aux elements(particuliere)  -> rep : elp ?"
                << "\n  ou grandeurs aux elements(tensorielle)   -> rep : elt ?"
                << "\n  arret de la manip                        -> rep : f ?";
           cout << "\n reponse ? "; rep = lect_return_defaut(false,"f");
           if (rep == "noe")
            { cout << "\n choisissez une grandeur dans la liste des ddl actuellement enregistrees : ";
              List_io < Ddl_enum_etendu>& lista = tabnoeud_type_ddl_retenu(num_mail);
              List_io < Ddl_enum_etendu>:: iterator iddl,iddlfin = lista.end();
              for (iddl=lista.begin();iddl != iddlfin; iddl++)
                cout << (*iddl) << " ";
              cout << "\n reponse ? "; rep = lect_return_defaut(false,"f"); bool trouve = false;
              // on vérifie que le nom fourni appartient bien à la liste
              if (Ddl_enum_etendu::VerifExistence(rep)) 
                 { // on vérifie qu'il appartiend à la liste des ddl proposés
                   Ddl_enum_etendu enu_etendu(rep);
                   if (Ddl_enum_etendu::Existe_dans_la_liste
                                                    (tabnoeud_type_ddl_retenu(num_mail),enu_etendu))
                          {trouve = true; x2=enu_etendu;}}; // x2 contient la grandeur à visualiser
              if (!trouve)
               { cout << "\n choix non valide, recommencez !"; choix_valide = false;}               
              else // on indique avec type_xi que les grandeurs sont aux noeuds et qu'il s'agit d'un ddl
               {choix_valide = true; type_xi=true;ddl_etpas_TQ_2=1;};
             }
           else if (rep == "net")
            { cout << "\n choisissez une grandeur dans la liste des ddl etendus actuellement enregistrees : ";
              List_io < Ddl_enum_etendu>& lista = tabnoeud_type_ddlEtendu_retenu(num_mail);
              List_io < Ddl_enum_etendu>:: iterator iddl,iddlfin = lista.end();
              for (iddl=lista.begin();iddl != iddlfin; iddl++)
                cout << (*iddl) << " ";
              cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
              // on vérifie que le nom fourni appartient bien à la liste
              if (Ddl_enum_etendu::VerifExistence(rep)) 
                 { // on vérifie qu'il appartiend à la liste des ddl proposés
                   Ddl_enum_etendu enu_etendu(rep);
                   if (Ddl_enum_etendu::Existe_dans_la_liste
                                                    (tabnoeud_type_ddlEtendu_retenu(num_mail),enu_etendu))
                          {trouve = true; x2=enu_etendu;}};
              if (!trouve)
               { cout << "\n choix non valide, recommencez !"; choix_valide = false;}               
              else // on indique avec type_xi que les grandeurs sont aux noeuds et qu'il s'agit d'un ddl
               {choix_valide = true; type_xi=true;ddl_etpas_TQ_2=2;};
             }
           else if (rep == "nop")
            { cout << "\n choisissez une grandeur dans la liste de grandeur particulieres actuellement enregistrees : ";
              List_io < TypeQuelconque>& listb = tabnoeud_TypeQuelconque_retenu(num_mail);
              List_io < TypeQuelconque>:: iterator iddl,iddlfin = listb.end();
              for (iddl=listb.begin();iddl != iddlfin; iddl++)
                cout << ((*iddl).EnuTypeQuelconque().NomPlein()) << " ";
              cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
              // on ne continue que si le type quelconque existe
              if (TypeQuelconque_enum_etendu::VerifExistence(rep))
               {// on regarde si c'est un type numérique              
                TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
                if (a.Type_numerique()) // cas d'un type numérique
                 { int nbordre = a.NbMaxiNumeroOrdre(); // récup du nombre de numéro d'ordre
                   if (nbordre != 1)
                    { // dans le cas où il y a plusieurs grandeurs scalaires il faut choisir
                      cout << "\n grandeur avec plusieurs composantes: donnez un numero ? "
                           << "\n pour un tableau, vecteur, liste: il s'agit de l'ordre de la grandeur "
                           << "\n pour un tenseur, un tableau multi-dim, c'est le dernier indice qui varie d'abord";
                      rep = lect_chaine(); int nn = ChangeEntier(rep);
                      if ((nn>=0) && (nn<=nbordre))  { if (nn==nbordre) {nb_ordre_2 = 0;} else {nb_ordre_2 = nn;};} 
                      else          { cout << "\n choix non valide, doit etre compris entre " << 1 << "  et " << nbordre << " ";} 
                      }
                   else { nb_ordre_2=1;}; // cas où il n'y qu'une seule valeur scalaire   
                   // on vérifie que le nom fourni appartient bien à la liste
                   List_io<TypeQuelconque>& tpg_ret = (tabnoeud_TypeQuelconque_retenu(num_mail)); // pour simplifier
                   List_io<TypeQuelconque>::iterator itq=find(tpg_ret.begin(),tpg_ret.end(),a);
                   if (find(tpg_ret.begin(),tpg_ret.end(),a) != tpg_ret.end())
                       {trouve = true; xx2=*itq;} 
                   if (!trouve)
                     { cout << "\n choix non valide, recommencez !"; choix_valide = false;}
                   else // on indique avec type_xi que les grandeurs sont aux éléments et que c'est une grandeur particuliere
                     {choix_valide = true; type_xi = false;ddl_etpas_TQ_2=0;};
                   }
                else
                 { cout << "\n type non numerique, courbe imporssible, donnez un autre type ";choix_valide = false;};
               }
              else
                { cout << "\n type inexistant, verifiez votre syntaxe ";choix_valide = false;};                                     
             }
           else if (rep == "ele")
            { cout << "\n choisissez une grandeur dans la liste de grandeur actuellement enregistrees : ";
              List_io < Ddl_enum_etendu>& listb = tabelement_type_ddl_retenu(num_mail);
              List_io < Ddl_enum_etendu>:: iterator iddl,iddlfin = listb.end();
              for (iddl=listb.begin();iddl != iddlfin; iddl++)
                cout << (*iddl) << " ";
              cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
              // on vérifie que le nom fourni appartient bien à la liste
              if (Ddl_enum_etendu::VerifExistence(rep)) 
                 { // on vérifie qu'il appartient à la liste des ddl proposés
                   Ddl_enum_etendu enu_etendu(rep);
                   if (Ddl_enum_etendu::Existe_dans_la_liste
                                                    (tabelement_type_ddl_retenu(num_mail),enu_etendu))
                          {trouve = true; x2=enu_etendu;}};
              if (!trouve)
               { cout << "\n choix non valide, recommencez !"; choix_valide = false;}
              else // on indique avec type_xi que les grandeurs sont aux éléments, qu'il s'agit d'un ddl
               {choix_valide = true; type_xi = false;ddl_etpas_TQ_2=3;};
             }
           else if (rep == "elp")
            { cout << "\n choisissez une grandeur dans la liste de grandeur particulieres actuellement enregistrees : ";
              List_io < TypeQuelconque>& listb = tabelement_typeParti_retenu(num_mail);
              List_io < TypeQuelconque>:: iterator iddl,iddlfin = listb.end();
              for (iddl=listb.begin();iddl != iddlfin; iddl++)
                cout << ((*iddl).EnuTypeQuelconque().NomPlein()) << " ";
              cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
              // on ne continue que si le type quelconque existe
              if (TypeQuelconque_enum_etendu::VerifExistence(rep))
               {// on regarde si c'est un type numérique              
                TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
                if (a.Type_numerique()) // cas d'un type numérique
                 { int nbordre = a.NbMaxiNumeroOrdre(); // récup du nombre de numéro d'ordre
                   if (nbordre != 1)
                    { // dans le cas où il y a plusieurs grandeurs scalaires il faut choisir
                      cout << "\n grandeur avec plusieurs composantes: donnez un numero ? "
                           << "\n pour un tableau, vecteur, liste: il s'agit de l'ordre de la grandeur "
                           << "\n pour un tenseur, un tableau multi-dim, c'est le dernier indice qui varie d'abord";
                      rep = lect_chaine(); int nn = ChangeEntier(rep);
                      if ((nn>=0) && (nn<=nbordre))  { if (nn==nbordre) {nb_ordre_2 = 0;} else {nb_ordre_2 = nn;};} 
                      else          { cout << "\n choix non valide, doit etre compris entre " << 1 << "  et " << nbordre << " ";} 
                      }
                   else { nb_ordre_2=1;}; // cas où il n'y qu'une seule valeur scalaire   
                   // on vérifie que le nom fourni appartient bien à la liste
                   List_io<TypeQuelconque>& tpg_ret = (tabelement_typeParti_retenu(num_mail)); // pour simplifier
                   List_io<TypeQuelconque>::iterator itq=find(tpg_ret.begin(),tpg_ret.end(),a);
                   if (find(tpg_ret.begin(),tpg_ret.end(),a) != tpg_ret.end())
                       {trouve = true; xx2=*itq;} 
                   if (!trouve)
                     { cout << "\n choix non valide, recommencez !"; choix_valide = false;}
                   else // on indique avec type_xi que les grandeurs sont aux éléments et que c'est une grandeur particuliere
                     {choix_valide = true; type_xi = false;ddl_etpas_TQ_2=0;};
                   }
                else
                 { cout << "\n type non numerique, courbe imporssible, donnez un autre type ";choix_valide = false;};
               }
              else
                { cout << "\n type inexistant, verifiez votre syntaxe ";choix_valide = false;};                                     
            }
           else if (rep == "elt")
            { cout << "\n choisissez une grandeur dans la liste de grandeur tensorielle actuellement enregistrees : ";
              List_io < TypeQuelconque>& listb = tabelement_evoluee_retenu(num_mail);
              List_io < TypeQuelconque>:: iterator iddl,iddlfin = listb.end();
              for (iddl=listb.begin();iddl != iddlfin; iddl++)
                cout << ((*iddl).EnuTypeQuelconque().NomPlein()) << " ";
              cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
              // on ne continue que si le type quelconque existe
              if (TypeQuelconque_enum_etendu::VerifExistence(rep))
               {// on regarde si c'est un type numérique              
                TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
                if (a.Type_numerique()) // cas d'un type numérique
                 { int nbordre = a.NbMaxiNumeroOrdre(); // récup du nombre de numéro d'ordre
                   if (nbordre != 1)
                    { // dans le cas où il y a plusieurs grandeurs scalaires il faut choisir
                      cout << "\n grandeur avec plusieurs composantes: donnez un numero ? "
                           << "\n pour un tableau, vecteur, liste: il s'agit de l'ordre de la grandeur "
                           << "\n pour un tenseur, un tableau multi-dim, c'est le dernier indice qui varie d'abord";
                      rep = lect_chaine(); int nn = ChangeEntier(rep);
                      if ((nn>=0) && (nn<=nbordre))  { if (nn==nbordre) {nb_ordre_2 = 0;} else {nb_ordre_2 = nn;};} 
                      else          { cout << "\n choix non valide, doit etre compris entre " << 1 << "  et " << nbordre << " ";} 
                      }
                   else { nb_ordre_2=1;}; // cas où il n'y qu'une seule valeur scalaire   
                   // on vérifie que le nom fourni appartient bien à la liste
                   List_io<TypeQuelconque>& tpg_ret = (tabelement_evoluee_retenu(num_mail)); // pour simplifier
                   List_io<TypeQuelconque>::iterator itq=find(tpg_ret.begin(),tpg_ret.end(),a);
                   if (find(tpg_ret.begin(),tpg_ret.end(),a) != tpg_ret.end())
                       {trouve = true; xx2=*itq;} 
                   if (!trouve)
                     { cout << "\n choix non valide, recommencez !"; choix_valide = false;}
                   else // on indique avec type_xi que les grandeurs sont aux éléments et que c'est une grandeur particuliere
                     {choix_valide = true; type_xi = false;ddl_etpas_TQ_2=0;};
                   }
                else
                 { cout << "\n type non numerique, courbe imporssible, donnez un autre type ";choix_valide = false;};
               }
              else
                { cout << "\n type inexistant, verifiez votre syntaxe ";choix_valide = false;};                                     
            }
           else if (rep == "f")
            { cout << "\n arret de la procedure .... ";
              return false;
            }
           else 
            { cout << "\n choix non valide, recommencez ! ";choix_valide = false;
             }
           } // fin du choix de x2         
     //  on regarde s'il s'agit de la grandeur ou de son accroissement de o à t
     cout << "\n en ordonnee: grandeur  ou variation entre 0 et t de la grandeur ? (rep: 1 ou 0) ";
     cout << "\n reponse ? "; rep = lect_chaine();
     if (rep == "1") accroi_x2=false; else accroi_x2 = true;
     // --- maintenant on s'occupe de x1 ---
      {bool choix_valide = false;
       while (!choix_valide)
          {cout << "\n ------- choix de la grandeur en abscisse ----------";
           if (type_xi)
            {cout << "\n  ddl aux noeuds                           -> rep : noe ?"
                  << "\n  ddl etendu aux noeuds                    -> rep : net ?"
                  << "\n  grandeur particuliere aux noeuds         -> rep : nop ?"
                  << "\n  arret de la manip                        -> rep : f ?";
             cout << "\n reponse ? "; rep = lect_return_defaut(false,"f");
             if (rep == "noe")
              { cout << "\n choisissez une grandeur dans la liste des ddl actuellement enregistrees : ";
                List_io < Ddl_enum_etendu>& lista = tabnoeud_type_ddl_retenu(num_mail);
                List_io < Ddl_enum_etendu>:: iterator iddl,iddlfin = lista.end();
                for (iddl=lista.begin();iddl != iddlfin; iddl++)
                  cout << (*iddl) << " ";
                cout << "\n reponse ? "; rep = lect_return_defaut(false,"f"); bool trouve = false;
                // on vérifie que le nom fourni appartient bien à la liste
                if (Ddl_enum_etendu::VerifExistence(rep)) 
                 { // on vérifie qu'il appartiend à la liste des ddl proposés
                   Ddl_enum_etendu enu_etendu(rep);
                   if (Ddl_enum_etendu::Existe_dans_la_liste
                                                    (tabnoeud_type_ddl_retenu(num_mail),enu_etendu))
                          {trouve = true; x1=enu_etendu;}
                 }; // x1 contient la grandeur à visualiser
                if (!trouve)
                  { cout << "\n choix non valide, recommencez !"; choix_valide = false;}               
                else // on indique avec ddl_etpas_TQ_1 qu'il s'agit d'un ddl principal au noeud
                  {choix_valide = true; ddl_etpas_TQ_1=1;};
              }
             else if (rep == "net")
              { cout << "\n choisissez une grandeur dans la liste des ddl etendus actuellement enregistrees : ";
                List_io < Ddl_enum_etendu>& lista = tabnoeud_type_ddlEtendu_retenu(num_mail);
                List_io < Ddl_enum_etendu>:: iterator iddl,iddlfin = lista.end();
                for (iddl=lista.begin();iddl != iddlfin; iddl++)
                   cout << (*iddl) << " ";
                cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
                // on vérifie que le nom fourni appartient bien à la liste
                if (Ddl_enum_etendu::VerifExistence(rep)) 
                 { // on vérifie qu'il appartiend à la liste des ddl proposés
                   Ddl_enum_etendu enu_etendu(rep);
                   if (Ddl_enum_etendu::Existe_dans_la_liste
                                                    (tabnoeud_type_ddlEtendu_retenu(num_mail),enu_etendu))
                          {trouve = true; x1=enu_etendu;}
                 };
                if (!trouve)
                 { cout << "\n choix non valide, recommencez !"; choix_valide = false;}               
                else // on indique avec ddl_etpas_TQ_1 qu'il s'agit d'un ddl étendu secondaire
                 {choix_valide = true; ddl_etpas_TQ_1=2;};
              }
             else if (rep == "nop")
               { cout << "\n choisissez une grandeur dans la liste de grandeur actuellement enregistrees : ";
                 List_io < TypeQuelconque>& listb = tabnoeud_TypeQuelconque_retenu(num_mail);
                 List_io < TypeQuelconque>:: iterator iddl,iddlfin = listb.end();
                 for (iddl=listb.begin();iddl != iddlfin; iddl++)
                     cout << ((*iddl).EnuTypeQuelconque().NomPlein()) << " ";
                 cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
                 // on ne continue que si le type quelconque existe
                 if (TypeQuelconque_enum_etendu::VerifExistence(rep))
                  {// on regarde si c'est un type numérique              
                   TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
                   if (a.Type_numerique()) // cas d'un type numérique
                    { int nbordre = a.NbMaxiNumeroOrdre(); // récup du nombre de numéro d'ordre
                      if (nbordre != 1)
                       { // dans le cas où il y a plusieurs grandeurs scalaires il faut choisir
                         cout << "\n grandeur avec plusieurs composantes: donnez un numero ? "
                              << "\n pour un tableau, vecteur, liste: il s'agit de l'ordre de la grandeur "
                              << "\n pour un tenseur, un tableau multi-dim, c'est le dernier indice qui varie d'abord";
                         rep = lect_chaine(); int nn = ChangeEntier(rep);
                         if ((nn>=0) && (nn<=nbordre))  { if (nn==nbordre) {nb_ordre_1 = 0;} else {nb_ordre_1 = nn;};} 
                         else          { cout << "\n choix non valide, doit etre compris entre " << 1 << "  et " << nbordre << " ";} 
                         }
                      else { nb_ordre_1=1;}; // cas où il n'y qu'une seule valeur scalaire   
                      // on vérifie que le nom fourni appartient bien à la liste
                      List_io<TypeQuelconque>& tpg_ret = (tabnoeud_TypeQuelconque_retenu(num_mail)); // pour simplifier
                      List_io<TypeQuelconque>::iterator itq=find(tpg_ret.begin(),tpg_ret.end(),a);
                      if (find(tpg_ret.begin(),tpg_ret.end(),a) != tpg_ret.end())
                          {trouve = true; xx1=*itq;} 
                      if (!trouve)
                        { cout << "\n choix non valide, recommencez !"; choix_valide = false;}
                      else // on indique avec type_xi que les grandeurs sont aux éléments et que c'est une grandeur particuliere
                        {choix_valide = true; type_xi = false;ddl_etpas_TQ_1=0;};
                      }
                   else
                    { cout << "\n type non numerique, courbe imporssible, donnez un autre type ";choix_valide = false;};
                   }
                 else
                   { cout << "\n type inexistant, verifiez votre syntaxe ";choix_valide = false;};                                     
               }
             else if (rep == "f")
              { cout << "\n arret de la procedure .... ";
                return false;
              }
             else 
              { cout << "\n choix non valide, recommencez ! ";choix_valide = false;
              };
            }
           else 
            { cout << "\n     grandeurs aux elements(generique)     -> rep : ele ?"
                   << "\n  ou grandeurs aux elements(particuliere)  -> rep : elp ?"
                   << "\n  ou grandeurs aux elements(tensorielle)   -> rep : elt ?"
                   ;
              int dima = ParaGlob::Dimension(); 
              cout <<  "\n  ou position du point: " ; 
              for (int i=1; i<= dima;i++) cout << " X" << i <<" ";  
              cout   << "         -> rep :  ?";
              cout   << "\n  arret de la manip                        -> rep : f ?";

              cout << "\n reponse ? "; rep = lect_return_defaut(false,"f");
              // tout d'abord on vérifie que ce n'est pas une position sur les axes de base
              if ((rep == "X1") || (rep == "X2") || (rep == "X3"))
                 { // on vérifie que la dimension est ok
                   if (((rep == "X3")&&(dima<3)) || ((rep == "X2")&&(dima==1)))
                   	{cout << "\n choix non valide, " << rep << " ne convient pas pour la dimension du probleme "
                   	      << dima << " recommencez ";
                   	 choix_valide = false;     
                   	}
                   else
                    {Ddl_enum_etendu enu_etendu(rep);
                 	   x1=enu_etendu;
                 	   choix_valide = true; 
                 	   ddl_etpas_TQ_1=3; // il s'agit de ddl étendue
                 	   type_xi = false; // car il s'agit des coordonnées du points d'integ par exemple	
                 	  };
                 }
              else if (rep == "f")
               { cout << "\n arret de la procedure .... ";
                 return false;
                }
              else if (rep == "ele") // car d'une grandeur de type ddl générique
               { cout << "\n choisissez une grandeur dans la liste de grandeur actuellement enregistrees : ";
                 List_io < Ddl_enum_etendu>& listb = tabelement_type_ddl_retenu(num_mail);
                 List_io < Ddl_enum_etendu>:: iterator iddl,iddlfin = listb.end();
                 for (iddl=listb.begin();iddl != iddlfin; iddl++)
                   cout << (*iddl).Nom() << " ";
                 rep = lect_chaine(); bool trouve = false;
                 //  on vérifie que le nom fourni appartient bien à la liste possible
                 if (Ddl_enum_etendu::VerifExistence(rep)) 
                    { // on vérifie qu'il appartiend à la liste des ddl proposés
                      Ddl_enum_etendu enu_etendu(rep);
                      if (Ddl_enum_etendu::Existe_dans_la_liste
                                                    (tabelement_type_ddl_retenu(num_mail),enu_etendu))
                          {trouve = true; x1=enu_etendu;}
                    };
                 if (!trouve)
                  { cout << "\n choix non valide, recommencez !"; choix_valide = false;}
                 else // sinon on valide le choix et on indique qu'il s'agit d'un ddl et non d'une grandeur particulière
                  {choix_valide = true;ddl_etpas_TQ_1=3; };
                }
              else if (rep == "elp") // cas d'une grandeur de type particulière 
               { cout << "\n choisissez une grandeur dans la liste de grandeur actuellement enregistrees : ";
                 List_io < TypeQuelconque>& listb = tabelement_typeParti_retenu(num_mail);
                 List_io < TypeQuelconque>:: iterator iddl,iddlfin = listb.end();
                 for (iddl=listb.begin();iddl != iddlfin; iddl++)
                     cout << ((*iddl).EnuTypeQuelconque().NomPlein()) << " ";
                 cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
                 // on ne continue que si le type quelconque existe
                 if (TypeQuelconque_enum_etendu::VerifExistence(rep))
                  {// on regarde si c'est un type numérique              
                   TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
                   if (a.Type_numerique()) // cas d'un type numérique
                    { int nbordre = a.NbMaxiNumeroOrdre(); // récup du nombre de numéro d'ordre
                      if (nbordre != 1)
                       { // dans le cas où il y a plusieurs grandeurs scalaires il faut choisir
                         cout << "\n grandeur avec plusieurs composantes: donnez un numero ? "
                              << "\n pour un tableau, vecteur, liste: il s'agit de l'ordre de la grandeur "
                              << "\n pour un tenseur, un tableau multi-dim, c'est le dernier indice qui varie d'abord";
                         rep = lect_chaine(); int nn = ChangeEntier(rep);
                         if ((nn>=0) && (nn<=nbordre))  { if (nn==nbordre) {nb_ordre_1 = 0;} else {nb_ordre_1 = nn;};} 
                         else          { cout << "\n choix non valide, doit etre compris entre " << 1 << "  et " << nbordre << " ";} 
                         }
                      else { nb_ordre_1=1;}; // cas où il n'y qu'une seule valeur scalaire   
                      // on vérifie que le nom fourni appartient bien à la liste
                      List_io<TypeQuelconque>& tpg_ret = (tabelement_typeParti_retenu(num_mail)); // pour simplifier
                      List_io<TypeQuelconque>::iterator itq=find(tpg_ret.begin(),tpg_ret.end(),a);
                      if (find(tpg_ret.begin(),tpg_ret.end(),a) != tpg_ret.end())
                          {trouve = true; xx1=*itq;} 
                      if (!trouve)
                        { cout << "\n choix non valide, recommencez !"; choix_valide = false;}
                      else // on indique avec type_xi que les grandeurs sont aux éléments et que c'est une grandeur particuliere
                        {choix_valide = true; type_xi = false;ddl_etpas_TQ_1=0;};
                      }
                   else
                    { cout << "\n type non numerique, courbe imporssible, donnez un autre type ";choix_valide = false;};
                   }
                 else
                   { cout << "\n type inexistant, verifiez votre syntaxe ";choix_valide = false;};                                     
               }
              else if (rep == "elt") // cas d'une grandeur de type tensorielle
               { cout << "\n choisissez une grandeur dans la liste de grandeur actuellement enregistrees : ";
                 List_io < TypeQuelconque>& listb = tabelement_evoluee_retenu(num_mail);
                 List_io < TypeQuelconque>:: iterator iddl,iddlfin = listb.end();
                 for (iddl=listb.begin();iddl != iddlfin; iddl++)
                     cout << ((*iddl).EnuTypeQuelconque().NomPlein()) << " ";
                 cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
                 // on ne continue que si le type quelconque existe
                 if (TypeQuelconque_enum_etendu::VerifExistence(rep))
                  {// on regarde si c'est un type numérique              
                   TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
                   if (a.Type_numerique()) // cas d'un type numérique
                    { int nbordre = a.NbMaxiNumeroOrdre(); // récup du nombre de numéro d'ordre
                      if (nbordre != 1)
                       { // dans le cas où il y a plusieurs grandeurs scalaires il faut choisir
                         cout << "\n grandeur avec plusieurs composantes: donnez un numero ? "
                              << "\n pour un tableau, vecteur, liste: il s'agit de l'ordre de la grandeur "
                              << "\n pour un tenseur, un tableau multi-dim, c'est le dernier indice qui varie d'abord";
                         rep = lect_chaine(); int nn = ChangeEntier(rep);
                         if ((nn>=0) && (nn<=nbordre))  { if (nn==nbordre) {nb_ordre_1 = 0;} else {nb_ordre_1 = nn;};} 
                         else          { cout << "\n choix non valide, doit etre compris entre " << 1 << "  et " << nbordre << " ";} 
                         }
                      else { nb_ordre_1=1;}; // cas où il n'y qu'une seule valeur scalaire   
                      // on vérifie que le nom fourni appartient bien à la liste
                      List_io<TypeQuelconque>& tpg_ret = (tabelement_evoluee_retenu(num_mail)); // pour simplifier
                      List_io<TypeQuelconque>::iterator itq=find(tpg_ret.begin(),tpg_ret.end(),a);
                      if (find(tpg_ret.begin(),tpg_ret.end(),a) != tpg_ret.end())
                          {trouve = true; xx1=*itq;} 
                      if (!trouve)
                        { cout << "\n choix non valide, recommencez !"; choix_valide = false;}
                      else // on indique avec type_xi que les grandeurs sont aux éléments et que c'est une grandeur evoluée
                        {choix_valide = true; type_xi = false;ddl_etpas_TQ_1=0;};
                      }
                   else
                    { cout << "\n type non numerique, courbe imporssible, donnez un autre type ";choix_valide = false;};
                   }
                 else
                   { cout << "\n type inexistant, verifiez votre syntaxe ";choix_valide = false;};                                     
               }
              else if (rep == "f")
                { cout << "\n arret de la procedure .... ";
                  return false;
                }
             };//-- fin du choix ele ou elp pour x1
           }; //-- fin du while choix_valide pour x1        
      }; // fin du choix de x1  
     //  on regarde s'il s'agit de la grandeur ou de son accroissement de o à t
     cout << "\n en abscisse: grandeur ou variation entre 0 et t de la grandeur ? (rep: 1 ou 0) ";
     cout << "\n reponse ? "; rep = lect_1_0(false);
     if (rep == "1") accroi_x1=false; else accroi_x1 = true;
     // appel de la méthode de la classe mère
     OrdreVisu::ChoixOrdre(); 
     return true;   
  };     


// lecture des paramètres de l'ordre dans un flux
void Choix_grandeurs_maple::Lecture_parametres_OrdreVisu(UtilLecture & entreePrinc)
 { // si dans le flot il existe l'identificateur adoc on lit sinon on passe
   if (strstr(entreePrinc.tablcarCVisu,"debut_grandeurs_maple")!=NULL)
     {// sauvegarde des listes actuelles
      Tableau <List_io < Ddl_enum_etendu > > tabnoeud_type_ddl_retenu_sauve(tabnoeud_type_ddl_retenu); // ddl principaux aux noeuds  à visualiser
      int type_sortie_ddl_retenue_sauve = type_sortie_ddl_retenue;
      Tableau <List_io < Ddl_enum_etendu > > tabnoeud_type_ddlEtendu_retenu_sauve(tabnoeud_type_ddlEtendu_retenu); // ddl etendu aux noeuds  à visualiser
      Tableau <List_io < TypeQuelconque > >  tabnoeud_TypeQuelconque_retenu_sauve(tabnoeud_TypeQuelconque_retenu); // grandeurs particulières aux noeuds
      Tableau <List_io < Ddl_enum_etendu > > tabelement_type_ddl_retenu_sauve(tabelement_type_ddl_retenu); // ddl aux elements  à visualiser
      
      // -> face d'éléments
      Tableau <List_io < TypeQuelconque > > tab_F_element_TypeQuelconque_retenu_sauve(tab_F_element_TypeQuelconque_retenu);
      Tableau <List_io < TypeQuelconque > > tab_F_element_TypeQuelconque_retenu_pourSM_sauve(tab_F_element_TypeQuelconque_retenu_pourSM);
      // -> arête d'éléments
      Tableau <List_io < TypeQuelconque > > tab_A_element_TypeQuelconque_retenu_sauve(tab_A_element_TypeQuelconque_retenu);
      Tableau <List_io < TypeQuelconque > > tab_A_element_TypeQuelconque_retenu_pourSM_sauve(tab_A_element_TypeQuelconque_retenu_pourSM);
      
      Tableau <List_io <int> > tab_num_noeud_sauve(tab_num_noeud); // liste des noeuds à visualiser
      Tableau <List_io <int> > tab_num_element_sauve(tab_num_element); // liste des éléments à visualiser 
      Tableau <List_io <int> > tab_num_integ_sauve(tab_num_integ); // liste des numéros de point d'integration à visualiser
      
      // -> les pti de face d'éléments
      Tableau <List_io <int> > tab_num_F_element_sauve(tab_num_F_element); // liste des éléments à visualiser
      Tableau <List_io <int> > tab_num_F_sauve(tab_num_F); // liste des num de face ou arêtes d'éléments à visualiser
      Tableau <List_io <int> > tab_num_F_integ_sauve(tab_num_F_integ); // liste des numéros de point d'integration à visualiser associé à tab_num_F_element
      Tableau <List_io <BlocScal> > nomDeRef_F_E_sauve(nomDeRef_F_E); // list de nom de références face  d'éléments associés
      Tableau <List_io <string> > nomDeRef_F_ptinteg_sauve(nomDeRef_F_ptinteg); // list de nom de références de pt d'integ de face d'éléments
      // -> les pti d'arête d'éléments
      Tableau <List_io <int> > tab_num_A_element_sauve(tab_num_A_element); // liste des éléments à visualiser
      Tableau <List_io <int> > tab_num_A_sauve(tab_num_A); // liste des num d'arêtes d'éléments à visualiser
      Tableau <List_io <int> > tab_num_A_integ_sauve(tab_num_A_integ); // liste des numéros de point d'integration à visualiser associé à tab_num_A_element
      Tableau <List_io <BlocScal> > nomDeRef_A_E_sauve(nomDeRef_A_E); // list de nom de références d'arête d'éléments  associé
      Tableau <List_io <string> > nomDeRef_A_ptinteg_sauve(nomDeRef_A_ptinteg); // list de nom de références de pt d'integ d'arête d'éléments
      
      Tableau < List_io <String_et_entier > >    // les torseurs associées aux conditions limite, à visualiser
      tab_list_torseur_condLim_retenu_sauve(tab_list_torseur_condLim_retenu);
      Tableau <List_io < TypeQuelconque > > tabelement_evoluee_retenu_s(tabelement_evoluee_retenu);
      Tableau <List_io <string> > nomDeRef_sauve(nomDeRef); // list de nom de références de noeuds
      Tableau <List_io <BlocScal> > nomDeRef_E_sauve(nomDeRef_E); // list de nom de références d'éléments et de point d'intégration associé
      Tableau <List_io <string> > nomDeRef_ptinteg_sauve(nomDeRef_ptinteg); // list de nom de références de pt d'integ d'éléments
      List_io <TypeQuelconque >  listeVecGlobbal_retenu_sauve(listeVecGlobbal_retenu); // les vecteurs globaux à visualiser
      listeVecGlobbal_retenu.clear();  // initialisation
      // ------parties moyennes et sommes
      Tableau <List_io <string> > tab_nomDeRef_SM_sauve(tab_nomDeRef_SM);
      Tableau <List_io <BlocScal> > tab_nomDeRef_E_SM_sauve(tab_nomDeRef_E_SM);
      Tableau <List_io <string> > tab_nomDeRef_ptinteg_SM_sauve(tab_nomDeRef_ptinteg_SM);
      Tableau <List_io < Ddl_enum_etendu > > tabnoeud_type_ddl_retenu_pourSM_sauve(tabnoeud_type_ddl_retenu_pourSM);
      Tableau <List_io < Ddl_enum_etendu > > tabnoeud_type_ddlEtendu_retenu_pourSM_sauve(tabnoeud_type_ddlEtendu_retenu_pourSM);
      Tableau <List_io < TypeQuelconque > > tabnoeud_TypeQuelconque_retenu_pourSM_sauve(tabnoeud_TypeQuelconque_retenu_pourSM);
      Tableau <List_io < Ddl_enum_etendu > > tabelement_type_ddl_retenu_pourSM_sauve(tabelement_type_ddl_retenu_pourSM);
      Tableau <List_io < TypeQuelconque > > tabelement_typeParti_retenu_pourSM_sauve(tabelement_typeParti_retenu_pourSM);
      Tableau <List_io < TypeQuelconque > > tabelement_evoluee_retenu_pourSM_sauve(tabelement_evoluee_retenu_pourSM);
      
      // concernant les faces et arêtes
      Tableau <List_io <BlocScal> > tab_nomDeRef_F_E_SM_sauve(tab_nomDeRef_F_E_SM);
      Tableau <List_io <string> > tab_nomDeRef_F_ptinteg_SM_sauve(tab_nomDeRef_F_ptinteg_SM);
      Tableau <List_io <BlocScal> > tab_nomDeRef_A_E_SM_sauve(tab_nomDeRef_A_E_SM);
      Tableau <List_io <string> > tab_nomDeRef_A_ptinteg_SM_sauve(tab_nomDeRef_A_ptinteg_SM);
      
      // 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);

      
      // essaie de lecture
      try 
        { string nom,nom2; 
          (*entreePrinc.entCVisu)  >> nom ;
          if (nom != "debut_grandeurs_maple")
            { cout << "\n Erreur en lecture des grandeurs a visualiser au format maple a partir d'un fichier .CVisu,"
                   << " le premier enregistrement doit etre le mot clef: debut_grandeurs_maple "
                   << " on ne tiens pas compte  de la liste fournie !! ";
            }
          else
           { // appel de l'ordre de la classe mère
             OrdreVisu::Lect_para_OrdreVisu_general(entreePrinc);
             // lecture  des grandeurs globales éventuelles
             if (strstr(entreePrinc.tablcarCVisu,"debut_grandeurs_globales")!=NULL)
               { // lecture de la liste des grandeurs
                 (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                 // on efface la liste actuelle
                 list_grand_global_retenu.erase(list_grand_global_retenu.begin(),list_grand_global_retenu.end());
                 // lecture de la liste demandée
                 int compteur=0; // pour éviter une boucle infinie
                 while (compteur < 1000000)
                   { (*entreePrinc.entCVisu) >> nom; compteur++;
                     if (nom != "fin_grandeurs_globales")
                       { // on vérifie que le nom lu est acceptable
 //                        if (find(list_grandeur_global.begin(),list_grandeur_global.end(),nom) != list_grandeur_global.end())
                         bool grandeur_ok = false; // init par défaut
                         // 1) on regarde dans la liste des grandeurs globales normales (inscrits en dur)
                         if (find(list_grandeur_global.begin(),list_grandeur_global.end(),nom) != list_grandeur_global.end())
                            grandeur_ok=true;
                         // 2) on regarde dans la liste réelle s'il ne s'agit pas d'une grandeur en string
                         if (ParaGlob::param->GrandeurGlobal(nom) != NULL)
                            grandeur_ok = true;
                         //en dernier lieu on fait un traitement spécial dans le cas où il s'agit d'intégrales
                         // même si les variables ne sont pas valides,
                         if (nom.find("INTEG_SUR_VOLUME_ET_TEMPS") != std::string::npos)
                           {grandeur_ok = true;}
                         else if (nom.find("INTEG_SUR_VOLUME") != std::string::npos)
                           {grandeur_ok = true;};
                         // enregistrement
                         if (grandeur_ok)
                            list_grand_global_retenu.push_back(nom);
                         else
                            cout << "\n lecture d'un nom de grandeur global ( "<< nom << " ) errone ! on n'en tiens pas compte";   
                       }
                     else break;                           
                   };
                 entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement   
               };
             int nb_maillage = lesMail->NbMaillage(); int imail; 
             // redimentionnement éventuelle
             tab_list_torseur_condLim_retenu.Change_taille(nb_maillage);
             while (strstr(entreePrinc.tablcarCVisu,"fin_grandeurs_maple")==NULL)
              { (*entreePrinc.entCVisu) >> imail; // lecture du numero de maillage
                if (imail > nb_maillage) // vérif de la validité du numéro de maillage
                  // si nb maillage trop grand, erreur, on génère une erreur pour arrêter la lecture
                  { cout << "\n erreur, le numero de maillage est trop grand !! nombre lu " << imail 
                         << " alors que nb_maillage enregistre: " << nb_maillage ;
                    cout << "\n Choix_grandeurs_maple::Lecture_parametres_OrdreVisu(... ";     
                    UtilLecture::ErrNouvelEnregCVisu sortie(-1) ; throw (sortie);
                  };
                entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                //---- lecture des torseurs ----
                if (strstr(entreePrinc.tablcarCVisu,"debut_list_torseur_reaction")!=NULL)
                {// lecture de la liste des références
                 (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                 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);
                 List_io <String_et_entier>::iterator jeint,jeintfin = list_torseur_condLim.end();
                 // on efface la liste actuelle
                 list_torseur_condLim_retenu.erase(list_torseur_condLim_retenu.begin(),list_torseur_condLim_retenu.end());
                 // lecture de la liste demandée
                 int compteur=0; // pour éviter une boucle infinie
                 while (compteur < 1000000)
                   { (*entreePrinc.entCVisu) >> nom; compteur++;
                     if (nom != "fin_list_torseur_reaction")
                       { // on vérifie que le nom lu est acceptable
                         bool choix_valide = false;
                         for (jeint=list_torseur_condLim.begin();jeint!=jeintfin;jeint++)
                           { if ((*jeint).nom == nom)
            	               { list_torseur_condLim_retenu.push_back(*jeint);
                                 choix_valide = true;
                                 break;
            	                };
                            };
                         if (!choix_valide)
                            cout << "\n lecture d'un nom de ref de torseur de reaction ( "
                                 << nom << " ) qui ne fait pas partie des refs de ddl bloque !"
                                 << " \n on n'en tiens pas compte car il n'y aura pas de reactions classiques "
                                 << " pour cette reference ";
                        }
                     else break;                           
                   };
                 entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement   
                };


                // === cas des sommes, moyennes etc. relativement à des références ===
                // --- les références des régions en noeuds
                if (strstr(entreePrinc.tablcarCVisu,"debut_list_SM_sur_refN")!=NULL)
                  { // lecture de la liste de références de noeuds
                    (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                    // on efface la liste actuelle
                    List_io <string>& lis_nomref = tab_nomDeRef_SM(imail);
                    lis_nomref.erase(lis_nomref.begin(),lis_nomref.end());
                    // lecture de la liste demandée
                    int compteur=0; // pour éviter une boucle infinie
                    while (compteur < 1000000)
                      { (*entreePrinc.entCVisu) >> nom; compteur++;
                        if (nom != "fin_list__SM_sur_refN")
                          { if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 1))
                              { cout << "\n erreur de nom: " << nom << ":  ne correspond pas a une reference de noeud correcte "
                                     << " on passe ! ";
                               }
                            else 
                             {lis_nomref.push_back(nom);}
                           }  
                        else break;                           
                       }
                    entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement   
                  };
                //---- les grandeurs à considérer aux noeuds ----
                // ** les ddl principaux aux noeuds
                if (strstr(entreePrinc.tablcarCVisu,"deb_list_ddl_SM_sur_refN")!=NULL)
                  { // lecture de la liste des ddl
                    (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                    // on efface la liste actuelle
                    List_io <Ddl_enum_etendu>& lis_sor = tabnoeud_type_ddl_retenu_pourSM(imail);
                    lis_sor.clear();
                    // lecture de la liste demandée
                    int compteur=0; // pour éviter une boucle infinie
                    while (compteur < 1000000)
                      { (*entreePrinc.entCVisu) >> nom; compteur++;
                        if (nom != "fin_list_ddl_SM_sur_refN")
                          { lis_sor.push_back(Ddl_enum_etendu(nom));}
                        else break;
                       }
                    entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                  };
                // ** les ddl étendus des noeuds
                if (strstr(entreePrinc.tablcarCVisu,"deb_list_ddl_etendu__SM_sur_refN")!=NULL)
                  { // lecture de la liste des ddl
                    (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                    // on efface la liste actuelle
                    List_io <Ddl_enum_etendu>& lis_sor = tabnoeud_type_ddlEtendu_retenu_pourSM(imail);
                    lis_sor.clear();
                    // lecture de la liste demandée
                    int compteur=0; // pour éviter une boucle infinie
                    while (compteur < 1000000)
                      { (*entreePrinc.entCVisu) >> nom; compteur++;
                        if (nom != "fin_list_ddl_etendu__SM_sur_refN")
                          { lis_sor.push_back(Ddl_enum_etendu(nom));}
                        else break;
                       }
                    entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                  };
                // ** les grandeurs particulières aux noeuds
                if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandParticuliere__SM_sur_refN")!=NULL)
                   { // lecture de la liste des grandeurs particulières
                     (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                     // on efface la liste actuelle
                     List_io<TypeQuelconque>& tpg_ret = (tabnoeud_TypeQuelconque_retenu_pourSM(imail)); // pour simplifier
                     tpg_ret.clear(); // on vide les listes
                     //listeVecGlobbal_retenu.clear();  // déjà fait et sert plus bas, donc doit -être initialisé une seule fois !!
                     // lecture de la liste demandée
                     int compteur=0; // pour éviter une boucle infinie
                     List_io<TypeQuelconque>& tpg = (tabnoeud_TypeQuelconque(imail)); // pour simplifier
                     while (compteur < 1000000)
                       { (*entreePrinc.entCVisu) >> nom; compteur++;
                         if (nom != "fin_list_GrandParticuliere__SM_sur_refN")
                           { TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom)); // création d'un type quelconque sans grandeur
                             List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                             bool trouve = false;
                             bool dans_global=false; // pour savoir si c'est dans le vecteur global ou pas
                             // si la grandeur n'existe pas au niveau de tabnoeud_TypeQuelconque on essaie au niveau des
                             // vecteur globaux
                             if (il == tpg.end())
                               {il = find(listeVecGlobbal.begin(),listeVecGlobbal.end(),a);
                                if (il != listeVecGlobbal.end())
                                  trouve = true;dans_global=true;
                                }
                             else // sinon c'est bon on a trouvé
                               {trouve = true;}; 
                             // si la grandeur existe on essaie de l'enregistrer sinon on passe
                             if (trouve)
                              {// s'il n'existe pas déjà on l'enregistre vraiment
                               if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                                { tpg_ret.push_back(*il);
                                  if (dans_global) listeVecGlobbal_retenu.push_back(*il);
                                }
                               }; 
                            } 
                         else break;
                        }
                     entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                    };
                // --- les references des régions en éléments + num du pti où sont calculés les SMs
                if (strstr(entreePrinc.tablcarCVisu,"debut_list_SM_sur_refE")!=NULL)
                  { // lecture de la liste de références de elements
                    (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                    // on efface les listes actuelles
                    List_io <BlocScal>& lis_nomref_E = tab_nomDeRef_E_SM(imail);
                    lis_nomref_E.clear();
                    // lecture de la liste demandée
                    int compteur=0; // pour éviter une boucle infinie
                    while (compteur < 1000000)
                      { (*entreePrinc.entCVisu) >> nom; compteur++;
                        if (nom != "fin_list__SM_sur_refE")
                          { if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 2))
                              { cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference d'element correcte "
                                     << " on passe ! ";
                               }
                            else 
                             { int numinteg; *entreePrinc.entCVisu >> numinteg; // lecture du num d'integ
                               lis_nomref_E.push_back(BlocScal(nom,numinteg)); }
                           }  
                        else break;                           
                       }
                    entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                  };
                // --- les references des regions en ref de pti d'éléments où sont calculés les SMs
                if (strstr(entreePrinc.tablcarCVisu,"debut_list_SM_sur_refpti")!=NULL)
                  { // lecture de la liste de références de points d'intégration d'élements
                    (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                    // on efface les listes actuelles
                    List_io <string>& lis_nomref_ptinteg = tab_nomDeRef_ptinteg_SM(imail);
                    lis_nomref_ptinteg.clear();
                    // lecture de la liste demandée
                    int compteur=0; // pour éviter une boucle infinie
                    while (compteur < 1000000)
                      { (*entreePrinc.entCVisu) >> nom; compteur++;
                        if (nom != "fin_list__SM_sur_refpti")
                          { if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 6))
                              { cout << "\n erreur de nom  (** "<< nom << " **) donne ne correspond pas a une reference de point "
                                     << " d'integration correcte,  on passe ! ";
                               }
                            else 
                             { lis_nomref_ptinteg.push_back(nom); }
                           }  
                        else break;                           
                       }
                    entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                  };
                //---- les grandeurs à considérer aux pti des éléments ----
                // ** les ddl
                if (strstr(entreePrinc.tablcarCVisu,"deb_list_ddl__SM_sur_refEpti")!=NULL)
                  { // lecture de la liste des ddl
                    (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                    // on efface la liste actuelle
                    List_io <Ddl_enum_etendu>& lis_sor = tabelement_type_ddl_retenu_pourSM(imail);
                    lis_sor.clear();
                    // lecture de la liste demandée
                    int compteur=0; // pour éviter une boucle infinie
                    while (compteur < 1000000)
                      { (*entreePrinc.entCVisu) >> nom; compteur++;
                        if (nom != "fin_list_ddl__SM_sur_refEpti")
                          { lis_sor.push_back(Ddl_enum_etendu(nom));}
                        else break;
                       }
                    entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                  };
                // ** les grandeurs particulières
                if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandParticuliere__SM_sur_refEpti")!=NULL)
                  { // lecture de la liste des grandeurs particulières
                    (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                    // on efface la liste actuelle
                    List_io<TypeQuelconque>& tpg_ret = (tabelement_typeParti_retenu_pourSM(imail)); // pour simplifier
                    tpg_ret.clear();
                    // lecture de la liste demandée
                    int compteur=0; // pour éviter une boucle infinie
                    List_io<TypeQuelconque>& tpg = (tabelement_typeParti(imail)); // pour simplifier
                    while (compteur < 1000000)
                      { (*entreePrinc.entCVisu) >> nom; compteur++;
                        if (nom != "fin_list_GrandParticuliere__SM_sur_refEpti")
                          { TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom)); // création d'un type quelconque sans grandeur
                            List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                            // si la grandeur existe on essaie de l'enregistrer sinon on passe
                            if (il != tpg.end()) 
                             {// s'il n'existe pas déjà on l'enregistre vraiment
                              if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                               { tpg_ret.push_back(*il);}
                              }; 
                           } 
                        else break;
                       }
                    entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                  };
                // ** les grandeurs évoluées  aux éléments a visualiser
                if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandEvoluee__SM_sur_refEpti")!=NULL)
                  { // lecture de la liste des grandeurs évoluées
                    (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                    // on efface la liste actuelle
                    List_io<TypeQuelconque>& tpg_ret = (tabelement_evoluee_retenu_pourSM(imail)); // pour simplifier
                    tpg_ret.clear();
                    // lecture de la liste demandée
                    int compteur=0; // pour éviter une boucle infinie
                    List_io<TypeQuelconque>& tpg = (tabelement_evoluee(imail)); // pour simplifier
                    while (compteur < 1000000)
                      { (*entreePrinc.entCVisu) >> nom; compteur++;
                        if (nom != "fin_list_GrandEvoluee__SM_sur_refEpti")
                          { TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom)); // création d'un type quelconque sans grandeur
                            List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                            // s'il n'existe pas déjà on l'enregistre vraiment
                            if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                               { tpg_ret.push_back(*il);}
                           } 
                        else break;
                       }
                    entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                  };

               // --- les references des régions en faces d'élément + num du pti où sont calculés les SMs
               if (strstr(entreePrinc.tablcarCVisu,"debut_list_SM_sur_refFE")!=NULL)
                 { // lecture de la liste de références de faces d'elements
                   (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                   // on efface les listes actuelles
                   List_io <BlocScal>& lis_nomref_F_E = tab_nomDeRef_F_E_SM(imail);
                   lis_nomref_F_E.clear();
                   // lecture de la liste demandée
                   int compteur=0; // pour éviter une boucle infinie
                   while (compteur < 1000000)
                     { (*entreePrinc.entCVisu) >> nom; compteur++;
                       if (nom != "fin_list__SM_sur_refFE")
                         { if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 2))
                             { cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference de faces d'element correcte "
                                    << " on passe ! ";
                              }
                           else
                            { int numinteg; *entreePrinc.entCVisu >> numinteg; // lecture du num d'integ
                              lis_nomref_F_E.push_back(BlocScal(nom,numinteg)); }
                          }
                       else break;
                      }
                   entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                 };
               // --- les references des regions en ref de pti de faces d'éléments où sont calculés les SMs
               if (strstr(entreePrinc.tablcarCVisu,"debut_list_SM_sur_refFpti")!=NULL)
                 { // lecture de la liste de références de points d'intégration de faces d'élements
                   (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                   // on efface les listes actuelles
                   List_io <string>& lis_nomref_ptinteg = tab_nomDeRef_F_ptinteg_SM(imail);
                   lis_nomref_ptinteg.clear();
                   // lecture de la liste demandée
                   int compteur=0; // pour éviter une boucle infinie
                   while (compteur < 1000000)
                     { (*entreePrinc.entCVisu) >> nom; compteur++;
                       if (nom != "fin_list__SM_sur_refFpti")
                         { if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 7))
                             { cout << "\n erreur de nom  (** "<< nom << " **) donne ne correspond pas a une reference de point "
                                    << " d'integration de face correcte,  on passe ! ";
                              }
                           else
                            { lis_nomref_ptinteg.push_back(nom); }
                          }
                       else break;
                      }
                   entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                 };
               //---- les grandeurs à considérer aux pti de faces d'éléments ----
               // ** les grandeurs
               if (strstr(entreePrinc.tablcarCVisu,"deb_list_Grandeur_SM_sur_refFEpti")!=NULL)
                 { // lecture de la liste des grandeurs
                   (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                   // on efface la liste actuelle
                   List_io<TypeQuelconque>& tpg_ret = (tab_F_element_TypeQuelconque_retenu_pourSM(imail)); // pour simplifier
                   tpg_ret.clear();
                   // lecture de la liste demandée
                   int compteur=0; // pour éviter une boucle infinie
                   List_io<TypeQuelconque>& tpg = (tab_F_element_TypeQuelconque(imail)); // pour simplifier
                   while (compteur < 1000000)
                     { (*entreePrinc.entCVisu) >> nom; compteur++;
                       if (nom != "fin_list_Grandeur_SM_sur_refFEpti")
                         { TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom)); // création d'un type quelconque sans grandeur
                           List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                           // si la grandeur existe on essaie de l'enregistrer sinon on passe
                           if (il != tpg.end())
                            {// s'il n'existe pas déjà on l'enregistre vraiment
                             if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                              { tpg_ret.push_back(*il);}
                             };
                          }
                       else break;
                      }
                   entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                 };

               // --- les references des régions en arêtes d'élément + num du pti où sont calculés les SMs
               if (strstr(entreePrinc.tablcarCVisu,"debut_list_SM_sur_refAE")!=NULL)
                 { // lecture de la liste de références d'arêtes d'elements
                   (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                   // on efface les listes actuelles
                   List_io <BlocScal>& lis_nomref_A_E = tab_nomDeRef_A_E_SM(imail);
                   lis_nomref_A_E.clear();
                   // lecture de la liste demandée
                   int compteur=0; // pour éviter une boucle infinie
                   while (compteur < 1000000)
                     { (*entreePrinc.entCVisu) >> nom; compteur++;
                       if (nom != "fin_list__SM_sur_refAE")
                         { if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 2))
                             { cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference d'aretes d'element correcte "
                                    << " on passe ! ";
                              }
                           else
                            { int numinteg; *entreePrinc.entCVisu >> numinteg; // lecture du num d'integ
                              lis_nomref_A_E.push_back(BlocScal(nom,numinteg)); }
                          }
                       else break;
                      }
                   entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                 };
               // --- les references des regions en ref de pti d'arêtes d'éléments où sont calculés les SMs
               if (strstr(entreePrinc.tablcarCVisu,"debut_list_SM_sur_refApti")!=NULL)
                 { // lecture de la liste de références de points d'intégration d'arêtes d'élements
                   (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                   // on efface les listes actuelles
                   List_io <string>& lis_nomref_ptinteg = tab_nomDeRef_A_ptinteg_SM(imail);
                   lis_nomref_ptinteg.clear();
                   // lecture de la liste demandée
                   int compteur=0; // pour éviter une boucle infinie
                   while (compteur < 1000000)
                     { (*entreePrinc.entCVisu) >> nom; compteur++;
                       if (nom != "fin_list__SM_sur_refApti")
                         { if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 8))
                             { cout << "\n erreur de nom  (** "<< nom << " **) donne ne correspond pas a une reference de point "
                                    << " d'integration d'arete correcte,  on passe ! ";
                              }
                           else
                            { lis_nomref_ptinteg.push_back(nom); }
                          }
                       else break;
                      }
                   entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                 };
               //---- les grandeurs à considérer aux pti d'arêtes d'éléments ----
               // ** les grandeurs
               if (strstr(entreePrinc.tablcarCVisu,"deb_list_Grandeur_SM_sur_refAEpti")!=NULL)
                 { // lecture de la liste des grandeurs
                   (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                   // on efface la liste actuelle
                   List_io<TypeQuelconque>& tpg_ret = (tab_A_element_TypeQuelconque_retenu_pourSM(imail)); // pour simplifier
                   tpg_ret.clear();
                   // lecture de la liste demandée
                   int compteur=0; // pour éviter une boucle infinie
                   List_io<TypeQuelconque>& tpg = (tab_A_element_TypeQuelconque(imail)); // pour simplifier
                   while (compteur < 1000000)
                     { (*entreePrinc.entCVisu) >> nom; compteur++;
                       if (nom != "fin_list_Grandeur_SM_sur_refAEpti")
                         { TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom)); // création d'un type quelconque sans grandeur
                           List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                           // si la grandeur existe on essaie de l'enregistrer sinon on passe
                           if (il != tpg.end())
                            {// s'il n'existe pas déjà on l'enregistre vraiment
                             if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                              { tpg_ret.push_back(*il);}
                             };
                          }
                       else break;
                      }
                   entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                 };

                //---- lecture des grandeurs aux noeuds individuellement ----
                if (strstr(entreePrinc.tablcarCVisu,"debut_liste_ddl_et_noeud")!=NULL) 
                 { entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                   // ** liste de noeuds
                   if (strstr(entreePrinc.tablcarCVisu,"deb_list_noeud")!=NULL)
                     { // lecture de la liste de noeuds
                       (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                       // on efface la liste actuelle
                       List_io <int>& lis_sor = tab_num_noeud(imail);
                       lis_sor.erase(lis_sor.begin(),lis_sor.end());
                       // lecture de la liste demandée
                       int compteur=0; // pour éviter une boucle infinie
                       while (compteur < 1000000)
                         { (*entreePrinc.entCVisu) >> nom; compteur++;
                           if (nom != "fin_list_noeud")
                             { lis_sor.push_back(ChangeEntier(nom));}
                           else break;                           
                          }
                       entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                      }
                   // ** les references de liste de noeuds
                   if (strstr(entreePrinc.tablcarCVisu,"deb_list_ref_noeud")!=NULL)
                     { // lecture de la liste de références de noeuds
                       (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                       // on efface la liste actuelle
                       List_io <string>& lis_nomref = nomDeRef(imail);
                       lis_nomref.erase(lis_nomref.begin(),lis_nomref.end());
                       // lecture de la liste demandée
                       int compteur=0; // pour éviter une boucle infinie
                       while (compteur < 1000000)
                         { (*entreePrinc.entCVisu) >> nom; compteur++;
                           if (nom != "fin_list_ref_noeud")
                             { if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 1))
                                 { cout << "\n erreur de nom: " << nom << ":  ne correspond pas a une reference de noeud correcte "
                                        << " on passe ! ";
                                  }
                               else 
                                {lis_nomref.push_back(nom);}
                              }  
                           else break;                           
                          }
                       entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement   
                      }
                   // ** les ddl principaux aux noeuds
                   if (strstr(entreePrinc.tablcarCVisu,"deb_list_ddl_noeud")!=NULL)
                     { // lecture de la liste des ddl
                       (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                       // on efface la liste actuelle
                       List_io <Ddl_enum_etendu>& lis_sor = tabnoeud_type_ddl_retenu(imail);
                       lis_sor.erase(lis_sor.begin(),lis_sor.end());
                       // lecture de la liste demandée
                       int compteur=0; // pour éviter une boucle infinie
                       while (compteur < 1000000)
                         { (*entreePrinc.entCVisu) >> nom; compteur++;
                           if (nom != "fin_list_ddl_noeud")
                             { lis_sor.push_back(Ddl_enum_etendu(nom));}
                           else break;
                          }
                       entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                      };
                   // ** le type de sortie: type_sortie_ddl_retenue
                   if (strstr(entreePrinc.tablcarCVisu,"type_sortie_ddl_retenue")!=NULL)
                     { // lecture du type de sortie
                       (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                       (*entreePrinc.entCVisu) >> type_sortie_ddl_retenue;
                       if ((type_sortie_ddl_retenue<0)||(type_sortie_ddl_retenue>2))
                       	{cout << "\n *** erreur en lecture du type_sortie_ddl_retenue (valeur a 0 ou a t ou delta ou...)"
                       	      << " la valeur doit-etre soit 0 soit 1 soit 2 et on a lue " << type_sortie_ddl_retenue
                       	      << " on essaie de continuer mais la sortie sera sans doute erronee ..."
                       	      << "\n Choix_grandeurs_maple::Lecture_parametres_OrdreVisu(...";
                       	};
                       entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                      }
                   else {type_sortie_ddl_retenue=0;}; // sinon mise en place de la valeur par défaut
                   // ** lecture des ddl etendus aux noeuds
                   if (strstr(entreePrinc.tablcarCVisu,"deb_list_ddl_etendu_noeud")!=NULL)
                     { // lecture de la liste des ddl
                       (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                       // on efface la liste actuelle
                       List_io <Ddl_enum_etendu>& lis_sor = tabnoeud_type_ddlEtendu_retenu(imail);
                       lis_sor.erase(lis_sor.begin(),lis_sor.end());
                       // lecture de la liste demandée
                       int compteur=0; // pour éviter une boucle infinie
                       while (compteur < 1000000)
                         { (*entreePrinc.entCVisu) >> nom; compteur++;
                           if (nom != "fin_list_ddl_etendu_noeud")
                             { lis_sor.push_back(Ddl_enum_etendu(nom));}
                           else break;
                          }
                       entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                     };
                   // ** les grandeurs particulières aux noeuds
                   if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandParticuliere_noeud")!=NULL)
                     { // lecture de la liste des grandeurs particulières
                       (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                       // on efface la liste actuelle
                       List_io<TypeQuelconque>& tpg_ret = (tabnoeud_TypeQuelconque_retenu(imail)); // pour simplifier
                       tpg_ret.clear(); // on vide les listes
                       listeVecGlobbal_retenu.clear();  // idem
                       // lecture de la liste demandée
                       int compteur=0; // pour éviter une boucle infinie
                       List_io<TypeQuelconque>& tpg = (tabnoeud_TypeQuelconque(imail)); // pour simplifier
                       while (compteur < 1000000)
                         { (*entreePrinc.entCVisu) >> nom; compteur++;
                           if (nom != "fin_list_GrandParticuliere_noeud")
                             { TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom)); // création d'un type quelconque sans grandeur
                               List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                               bool trouve = false;
                               bool dans_global=false; // pour savoir si c'est dans le vecteur global ou pas
                               // si la grandeur n'existe pas au niveau de tabnoeud_TypeQuelconque on essaie au niveau des
                               // vecteur globaux
                               if (il == tpg.end())
                                 {il = find(listeVecGlobbal.begin(),listeVecGlobbal.end(),a);
                                  if (il != listeVecGlobbal.end())
                                    trouve = true;dans_global=true;
                                  }
                               else // sinon c'est bon on a trouvé
                                 {trouve = true;}; 
                               // si la grandeur existe on essaie de l'enregistrer sinon on passe
                               if (trouve)
                                {// s'il n'existe pas déjà on l'enregistre vraiment
                                 if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                                  { tpg_ret.push_back(*il);
                                    if (dans_global) listeVecGlobbal_retenu.push_back(*il);
                                  }
                                 }; 
                              } 
                           else break;
                          }
                       entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                      };
                   // puis un autre pour "fin_liste_ddl_et_noeud"
                   entreePrinc.NouvelleDonneeCVisu(); 
                  };

                // ----- lecture des grandeurs aux points d'intégrations d'éléments ------
                if (strstr(entreePrinc.tablcarCVisu,"debut_liste_ddl_ptinteg")!=NULL) 
                 { entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                   //  ** les éléments et points d'intégration
                   if (strstr(entreePrinc.tablcarCVisu,"deb_list_NbElement_NbPtInteg")!=NULL)
                     { // lecture de la liste des éléments et points d'intégration
                       (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                       // on efface les listes actuelles
                       List_io <int>& lis_sor = tab_num_element(imail);
                       List_io <int>& lis_sor2 = tab_num_integ(imail);
                       lis_sor.erase(lis_sor.begin(),lis_sor.end());
                       lis_sor2.erase(lis_sor2.begin(),lis_sor2.end());
                       // lecture de la liste demandée
                       int compteur=0; // pour éviter une boucle infinie
                       while (compteur < 1000000)
                         { (*entreePrinc.entCVisu) >> nom ; compteur++;
                           if (nom != "fin_list_NbElement_NbPtInteg") 
                             {(*entreePrinc.entCVisu) >> nom2 ;
                              lis_sor.push_back(ChangeEntier(nom));
                              lis_sor2.push_back(ChangeEntier(nom2));
                              }
                           else break;
                          }
                       entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                      }
                   // ** les references de liste d'éléments
                   if (strstr(entreePrinc.tablcarCVisu,"deb_list_ref_element")!=NULL)
                     { // lecture de la liste de références de elements
                       (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                       // on efface les listes actuelles
                       List_io <BlocScal>& lis_nomref_E = nomDeRef_E(imail);
                       lis_nomref_E.erase(lis_nomref_E.begin(),lis_nomref_E.end());
                       // lecture de la liste demandée
                       int compteur=0; // pour éviter une boucle infinie
                       while (compteur < 1000000)
                         { (*entreePrinc.entCVisu) >> nom; compteur++;
                           if (nom != "fin_list_ref_element")
                             { if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 2))
                                 { cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference d'element correcte "
                                        << " on passe ! ";
                                  }
                               else 
                                { int numinteg; *entreePrinc.entCVisu >> numinteg; // lecture du num d'integ
                                  lis_nomref_E.push_back(BlocScal(nom,numinteg)); }
                              }  
                           else break;                           
                          }
                       entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                      }
                   // *** les references de liste de points d'intégration d'éléments
                   if (strstr(entreePrinc.tablcarCVisu,"deb_list_ref_ptinteg_element")!=NULL)
                     { // lecture de la liste de références de points d'intégration d'élements
                       (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                       // on efface les listes actuelles
                       List_io <string>& lis_nomref_ptinteg = nomDeRef_ptinteg(imail);
                       lis_nomref_ptinteg.erase(lis_nomref_ptinteg.begin(),lis_nomref_ptinteg.end());
                       // lecture de la liste demandée
                       int compteur=0; // pour éviter une boucle infinie
                       while (compteur < 1000000)
                         { (*entreePrinc.entCVisu) >> nom; compteur++;
                           if (nom != "fin_list_ref_ptinteg_element")
                             { if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 6))
                                 { cout << "\n erreur de nom  (** "<< nom << " **) donne ne correspond pas a une reference de point "
                                        << " d'integration correcte,  on passe ! ";
                                  }
                               else 
                                { lis_nomref_ptinteg.push_back(nom); }
                              }  
                           else break;                           
                          }
                       entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                      }
                   // ** les ddl 
                   if (strstr(entreePrinc.tablcarCVisu,"deb_list_ddl_element")!=NULL)
                     { // lecture de la liste des ddl
                       (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                       // on efface la liste actuelle
                       List_io <Ddl_enum_etendu>& lis_sor = tabelement_type_ddl_retenu(imail);
                       lis_sor.erase(lis_sor.begin(),lis_sor.end());
                       // lecture de la liste demandée
                       int compteur=0; // pour éviter une boucle infinie
                       while (compteur < 1000000)
                         { (*entreePrinc.entCVisu) >> nom; compteur++;
                           if (nom != "fin_list_ddl_element")
                             { lis_sor.push_back(Ddl_enum_etendu(nom));}
                           else break;
                          }
                       entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                      }
                   // ** les grandeurs particulières
                   if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandParticuliere_element")!=NULL)
                     { // lecture de la liste des grandeurs particulières
                       (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                       // on efface la liste actuelle
                       List_io<TypeQuelconque>& tpg_ret = (tabelement_typeParti_retenu(imail)); // pour simplifier
                       tpg_ret.clear();
                       // lecture de la liste demandée
                       int compteur=0; // pour éviter une boucle infinie
                       List_io<TypeQuelconque>& tpg = (tabelement_typeParti(imail)); // pour simplifier
                       while (compteur < 1000000)
                         { (*entreePrinc.entCVisu) >> nom; compteur++;
                           if (nom != "fin_list_GrandParticuliere_element")
                             {// ici on est obliger de tester l'existence du type particulier, s'il n'existe
                              // pas on le crée, car c'est peut-être un type automatique
                              // ensuite à la sortie il y aura une vérification d'existence
                              // pour l'instant on regarde uniquement le mot clé INTEG_SUR_VOLUME
                              TypeQuelconque_enum_etendu tq; // init par défaut
                              if (!TypeQuelconque_enum_etendu::VerifExistence(nom))
                               { // on regarde si le nom contient la partie INTEG_SUR_VOLUME
                                 if (nom.find("INTEG_SUR_VOLUME_ET_TEMPS") != std::string::npos)
                                   {tq =TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
                                     (INTEG_SUR_VOLUME_ET_TEMPS,nom,RIEN_TYPEGRANDEUR);
                                   }
                                 else if (nom.find("INTEG_SUR_VOLUME") != std::string::npos)
                                   {tq =TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
                                     (INTEG_SUR_VOLUME,nom,RIEN_TYPEGRANDEUR);
                                   }
                                 else // sinon on met un message et on met un type par défaut
                                  cout << "\n *** attention le type quelconque "<< nom
                                       << " n'est pas reconnu, aucune sortie prevu pour lui "
                                       << endl;
                               }
                              else
                               {tq = TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom);};
                              TypeQuelconque a(tq); // création d'un type quelconque sans grandeur
                              //TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom)); // création d'un type quelconque sans grandeur
                              List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                              // si la grandeur existe on essaie de l'enregistrer sinon on passe
                              if (il != tpg.end())
                               {// s'il n'existe pas déjà on l'enregistre vraiment
                                if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                                 { tpg_ret.push_back(*il);}
                                };
                              } 
                           else break;
                          }
                       entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                      }
                   // ** les grandeurs évoluées  aux éléments a visualiser
                   if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandEvoluee_element")!=NULL)
                        { // lecture de la liste des grandeurs évoluées
                          (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                          // on efface la liste actuelle
                          List_io<TypeQuelconque>& tpg_ret = (tabelement_evoluee_retenu(imail)); // pour simplifier
                          tpg_ret.clear();
                          // lecture de la liste demandée
                          int compteur=0; // pour éviter une boucle infinie
                          List_io<TypeQuelconque>& tpg = (tabelement_evoluee(imail)); // pour simplifier
                          while (compteur < 1000000)
                            { (*entreePrinc.entCVisu) >> nom; compteur++;
                              if (nom != "fin_list_GrandEvoluee_element")
                                { TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom)); // création d'un type quelconque sans grandeur
                                  List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                                  // s'il n'existe pas déjà on l'enregistre vraiment
                                  if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                                     { tpg_ret.push_back(*il);}
                                 } 
                              else break;
                             }
                          entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                        };
                   // puis un autre pour "fin_liste_ddl_ptinteg"
                   entreePrinc.NouvelleDonneeCVisu(); 
                  }    

               // ----- lecture des grandeurs aux points d'intégrations de faces d'éléments ------
               if (strstr(entreePrinc.tablcarCVisu,"debut_liste_grandeurs_ptinteg_F_E")!=NULL)
                { entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                  //  ** les faces d'éléments et points d'intégration
                  if (strstr(entreePrinc.tablcarCVisu,"deb_list_NbFaceElement_NbPtInteg")!=NULL)
                    { // lecture de la liste des faces d'éléments et points d'intégration
                      (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                      // on efface les listes actuelles
                      List_io <int>& lis_sor = tab_num_F_element(imail);
                      List_io <int>& lis_sor2 = tab_num_F_integ(imail);
                      List_io <int>& lis_sor3 = tab_num_F(imail);
                      string nom3;
                    
                      lis_sor.erase(lis_sor.begin(),lis_sor.end());
                      lis_sor2.erase(lis_sor2.begin(),lis_sor2.end());
                      lis_sor3.erase(lis_sor3.begin(),lis_sor3.end());
                      // lecture de la liste demandée
                      int compteur=0; // pour éviter une boucle infinie
                      while (compteur < 1000000)
                        { (*entreePrinc.entCVisu) >> nom ; compteur++;
                          if (nom != "fin_list_NbFaceElement_NbPtInteg")
                            {(*entreePrinc.entCVisu) >> nom3 >> nom2 ;
                             lis_sor.push_back(ChangeEntier(nom));
                             lis_sor3.push_back(ChangeEntier(nom3));
                             lis_sor2.push_back(ChangeEntier(nom2));
                             }
                          else break;
                         }
                      entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                     }
                  // ** les references de liste de faces d'éléments
                  if (strstr(entreePrinc.tablcarCVisu,"deb_list_ref_F_element")!=NULL)
                    { // lecture de la liste de références de faces d'élement
                      (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                      // on efface les listes actuelles
                      List_io <BlocScal>& lis_nomref_F_E = nomDeRef_F_E(imail);
                      lis_nomref_F_E.erase(lis_nomref_F_E.begin(),lis_nomref_F_E.end());
                      // lecture de la liste demandée
                      int compteur=0; // pour éviter une boucle infinie
                      while (compteur < 1000000)
                        { (*entreePrinc.entCVisu) >> nom; compteur++;
                          if (nom != "fin_list_ref_F_element")
                            { if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 3))
                                { cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference de faces d'element correcte "
                                       << " on passe ! ";
                                 }
                              else
                               { int numinteg; *entreePrinc.entCVisu >> numinteg; // lecture du num d'integ
                                 lis_nomref_F_E.push_back(BlocScal(nom,numinteg)); }
                             }
                          else break;
                         }
                      entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                     }
                  // *** les references de liste de points d'intégration de faces d'élément
                  if (strstr(entreePrinc.tablcarCVisu,"deb_list_ref_ptinteg_F_element")!=NULL)
                    { // lecture de la liste de références de points d'intégration de faces d'élement
                      (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                      // on efface les listes actuelles
                      List_io <string>& lis_nomref_ptinteg = nomDeRef_F_ptinteg(imail);
                      lis_nomref_ptinteg.erase(lis_nomref_ptinteg.begin(),lis_nomref_ptinteg.end());
                      // lecture de la liste demandée
                      int compteur=0; // pour éviter une boucle infinie
                      while (compteur < 1000000)
                        { (*entreePrinc.entCVisu) >> nom; compteur++;
                          if (nom != "fin_list_ref_ptinteg_F_element")
                            { if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 7))
                                { cout << "\n erreur de nom  (** "<< nom << " **) donne ne correspond pas a une reference de point "
                                       << " d'integration correcte pour une face d'element,  on passe ! ";
                                 }
                              else
                               { lis_nomref_ptinteg.push_back(nom); }
                             }
                          else break;
                         }
                      entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                     }
                  // ** les grandeurs
                  if (strstr(entreePrinc.tablcarCVisu,"deb_list_Grandeur_F_element")!=NULL)
                    { // lecture de la liste des grandeurs
                      (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                      // on efface la liste actuelle
                      List_io<TypeQuelconque>& tpg_ret = (tab_F_element_TypeQuelconque_retenu(imail)); // pour simplifier
                      tpg_ret.clear();
                      // lecture de la liste demandée
                      int compteur=0; // pour éviter une boucle infinie
                      List_io<TypeQuelconque>& tpg = (tab_F_element_TypeQuelconque(imail)); // pour simplifier
                      while (compteur < 1000000)
                        { (*entreePrinc.entCVisu) >> nom; compteur++;
                          if (nom != "fin_list_Grandeur_F_element")
                            {// ici on est obliger de tester l'existence du type particulier, s'il n'existe
                             // pas on le crée, car c'est peut-être un type automatique
                             // ensuite à la sortie il y aura une vérification d'existence
                             // pour l'instant on regarde uniquement le mot clé INTEG_SUR_VOLUME
                             TypeQuelconque_enum_etendu tq; // init par défaut
                             if (!TypeQuelconque_enum_etendu::VerifExistence(nom))
                              { // on regarde si le nom contient la partie INTEG_SUR_VOLUME
                                if (nom.find("INTEG_SUR_VOLUME_ET_TEMPS") != std::string::npos)
                                  {tq =TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
                                    (INTEG_SUR_VOLUME_ET_TEMPS,nom,RIEN_TYPEGRANDEUR);
                                  }
                                else if (nom.find("INTEG_SUR_VOLUME") != std::string::npos)
                                  {tq =TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
                                    (INTEG_SUR_VOLUME,nom,RIEN_TYPEGRANDEUR);
                                  }
                                else // sinon on met un message et on met un type par défaut
                                 cout << "\n *** attention le type quelconque "<< nom
                                      << " n'est pas reconnu, aucune sortie prevu pour lui "
                                      << endl;
                              }
                             else
                              {tq = TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom);};
                             TypeQuelconque a(tq); // création d'un type quelconque sans grandeur
                             //TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom)); // création d'un type quelconque sans grandeur
                             List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                             // si la grandeur existe on essaie de l'enregistrer sinon on passe
                             if (il != tpg.end())
                              {// s'il n'existe pas déjà on l'enregistre vraiment
                               if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                                { tpg_ret.push_back(*il);}
                               };
                             }
                          else break;
                         }
                      entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                     }
                  // puis un autre pour "fin_liste_grandeurs_ptinteg_F_E"
                  entreePrinc.NouvelleDonneeCVisu();
                 }

               // ----- lecture des grandeurs aux points d'intégrations d'arêtes  d'éléments ------
               if (strstr(entreePrinc.tablcarCVisu,"debut_liste_grandeurs_ptinteg_A_E")!=NULL)
                { entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                  //  ** les arêtes d'éléments et points d'intégration
                  if (strstr(entreePrinc.tablcarCVisu,"deb_list_NbAreteElement_NbPtInteg")!=NULL)
                    { // lecture de la liste des faces d'éléments et points d'intégration
                      (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                      // on efface les listes actuelles
                      List_io <int>& lis_sor = tab_num_A_element(imail);
                      List_io <int>& lis_sor2 = tab_num_A_integ(imail);
                      List_io <int>& lis_sor3 = tab_num_A(imail);
                      string nom3;
                    
                      lis_sor.erase(lis_sor.begin(),lis_sor.end());
                      lis_sor2.erase(lis_sor2.begin(),lis_sor2.end());
                      lis_sor3.erase(lis_sor3.begin(),lis_sor3.end());
                      // lecture de la liste demandée
                      int compteur=0; // pour éviter une boucle infinie
                      while (compteur < 1000000)
                        { (*entreePrinc.entCVisu) >> nom ; compteur++;
                          if (nom != "fin_list_NbAreteElement_NbPtInteg")
                            {(*entreePrinc.entCVisu) >> nom3 >> nom2 ;
                             lis_sor.push_back(ChangeEntier(nom));
                             lis_sor3.push_back(ChangeEntier(nom3));
                             lis_sor2.push_back(ChangeEntier(nom2));
                             }
                          else break;
                         }
                      entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                     }
                  // ** les references de liste d'arêtes d'éléments
                  if (strstr(entreePrinc.tablcarCVisu,"deb_list_ref_A_element")!=NULL)
                    { // lecture de la liste de références d'arêtes d'élement
                      (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                      // on efface les listes actuelles
                      List_io <BlocScal>& lis_nomref_A_E = nomDeRef_A_E(imail);
                      lis_nomref_A_E.erase(lis_nomref_A_E.begin(),lis_nomref_A_E.end());
                      // lecture de la liste demandée
                      int compteur=0; // pour éviter une boucle infinie
                      while (compteur < 1000000)
                        { (*entreePrinc.entCVisu) >> nom; compteur++;
                          if (nom != "fin_list_ref_A_element")
                            { if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 4))
                                { cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference d'arete d'element correcte "
                                       << " on passe ! ";
                                 }
                              else
                               { int numinteg; *entreePrinc.entCVisu >> numinteg; // lecture du num d'integ
                                 lis_nomref_A_E.push_back(BlocScal(nom,numinteg)); }
                             }
                          else break;
                         }
                      entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                     }
                  // *** les references de liste de points d'intégration d'arêtes d'élément
                  if (strstr(entreePrinc.tablcarCVisu,"deb_list_ref_ptinteg_A_element")!=NULL)
                    { // lecture de la liste de références de points d'intégration d'arêtes d'élement
                      (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                      // on efface les listes actuelles
                      List_io <string>& lis_nomref_ptinteg = nomDeRef_A_ptinteg(imail);
                      lis_nomref_ptinteg.erase(lis_nomref_ptinteg.begin(),lis_nomref_ptinteg.end());
                      // lecture de la liste demandée
                      int compteur=0; // pour éviter une boucle infinie
                      while (compteur < 1000000)
                        { (*entreePrinc.entCVisu) >> nom; compteur++;
                          if (nom != "fin_list_ref_ptinteg_A_element")
                            { if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 8))
                                { cout << "\n erreur de nom  (** "<< nom << " **) donne ne correspond pas a une reference de point "
                                       << " d'integration correcte pour une arete d'element,  on passe ! ";
                                 }
                              else
                               { lis_nomref_ptinteg.push_back(nom); }
                             }
                          else break;
                         }
                      entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                     }
                  // ** les grandeurs
                  if (strstr(entreePrinc.tablcarCVisu,"deb_list_Grandeur_A_element")!=NULL)
                    { // lecture de la liste des grandeurs
                      (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                      // on efface la liste actuelle
                      List_io<TypeQuelconque>& tpg_ret = (tab_A_element_TypeQuelconque_retenu(imail)); // pour simplifier
                      tpg_ret.clear();
                      // lecture de la liste demandée
                      int compteur=0; // pour éviter une boucle infinie
                      List_io<TypeQuelconque>& tpg = (tab_A_element_TypeQuelconque(imail)); // pour simplifier
                      while (compteur < 1000000)
                        { (*entreePrinc.entCVisu) >> nom; compteur++;
                          if (nom != "fin_list_Grandeur_A_element")
                            {// ici on est obliger de tester l'existence du type particulier, s'il n'existe
                             // pas on le crée, car c'est peut-être un type automatique
                             // ensuite à la sortie il y aura une vérification d'existence
                             // pour l'instant on regarde uniquement le mot clé INTEG_SUR_VOLUME
                             TypeQuelconque_enum_etendu tq; // init par défaut
                             if (!TypeQuelconque_enum_etendu::VerifExistence(nom))
                              { // on regarde si le nom contient la partie INTEG_SUR_VOLUME
                                if (nom.find("INTEG_SUR_VOLUME_ET_TEMPS") != std::string::npos)
                                  {tq =TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
                                    (INTEG_SUR_VOLUME_ET_TEMPS,nom,RIEN_TYPEGRANDEUR);
                                  }
                                else if (nom.find("INTEG_SUR_VOLUME") != std::string::npos)
                                  {tq =TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
                                    (INTEG_SUR_VOLUME,nom,RIEN_TYPEGRANDEUR);
                                  }
                                else // sinon on met un message et on met un type par défaut
                                 cout << "\n *** attention le type quelconque "<< nom
                                      << " n'est pas reconnu, aucune sortie prevu pour lui "
                                      << endl;
                              }
                             else
                              {tq = TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom);};
                             TypeQuelconque a(tq); // création d'un type quelconque sans grandeur
                             //TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom)); // création d'un type quelconque sans grandeur
                             List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                             // si la grandeur existe on essaie de l'enregistrer sinon on passe
                             if (il != tpg.end())
                              {// s'il n'existe pas déjà on l'enregistre vraiment
                               if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                                { tpg_ret.push_back(*il);}
                               };
                             }
                          else break;
                         }
                      entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
                     }
                  // puis un autre pour "fin_liste_grandeurs_ptinteg_A_E"
                  entreePrinc.NouvelleDonneeCVisu();
                 }

                // informations particulières pour le cas où il y a une animation
                if (strstr(entreePrinc.tablcarCVisu,"debut_info_particulier")!=NULL)
                 { // lecture de la liste des grandeurs
                   (*entreePrinc.entCVisu) >> nom; // on passe le mot clé
                   if (strstr(entreePrinc.tablcarCVisu,"grandeur_au_noeud?")!=NULL)
                      (*entreePrinc.entCVisu) >> nom >> type_xi;
                   if (strstr(entreePrinc.tablcarCVisu,"x1=")!=NULL)
                      (*entreePrinc.entCVisu) >> nom >> x1;
                   if (strstr(entreePrinc.tablcarCVisu,"x2=")!=NULL)
                      (*entreePrinc.entCVisu) >> nom >> x2;
                   if (strstr(entreePrinc.tablcarCVisu,"accroi_x1=")!=NULL)
                      (*entreePrinc.entCVisu) >> nom >> accroi_x1;
                   if (strstr(entreePrinc.tablcarCVisu,"accroi_x2=")!=NULL)
                      (*entreePrinc.entCVisu) >> nom >> accroi_x2;
                   // on ne lit pas le mot clé fin_info_particulier       
                   entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement pour la suite
                  }
                  
                // lecture du paramètre de pilotage du style de sortie
                if (strstr(entreePrinc.tablcarCVisu,"parametre_style_de_sortie")!=NULL)
                 { // lecture du style
                   (*entreePrinc.entCVisu) >> nom >> style_de_sortie; 
                   entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement pour la suite
                 };
                // lecture  du type de sortie des tenseurs
                if (strstr(entreePrinc.tablcarCVisu,"tenseur_en_absolue_")!=NULL)
                  {(*entreePrinc.entCVisu) >> nom >> absolue;
                   if (nom != "tenseur_en_absolue_")
                    { cout << "\n lecture de l'indicateur de type de tensue, on a lue ( "<< nom
                           << " ) et on attendait tenseur_en_absolue_"
                           << " la suite de la lecture du .CVisu risque d'etre completement fausse, on arrete !!" ; 
                      cout << "\n Choix_grandeurs_maple::Lecture_parametres_OrdreVisu(... ";
                      UtilLecture::ErrNouvelEnregCVisu sortie(-1) ; throw (sortie);
                    }
                   else // sinon c'est ok
                    {entreePrinc.NouvelleDonneeCVisu();}; // on passe un enregistrement
                  };
              } // -- fin du while sur les maillages
            } // -- fin du if then else sur "debut_grandeurs_maple"
          // vérification des listes de pt d'integ et d'éléments relativement au grandeur à sortir
          VerifListes();
         } // -- fin du try    
      catch (ErrSortieFinale)
           // cas d'une direction voulue vers la sortie
           // on relance l'interuption pour le niveau supérieur
         { ErrSortieFinale toto;
           throw (toto);
         }
      catch (...)// erreur de lecture
       {  cout << "\n Erreur en lecture pour les grandeurs a visualiser au format maple a partir d'un fichier .CVisu,"
               << " on ne tiens pas compte  de la liste fournie !! ";
          // récup des  listes sauvées
          tabnoeud_type_ddl_retenu=tabnoeud_type_ddl_retenu_sauve; // ddl principaux aux noeuds  à visualiser
          tabelement_type_ddl_retenu=tabelement_type_ddl_retenu_sauve; // ddl aux elements  à visualiser
          tabnoeud_type_ddlEtendu_retenu=tabnoeud_type_ddlEtendu_retenu_sauve; // ddl étendu aux noeuds
          tabnoeud_TypeQuelconque_retenu=tabnoeud_TypeQuelconque_retenu_sauve; // les grandeurs quelconques
          tabelement_evoluee_retenu = tabelement_evoluee_retenu_s;
          // -> face d'éléments
          tab_F_element_TypeQuelconque_retenu = tab_F_element_TypeQuelconque_retenu_sauve;
          tab_F_element_TypeQuelconque_retenu_pourSM = tab_F_element_TypeQuelconque_retenu_pourSM_sauve;
          // -> arête d'éléments
          tab_A_element_TypeQuelconque_retenu = tab_A_element_TypeQuelconque_retenu_sauve;
          tab_A_element_TypeQuelconque_retenu_pourSM = tab_A_element_TypeQuelconque_retenu_pourSM_sauve;

          tab_num_noeud=tab_num_noeud_sauve; // liste des noeuds à visualiser
          tab_num_element=tab_num_element_sauve; // liste des éléments à visualiser 
          tab_num_integ=tab_num_integ_sauve; // liste des numéros de point d'integration à visualiser 
          type_sortie_ddl_retenue=type_sortie_ddl_retenue_sauve;      
          nomDeRef = nomDeRef_sauve; // list de nom de références de noeuds
          nomDeRef_E = nomDeRef_E_sauve; // list de nom de références d'éléments et de point d'intégration associé
          nomDeRef_ptinteg = nomDeRef_ptinteg_sauve; // list de nom de références de pt d'integ
          listeVecGlobbal_retenu =  listeVecGlobbal_retenu_sauve; // les vecteurs globaux
          
          
          // -> les pti de face d'éléments
          tab_num_F_element = tab_num_F_element_sauve; // liste des éléments à visualiser
          tab_num_F = tab_num_F_sauve; // liste des num de face ou arêtes d'éléments à visualiser
          tab_num_F_integ = tab_num_F_integ_sauve; // liste des numéros de point d'integration à visualiser associé à tab_num_F_element
          nomDeRef_F_E = nomDeRef_F_E_sauve; // list de nom de références face  d'éléments associés
          nomDeRef_F_ptinteg = nomDeRef_F_ptinteg_sauve; // list de nom de références de pt d'integ de face d'éléments
          // -> les pti d'arête d'éléments
          tab_num_A_element = tab_num_A_element_sauve; // liste des éléments à visualiser
          tab_num_A = tab_num_A_sauve; // liste des num d'arêtes d'éléments à visualiser
          tab_num_A_integ = tab_num_A_integ_sauve; // liste des numéros de point d'integration à visualiser associé à tab_num_A_element
          nomDeRef_A_E = nomDeRef_A_E_sauve; // list de nom de références d'arête d'éléments  associé
          nomDeRef_A_ptinteg = nomDeRef_A_ptinteg_sauve; // list de nom de références de pt d'integ d'arête d'éléments

          // ------parties moyennes et sommes
          tab_nomDeRef_SM = tab_nomDeRef_SM_sauve;
          tab_nomDeRef_E_SM = tab_nomDeRef_E_SM_sauve;
          tab_nomDeRef_ptinteg_SM = tab_nomDeRef_ptinteg_SM_sauve;
          tabnoeud_type_ddl_retenu_pourSM = tabnoeud_type_ddl_retenu_pourSM_sauve;
          tabnoeud_type_ddlEtendu_retenu_pourSM = tabnoeud_type_ddlEtendu_retenu_pourSM_sauve;
          tabnoeud_TypeQuelconque_retenu_pourSM = tabnoeud_TypeQuelconque_retenu_pourSM_sauve;
          tabelement_type_ddl_retenu_pourSM = tabelement_type_ddl_retenu_pourSM_sauve;
          tabelement_typeParti_retenu_pourSM = tabelement_typeParti_retenu_pourSM_sauve;
          tabelement_evoluee_retenu_pourSM = tabelement_evoluee_retenu_pourSM_sauve;
        
          // concernant les faces et arêtes
          tab_nomDeRef_F_E_SM = tab_nomDeRef_F_E_SM_sauve;
          tab_nomDeRef_F_ptinteg_SM = tab_nomDeRef_F_ptinteg_SM_sauve;
          tab_nomDeRef_A_E_SM = tab_nomDeRef_A_E_SM_sauve;
          tab_nomDeRef_A_ptinteg_SM = tab_nomDeRef_A_ptinteg_SM_sauve;
          
          if (ParaGlob::NiveauImpression() >= 4)
             cout  << "\n Choix_grandeurs_maple::Lecture_parametres_OrdreVisu(..";
        }
      // on passe à un nouvel enregistrement
      entreePrinc.NouvelleDonneeCVisu();
     };
   // dans le cas où il y a des vecteurs globaux qui ont été retenus,
   // il faut définir  aux noeuds des conteneurs adéquates
   if (listeVecGlobbal_retenu.size() != 0)
    { // def de conteneurs pour le passage d'infos
      List_io < Ddl_enum_etendu > lienu; // une liste vide
      List_io < TypeQuelconque > litq; // une autre pour les quelconques
      Tableau <List_io < TypeQuelconque > * > tabQ(2); 
      tabQ(1)= &listeVecGlobbal_retenu;tabQ(2)=&litq;
      // on est obligé d'utiliser un tableau dont le second terme est nul,
      // ceci pour pouvoir utiliser "AjoutConteneurAuNoeud" tel quel
      int nbmail_total = lesMail->NbMaillage();
      for (int imail=1;imail <= nbmail_total;imail++)
         lesMail->AjoutConteneurAuNoeud(imail,lienu,tabQ);
    };
   // on introduit certains conteneurs internes des maillages si besoin est en fonction
   // des choix de l'utilisateurs: utiles uniquement pour certaines grandeurs
   lesMail->Intro_Conteneurs_internes_noeud_relier_auto_autres_grandeur(tabnoeud_TypeQuelconque_retenu);

  };

// écriture des paramètres de l'ordre dans un flux
void Choix_grandeurs_maple::Ecriture_parametres_OrdreVisu(UtilLecture & entreePrinc)
 { // récup du flot  
   ostream & sort = (*(entreePrinc.Sort_CommandeVisu()));
   // on commente le fonctionnement
	  bool fr = ParaGlob::Francais(); // pour simplifier
   if (fr)
	    {sort << "\n #  ----------------------------- definition des grandeurs a visualiser (maple): ---------------- "
           << "\n debut_grandeurs_maple  #  un mot cle de debut (debut_grandeurs_maple),";
	    }
	  else 
	    {sort << "\n #  ----------------------------- definition of the quantities which are to be visualised (maple): ---------------- "
           << "\n debut_grandeurs_maple  #  a key word that indicates the beginning for .maple output  (debut_grandeurs_maple),";
	    };
   // appel de l'ordre de la classe mère
   OrdreVisu::Ecrit_para_OrdreVisu_general(entreePrinc);
   // on sort les grandeurs globales éventuelles
   if (fr)
	   {sort << "\n # les grandeurs globales (energie, puissance ....) un mot cle de debut, le nom des grandeurs puis un mot de fin";}
	  else
	   {sort << "\n # global quantities (energie, power ....) a keyword for the beginning, the name of the quantities, then a keyword for the end ";};
   sort <<"\n debut_grandeurs_globales    ";
   List_io <string>::iterator jaint,jaintfin = list_grand_global_retenu.end();
   for (jaint=list_grand_global_retenu.begin();jaint!=jaintfin;jaint++)
       sort << *jaint << " ";
   sort << " fin_grandeurs_globales  ";
   // puis les paramètres propres
   if (fr)
	   {sort << "\n #  ensuite pour chaque maillage:,"
          << "\n #    le numero du maillage <un entier>,  "
          << "\n #    les infos pour la visualisation eventuelle des torseurs de reaction,"
          
          << "\n #    les infos pour la visualisation eventuelle de sommes, moyennes etc. sur des références "
          << "\n #         - de noeuds "
          << "\n #         - d'elements "
          << "\n #         - de face d'element "
          << "\n #         - d'arete d'element "
          
          << "\n #    les infos pour la visualisation eventuelle aux noeud,"
          << "\n #         - tout d'abord les ddl principaux (position, deplacements, temperature etc.)"
          << "\n #         - puis les ddl etendus et particulieres qui peuvent representer des grandeurs diverses "
          << "\n #    les infos pour la visualisation eventuelle aux elements,"
          << "\n #         - tout d'abord les grandeurs generiques (deformations, contraintes etc.)"
          << "\n #         - puis les grandeurs particulieres, par exemple specifique a une loi de comp ou une mesure de def "

          << "\n #    les infos pour la visualisation eventuelle aux faces d'element de grandeurs quelconques,"
          << "\n #    les infos pour la visualisation eventuelle aux aretes d'element de grandeurs quelconques,"

          << "\n #  enfin un mot cle de fin ( fin_grandeurs_maple)";
	   }
	  else 
	   {sort << "\n #  then for each mesh:,"
          << "\n #    the numer of the mesh <an integer>,  "
          << "\n #    the informations for a possible visualisation of the reaction wrenches,"
          
          << "\n #    the informations for a possible visualisation of summ, average ... on references "
          << "\n #         - for nodes "
          << "\n #         - for elements "
          << "\n #         - for element facets "
          << "\n #         - for element edges "
          
          << "\n #    the informations for a possible visualisation at nodes,"
          << "\n #         - firstly, the direct dof (position, displacement, temperature etc.)"
          << "\n #         - secondly the extend and specific dof which can represent  other entities "
          << "\n #    the informations for a possible visualisation at elements,"
          << "\n #         - firstly, the generic quantities (deformations, stress,  etc.)"
          << "\n #         - secondly the particular quantities, for instance, specific for a behaviour, or a measure of deformation  "
          
          << "\n #    the informations for a possible visualisation at element facet,"
          << "\n #    the informations for a possible visualisation at element edge,"

          << "\n #  and finally a keyword for the end  ( fin_grandeurs_maple)";
	   };
   // préparation pour la sortie des listes 
   list<int>::const_iterator ili,ilifin,ili2,ilifin2,iti,itifin;
   list<Ddl_enum_etendu>::const_iterator ild,ildfin;
   list<TypeQuelconque>::const_iterator iGP,iGPfin;
   List_io < bool >::const_iterator ivinit,ivinitfin;
   int nb_mail = tabnoeud_type_ddl_retenu.Taille();
   // -- le détail des grandeurs par maillage
   for (int imail=1;imail<=nb_mail;imail++)
    { // ** le numero de maillage
      sort << "\n " << imail; 
		    if (fr) {sort << " # le numero de maillage";} else {sort << " # the number of the mesh";};
      // ** les torseurs de reaction       
      {if (fr)
        {sort << "\n # les torseurs de reaction:  un mot cle de debut:  debut_list_torseur_reaction";
         sort << "\n # une liste de nom  <chaine de caracteres >, puis <fin_list_torseur_reaction>";
        }
       else
        {sort << "\n # the wrenches of reaction:  a keyword for the beginning:  debut_list_torseur_reaction";
         sort << "\n # a list of name  <string >, then <fin_list_torseur_reaction>";
        };
       sort <<"\n debut_list_torseur_reaction  " ;
       // --- les references des regions ou sont calculé le torseur de reaction
       {List_io <String_et_entier >& list_torseur_condLim_retenu = tab_list_torseur_condLim_retenu(imail);
        List_io <String_et_entier>::iterator keint,keintfin = list_torseur_condLim_retenu.end();
        for (keint=list_torseur_condLim_retenu.begin();keint!=keintfin;keint++)
            sort << (*keint).nom << " ";
        sort << " fin_list_torseur_reaction  ";
       };
      };
      // <-><-><-><-><-><-> les sommes, moyennes etc. sur des références <-><-><-><-><-><->
      // ====== sur les ref de noeuds =======
      {if (fr)
         {sort << "\n # les sommes, moyennes etc.  sur ref de noeuds:  un mot cle de debut:  debut_list_SM_sur_refN";
          sort << "\n # une liste de nom de ref <chaine de caracteres >, puis <fin_list__SM_sur_refN>";
         }
        else
         {sort << "\n # the sum on a ref of nodes:  a keyword for the beginning:  debut_list_SM_sur_refN";
          sort << "\n # a list of name  <string >, then <fin_list__SM_sur_refN>";
         };
        sort <<"\n debut_list_SM_sur_refN  " ;
         // --- les références des régions en noeuds
        {List_io <string >& nomDeRef_SM = tab_nomDeRef_SM(imail);
         List_io <string>::iterator keint,keintfin = nomDeRef_SM.end();
         for (keint=nomDeRef_SM.begin();keint!=keintfin;keint++)
             sort << (*keint) << " ";
         sort << " fin_list__SM_sur_refN  ";
        };
         //---- les grandeurs à considérer aux noeuds ----
        {// ** les ddl principaux aux noeuds
         {if (fr) {sort << "\n #   debut de la liste des ddl a considerer <deb_list_ddl_SM_sur_refN>, (une liste de ddl),"
                        <<  " puis <fin_list_ddl_SM_sur_refN>";}
          else	{sort << "\n #   beginning of the list of the dof  <deb_list_ddl_SM_sur_refN> , (the list), then <fin_list_ddl_SM_sur_refN>";};
          
          sort << "\n deb_list_ddl_SM_sur_refN    ";
          ildfin = tabnoeud_type_ddl_retenu_pourSM(imail).end();
          for (ild=tabnoeud_type_ddl_retenu_pourSM(imail).begin();ild!=ildfin;ild++)
            sort <<  (*ild);
          sort << "     fin_list_ddl_SM_sur_refN   ";
         };
         // ** les ddl étendus des noeuds
         {// on encapsule pour une gestion visuelle plus facile
          // ---- les ddl étendus
          if (fr) {sort << "\n #   debut de la liste des ddl etendus a considerer, (une liste de ddl),"
                        <<  " puis <fin_list_ddl_etendu__SM_sur_refN>";}
          else	{sort << "\n #   beginning of the list of the extended dof  <deb_list_ddl__SM_sur_refN> , (the list), then <fin_list_ddl__SM_sur_refN>";};
          sort << "\n deb_list_ddl_etendu__SM_sur_refN    ";
          ildfin = tabnoeud_type_ddlEtendu_retenu_pourSM(imail).end();
          for (ild=tabnoeud_type_ddlEtendu_retenu_pourSM(imail).begin();ild!=ildfin;ild++)
            sort <<  (*ild);
          sort << "     fin_list_ddl_etendu__SM_sur_refN   ";
          if (fr) { sort << " # fin des ddl etendu pour _SM_sur_refNs";}
          else { sort << " # end of the extended dof for _SM_sur_refNs";};
         };
         // ** les grandeurs quelconques aux noeuds
         {// on encapsule pour une gestion visuelle plus facile
          // ---- les grandeurs quelconques ---
          if (fr) {sort << "\n #   debut de la liste des grandeurs particulieres a considerer, (une liste de string),"
                        <<  " puis <fin_list_GrandParticuliere__SM_sur_refN>";}
          else	{sort << "\n #   beginning of the list of particular values at node (a string list) <deb_list_GrandParticuliere__SM_sur_refN> , (the list), then <fin_list_GrandParticuliere__SM_sur_refN>";};
          sort << "\n deb_list_GrandParticuliere__SM_sur_refN    ";
          iGPfin = tabnoeud_TypeQuelconque_retenu_pourSM(imail).end();
          for (iGP=tabnoeud_TypeQuelconque_retenu_pourSM(imail).begin();iGP!=iGPfin;iGP++)
              sort << ((*iGP).EnuTypeQuelconque().NomPlein()) << " ";
          sort << "     fin_list_GrandParticuliere__SM_sur_refN   ";
          if (fr) { sort << " # fin des grandeurs particulieres aux _SM_sur_refNs";}else { sort << " # end of the particular values for _SM_sur_refN";};
         };
        };
      };
      // ====== sur les ref de d'éléments =======
      { if (fr)
         {sort << "\n # les SM sur ref d'elements:  un mot cle de debut:  debut_list_SM_sur_refE";
          sort << "\n # une liste de nom de ref d'elements <chaine de caracteres >, le pti associe "
               << "\n # puis <fin_list__SM_sur_refE>";
         }
        else
         {sort << "\n # the sum on a ref of element:  a keyword for the beginning:  debut_list_SM_sur_refE";
          sort << "\n # a list of name  <string > + 1 pti, then <fin_list__SM_sur_refE>";
         };
        sort <<"\n debut_list_SM_sur_refE  " ;
        // --- les references des régions en éléments + num du pti où sont calculés les SMs
        {List_io <BlocScal >& nomDeRef_E_SM = tab_nomDeRef_E_SM(imail);
         List_io <BlocScal>::iterator keint,keintfin = nomDeRef_E_SM.end();
         for (keint=nomDeRef_E_SM.begin();keint!=keintfin;keint++)
          {sort << " " << (*keint).NomRef();  sort << " " << (int)((*keint).Val()); }
         sort << " fin_list__SM_sur_refE  ";
        };
        // -- idem sur les pti
        if (fr)
         {sort << "\n # les SMs sur ref de pti:  un mot cle de debut:  debut_list_SM_sur_refpti";
          sort << "\n # une liste de nom de ref <chaine de caracteres >, puis <fin_list__SM_sur_refpti>";
         }
        else
         {sort << "\n # the sum on a ref of element:  a keyword for the beginning:  debut_list_SM_sur_refpti";
          sort << "\n # a list of name  <string >, then <fin_list__SM_sur_refpti>";
         };
        sort <<"\n debut_list_SM_sur_refpti  " ;
        // --- les references des regions en ref de pti où sont calculés les SMs
        {List_io <string >& nomDeRef_ptinteg_SM = tab_nomDeRef_ptinteg_SM(imail);
         List_io <string>::iterator keint,keintfin = nomDeRef_ptinteg_SM.end();
         for (keint=nomDeRef_ptinteg_SM.begin();keint!=keintfin;keint++)
             sort << (*keint) << " ";
         sort << " fin_list__SM_sur_refpti  ";
        };
         //---- les grandeurs à considérer aux pti des éléments ----
        {// ** les ddl
         {sort << "\n # debut de la liste des ddl a considerer , (une liste de ddl),  "
               <<                                           "  puis <fin_list_ddl__SM_sur_refEpti>";
          sort << "\n deb_list_ddl__SM_sur_refEpti   ";
          ildfin = tabelement_type_ddl_retenu_pourSM(imail).end();
          for (ild=tabelement_type_ddl_retenu_pourSM(imail).begin();ild!=ildfin;ild++)
            sort << (*ild) << " ";
          sort << "      fin_list_ddl__SM_sur_refEpti          # fin de la liste de ddl a considerer pour les elements";
         };
         // ** les grandeurs particulières
         {if (fr) {sort << "\n #   debut de la liste des grandeurs particulieres a considerer pour les _SM_sur_refEptis, (une liste de string),"
                        <<  " puis <fin_list_GrandParticuliere__SM_sur_refEpti>";}
          else	{sort << "\n #   beginning of the list of particular values at the _SM_sur_refEpti (a string list) <deb_list_GrandParticuliere__SM_sur_refEpti> , (the list), then <fin_list_GrandParticuliere__SM_sur_refEpti>";};
          sort << "\n deb_list_GrandParticuliere__SM_sur_refEpti   ";
          iGPfin = tabelement_typeParti_retenu_pourSM(imail).end();
          for (iGP=tabelement_typeParti_retenu_pourSM(imail).begin();iGP!=iGPfin;iGP++)
           sort << ((*iGP).EnuTypeQuelconque().NomPlein()) << " ";
          sort << "      fin_list_GrandParticuliere__SM_sur_refEpti   ";
          if (fr) { sort << " # fin des grandeurs particulieres aux _SM_sur_refEptis";}else { sort << " # end of the particular values at the _SM_sur_refEpti";};
         };
         // ** les grandeurs évoluées  aux éléments a visualiser
         { if (fr) {sort << "\n #   tableau de grandeurs evoluees  aux _SM_sur_refEptis a visualiser, un par maillage";
                   sort << "\n deb_list_GrandEvoluee__SM_sur_refEpti " ;
                  }
          else    {sort << "\n #   beginning of the list of tensorial values at _SM_sur_refEpti, one for a mesh ";
                   sort << "\n deb_list_GrandEvoluee__SM_sur_refEpti " ;
                  };
          List_io < TypeQuelconque >::iterator ilq,ilqfin=tabelement_evoluee_retenu_pourSM(imail).end();
          for (ilq=tabelement_evoluee_retenu_pourSM(imail).begin();ilq!=ilqfin;ilq++)
            { sort << ((*ilq).EnuTypeQuelconque().NomPlein()) << " " ;};
          if (fr) {sort << " fin_list_GrandEvoluee__SM_sur_refEpti " ;}
          else    {sort << " fin_list_GrandEvoluee__SM_sur_refEpti " ;};
         };
        };
      };
      // ====== sur les ref de faces d'élément =======
      { // 1) les ref de faces d'élément
        if (fr)
         {sort << "\n # les SM sur ref de faces d'element:  un mot cle de debut:  debut_list_SM_sur_refFE";
          sort << "\n # une liste de nom de ref de faces d'element <chaine de caracteres >, le pti associe "
               << "\n # puis <fin_list__SM_sur_refFE>";
         }
        else
         {sort << "\n # the sum on a ref of element facet:  a keyword for the beginning:  debut_list_SM_sur_refFE";
          sort << "\n # a list of name  <string > + 1 pti, then <fin_list__SM_sur_refFE>";
         };
        //  ... écriture des references de faces d'élément + num du pti où sont calculés les SMs
        {sort <<"\n debut_list_SM_sur_refFE  " ;
         List_io <BlocScal >& nomDeRef_F_E_SM = tab_nomDeRef_F_E_SM(imail);
         List_io <BlocScal>::iterator keint,keintfin = nomDeRef_F_E_SM.end();
         for (keint=nomDeRef_F_E_SM.begin();keint!=keintfin;keint++)
          {sort << " " << (*keint).NomRef();  sort << " " << (int)((*keint).Val()); }
         sort << " fin_list__SM_sur_refFE  ";
        };
        //  2) idem sur les ref de pti de face
        if (fr)
         {sort << "\n # les SMs sur ref de pti de face:  un mot cle de debut:  debut_list_SM_sur_refFpti";
          sort << "\n # une liste de nom de ref <chaine de caracteres >, puis <fin_list__SM_sur_refFpti>";
         }
        else
         {sort << "\n # the sum on a ref of element facet:  a keyword for the beginning:  debut_list_SM_sur_refFpti";
          sort << "\n # a list of name  <string >, then <fin_list__SM_sur_refFpti>";
         };
        //  ... écriture des references des regions en ref de pti où sont calculés les SMs
        {sort <<"\n debut_list_SM_sur_refFpti  " ;
         List_io <string >& nomDeRef_ptinteg_SM = tab_nomDeRef_F_ptinteg_SM(imail);
         List_io <string>::iterator keint,keintfin = nomDeRef_ptinteg_SM.end();
         for (keint=nomDeRef_ptinteg_SM.begin();keint!=keintfin;keint++)
             sort << (*keint) << " ";
         sort << " fin_list__SM_sur_refFpti  ";
        };
        // 3)  écriture de la liste des grandeurs à considérer aux pti des faces d'élément ----
        {if (fr) {sort << "\n #   debut de la liste des grandeurs  a considerer pour les SM sur face, (une liste de string),"
                       <<  " <deb_list_Grandeur_SM_sur_refFEpti> , (la liste),  puis <fin_list_Grandeur_SM_sur_refFEpti>";}
         else {sort << "\n #   beginning of the list of values at the SM on facet (a string list),"
                    << " <deb_list_Grandeur_SM_sur_refFEpti> , (the list), then <fin_list_Grandeur_SM_sur_refFEpti>";};
         sort << "\n deb_list_Grandeur_SM_sur_refFEpti   ";
         iGPfin = tab_F_element_TypeQuelconque_retenu_pourSM(imail).end();
         for (iGP=tab_F_element_TypeQuelconque_retenu_pourSM(imail).begin();iGP!=iGPfin;iGP++)
          sort << ((*iGP).EnuTypeQuelconque().NomPlein()) << " ";
         sort << "      fin_list_Grandeur_SM_sur_refFEpti   ";
         if (fr) { sort << " # fin des grandeurs  aux _SM_sur_refFEptis";}else { sort << " # end of the  values at the _SM_sur_refFEpti";};
        };
      };
      // ====== sur les ref d'arêtes d'élément =======
      { // 1) les ref d'arêtes d'élément
        if (fr)
         {sort << "\n # les SM sur ref d'aretes d'element:  un mot cle de debut:  debut_list_SM_sur_refAE";
          sort << "\n # une liste de nom de ref d'aretes d'element <chaine de caracteres >, le pti associe "
               << "\n # puis <fin_list__SM_sur_refAE>";
         }
        else
         {sort << "\n # the sum on a ref of element edge:  a keyword for the beginning:  debut_list_SM_sur_refAE";
          sort << "\n # a list of name  <string > + 1 pti, then <fin_list__SM_sur_refAE>";
         };
        //  ... écriture des references d'arêtes d'élément + num du pti où sont calculés les SMs
        {sort <<"\n debut_list_SM_sur_refAE  " ;
         List_io <BlocScal >& nomDeRef_A_E_SM = tab_nomDeRef_A_E_SM(imail);
         List_io <BlocScal>::iterator keint,keintfin = nomDeRef_A_E_SM.end();
         for (keint=nomDeRef_A_E_SM.begin();keint!=keintfin;keint++)
          {sort << " " << (*keint).NomRef();  sort << " " << (int)((*keint).Val()); }
         sort << " fin_list__SM_sur_refAE  ";
        };
        //  2) idem sur les ref de pti d'arêtes
        if (fr)
         {sort << "\n # les SMs sur ref de pti d'aretes:  un mot cle de debut:  debut_list_SM_sur_refApti";
          sort << "\n # une liste de nom de ref <chaine de caracteres >, puis <fin_list__SM_sur_refApti>";
         }
        else
         {sort << "\n # the sum on a ref of element edges:  a keyword for the beginning:  debut_list_SM_sur_refApti";
          sort << "\n # a list of name  <string >, then <fin_list__SM_sur_refApti>";
         };
        //  ... écriture des references des ref de pti d'arêtes où sont calculés les SMs
        {sort <<"\n debut_list_SM_sur_refApti  " ;
         List_io <string >& nomDeRef_ptinteg_SM = tab_nomDeRef_A_ptinteg_SM(imail);
         List_io <string>::iterator keint,keintfin = nomDeRef_ptinteg_SM.end();
         for (keint=nomDeRef_ptinteg_SM.begin();keint!=keintfin;keint++)
             sort << (*keint) << " ";
         sort << " fin_list__SM_sur_refApti  ";
        };
        // 3)  écriture de la liste des grandeurs à considérer aux pti des arêtes d'élément ----
        {if (fr) {sort << "\n #   debut de la liste des grandeurs  a considerer pour les SM sur aretes, (une liste de string),"
                       <<  " <deb_list_Grandeur_SM_sur_refAEpti> , (la liste),  puis <fin_list_Grandeur_SM_sur_refAEpti>";}
         else {sort << "\n #   beginning of the list of values at the SM on edge (a string list),"
                    << " <deb_list_Grandeur_SM_sur_refAEpti> , (the list), then <fin_list_Grandeur_SM_sur_refAEpti>";};
         sort << "\n deb_list_Grandeur_SM_sur_refAEpti   ";
         iGPfin = tab_A_element_TypeQuelconque_retenu_pourSM(imail).end();
         for (iGP=tab_A_element_TypeQuelconque_retenu_pourSM(imail).begin();iGP!=iGPfin;iGP++)
          sort << ((*iGP).EnuTypeQuelconque().NomPlein()) << " ";
         sort << "      fin_list_Grandeur_SM_sur_refAEpti   ";
         if (fr) { sort << " # fin des grandeurs  aux _SM_sur_refAEptis";}else { sort << " # end of the  values at the _SM_sur_refAEpti";};
        };
      };
      // <-><-><-><-><-><-> les grandeurs individuelles <-><-><-><-><-><->
      //---- les grandeurs aux noeuds ----
      { sort <<"\n debut_liste_ddl_et_noeud    ";
        if (fr) {sort << " # ** debut des ddl principaux aux noeuds " ;}
        else    {sort << " # ** beginning of the dof at nodes " ;}
        // ** liste de noeuds
        {// on encapsule pour une gestion visuelle plus facile
         if (fr)
           {sort << "\n #  debut de la liste de noeuds,  puis une liste de numero de noeud <entier>, puis <fin_list_noeud>";}
         else
           {sort << "\n #  beginning of the list at nodes,  then a list of number of node  <integer>, then <fin_list_noeud>";};
         sort << "\n deb_list_noeud ";
         ilifin = tab_num_noeud(imail).end();
         for (ili=tab_num_noeud(imail).begin();ili!=ilifin;ili++)
           sort << " " << (*ili);
         sort << " fin_list_noeud  ";
        };
        // ** les references de liste de noeuds
        {if (fr) {sort << "\n #  debut de la liste des ref de noeuds,  puis une liste de nom  <chaine de caracteres >, "
                        <<   "puis <fin_list_ref_noeud>";}
         else {sort << "\n #  beginning of the list of reference of nodes,  then a liste of name <string >, then <fin_list_ref_noeud>";};
         sort << "\n deb_list_ref_noeud ";
         List_io <string >::iterator ilnom,ilnomfin = nomDeRef(imail).end();
         for (ilnom=nomDeRef(imail).begin();ilnom!=ilnomfin;ilnom++)
           sort << " " << (*ilnom);
         sort << " fin_list_ref_noeud  ";
        };
        // ** les ddl principaux aux noeuds
        {if (fr) {sort << "\n #   debut de la liste des ddl a considerer aux noeuds, (une liste de ddl),"
                       <<  " puis <fin_list_ddl_noeud>";}
         else	{sort << "\n #   beginning of the list of the dof at node <deb_list_ddl_noeud> , (the list), then <fin_list_ddl_noeud>";};
         
         sort << "\n deb_list_ddl_noeud    ";
         ildfin = tabnoeud_type_ddl_retenu(imail).end();
         for (ild=tabnoeud_type_ddl_retenu(imail).begin();ild!=ildfin;ild++)
           sort <<  (*ild);
     /*    { sort << " ";
           if ((*ild).Nom_vide()) sort << Nom_ddl((*ild).Enum()); else sort << (*ild).Nom();
         }*/
         sort << "     fin_list_ddl_noeud   ";
        };
        // ** le type de sortie: type_sortie_ddl_retenue
        { sort << "\n type_sortie_ddl_retenue= " << type_sortie_ddl_retenue;
        };
        // ** les ddl étendus des noeuds
        { // on encapsule pour une gestion visuelle plus facile
          // ---- les ddl étendus
          if (fr) {sort << "\n #   debut de la liste des ddl etendus a considerer aux noeuds, (une liste de ddl),"
                        <<  " puis <fin_list_ddl_etendu_noeud>";}
          else	{sort << "\n #   beginning of the list of the extended dof at node <deb_list_ddl_noeud> , (the list), then <fin_list_ddl_noeud>";};
          sort << "\n deb_list_ddl_etendu_noeud    ";
          ildfin = tabnoeud_type_ddlEtendu_retenu(imail).end();
          for (ild=tabnoeud_type_ddlEtendu_retenu(imail).begin();ild!=ildfin;ild++)
            sort <<  (*ild);
          sort << "     fin_list_ddl_etendu_noeud   ";
          if (fr) { sort << " # fin des ddl etendu aux noeuds";}else { sort << " # end of the extended dof at nodes";};
        };
        // ** les grandeurs quelconques aux noeuds
        { // on encapsule pour une gestion visuelle plus facile
          // ---- les grandeurs quelconques ---
          if (fr) {sort << "\n #   debut de la liste des grandeurs particulieres a considerer aux noeuds, (une liste de string),"
                        <<  " puis <fin_list_GrandParticuliere_noeud>";}
          else	{sort << "\n #   beginning of the list of particular values at node (a string list) <deb_list_GrandParticuliere_noeud> , (the list), then <fin_list_GrandParticuliere_noeud>";};
          sort << "\n deb_list_GrandParticuliere_noeud    ";
          iGPfin = tabnoeud_TypeQuelconque_retenu(imail).end();
          for (iGP=tabnoeud_TypeQuelconque_retenu(imail).begin();iGP!=iGPfin;iGP++)
              sort << ((*iGP).EnuTypeQuelconque().NomPlein()) << " ";
          sort << "     fin_list_GrandParticuliere_noeud   ";
          if (fr) { sort << " # fin des grandeurs particulieres aux noeuds";}else { sort << " # end of the particular values at nodes";};
        };
        // ---- fin des grandeurs aux noeuds ----
        sort <<"\n fin_liste_ddl_et_noeud     ";
        if (fr) { sort << " # fin des grandeurs aux noeuds";}else { sort << " # end of the quantities at nodes";};
      };
      
      // ---- les grandeurs aux points d'intégrations d'éléments ----
      { sort <<"\n debut_liste_ddl_ptinteg  ";
        if (fr) { sort << "# ** debut des grandeurs aux elements " ;}else { sort << " # ** beginning of the quantities at elements";};
        //  ** les éléments et points d'intégration
        {if (fr)
          { sort << "\n #  debut de la liste des elements et points d'integration, une liste de  "
                 << " (un element, un numero de pt d'integ), puis <fin_list_NbElement_NbPtInteg>";
          }
         else
          { sort << "\n #  beginning of the lists of elements+integration points, a list of  "
                 << " (one element, an number of a integration point), then <fin_list_NbElement_NbPtInteg>";
          };
         sort << "\n deb_list_NbElement_NbPtInteg  ";
         ilifin = tab_num_element(imail).end();
         ilifin2 = tab_num_integ(imail).end();
         ili2=tab_num_integ(imail).begin();
         for (ili=tab_num_element(imail).begin();ili!=ilifin;ili++,ili2++)
           sort << " " << (*ili) << " " << (*ili2);
         sort << " fin_list_NbElement_NbPtInteg  ";
        }
        // ** les references de liste d'éléments
        {if (fr)// encapsulage
          { sort << "\n #  debut de la liste des ref d'elements,  puis une liste de: nom  <chaine de caracteres > + numero d'integ, "
                 <<                                                         "puis <fin_list_ref_element>";}
         else
          { sort << "\n #  beginning of the list of elements, then a list of : name  <string > + number of integration, "
                 <<                                                         "then <fin_list_ref_element>";}
         sort << "\n deb_list_ref_element ";
         List_io <BlocScal >::iterator ilnomel,ilnomelfin = nomDeRef_E(imail).end();
         for (ilnomel=nomDeRef_E(imail).begin();ilnomel!=ilnomelfin;ilnomel++)
          {sort << " " << (*ilnomel).NomRef();  sort << " " << (int)((*ilnomel).Val()); }
         sort << " fin_list_ref_element  ";
        };
        // *** les references de liste de points d'intégration d'éléments
        {if (fr)
          { sort << "\n #  debut de la liste des ref de ptinteg d'elements,  puis une liste de: nom  <chaine de caracteres >  "
                 <<                                                         "puis <fin_list_ref_ptinteg_element>";}
         else
          { sort << "\n #  beginning of the list of ref of integ point for element,  then a list of name  <string >  "
                 <<                                                         "then <fin_list_ref_ptinteg_element>";}
         sort << "\n deb_list_ref_ptinteg_element ";
         List_io <string >::iterator ilnomel,ilnomelfin = nomDeRef_ptinteg(imail).end();
         for (ilnomel=nomDeRef_ptinteg(imail).begin();ilnomel!=ilnomelfin;ilnomel++)
          {sort << " " << (*ilnomel) << " " ; }
         sort << " fin_list_ref_ptinteg_element  ";
        };
        // ** les ddl
        {sort << "\n # debut de la liste des ddl a considerer pour les elements, (une liste de ddl),  "
              <<                                                          "  puis <fin_list_ddl_element>";
         sort << "\n deb_list_ddl_element   ";
         ildfin = tabelement_type_ddl_retenu(imail).end();
         for (ild=tabelement_type_ddl_retenu(imail).begin();ild!=ildfin;ild++)
           sort << (*ild) << " ";
         sort << "      fin_list_ddl_element          # fin de la liste de ddl a considerer pour les elements";
        };
        // ** les grandeurs particulières
        {if (fr) {sort << "\n #   debut de la liste des grandeurs particulieres a considerer pour les elements, (une liste de string),"
                       <<  " puis <fin_list_GrandParticuliere_element>";}
         else	{sort << "\n #   beginning of the list of particular values at the element (a string list) <deb_list_GrandParticuliere_element> , (the list), then <fin_list_GrandParticuliere_element>";};
         sort << "\n deb_list_GrandParticuliere_element   ";
         iGPfin = tabelement_typeParti_retenu(imail).end();
         for (iGP=tabelement_typeParti_retenu(imail).begin();iGP!=iGPfin;iGP++)
          sort << ((*iGP).EnuTypeQuelconque().NomPlein()) << " ";
         sort << "      fin_list_GrandParticuliere_element   ";
         if (fr) { sort << " # fin des grandeurs particulieres aux elements";}else { sort << " # end of the particular values at the element";};
        };
        // ** les grandeurs évoluées  aux éléments a visualiser
        { if (fr) {sort << "\n #   tableau de grandeurs evoluees  aux elements a visualiser, un par maillage";
                  sort << "\n deb_list_GrandEvoluee_element " ;
                 }
         else    {sort << "\n #   beginning of the list of tensorial values at element, one for a mesh ";
                  sort << "\n deb_list_GrandEvoluee_element " ;
                 };
         List_io < TypeQuelconque >::iterator ilq,ilqfin=tabelement_evoluee_retenu(imail).end();
         for (ilq=tabelement_evoluee_retenu(imail).begin();ilq!=ilqfin;ilq++)
           { sort << ((*ilq).EnuTypeQuelconque().NomPlein()) << " " ;};
         if (fr) {sort << " fin_list_GrandEvoluee_element " ;}
         else    {sort << " fin_list_GrandEvoluee_element " ;};
        };
        // ---- fin des grandeurs aux points d'intégrations ----
        sort <<"\n fin_liste_ddl_ptinteg   # fin des grandeurs aux elements ";
     };
      // ---- les grandeurs aux points d'intégrations de faces d'élément ----
      { sort <<"\n debut_liste_grandeurs_ptinteg_F_E  ";
        if (fr) { sort << "# ** debut des grandeurs aux faces d'elements " ;}else { sort << " # ** beginning of the quantities at element facet";};
        //  ** les éléments, faces et points d'intégration
        {if (fr)
          { sort << "\n #  debut de la liste des faces d'element et points d'integration, une liste de  "
                 << " (un element, une face, un numero de pt d'integ), puis <fin_list_NbFaceElement_NbPtInteg>";
          }
         else
          { sort << "\n #  beginning of the lists of facet elements + integration points, a list of  "
                 << " (one element, face,  an number of a integration point), then <fin_list_NbFaceElement_NbPtInteg>";
          };
         sort << "\n deb_list_NbFaceElement_NbPtInteg  ";
         ilifin = tab_num_F_element(imail).end();
         ilifin2 = tab_num_F_integ(imail).end();
         ili2=tab_num_F_integ(imail).begin();
         iti = tab_num_F(imail).begin();
         for (ili=tab_num_F_element(imail).begin();ili!=ilifin;ili++,ili2++,iti++)
           sort << " " << (*ili) <<" " << (*iti)<< " " << (*ili2);
         sort << " fin_list_NbFaceElement_NbPtInteg  ";
        }
        // ** les references de liste de faces d'élément
        {if (fr)// encapsulage
          { sort << "\n #  debut de la liste des ref de faces d'element,  puis une liste de: nom  <chaine de caracteres > + numero d'integ, "
                 <<                                                         "puis <fin_list_ref_F_element>";}
         else
          { sort << "\n #  beginning of the list of element facet, then a list of : name  <string > + number of integration, "
                 <<                                                         "then <fin_list_ref_F_element>";}
         sort << "\n deb_list_ref_F_element ";
         List_io <BlocScal >::iterator ilnomel,ilnomelfin = nomDeRef_F_E(imail).end();
         for (ilnomel=nomDeRef_F_E(imail).begin();ilnomel!=ilnomelfin;ilnomel++)
          {sort << " " << (*ilnomel).NomRef();  sort << " " << (int)((*ilnomel).Val()); }
         sort << " fin_list_ref_F_element  ";
        };
        // *** les references de liste de points d'intégration de faces d'élément
        {if (fr)
          { sort << "\n #  debut de la liste des ref de ptinteg de faces d'element,  puis une liste de: nom  <chaine de caracteres >  "
                 <<                                                         "puis <fin_list_ref_ptinteg_F_element>";}
         else
          { sort << "\n #  beginning of the list of ref of integ point for element facet,  then a list of name  <string >  "
                 <<                                                         "then <fin_list_ref_ptinteg_F_element>";}
         sort << "\n deb_list_ref_ptinteg_F_element ";
         List_io <string >::iterator ilnomel,ilnomelfin = nomDeRef_F_ptinteg(imail).end();
         for (ilnomel=nomDeRef_F_ptinteg(imail).begin();ilnomel!=ilnomelfin;ilnomel++)
          {sort << " " << (*ilnomel) << " " ; }
         sort << " fin_list_ref_ptinteg_F_element  ";
        };
        // ** les grandeurs
        {if (fr) {sort << "\n #   debut de la liste des grandeurs  a considerer pour les faces d'elements, (une liste de string),"
                       <<  " puis <fin_list_Grandeur_F_element>";}
         else {sort << "\n #   beginning of the list of particular values at the element facet (a string list) <deb_list_Grandeur_F_element> , (the list), then <fin_list_Grandeur_F_element>";};
         sort << "\n deb_list_Grandeur_F_element   ";
         iGPfin = tab_F_element_TypeQuelconque_retenu(imail).end();
         for (iGP=tab_F_element_TypeQuelconque_retenu(imail).begin();iGP!=iGPfin;iGP++)
          sort << ((*iGP).EnuTypeQuelconque().NomPlein()) << " ";
         sort << "      fin_list_Grandeur_F_element   ";
        };
        // ---- fin des grandeurs aux points d'intégrations des faces d'éléments ----
        sort <<"\n fin_liste_grandeurs_ptinteg_F_E   # fin des grandeurs aux faces d'elements ";
     };
      // ---- les grandeurs aux points d'intégrations des arêtes d'élément ----
      { sort <<"\n debut_liste_grandeurs_ptinteg_A_E  ";
        if (fr) { sort << "# ** debut des grandeurs aux aretes d'elements " ;}else { sort << " # ** beginning of the quantities at element edges";};
        //  ** les éléments, arete et points d'intégration
        {if (fr)
          { sort << "\n #  debut de la liste des aretes d'element et points d'integration, une liste de  "
                 << " (un element, une arete, un numero de pt d'integ), puis <fin_list_NbAreteElement_NbPtInteg>";
          }
         else
          { sort << "\n #  beginning of the lists of edge elements + integration points, a list of  "
                 << " (one element, facet,  an number of a integration point), then <fin_list_NbAreteElement_NbPtInteg>";
          };
         sort << "\n deb_list_NbAreteElement_NbPtInteg  ";
         ilifin = tab_num_A_element(imail).end();
         ilifin2 = tab_num_A_integ(imail).end();
         ili2=tab_num_A_integ(imail).begin();
         iti = tab_num_A(imail).begin();
         for (ili=tab_num_A_element(imail).begin();ili!=ilifin;ili++,ili2++,iti++)
           sort << " " << (*ili) <<" " << (*iti)<< " " << (*ili2);
         sort << " fin_list_NbAreteElement_NbPtInteg  ";
        }
        // ** les references de liste d'arêtes d'élément
        {if (fr)// encapsulage
          { sort << "\n #  debut de la liste des ref d'arete d'element,  puis une liste de: nom  <chaine de caracteres > + numero d'integ, "
                 <<                                                         "puis <fin_list_ref_A_element>";}
         else
          { sort << "\n #  beginning of the list of elements edge, then a list of : name  <string > + number of integration, "
                 <<                                                         "then <fin_list_ref_A_element>";}
         sort << "\n deb_list_ref_A_element ";
         List_io <BlocScal >::iterator ilnomel,ilnomelfin = nomDeRef_A_E(imail).end();
         for (ilnomel=nomDeRef_A_E(imail).begin();ilnomel!=ilnomelfin;ilnomel++)
          {sort << " " << (*ilnomel).NomRef();  sort << " " << (int)((*ilnomel).Val()); }
         sort << " fin_list_ref_A_element  ";
        };
        // *** les references de liste de points d'intégration d'arêtes d'élément
        {if (fr)
          { sort << "\n #  debut de la liste des ref de ptinteg d'aretes d'element,  puis une liste de: nom  <chaine de caracteres >  "
                 <<                                                         "puis <fin_list_ref_ptinteg_A_element>";}
         else
          { sort << "\n #  beginning of the list of ref of integ point for element edge,  then a list of name  <string >  "
                 <<                                                         "then <fin_list_ref_ptinteg_A_element>";}
         sort << "\n deb_list_ref_ptinteg_A_element ";
         List_io <string >::iterator ilnomel,ilnomelfin = nomDeRef_A_ptinteg(imail).end();
         for (ilnomel=nomDeRef_A_ptinteg(imail).begin();ilnomel!=ilnomelfin;ilnomel++)
          {sort << " " << (*ilnomel) << " " ; }
         sort << " fin_list_ref_ptinteg_A_element  ";
        };
        // ** les grandeurs
        {if (fr) {sort << "\n #   debut de la liste des grandeurs  a considerer pour les aretes d'elements, (une liste de string),"
                       <<  " puis <fin_list_Grandeur_A_element>";}
         else {sort << "\n #   beginning of the list of particular values at the element edge (a string list) <deb_list_Grandeur_A_element> , (the list), then <fin_list_Grandeur_A_element>";};
         sort << "\n deb_list_Grandeur_A_element   ";
         iGPfin = tab_A_element_TypeQuelconque_retenu(imail).end();
         for (iGP=tab_A_element_TypeQuelconque_retenu(imail).begin();iGP!=iGPfin;iGP++)
          sort << ((*iGP).EnuTypeQuelconque().NomPlein()) << " ";
         sort << "      fin_list_Grandeur_A_element   ";
        };
        // ---- fin des grandeurs aux points d'intégrations des arêtes d'éléments ----
        sort <<"\n fin_liste_grandeurs_ptinteg_A_E   # fin des grandeurs aux aretes d'elements ";
     };
   };
   // --- informations particulière pour le cas où il y a une animation
   sort << "\n# informations particuliere dans le cas ou il y a une animation";
   sort << "\n# type_xi indique si oui ou non les grandeurs a tracer sont aux noeuds (sinon c'est au elements)";
   sort << "\n# x1 et x2 indiquent les noms des ddls des grandeurs en x et y. accroi_x1 et accroi_x2 indiquent "; 
   sort << "\n# si oui ou non x1 et x2 represente l'accroissement entre 0 et t de la grandeur ou bien la grandeur elle meme.";  
   sort << "\n debut_info_particulier ";
   sort << " grandeur_au_noeud? " << type_xi << "  x1= " << x1 << " x2= " << x2 
        << " accroi_x1= " << accroi_x1 << " accroi_x2= " << accroi_x2
        << "  fin_info_particulier ";
   // un paramètre de pilotage du style de sortie
   sort << "\n# un parametre de pilotage du style de sortie";
   sort << "\n parametre_style_de_sortie " << style_de_sortie;
   // le type de sortie des tenseurs
   sort << "\n# un parametre indiquant si les tenseurs sont en absolue (rep 1) ou suivant un repere ad hoc"
        << "\n# (tangent pour les coques, suivant la fibre moyenne pour les element 1D ) ";
   sort << "\n tenseur_en_absolue_  " <<  absolue;
   // fin
   sort << "\n fin_grandeurs_maple  # fin des grandeurs a visualiser au format maple \n";
  };


   
   
   

