
// 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 "Enum_chargement.h"

#include <iomanip>


// entrée du choix pour les moyennes sommes etc. sur ref E
void Choix_grandeurs_maple::Entree_somme_moy_E(string& rep)
  { // cas de grandeurs aux éléments, on boucle sur les maillages
    //int dim = ParaGlob::Dimension();
    cout << "\n --- somme, moyenne, max, min etc. sur des references d'elements et de pti ---";
    // on récupère la liste des maillages à visualiser
    const list <int>& list_mail = choix_mail->List_choisit();
    list<int>::const_iterator ilm,ilmfin=list_mail.end();
    int taille_list_maille = list_mail.size();
    if (list_mail.size() == 0)
      { cout << "\n aucun maillage n'est definit ! , il faut commencer par definir les maillages pour"
             << " lesquels on veut une sortie ";
        return;
       };      
     // on balaie les différents maillages
     for (ilm = list_mail.begin();ilm!=ilmfin;ilm++)
       { int n_mail = abs(*ilm); // numéro du maillage
       
         // -- boucle sur les maillages
         // affichage du nom du maillages s'il y en a plusieurs
         if (taille_list_maille > 1)
           cout << "\n ======>>>>>   maillage : " << lesMail->NomMaillage(n_mail);

         // -------------- cas des ddl principaux définis aux éléments -----------------
         {cout << "\n -------- cas des ddl principaux definis aux elements ---------";
          // on affiche la liste actuelle
          if ((tabelement_type_ddl_retenu_pourSM(n_mail)).size())
           { cout << "\n liste actuelle des element a sortir en info:   ";
             List_io <int>::iterator ieint,ieintfin = tab_num_element(n_mail).end();
             for (ieint=tab_num_element(n_mail).begin();ieint!=ieintfin;ieint++)
               cout << *ieint << " ";
             cout << "\n liste des grandeurs actuellement a sortir:   ";  
             List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabelement_type_ddl_retenu_pourSM(n_mail)).end();
             for (iet=(tabelement_type_ddl_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
               cout << (*iet) << " " ;
             cout << endl;
           };
          // on affiche les différentes grandeurs possibles
          cout << "\n maillage nb : " << n_mail ;
          cout << "\n la liste des grandeurs disponibles est la suivante : ";
          List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabelement_type_ddl(n_mail)).end();
          for (iet=(tabelement_type_ddl(n_mail)).begin();iet!=ietfin;iet++)
                     cout << (*iet) << " " ;
          cout << "\n grandeurs que vous voulez visualiser                    ( rep : grandeurs?)"
               << "\n REMARQUE : il faut donner uniquement un jeux de ddl                        "
               << "\n def au meme point d'integration (contraintes/def                           "
               << "\n ou (exclusif) erreur ou ...)                                               "
               << "\n effacer la liste actuelle                                (rep : ef)        "
               << "\n                                          (pour terminer tapez : fin (ou f))";
          rep = "";
          while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
             { cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
               if (rep == "to")
                // cas de toutes les grandeurs
                {List_io<Ddl_enum_etendu>::iterator ite,itefin = tabelement_type_ddl(n_mail).end();
                 for (ite = tabelement_type_ddl(n_mail).begin();ite != itefin; ite++)
                   tabelement_type_ddl_retenu_pourSM(n_mail).push_back(*ite);
                 }  
               else if (Ddl_enum_etendu::VerifExistence(rep))
                 // on vérifie que cette grandeur existe 
                 // enregistrement
                 {  Ddl_enum_etendu a = Ddl_enum_etendu::RecupDdl_enum_etendu(rep);
                    (tabelement_type_ddl_retenu_pourSM(n_mail)).push_back(a);
                    (tabelement_type_ddl_retenu_pourSM(n_mail)).unique(); // supprime le doublon si nécessaire
                 }
               else if (rep == "ef") 
                { // on efface la liste
                  (tabelement_type_ddl_retenu_pourSM(n_mail)).clear();
                 }
               else if (((Minuscules(rep) == "fin") || (Minuscules(rep) == "f")) 
                     && ( (tabelement_type_ddl_retenu_pourSM(n_mail)).size()==0))
                 { rep = "-"; cout << " \n *** ERREUR: vous devez definir au moins une grandeur a visualiser !!";} 
               else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                cout << " erreur de syntaxe dans le ddl! recommencez ";
             };
         };
         // -------------- cas des grandeurs particulières  définis aux éléments -----------------
         // def d'une liste de travail, pour vérifier que tous les grandeurs particuliers sont relatives
         // à un même point d'intégration
         List_io < Ddl_enum_etendu > li_ddl_particulieres;
         {cout << "\n -------- cas des grandeurs particulières definies aux elements ---------";
          // dans le cas où aucune grandeur particulière sont défini on passe
          if ( (tabelement_typeParti(n_mail)).size() == 0)
           { cout << "\n aucune grandeur particuliere n'est definit, donc aucune proposition ";}
          else
           { // on affiche la liste actuelle
             if ((tabelement_typeParti_retenu_pourSM(n_mail)).size())
                { cout << "\n liste actuelle des element a sortir en info:   ";
                  List_io <int>::iterator ieint,ieintfin = tab_num_element(n_mail).end();
                  for (ieint=tab_num_element(n_mail).begin();ieint!=ieintfin;ieint++)
                    cout << (*ieint) << " ";
                  cout << "\n liste des grandeurs particulieres actuellement a sortir:   ";  
                  List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_typeParti_retenu_pourSM(n_mail)).end();
                  for (iet=(tabelement_typeParti_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
                    cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
                  cout << endl;  
                };
             // on affiche les différentes grandeurs possibles
             cout << "\n maillage nb : " << n_mail ;
             cout << "\n la liste des grandeurs particulieres disponibles est la suivante : ";
             List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_typeParti(n_mail)).end();
             for (iet=(tabelement_typeParti(n_mail)).begin();iet!=ietfin;iet++)
                        cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
             cout << "\n";            
             cout << "\n grandeurs que vous voulez visualiser                         ( rep : grandeurs?)"
                  << "\n REMARQUE : il faut donner uniquement un jeu de grandeurs                        "
                  << "\n definies  au meme point d'integration                                           "
                  << "\n effacer la liste actuelle                                    (rep : ef)         "
                  << "\n toutes les grandeurs :                                       (rep : to)         "
                  << "\n                                               (pour terminer tapez : fin (ou f))";
             rep = "";
             while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
               { cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
                 if (rep == "to")
                  // cas de toutes les grandeurs
                  {List_io<TypeQuelconque>& tpg_ret = (tabelement_typeParti_retenu_pourSM(n_mail)); // pour simplifier
                   List_io<TypeQuelconque>& tpg = (tabelement_typeParti(n_mail)); // pour simplifier
                   List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
                   for (ite = tabelement_typeParti(n_mail).begin();ite != itefin; ite++)
                        if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
                          { tpg_ret.push_back(*ite);
                            // on enregistre également le ddl associé qui définit le point d'integ où est calculé la grandeur
                            // particulière
                            li_ddl_particulieres.push_back(Ddl_enum_etendu((*ite).Enum()));
                           }; 
                  }
                 else if (TypeQuelconque_enum_etendu::VerifExistence(rep) ) // vérif que c'est une grandeur possible
                   { // maintenant on vérifie qu'elle appartient à la liste des grandeurs disponibles
                     TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
                     List_io<TypeQuelconque>& tpg_ret = (tabelement_typeParti_retenu_pourSM(n_mail)); // pour simplifier
                     List_io<TypeQuelconque>& tpg = (tabelement_typeParti(n_mail)); // pour simplifier
                     if (find(tpg.begin(),tpg.end(),a) != tpg.end())
                      { // il existe -> enregistrement
                        List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                        // s'il n'existe pas déjà on l'enregistre vraiment
                        if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                          { tpg_ret.push_back(*il);
                            // on enregistre également le ddl associé qui définit le point d'integ où est calculé la grandeur
                            // particulière
                            li_ddl_particulieres.push_back(Ddl_enum_etendu((*il).Enum()));
                           }; 
                       }
                     else
                      { cout << "\n erreur, grandeur non disponible !, recommencez ";};
                   }
                 else if (rep == "ef") 
                  { // on efface la liste
                    (tabelement_typeParti_retenu_pourSM(n_mail)).clear();
                  }
                 else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                  cout << " erreur de syntaxe  recommencez ";
               };
           }; //-- fin du choix sur le fait qu'il existe ou non des grandeurs particulières pour le maillage
         };
         // -------------- cas des grandeurs évoluées définis aux éléments -----------------
         // def d'une liste de travail, pour vérifier que tous les grandeurs évoluées sont relatives
         // à un même point d'intégration
         List_io < Ddl_enum_etendu > li_ddl_evoluees;
         {cout << "\n -------- cas des grandeurs évoluees definies aux elements ---------";
          // dans le cas où aucune grandeur particulière sont défini on passe
          if ( (tabelement_evoluee(n_mail)).size() == 0)
           { cout << "\n aucune grandeur tensorielle n'est definit, donc aucune proposition ";}
          else
           { // on affiche la liste actuelle
             if ((tabelement_evoluee_retenu_pourSM(n_mail)).size())
                    { cout << "\n liste actuelle des element a sortir en info:   ";
                      List_io <int>::iterator ieint,ieintfin = tab_num_element(n_mail).end();
                      for (ieint=tab_num_element(n_mail).begin();ieint!=ieintfin;ieint++)
                        cout << (*ieint) << " ";
                      cout << "\n liste des grandeurs tensorielles actuellement a sortir: (attention: peuvent ne pas etre definies)  ";
                      List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_evoluee_retenu_pourSM(n_mail)).end();
                      for (iet=(tabelement_evoluee_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
                        cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
                      cout << endl;  
                    };
             // on affiche les différentes grandeurs possibles
             cout << "\n maillage nb : " << n_mail ;
             cout << "\n la liste des grandeurs tensorielles disponibles est la suivante : (attention: peuvent ne pas etre definies)";
             List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_evoluee(n_mail)).end();
             for (iet=(tabelement_evoluee(n_mail)).begin();iet!=ietfin;iet++)
                     cout << "\n" <<  ((*iet).EnuTypeQuelconque().NomPlein()) ;
             cout << "\n";
             cout << "\n grandeurs que vous voulez visualiser                         ( rep : grandeurs?)"
                  << "\n REMARQUE : il faut donner uniquement un jeu de grandeurs                        "
                  << "\n defini      au meme point d'integration                                         "
                  << "\n effacer la liste actuelle                                    (rep : ef)         "
                  << "\n toutes les grandeurs :                                       (rep : to)         "
                  << "\n                                               (pour terminer tapez : fin (ou f))";
             rep = "";
             while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                { cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
                  if (rep == "to")
                   // cas de toutes les grandeurs
                   {List_io<TypeQuelconque>& tpg_ret = (tabelement_evoluee_retenu_pourSM(n_mail)); // pour simplifier
                    List_io<TypeQuelconque>& tpg = (tabelement_evoluee(n_mail)); // pour simplifier
                    List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
                    for (ite = tabelement_evoluee(n_mail).begin();ite != itefin; ite++)
                         if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
                           { tpg_ret.push_back(*ite);
                             // on enregistre également le ddl associé qui définit le point d'integ où est calculé la grandeur
                             // évoluées
                             li_ddl_particulieres.push_back(Ddl_enum_etendu((*ite).Enum()));
                            }; 
                   }
                  else if (TypeQuelconque_enum_etendu::VerifExistence(rep) ) // vérif que c'est une grandeur possible
                    { // maintenant on vérifie qu'elle appartient à la liste des grandeurs disponibles
                      TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
                      List_io<TypeQuelconque>& tpg_ret = (tabelement_evoluee_retenu_pourSM(n_mail)); // pour simplifier
                      List_io<TypeQuelconque>& tpg = (tabelement_evoluee(n_mail)); // pour simplifier
                      if (find(tpg.begin(),tpg.end(),a) != tpg.end())
                       { // il existe -> enregistrement
                         List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                         // s'il n'existe pas déjà on l'enregistre vraiment
                         if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                           { tpg_ret.push_back(*il);
                             // on enregistre également le ddl associé qui définit le point d'integ où est calculé la grandeur
                             // évoluées
                             li_ddl_particulieres.push_back(Ddl_enum_etendu((*il).Enum()));
                            }; 
                        }
                      else
                       { cout << "\n erreur, grandeur non disponible !, recommencez ";};
                    }
                  else if (rep == "ef") 
                   { // on efface la liste
                     (tabelement_evoluee_retenu_pourSM(n_mail)).clear();
                   }
                  else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                   cout << " erreur de syntaxe  recommencez ";
                };
           }; //-- fin du choix sur le fait qu'il existe ou non des grandeurs évoluées pour le maillage
         };
         // -------------- on s'occupe maintenant des références associées -----------------
         {cout << "\n -------- definition des references d'elements ---------";
          // cas des références d'éléments
          if ((tab_nomDeRef_E_SM(n_mail)).size() != 0)
                         { cout << "\n liste actuelle de reference d'elements:  (ref et num integ) ";
                           List_io <BlocScal >::iterator ieint1,ieintfin1 = (tab_nomDeRef_E_SM(n_mail)).end();
                           for (ieint1=(tab_nomDeRef_E_SM(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
                             cout << (*ieint1).NomRef() << " "<< (int) ((*ieint1).Val()) << " ";
                           cout << endl;  
                         };
          // cas des références de point d'intégration d'éléments  
          if ((tab_nomDeRef_ptinteg_SM(n_mail)).size() != 0)
                         { cout << "\n liste actuelle de reference de pt d'integration d'elements:  (ref) ";
                           List_io <string >::iterator ieint1,ieintfin1 = (tab_nomDeRef_ptinteg_SM(n_mail)).end();
                           for (ieint1=(tab_nomDeRef_ptinteg_SM(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
                             cout << (*ieint1) << " ";
                           cout << endl;  
                         };
          cout    << "\n choix d'une reference de liste d'element (avec 1 ou tous les pti)   -> (choix : refE)"
                  << "\n (dans ce dernier cas il faut que tous les elements soient de meme type)           "
                  << "\n choix d'une reference de liste de point d'integration d'element     -> (choix : refpti)"
                  << "\n donnez le type de choix puis les infos correspondantes                            "
                  << "\n choix de tous les ref d'elements                                    -> (choix : torefE)"
                  << "\n choix de tous les ref de pti                                        -> (choix : torefpti)"
                  << "\n effacer la liste actuelle des references d'elements                 ->  (rep : efref) "
                  << "\n afficher la liste des references d'elements existants               ->  (rep : affref) "                    
                  << "\n effacer la liste actuelle des references de pt integ d'element      ->  (rep : efrefpti) " 
                  << "\n afficher la liste des references de pt integ d'elements existants   ->  (rep : affrefpti) "                    
                  << "\n                                                             (tapez fin pour finir(ou f))";
          string rep = "";
          // -- début boucle choix position sur element
          while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f")) 
           { cout << "\n choix ? ";rep = lect_return_defaut(false,"f");
             if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f")) break;
             // def du conteneur des numéros que l'on cherche
             // comme on peut en définir plusieurs d'un coup (par exemple tous les pti d'un élément) on utilise une liste
             list <Maillage::NBelemEtptInteg> list_nut; // à chaque passage elle est initialisée et donc vide au début
             Maillage::NBelemEtptInteg nut; // idem, initialisé à chaque passage
             if (rep == "refE")
               { string nom_ref;
                 cout << "\n nom de la reference ? ";
                 nom_ref= lect_chaine();
                 // vérif que la référence existe
                 if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 2))
                   { cout << "\n erreur de nom (** "<< nom_ref << " **)  donne ne correspond pas a une reference d'element correcte ";}
                 else 
                   { // choix du point d'intégration, ici on ne va pas utiliser la liste list_nut, mais une liste particulière
                     string repo;
                     cout << " numero d'un point d'integration ou: -1 pour tous les pti ? ";
                     repo= lect_chaine(); nut.nbPtInteg = ChangeEntier(repo);
                     if (nut.nbPtInteg != -1) // cas d'un seul pti
                      {// on vérifie que ce point d'intégration est valide pour tous les éléments de la référence
                       bool veriflocal = true;
                       //List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_E_SM(n_mail).end();
                       
                       // --- cas des ddl principaux
                       {List_io < Ddl_enum_etendu >& li_ddl = tabelement_type_ddl_retenu_pourSM(n_mail);
                        List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
                        // boucle sur les ddl retenus
                        for (ite = li_ddl.begin();ite != itefin; ite++)
                         { // recup de la reference correspondant au mot cle
                           const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                           const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
                           int taillen=reff.Taille(); // nombre d'éléments dans la référence
                           for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                            { nut.nbElem = reff.Numero(ielem);
                              // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                              if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                               { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                      << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                      << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                                 veriflocal = false;
                                };
                            }; //-- fin de la boucle sur les éléments de la référence
                         }; //-- fin de la boucle sur les ddl retenus
                       };
                       // --- cas des types particuliers aux éléments
                       {List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_particulieres.end();
                        // boucle sur les ddl retenus
                        for (ite = li_ddl_particulieres.begin();ite != itefin; ite++)
                         { // recup de la reference correspondant au mot cle
                           const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                           const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
                           int taillen=reff.Taille(); // nombre d'éléments dans la référence
                           for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                            { nut.nbElem = reff.Numero(ielem);
                              // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                              if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                               { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                      << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                      << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                                 veriflocal = false;
                                };
                            }; //-- fin de la boucle sur les éléments de la référence
                         }; //-- fin de la boucle sur les ddl retenus
                       };
                       // --- cas des types évolués aux éléments
                       {List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_evoluees.end();
                        // boucle sur les ddl retenus
                        for (ite = li_ddl_evoluees.begin();ite != itefin; ite++)
                         { // recup de la reference correspondant au mot cle
                           const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                           const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
                           int taillen=reff.Taille(); // nombre d'éléments dans la référence
                           for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                            { nut.nbElem = reff.Numero(ielem);
                              // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                              if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                               { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                      << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                      << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                                 veriflocal = false;
                                };
                            }; //-- fin de la boucle sur les éléments de la référence
                         }; //-- fin de la boucle sur les ddl retenus
                       };
                       // --- on enregistre si la vérification a été ok
                       if (veriflocal)
                         { tab_nomDeRef_E_SM(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
                           tab_nomDeRef_E_SM(n_mail).sort(); // on ordonne
                           tab_nomDeRef_E_SM(n_mail).unique();// on supprime les doublons
                         };
                      }
                     else  // cas de tous les pti
                      { // il faut d'abord que l'on vérifie que tous les pti pour tous les éléments sont valides
                        // .. on commence par tester si un premier élément existe vraiment et si oui, on récupère le nb de pti associé
                        bool veriflocal = true;
                        int nbpti = 0; // init
                        { // on encapsule pour pas de redondance de nom
                          const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                          const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
                          int taillen=reff.Taille(); // nombre d'éléments dans la référence
                          if (taillen < 1) {veriflocal = false;} // cas d'une ref vide, on ne peut pas aller plus loin
                          else
                           {nut.nbElem = reff.Numero(1);
                            if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
                             {if (nut.nbElem < 0)
                                { cout << "\n le numero d'element doit etre superieur a 0 !!!";};
                              if (nut.nbElem > lesMail->Nombre_element(n_mail))
                                { cout << "\n chois non valide, le numero d'element doit etre inferieur ou egal "
                                       << "   au nombre total d'element du maillage !!!";
                                };
                              veriflocal = false;
                             }
                            else // sinon c'est ok, on continue au niveau des pti
                             {Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
                             
                              List_io < Ddl_enum_etendu >& li_ddl = tabelement_type_ddl_retenu_pourSM(n_mail);
                              List_io<Ddl_enum_etendu>::iterator ite = li_ddl.end(); //une initialisation
                              // on cherche un élément valide
                              if (!(li_ddl.empty()))
                                { ite = li_ddl.begin();} // la liste n'est pas vide, on prend le premier élément
                              else if (!(li_ddl_particulieres.empty()))
                                { ite = li_ddl_particulieres.begin();}
                              else if (!(li_ddl_evoluees.empty()))
                                { ite = li_ddl_evoluees.begin();}
                              else // toutes les listes sont vides on ne peut pas aller plus loin
                                {veriflocal = false;};
                              // si c'est ok:
                              if (veriflocal)
                                {nbpti = ele.NbPtInteg((*ite).Enum());};
                              };
                           };
                        };
                        // .. puis on balaie l'ensemble des éléments et l'ensemble des pti
                        if (veriflocal)
                          {//List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_E_SM(n_mail).end();
                       
                           // --- cas des ddl principaux
                           {List_io < Ddl_enum_etendu >& li_ddl = tabelement_type_ddl_retenu_pourSM(n_mail);
                            List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
                            // boucle sur les ddl retenus
                            for (ite = li_ddl.begin();ite != itefin; ite++)
                             { // recup de la reference correspondant au mot cle
                               const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                               const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
                               int taillen=reff.Taille(); // nombre d'éléments dans la référence
                               for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                                { nut.nbElem = reff.Numero(ielem);
                                  for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
                                    // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                                    if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                                     { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                            << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                            << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                                       veriflocal = false;
                                       break;
                                     };
                                    if (!veriflocal) break;
                                }; //-- fin de la boucle sur les éléments de la référence
                               if (!veriflocal) break;
                             }; //-- fin de la boucle sur les ddl retenus
                           };
                           // --- cas des types particuliers aux éléments
                           {List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_particulieres.end();
                            // boucle sur les ddl retenus
                            for (ite = li_ddl_particulieres.begin();ite != itefin; ite++)
                             { // recup de la reference correspondant au mot cle
                               const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                               const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
                               int taillen=reff.Taille(); // nombre d'éléments dans la référence
                               for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                                { nut.nbElem = reff.Numero(ielem);
                                  for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
                                    // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                                    if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                                     { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                          << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                          << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                                       veriflocal = false;
                                       break;
                                     };
                                    if (!veriflocal) break;
                                }; //-- fin de la boucle sur les éléments de la référence
                               if (!veriflocal) break;
                             }; //-- fin de la boucle sur les ddl retenus
                           };
                           // --- cas des types évolués aux éléments
                           {List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_evoluees.end();
                            // boucle sur les ddl retenus
                            for (ite = li_ddl_evoluees.begin();ite != itefin; ite++)
                             { // recup de la reference correspondant au mot cle
                               const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                               const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
                               int taillen=reff.Taille(); // nombre d'éléments dans la référence
                               for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                                { nut.nbElem = reff.Numero(ielem);
                                  for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
                                    // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                                    if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                                     { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                          << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                          << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                                       veriflocal = false;
                                       break;
                                     };
                                    if (!veriflocal) break;
                                }; //-- fin de la boucle sur les éléments de la référence
                               if (!veriflocal) break;
                             }; //-- fin de la boucle sur les ddl retenus
                           };
                          };
                       
                        // arrivée ici, si tout est ok on enregistre
                        if (veriflocal)
//                          for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
//                            { tab_nomDeRef_E_SM(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
//                              tab_nomDeRef_E_SM(n_mail).sort(); // on ordonne
//                              tab_nomDeRef_E_SM(n_mail).unique();// on supprime les doublons
//                            };
                            { nut.nbPtInteg = -1;
                              tab_nomDeRef_E_SM(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
                              tab_nomDeRef_E_SM(n_mail).sort(); // on ordonne
                              tab_nomDeRef_E_SM(n_mail).unique();// on supprime les doublons
                            };
                      };
                   }; // fin du choix du point d'intégration et de l'enregistrement
               }
             else if (rep == "refpti")
               { string nom_ref;
                 cout << "\n nom de la reference ? ";nom_ref= lect_chaine();
                 // vérif que la référence existe
                 if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 6))
                   { cout << "\n erreur de nom (** "<< nom_ref << " **)  donne ne correspond pas a une reference de point d'integration "
                          << " d'element correcte ";}
                 else 
                   { // on vérifie que le choix est valide 
                     bool veriflocal = true;
                    
                     // --- cas des ddl principaux
                     {List_io < Ddl_enum_etendu >& li_ddl = tabelement_type_ddl_retenu_pourSM(n_mail);
                      List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
                      // boucle sur les ddl retenus
                      for (ite = li_ddl.begin();ite != itefin; ite++)
                       { // recup de la reference correspondant au mot cle
                         const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                         const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'élément
                         int taillen=reff.Taille(); // nombre d'éléments dans la référence
                         for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                          { nut.nbElem = reff.NumeroElem(ielem);
                            nut.nbPtInteg = reff.NumeroFA(ielem);
                            // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                            if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                             { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                    << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                    << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                               veriflocal = false;
                              };
                          }; //-- fin de la boucle sur les éléments de la référence
                       }; //-- fin de la boucle sur les ddl retenus
                     };
                     // --- cas des types particuliers aux éléments
                     {List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_particulieres.end();
                      // boucle sur les ddl retenus
                      for (ite = li_ddl_particulieres.begin();ite != itefin; ite++)
                       { // recup de la reference correspondant au mot cle
                         const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                         const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'élément
                         int taillen=reff.Taille(); // nombre d'éléments dans la référence
                         for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                          { nut.nbElem = reff.NumeroElem(ielem);
                            nut.nbPtInteg = reff.NumeroFA(ielem);
                            // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                            if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                             { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                    << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                    << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                               veriflocal = false;
                              };
                          }; //-- fin de la boucle sur les éléments de la référence
                       }; //-- fin de la boucle sur les ddl retenus
                     };
                     // --- cas des types évolués aux éléments
                     {List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_evoluees.end();
                      // boucle sur les ddl retenus
                      for (ite = li_ddl_evoluees.begin();ite != itefin; ite++)
                       { // recup de la reference correspondant au mot cle
                         const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                         const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'élément
                         int taillen=reff.Taille(); // nombre d'éléments dans la référence
                         for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                          { nut.nbElem = reff.NumeroElem(ielem);
                            nut.nbPtInteg = reff.NumeroFA(ielem);
                            // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                            if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                             { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                    << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                    << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                               veriflocal = false;
                              };
                          }; //-- fin de la boucle sur les éléments de la référence
                       }; //-- fin de la boucle sur les ddl retenus
                     };
                    
                     // on enregistre si la vérification a été ok
                     if (veriflocal)
                       { tab_nomDeRef_ptinteg_SM(n_mail).push_back(nom_ref);
                         tab_nomDeRef_ptinteg_SM(n_mail).sort(); // on ordonne
                         tab_nomDeRef_ptinteg_SM(n_mail).unique();// on supprime les doublons
                       };
                   }; // fin de la vérification
                }
             else if (rep == "torefE")
               { // on va balayer tous les références
                 const Reference* refi = lesRef->Init_et_Premiere();
                 list <string> inter;
                 while (refi != NULL)
                  { if (refi->Indic() == 2)
                      inter.push_back(refi->Nom());
                    refi = lesRef->Reference_suivante();
                  };
                 // maintenant on va indiquer les pti
                 // choix du point d'intégration, ici on ne va pas utiliser la liste list_nut, mais une liste particulière
                 string repo;
                 cout << " numero d'un point d'integration ou: -1 pour tous les pti ? ";
                 repo= lect_chaine(); nut.nbPtInteg = ChangeEntier(repo);
                 list <string>::iterator il,ilfin=inter.end();
                 if (nut.nbPtInteg != -1) // cas d'un seul pti
                   { bool veriflocal = true;
                     for (il = inter.begin();il != ilfin; il++)
                        {// on vérifie que ce point d'intégration est valide pour tous les éléments de la référence
                          // --- cas des ddl principaux
                         {List_io < Ddl_enum_etendu >& li_ddl = tabelement_type_ddl_retenu_pourSM(n_mail);
                          List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
                          // boucle sur les ddl retenus
                          for (ite = li_ddl.begin();ite != itefin; ite++)
                           { // recup de la reference
                             const Reference& refi = lesRef->Trouve((*il),n_mail);
                             const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
                             int taillen=reff.Taille(); // nombre d'éléments dans la référence
                             for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                              { nut.nbElem = reff.Numero(ielem);
                                // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                                if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                                 { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                        << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                        << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                                   veriflocal = false;
                                  };
                              }; //-- fin de la boucle sur les éléments de la référence
                           }; //-- fin de la boucle sur les ddl retenus
                         };
                         // --- cas des types particuliers aux éléments
                         {List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_particulieres.end();
                          // boucle sur les ddl retenus
                          for (ite = li_ddl_particulieres.begin();ite != itefin; ite++)
                           { // recup de la reference correspondant au mot cle
                             const Reference& refi = lesRef->Trouve((*il),n_mail);
                             const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
                             int taillen=reff.Taille(); // nombre d'éléments dans la référence
                             for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                              { nut.nbElem = reff.Numero(ielem);
                                // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                                if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                                 { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                        << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                        << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                                   veriflocal = false;
                                  };
                              }; //-- fin de la boucle sur les éléments de la référence
                           }; //-- fin de la boucle sur les ddl retenus
                         };
                         // --- cas des types évolués aux éléments
                         {List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_evoluees.end();
                          // boucle sur les ddl retenus
                          for (ite = li_ddl_evoluees.begin();ite != itefin; ite++)
                           { // recup de la reference correspondant au mot cle
                             const Reference& refi = lesRef->Trouve((*il),n_mail);
                             const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
                             int taillen=reff.Taille(); // nombre d'éléments dans la référence
                             for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                              { nut.nbElem = reff.Numero(ielem);
                                // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                                if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                                 { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                        << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                        << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                                   veriflocal = false;
                                  };
                              }; //-- fin de la boucle sur les éléments de la référence
                           }; //-- fin de la boucle sur les ddl retenus
                         };
                        };
                     // --- on enregistre si la vérification a été ok
                     if (veriflocal)
                      for (il = inter.begin();il != ilfin; il++)
                        { tab_nomDeRef_E_SM(n_mail).push_back(BlocScal((*il),nut.nbPtInteg));
                           tab_nomDeRef_E_SM(n_mail).sort(); // on ordonne
                           tab_nomDeRef_E_SM(n_mail).unique();// on supprime les doublons
                         };
                     }
                 else  // cas de tous les pti
                   { bool veriflocal = true;
                     for (il = inter.begin();il != ilfin; il++)
                        { // il faut d'abord que l'on vérifie que tous les pti pour tous les éléments sont valides
                          // .. on commence par tester si un premier élément existe vraiment et si oui, on récupère le nb de pti associé
                          int nbpti = 0; // init
                          { // on encapsule pour pas de redondance de nom
                            const Reference& refi = lesRef->Trouve((*il),n_mail);
                            const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
                            int taillen=reff.Taille(); // nombre d'éléments dans la référence
                            if (taillen < 1) {veriflocal = false;} // cas d'une ref vide, on ne peut pas aller plus loin
                            else
                             {nut.nbElem = reff.Numero(1);
                              if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
                               {if (nut.nbElem < 0)
                                  { cout << "\n le numero d'element doit etre superieur a 0 !!!";};
                                if (nut.nbElem > lesMail->Nombre_element(n_mail))
                                  { cout << "\n chois non valide, le numero d'element doit etre inferieur ou egal "
                                         << "   au nombre total d'element du maillage !!!";
                                    veriflocal = false;
                                  };
                               }
                              else // sinon c'est ok, on continue au niveau des pti
                               {Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
                               
                                List_io < Ddl_enum_etendu >& li_ddl = tabelement_type_ddl_retenu_pourSM(n_mail);
                                List_io<Ddl_enum_etendu>::iterator ite = li_ddl.end(); //une initialisation
                                // on cherche un élément valide
                                if (!(li_ddl.empty()))
                                  { ite = li_ddl.begin();} // la liste n'est pas vide, on prend le premier élément
                                else if (!(li_ddl_particulieres.empty()))
                                  { ite = li_ddl_particulieres.begin();}
                                else if (!(li_ddl_evoluees.empty()))
                                  { ite = li_ddl_evoluees.begin();}
                                else // toutes les listes sont vides on ne peut pas aller plus loin
                                  {veriflocal = false;};
                                // si c'est ok:
                                if (veriflocal)
                                  {nbpti = ele.NbPtInteg((*ite).Enum());};
                                };
                             };
                          };
                          // .. puis on balaie l'ensemble des éléments et l'ensemble des pti
                          if (veriflocal)
                            {// --- cas des ddl principaux
                             {List_io < Ddl_enum_etendu >& li_ddl = tabelement_type_ddl_retenu_pourSM(n_mail);
                              List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
                              // boucle sur les ddl retenus
                              for (ite = li_ddl.begin();ite != itefin; ite++)
                               { // recup de la reference correspondant au mot cle
                                 const Reference& refi = lesRef->Trouve((*il),n_mail);
                                 const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
                                 int taillen=reff.Taille(); // nombre d'éléments dans la référence
                                 for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                                  { nut.nbElem = reff.Numero(ielem);
                                    for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
                                      // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                                      if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                                       { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                              << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                              << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                                         veriflocal = false;
                                         break;
                                       };
                                      if (!veriflocal) break;
                                  }; //-- fin de la boucle sur les éléments de la référence
                                 if (!veriflocal) break;
                               }; //-- fin de la boucle sur les ddl retenus
                             };
                             // --- cas des types particuliers aux éléments
                             {List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_particulieres.end();
                              // boucle sur les ddl retenus
                              for (ite = li_ddl_particulieres.begin();ite != itefin; ite++)
                               { // recup de la reference correspondant au mot cle
                                 const Reference& refi = lesRef->Trouve((*il),n_mail);
                                 const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
                                 int taillen=reff.Taille(); // nombre d'éléments dans la référence
                                 for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                                  { nut.nbElem = reff.Numero(ielem);
                                    for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
                                      // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                                      if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                                       { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                            << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                            << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                                         veriflocal = false;
                                         break;
                                       };
                                      if (!veriflocal) break;
                                  }; //-- fin de la boucle sur les éléments de la référence
                                 if (!veriflocal) break;
                               }; //-- fin de la boucle sur les ddl retenus
                             };
                             // --- cas des types évolués aux éléments
                             {List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_evoluees.end();
                              // boucle sur les ddl retenus
                              for (ite = li_ddl_evoluees.begin();ite != itefin; ite++)
                               { // recup de la reference correspondant au mot cle
                                 const Reference& refi = lesRef->Trouve((*il),n_mail);
                                 const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
                                 int taillen=reff.Taille(); // nombre d'éléments dans la référence
                                 for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                                  { nut.nbElem = reff.Numero(ielem);
                                    for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
                                      // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                                      if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                                       { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                            << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                            << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                                         veriflocal = false;
                                         break;
                                       };
                                      if (!veriflocal) break;
                                  }; //-- fin de la boucle sur les éléments de la référence
                                 if (!veriflocal) break;
                               }; //-- fin de la boucle sur les ddl retenus
                             };
                            };
                        };
                     // arrivée ici, si tout est ok on enregistre
                     if (veriflocal)
                      for (il = inter.begin();il != ilfin; il++)
                         { nut.nbPtInteg = -1;
                           tab_nomDeRef_E_SM(n_mail).push_back(BlocScal((*il),nut.nbPtInteg));
                           tab_nomDeRef_E_SM(n_mail).sort(); // on ordonne
                           tab_nomDeRef_E_SM(n_mail).unique();// on supprime les doublons
                         };
                   };
               }
             else if (rep == "torefpti")
               { // on va balayer tous les références
                 const Reference* refi = lesRef->Init_et_Premiere();
                 while (refi != NULL)
                  { if (refi->Indic() == 6)
                     { // on vérifie que le choix est valide
                       bool veriflocal = true;
                      
                       // --- cas des ddl principaux
                       {List_io < Ddl_enum_etendu >& li_ddl = tabelement_type_ddl_retenu_pourSM(n_mail);
                        List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
                        // boucle sur les ddl retenus
                        for (ite = li_ddl.begin();ite != itefin; ite++)
                         { // recup de la reference correspondant au mot cle
                           const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'élément
                           int taillen=reff.Taille(); // nombre d'éléments dans la référence
                           for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                            { nut.nbElem = reff.NumeroElem(ielem);
                              nut.nbPtInteg = reff.NumeroFA(ielem);
                              // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                              if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                               { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                      << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                      << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                                 veriflocal = false;
                                };
                            }; //-- fin de la boucle sur les éléments de la référence
                         }; //-- fin de la boucle sur les ddl retenus
                       };
                       // --- cas des types particuliers aux éléments
                       {List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_particulieres.end();
                        // boucle sur les ddl retenus
                        for (ite = li_ddl_particulieres.begin();ite != itefin; ite++)
                         { // recup de la reference correspondant au mot cle
                           const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'élément
                           int taillen=reff.Taille(); // nombre d'éléments dans la référence
                           for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                            { nut.nbElem = reff.NumeroElem(ielem);
                              nut.nbPtInteg = reff.NumeroFA(ielem);
                              // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                              if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                               { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                      << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                      << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                                 veriflocal = false;
                                };
                            }; //-- fin de la boucle sur les éléments de la référence
                         }; //-- fin de la boucle sur les ddl retenus
                       };
                       // --- cas des types évolués aux éléments
                       {List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_evoluees.end();
                        // boucle sur les ddl retenus
                        for (ite = li_ddl_evoluees.begin();ite != itefin; ite++)
                         { // recup de la reference correspondant au mot cle
                           const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'élément
                           int taillen=reff.Taille(); // nombre d'éléments dans la référence
                           for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                            { nut.nbElem = reff.NumeroElem(ielem);
                              nut.nbPtInteg = reff.NumeroFA(ielem);
                              // vérification de l'adéquation numéro de point d'intégration et énumération et élément
                              if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
                               { cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
                                      << " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide  pour l'element "
                                      << nut.nbElem << " du maillage " << n_mail << " !!!! ";
                                 veriflocal = false;
                                };
                            }; //-- fin de la boucle sur les éléments de la référence
                         }; //-- fin de la boucle sur les ddl retenus
                       };
                      
                       // on enregistre si la vérification a été ok
                       if (veriflocal)
                         { tab_nomDeRef_ptinteg_SM(n_mail).push_back(refi->Nom());
                           tab_nomDeRef_ptinteg_SM(n_mail).sort(); // on ordonne
                           tab_nomDeRef_ptinteg_SM(n_mail).unique();// on supprime les doublons
                         };
                     }; // fin de la vérification
                    refi = lesRef->Reference_suivante();
                  };
               }
             else if (rep == "efref")
              { // on efface la liste des références d'éléments et la liste de pt d'integ associée
                (tab_nomDeRef_E_SM(n_mail)).clear();
              }
             else if (rep == "affref") 
              { // affichage de la liste des références d'éléments enregistrées dans les maillages
                cout << "\n liste des references d'elements ";
                if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
                const Reference* reff =NULL; bool prempass = true;
                do { 
                   if (prempass)
                     { reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
                   else
                     { reff = lesRef->Reference_suivante();} // récup de la ref courante  
                   // sortie de la ref si c'est le bon maillage, et si c'est une ref d'élément
                   if (reff != NULL)
                      if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 2)) cout << reff->Nom() << " ";
                   prempass = false; 
                    } while (reff != NULL);
              }
             else if (rep == "efrefpti") 
              { // on efface la liste des références de pt d'integ d'éléments 
                (tab_nomDeRef_ptinteg_SM(n_mail)).clear();
              }
             else if (rep == "affrefpti")
              { // affichage de la liste des références de pti enregistrées dans les maillages
                cout << "\n liste des references de pt integ d'elements ";
                if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
                const Reference* reff =NULL; bool prempass = true;
                do { 
                   if (prempass)
                     { reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
                   else
                     { reff = lesRef->Reference_suivante();} // récup de la ref courante  
                   // sortie de la ref si c'est le bon maillage, et si c'est une ref d'élément
                   if (reff != NULL)
                      if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 6)) cout << reff->Nom() << " ";
                   prempass = false; 
                    } while (reff != NULL);
              }
             else
              { cout << "\n reponse non valide, recommencez " << endl;
              };
           };  // -- fin boucle choix
         };
        
       }; //-- fin de la boucle sur les maillages
  };
// entrée du choix pour les moyennes sommes etc. sur ref de face d'E
void Choix_grandeurs_maple::Entree_somme_moy_F_E(string& rep)
  { // cas de grandeurs aux faces d'éléments, on boucle sur les maillages
    //int dim = ParaGlob::Dimension();
    cout << "\n --- somme, moyenne, max, min etc. sur des references de faces d'element et de pti ---";
    // on récupère la liste des maillages à visualiser
    const list <int>& list_mail = choix_mail->List_choisit();
    list<int>::const_iterator ilm,ilmfin=list_mail.end();
    int taille_list_maille = list_mail.size();
    if (list_mail.size() == 0)
      { cout << "\n aucun maillage n'est definit ! , il faut commencer par definir les maillages pour"
             << " lesquels on veut une sortie ";
        return;
      };
    // on balaie les différents maillages
    for (ilm = list_mail.begin();ilm!=ilmfin;ilm++)
       { int n_mail = abs(*ilm); // numéro du maillage
       
         // -- boucle sur les maillages
         // affichage du nom du maillages s'il y en a plusieurs
         if (taille_list_maille > 1)
           cout << "\n ======>>>>>   maillage : " << lesMail->NomMaillage(n_mail);

         // -------------- choix des grandeurs quelconques  définis aux faces d'éléments -----------------
         // def de la liste de travail qui contient les grandeurs à visualiser,
         // sert également pour vérifier que tous les grandeurs quelconques sont relatives
         // à un même point d'intégration
         List_io < EnumTypeQuelconque > li_enu_quelconque;
         {cout << "\n -------- cas des grandeurs quelconques definies aux faces d'elements ---------";
          // dans le cas où aucune grandeur particulière sont défini on passe
          if ( (tab_F_element_TypeQuelconque(n_mail)).size() == 0)
           { cout << "\n aucune grandeur particuliere n'est definit, donc aucune proposition ";}
          else
           { // on affiche la liste actuelle
             if ((tab_F_element_TypeQuelconque_retenu_pourSM(n_mail)).size())
                { cout << "\n liste actuelle des faces element a sortir en info: < (num_ele, num_face) > ";
                  List_io <int>::iterator ieint,ieintfin = tab_num_F_element(n_mail).end();
                  List_io <int>::iterator ifint = tab_num_F(n_mail).begin();
                  for (ieint=tab_num_F_element(n_mail).begin();ieint!=ieintfin;ieint++,ifint++)
                    cout << " (" << (*ieint) << ", "<<(*ifint)<<") ";
                  cout << "\n liste des grandeurs quelconques actuellement a sortir:   ";
                  List_io < TypeQuelconque >::iterator iet,ietfin = (tab_F_element_TypeQuelconque_retenu_pourSM(n_mail)).end();
                  for (iet=(tab_F_element_TypeQuelconque_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
                    cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
                  cout << endl;
                };
             // on affiche les différentes grandeurs possibles
             cout << "\n maillage nb : " << n_mail ;
             cout << "\n la liste des grandeurs  disponibles est la suivante : ";
             List_io < TypeQuelconque >::iterator iet,ietfin = (tab_F_element_TypeQuelconque(n_mail)).end();
             for (iet=(tab_F_element_TypeQuelconque(n_mail)).begin();iet!=ietfin;iet++)
                        cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
             cout << "\n";
             cout << "\n grandeurs que vous voulez visualiser                         ( rep : grandeurs?)"
                  << "\n REMARQUE : il faut donner uniquement un jeu de grandeurs                        "
                  << "\n definies  au meme point d'integration                                           "
                  << "\n effacer la liste actuelle                                    (rep : ef)         "
                  << "\n toutes les grandeurs :                                       (rep : to)         "
                  << "\n                                               (pour terminer tapez : fin (ou f))";
             rep = "";
             while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
               { cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
                 if (rep == "to")
                  // cas de toutes les grandeurs
                  {List_io<TypeQuelconque>& tpg_ret = (tab_F_element_TypeQuelconque_retenu_pourSM(n_mail)); // pour simplifier
                   List_io<TypeQuelconque>& tpg = (tab_F_element_TypeQuelconque(n_mail)); // pour simplifier
                   List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
                   for (ite = tab_F_element_TypeQuelconque(n_mail).begin();ite != itefin; ite++)
                        if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
                          { tpg_ret.push_back(*ite);
                            // on enregistre également le EnumTypeQuelconque associé qui définit le point d'integ où est calculé la grandeur
                            li_enu_quelconque.push_back((*ite).EnuTypeQuelconque().EnumTQ());
                           };
                  }
                 else if (TypeQuelconque_enum_etendu::VerifExistence(rep) ) // vérif que c'est une grandeur possible
                   { // maintenant on vérifie qu'elle appartient à la liste des grandeurs disponibles
                     TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
                     List_io<TypeQuelconque>& tpg_ret = (tab_F_element_TypeQuelconque_retenu_pourSM(n_mail)); // pour simplifier
                     List_io<TypeQuelconque>& tpg = (tab_F_element_TypeQuelconque(n_mail)); // pour simplifier
                     if (find(tpg.begin(),tpg.end(),a) != tpg.end())
                      { // il existe -> enregistrement
                        List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                        // s'il n'existe pas déjà on l'enregistre vraiment
                        if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                          { tpg_ret.push_back(*il);
                            // on enregistre également le enum quelconque associé qui définit le point d'integ où est calculé la grandeur
                            // particulière
                            li_enu_quelconque.push_back((*il).EnuTypeQuelconque().EnumTQ());
                           };
                       }
                     else
                      { cout << "\n erreur, grandeur non disponible !, recommencez ";};
                   }
                 else if (rep == "ef")
                  { // on efface la liste
                    (tab_F_element_TypeQuelconque_retenu_pourSM(n_mail)).clear();
                  }
                 else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                  cout << " erreur de syntaxe  recommencez ";
               };
           }; //-- fin du choix sur le fait qu'il existe ou non des grandeurs quelconques
         };
         // -------------- on s'occupe maintenant des références associées pour le calcul des sommes moy... -----------------
         {cout << "\n -------- definition des references de faces d'elements ---------";
          // cas des références de faces d'élément
          if ((tab_nomDeRef_F_E_SM(n_mail)).size() != 0)
             { cout << "\n liste actuelle de reference de faces d'elements : (nom refFE et num integ) ";
               List_io <BlocScal >::iterator ieint1,ieintfin1 = (tab_nomDeRef_F_E_SM(n_mail)).end();
               for (ieint1=(tab_nomDeRef_F_E_SM(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
                 cout << (*ieint1).NomRef() << " "<< (int) ((*ieint1).Val()) << " ";
               cout << endl;
             };
          // cas des références de point d'intégration de faces d'élément
          if ((tab_nomDeRef_F_ptinteg_SM(n_mail)).size() != 0)
             { cout << "\n liste actuelle de reference de pt d'integration de faces d'element:  (nom refFpti) ";
               List_io <string >::iterator ieint1,ieintfin1 = (tab_nomDeRef_F_ptinteg_SM(n_mail)).end();
               for (ieint1=(tab_nomDeRef_F_ptinteg_SM(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
                 cout << (*ieint1) << " ";
               cout << endl;
             };
          cout    << "\n choix d'une reference de face d'element (avec 1 ou tous les pti)    -> (choix : refFE)"
                  << "\n (dans ce dernier cas il faut que toutes les faces aient le meme nbpti )           "
                  << "\n choix d'une reference de point d'integration de faces d'element     -> (choix : refFpti)"
                  << "\n donnez le type de choix puis les infos correspondantes                            "
                  << "\n choix de tous les ref de face d'elements                            -> (choix : torefFE)"
                  << "\n choix de tous les ref de pti de face                                -> (choix : torefFpti)"
                  << "\n effacer la liste actuelle des references de faces                   ->  (rep : efrefF) "
                  << "\n afficher la liste des references de faces existantes                ->  (rep : affrefF) "
                  << "\n effacer la liste actuelle des references de pt integ de faces       ->  (rep : efrefFpti) "
                  << "\n afficher la liste des references de pt integ de faces existantes    ->  (rep : affrefFpti) "
                  << "\n                                                             (tapez fin pour finir(ou f))";
          string rep = "";
          // -- début boucle choix position sur element
          while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
           { cout << "\n choix ? ";rep = lect_return_defaut(false,"f");
             if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f")) break;
             // def du conteneur des numéros que l'on cherche
             // comme on peut en définir plusieurs d'un coup (par exemple tous les pti d'une face d'élément) on utilise une liste
             list <Maillage::NBelemFAEtptInteg> list_nut; // à chaque passage elle est initialisée et donc vide au début
             Maillage::NBelemFAEtptInteg nut; // idem, initialisé à chaque passage
             if (rep == "refFE")
               { string nom_ref;
                 cout << "\n nom de la reference ? ";
                 nom_ref= lect_chaine();
                 // vérif que la référence existe
                 if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 3))
                   { cout << "\n erreur de nom (** "<< nom_ref << " **)  donne ne correspond pas a une reference de faces d'element correcte ";}
                 else
                   { // choix du point d'intégration, ici on ne va pas utiliser la liste list_nut, mais une liste particulière
                     string repo;
                     cout << " numero d'un point d'integration ou: -1 pour tous les pti ? ";
                     repo= lect_chaine(); nut.nbPtInteg = ChangeEntier(repo);
                     if (nut.nbPtInteg != -1) // cas d'un seul pti
                      {// on vérifie que ce point d'intégration est valide pour tous les éléments de la référence
                       bool veriflocal = true;
                       //List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_F_E_SM(n_mail).end();
                       
                       // --- cas des types quelconques aux faces d'éléments
                       {List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
                        // boucle sur les grandeurs retenus
                        for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
                         { // recup de la reference correspondant au mot cle
                           const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                           const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de faces d'élément
                           int taillen=reff.Taille(); // nombre d'éléments dans la référence
                           for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                            { nut.nbElem = reff.NumeroElem(ielem);
                              nut.nbFA  = reff.NumeroFA(ielem);
                              Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
                              // test si l'élément face existe
                              if (!ele.SurfExiste(nut.nbFA))
                               {cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                     << " du maillage "<< n_mail
                                     << " ceci pour la reference " << reff.Nom()
                                     << " !!!" << flush ;
                                veriflocal = false;
                               }
                              else
                               {const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
                                int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
                                // vérification que le  point d'intégration est possible
                                if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
                                 { cout << "\n le numero de pti " << nut.nbPtInteg
                                        << " pour la grandeur  " << NomTypeQuelconque((*ite)) << " n'est pas valide  "
                                        << " pour la face " << nut.nbFA << "pour l'element "
                                        << nut.nbElem << " du maillage " << n_mail
                                        << ", car la face ne comporte que " << max_pti << " pti possible(s) "
                                        << " !!!! " << flush;
                                   veriflocal = false;
                                 };
                               };
                            }; //-- fin de la boucle sur les éléments de la référence
                         }; //-- fin de la boucle sur les ddl retenus
                       };
                       // --- on enregistre si la vérification a été ok
                       if (veriflocal)
                         { tab_nomDeRef_F_E_SM(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
                           tab_nomDeRef_F_E_SM(n_mail).sort(); // on ordonne
                           tab_nomDeRef_F_E_SM(n_mail).unique();// on supprime les doublons
                         };
                      }
                     else  // cas de tous les pti
                      { // il faut d'abord que l'on vérifie que tous les pti pour tous les faces d'élément sont valides
                        // .. on commence par tester si une première face d'élément existe vraiment et si oui, on récupère le nb de pti associé
                        bool veriflocal = true;
                        int nbpti = 0; // init-> ensuite sera == au nombre de pti pour chaque élément
                        { // on encapsule pour pas de redondance de nom
                          const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                          const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de face d'élément
                          int taillen=reff.Taille(); // nombre d'éléments dans la référence
                          if (taillen < 1) {veriflocal = false;} // cas d'une ref vide, on ne peut pas aller plus loin
                          else
                           {nut.nbElem = reff.NumeroElem(1);
                            nut.nbFA = reff.NumeroFA(1);
                            if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
                             {if (nut.nbElem < 0)
                                { cout << "\n le numero d'element (ici"<<nut.nbElem<<") doit etre superieur a 0 !!!";};
                              if (nut.nbElem > lesMail->Nombre_element(n_mail))
                                { cout << "\n chois non valide, le numero d'element (ici"<<nut.nbElem<<") doit etre inferieur ou egal "
                                       << "   au nombre total d'element du maillage ("<<lesMail->Nombre_element(n_mail)<<") !!!";
                                };
                              veriflocal = false;
                             }
                            else // sinon c'est ok, on continue au niveau des pti
                             {Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
                              // test si l'élément face existe
                              if (!ele.SurfExiste(nut.nbFA))
                               {cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                     << " du maillage "<< n_mail
                                     << " ceci pour la reference " << reff.Nom()
                                     << " !!!" << flush ;
                                veriflocal = false;
                               }
                              else
                               {const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
                                int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
                                List_io < TypeQuelconque >& li_quelc = tab_F_element_TypeQuelconque_retenu_pourSM(n_mail);
                                // on regarde si les listes ne sont pas toutes vides
                                if ((li_quelc.empty())&&(li_enu_quelconque.empty()))
                                  {// toutes les listes sont vides, on ne pourra pas aller plus loin
                                   veriflocal = false;
                                  }
                                else // sinon on peut continuer
                                  {nbpti = max_pti;};
                               };
                             }
                           };
                        };
                        // .. puis on balaie l'ensemble des éléments et l'ensemble des pti
                        if (veriflocal)
                          {//List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_F_E_SM(n_mail).end();
                       
                           // --- cas des types quelconques aux faces d'éléments
                           {List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
                            // boucle sur les grandeurs retenus
                            for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
                             { // recup de la reference correspondant au mot cle
                               const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                               const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de faces d'élément
                               int taillen=reff.Taille(); // nombre d'éléments dans la référence
                               for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                                { nut.nbElem = reff.NumeroElem(ielem);
                                  nut.nbFA = reff.NumeroFA(ielem);
                                  Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
                                  if (!ele.SurfExiste(nut.nbFA))
                                   {cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                         << " du maillage "<< n_mail
                                         << " ceci pour la reference " << reff.Nom()
                                         << " !!!" << flush ;
                                    veriflocal = false;break;
                                   }
                                  else
                                   {const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
                                    int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
                                    
                                    // vérification que l'on a le même nombre de pti
                                    if (max_pti != nbpti)
                                     { cout << "\n ---> traitement de la reference: "<<refi.Nom()<<" : ";
                                       cout << "\n la face "<<nut.nbFA<<" de l'element "<<nut.nbElem << " du maillage " << n_mail
                                            << " contient "<<max_pti<< " pti , alors qu'il en faudrait: "<<nbpti
                                            << "\n les faces sont donc differentes, on ne peut pas utiliser cette reference !! "
                                            << flush;
                                       veriflocal = false;
                                     };
                                    if (!veriflocal) break;
                                   };
                                }; //-- fin de la boucle sur les éléments de la référence
                               if (!veriflocal) break;
                             }; //-- fin de la boucle sur les ddl retenus
                           };
                          };
                       
                        // arrivée ici, si tout est ok on enregistre
                        if (veriflocal)
                            { nut.nbPtInteg = -1;
                              tab_nomDeRef_F_E_SM(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
                              tab_nomDeRef_F_E_SM(n_mail).sort(); // on ordonne
                              tab_nomDeRef_F_E_SM(n_mail).unique();// on supprime les doublons
                            };
                      };
                   }; // fin du choix du point d'intégration et de l'enregistrement
               }
             else if (rep == "refFpti")
               { string nom_ref;
                 cout << "\n nom de la reference ? ";nom_ref= lect_chaine();
                 // vérif que la référence existe
                 if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 7))
                   { cout << "\n erreur de nom (** "<< nom_ref << " **)  donne ne correspond pas a une reference de point d'integration "
                          << " de face d'element correcte ";}
                 else
                   { // on vérifie que le choix est valide
                     bool veriflocal = true;
                     // --- cas des types quelconques aux éléments
                     {List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
                      // boucle sur les grandeurs retenus
                      for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
                       { // recup de la reference correspondant au mot cle
                         const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                         const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref de pti de faces d'élément
                         int taillen=reff.Taille(); // nombre d'éléments dans la référence
                         for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                          { nut.nbElem = reff.NumeroElem(ielem);
                            nut.nbFA = reff.NumeroFA(ielem);
                            nut.nbPtInteg = reff.NumeroPti(ielem);
                            
                            Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
                            if (!ele.SurfExiste(nut.nbFA))
                             {cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                   << " du maillage "<< n_mail
                                   << " ceci pour la reference " << reff.Nom()
                                   << " !!!" << flush ;
                              veriflocal = false;
                             }
                            else
                             {const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
                              int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
                              // vérification que le  point d'intégration est possible
                              if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
                               { cout << "\n le numero de pti " << nut.nbPtInteg
                                      << " pour la grandeur  " << NomTypeQuelconque((*ite)) << " n'est pas valide  "
                                      << " pour la face " << nut.nbFA << "pour l'element "
                                      << nut.nbElem << " du maillage " << n_mail
                                      << ", car la face ne comporte que " << max_pti << " pti possible(s) "
                                      << " !!!! " << flush;
                                 veriflocal = false;
                               };
                              };
                          }; //-- fin de la boucle sur les éléments de la référence
                       }; //-- fin de la boucle sur les grandeurs retenus
                     };
                    
                     // on enregistre si la vérification a été ok
                     if (veriflocal)
                       { tab_nomDeRef_F_ptinteg_SM(n_mail).push_back(nom_ref);
                         tab_nomDeRef_F_ptinteg_SM(n_mail).sort(); // on ordonne
                         tab_nomDeRef_F_ptinteg_SM(n_mail).unique();// on supprime les doublons
                       };
                   }; // fin de la vérification
                }
             else if (rep == "torefFE")
               { // on va balayer tous les références
                 const Reference* refi = lesRef->Init_et_Premiere();
                 list <string> inter;
                 while (refi != NULL)
                  { if (refi->Indic() == 3)
                      inter.push_back(refi->Nom());
                    refi = lesRef->Reference_suivante();
                  };
                 // maintenant on va indiquer les pti
                 // choix du point d'intégration, ici on ne va pas utiliser la liste list_nut, mais une liste particulière
                 string repo;
                 cout << " numero d'un point d'integration ou: -1 pour tous les pti ? ";
                 repo= lect_chaine(); nut.nbPtInteg = ChangeEntier(repo);
                 list <string>::iterator il,ilfin=inter.end();
                 if (nut.nbPtInteg != -1) // cas d'un seul pti
                   { bool veriflocal = true;
                     for (il = inter.begin();il != ilfin; il++)
                        {// on vérifie que ce point d'intégration est valide pour tous les faces d'éléments de la référence
                         // --- cas des types quelconques aux faces d'éléments
                         {List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
                          // boucle sur les grandeurs retenus
                          for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
                           { // recup de la reference correspondant au mot cle
                             const Reference& refi = lesRef->Trouve((*il),n_mail);
                             const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de faces d'élément
                             int taillen=reff.Taille(); // nombre d'éléments dans la référence
                             for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                              { nut.nbElem = reff.NumeroElem(ielem);
                                nut.nbFA  = reff.NumeroFA(ielem);
                                Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
                                if (!ele.SurfExiste(nut.nbFA))
                                 {cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                       << " du maillage "<< n_mail
                                       << " ceci pour la reference " << reff.Nom()
                                       << " !!!" << flush ;
                                  veriflocal = false;
                                 }
                                else
                                 {const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
                                  int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
                                  // vérification que le  point d'intégration est possible
                                  if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
                                   { cout << "\n le numero de pti " << nut.nbPtInteg
                                          << " pour la grandeur  " << NomTypeQuelconque((*ite)) << " n'est pas valide  "
                                          << " pour la face " << nut.nbFA << "pour l'element "
                                          << nut.nbElem << " du maillage " << n_mail
                                          << ", car la face ne comporte que " << max_pti << " pti possible(s) "
                                          << " !!!! " << flush;
                                     veriflocal = false;
                                   };
                                 };
                              }; //-- fin de la boucle sur les éléments de la référence
                           }; //-- fin de la boucle sur les ddl retenus
                         };
                        };
                     // --- on enregistre si la vérification a été ok
                     if (veriflocal)
                      for (il = inter.begin();il != ilfin; il++)
                        { tab_nomDeRef_F_E_SM(n_mail).push_back(BlocScal((*il),nut.nbPtInteg));
                           tab_nomDeRef_F_E_SM(n_mail).sort(); // on ordonne
                           tab_nomDeRef_F_E_SM(n_mail).unique();// on supprime les doublons
                         };
                     }
                 else  // cas de tous les pti
                   { bool veriflocal = true;
                     for (il = inter.begin();il != ilfin; il++)
                        { // il faut d'abord que l'on vérifie que tous les pti pour tous les éléments sont valides
                          // .. on commence par tester si une première face d'élément existe vraiment et si oui, on récupère le nb de pti associé
                          int nbpti = 0; // init-> ensuite sera == au nombre de pti pour chaque élément
                          { // on encapsule pour pas de redondance de nom
                            const Reference& refi = lesRef->Trouve((*il),n_mail);
                            const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de faces d'élément
                            int taillen=reff.Taille(); // nombre d'éléments dans la référence
                            if (taillen < 1) {veriflocal = false;} // cas d'une ref vide, on ne peut pas aller plus loin
                            else
                             {nut.nbElem = reff.NumeroElem(1);
                              nut.nbFA = reff.NumeroFA(1);
                              if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
                               {if (nut.nbElem < 0)
                                  { cout << "\n le numero d'element doit etre superieur a 0 !!!";};
                                if (nut.nbElem > lesMail->Nombre_element(n_mail))
                                  { cout << "\n chois non valide, le numero d'element doit etre inferieur ou egal "
                                         << "   au nombre total d'element du maillage !!!";
                                  };
                                veriflocal = false;
                               }
                              else // sinon c'est ok, on continue au niveau des pti
                               {Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
                                // test si l'élément face existe
                                if (!ele.SurfExiste(nut.nbFA))
                                 {cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                       << " du maillage "<< n_mail
                                       << " ceci pour la reference " << reff.Nom()
                                       << " !!!" << flush ;
                                  veriflocal = false;
                                 }
                                else
                                 {const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
                                  int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
                                  List_io < TypeQuelconque >& li_quelc = tab_F_element_TypeQuelconque_retenu_pourSM(n_mail);
                                  // on regarde si les listes ne sont pas toutes vides
                                  if ((li_quelc.empty())&&(li_enu_quelconque.empty()))
                                    {// toutes les listes sont vides, on ne pourra pas aller plus loin
                                     veriflocal = false;
                                    }
                                  else // sinon on peut continuer
                                    {nbpti = max_pti;};
                                 };
                               };
                             };
                          };
                          // .. puis on balaie l'ensemble des éléments et l'ensemble des pti
                          if (veriflocal)
                            {// --- cas des types quelconques aux faces d'éléments
                             {List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
                              // boucle sur les grandeurs retenus
                              for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
                               { // recup de la reference correspondant au mot cle
                                 const Reference& refi = lesRef->Trouve((*il),n_mail);
                                 const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de faces d'élément
                                 int taillen=reff.Taille(); // nombre d'éléments dans la référence
                                 for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                                  {nut.nbElem = reff.NumeroElem(ielem);
                                   nut.nbFA = reff.NumeroFA(ielem);
                                   Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
                                   if (!ele.SurfExiste(nut.nbFA))
                                    {cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                          << " du maillage "<< n_mail
                                          << " ceci pour la reference " << reff.Nom()
                                          << " !!!" << flush ;
                                     veriflocal = false;break;
                                    }
                                   else
                                    {const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
                                     int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
                                     
                                     // vérification que l'on a le même nombre de pti
                                     if (max_pti != nbpti)
                                      { cout << "\n ---> traitement de la reference: "<<refi.Nom()<<" : ";
                                        cout << "\n la face "<<nut.nbFA<<" de l'element "<<nut.nbElem << " du maillage " << n_mail
                                             << " contient "<<max_pti<< " pti , alors qu'il en faudrait: "<<nbpti
                                             << "\n les faces sont donc differentes, on ne peut pas utiliser cette reference !! "
                                             << flush;
                                        veriflocal = false;
                                      };
                                     if (!veriflocal) break;
                                    };
                                  }; //-- fin de la boucle sur les éléments de la référence
                                 if (!veriflocal) break;
                               }; //-- fin de la boucle sur les ddl retenus
                             };
                            };
                        };
                     // arrivée ici, si tout est ok on enregistre
                     if (veriflocal)
                      for (il = inter.begin();il != ilfin; il++)
                         { nut.nbPtInteg = -1;
                           tab_nomDeRef_F_E_SM(n_mail).push_back(BlocScal((*il),nut.nbPtInteg));
                           tab_nomDeRef_F_E_SM(n_mail).sort(); // on ordonne
                           tab_nomDeRef_F_E_SM(n_mail).unique();// on supprime les doublons
                         };
                   };
               }
             else if (rep == "torefFpti")
               { // on va balayer tous les références
                 const Reference* refi = lesRef->Init_et_Premiere();
                 while (refi != NULL)
                  { if (refi->Indic() == 7)
                     { // on vérifie que le choix est valide
                       bool veriflocal = true;
                      
                       // --- cas des types quelconques aux faces d'éléments
                       {List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
                        // boucle sur les ddl retenus
                        for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
                         { // recup de la reference correspondant au mot cle
                           const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref d'élément
                           int taillen=reff.Taille(); // nombre d'éléments dans la référence
                           for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                            { nut.nbElem = reff.NumeroElem(ielem);
                              nut.nbFA = reff.NumeroFA(ielem);
                              nut.nbPtInteg = reff.NumeroPti(ielem);
                              
                              Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
                              if (!ele.SurfExiste(nut.nbFA))
                               {cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                     << " du maillage "<< n_mail
                                     << " ceci pour la reference " << reff.Nom()
                                     << " !!!" << flush ;
                                veriflocal = false;
                               }
                              else
                               {const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
                                int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
                                // vérification que le  point d'intégration est possible
                                if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
                                 { cout << "\n le numero de pti " << nut.nbPtInteg
                                        << " pour la grandeur  " << NomTypeQuelconque((*ite)) << " n'est pas valide  "
                                        << " pour la face " << nut.nbFA << "pour l'element "
                                        << nut.nbElem << " du maillage " << n_mail
                                        << ", car la face ne comporte que " << max_pti << " pti possible(s) "
                                        << " !!!! " << flush;
                                   veriflocal = false;
                                 };
                               };
                            }; //-- fin de la boucle sur les éléments de la référence
                         }; //-- fin de la boucle sur les grandeurs retenus
                       };
                      
                       // on enregistre si la vérification a été ok
                       if (veriflocal)
                         { tab_nomDeRef_F_ptinteg_SM(n_mail).push_back(refi->Nom());
                           tab_nomDeRef_F_ptinteg_SM(n_mail).sort(); // on ordonne
                           tab_nomDeRef_F_ptinteg_SM(n_mail).unique();// on supprime les doublons
                         };
                     }; // fin de la vérification
                    refi = lesRef->Reference_suivante();
                  };
               }
             else if (rep == "efrefF")
              { // on efface la liste des références d'éléments et la liste de pt d'integ associée
                (tab_nomDeRef_F_E_SM(n_mail)).clear();
              }
             else if (rep == "affrefF")
              { // affichage de la liste des références d'éléments enregistrées dans les maillages
                cout << "\n liste des references de face d'elements ";
                if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
                const Reference* reff =NULL; bool prempass = true;
                do {
                     if (prempass)
                       { reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
                     else
                       { reff = lesRef->Reference_suivante();} // récup de la ref courante
                     // sortie de la ref si c'est le bon maillage, et si c'est une ref de faces d'élément
                     if (reff != NULL)
                        if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 3)) cout << reff->Nom() << " ";
                     prempass = false;
                   } while (reff != NULL);
              }
             else if (rep == "efrefFpti")
              { // on efface la liste des références de pt d'integ de faces d'éléments
                (tab_nomDeRef_F_ptinteg_SM(n_mail)).clear();
              }
             else if (rep == "affrefFpti")
              { // affichage de la liste des références de pti enregistrées dans les maillages
                cout << "\n liste des references de pt integ de faces d'elements ";
                if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
                const Reference* reff =NULL; bool prempass = true;
                do {
                   if (prempass)
                     { reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
                   else
                     { reff = lesRef->Reference_suivante();} // récup de la ref courante
                   // sortie de la ref si c'est le bon maillage, et si c'est une ref de faces d'élément
                   if (reff != NULL)
                      if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 7)) cout << reff->Nom() << " ";
                   prempass = false;
                    } while (reff != NULL);
              }
             else
              { cout << "\n reponse non valide, recommencez " << endl;
              };
           };  // -- fin boucle choix
         };
        
       }; //-- fin de la boucle sur les maillages
  };
// entrée du choix pour les moyennes sommes etc. sur ref d'arête d'E
void Choix_grandeurs_maple::Entree_somme_moy_A_E(string& rep)
   { // cas de grandeurs aux arêtes d'éléments, on boucle sur les maillages
    //int dim = ParaGlob::Dimension();
    cout << "\n --- somme, moyenne, max, min etc. sur des references de aretes d'element et de pti ---";
    // on récupère la liste des maillages à visualiser
    const list <int>& list_mail = choix_mail->List_choisit();
    list<int>::const_iterator ilm,ilmfin=list_mail.end();
    int taille_list_maille = list_mail.size();
    if (list_mail.size() == 0)
      { cout << "\n aucun maillage n'est definit ! , il faut commencer par definir les maillages pour"
             << " lesquels on veut une sortie ";
        return;
      };
    // on balaie les différents maillages
    for (ilm = list_mail.begin();ilm!=ilmfin;ilm++)
       { int n_mail = abs(*ilm); // numéro du maillage
       
         // -- boucle sur les maillages
         // affichage du nom du maillages s'il y en a plusieurs
         if (taille_list_maille > 1)
           cout << "\n ======>>>>>   maillage : " << lesMail->NomMaillage(n_mail);

         // -------------- choix des grandeurs quelconques  définies aux arêtes d'éléments -----------------
         // def de la liste de travail qui contient les grandeurs à visualiser,
         // sert également pour vérifier que tous les grandeurs quelconques sont relatives
         // à un même point d'intégration
         List_io < EnumTypeQuelconque > li_enu_quelconque;
         {cout << "\n -------- cas des grandeurs quelconques definies aux aretes d'elements ---------";
          // dans le cas où aucune grandeur particulière sont défini on passe
          if ( (tab_A_element_TypeQuelconque(n_mail)).size() == 0)
           { cout << "\n aucune grandeur particuliere n'est definit, donc aucune proposition ";}
          else
           { // on affiche la liste actuelle
             if ((tab_A_element_TypeQuelconque_retenu_pourSM(n_mail)).size())
                { cout << "\n liste actuelle des aretes d'element a sortir en info: < (num_ele, num_arete) > ";
                  List_io <int>::iterator ieint,ieintfin = tab_num_A_element(n_mail).end();
                  List_io <int>::iterator ifint = tab_num_A(n_mail).begin();
                  for (ieint=tab_num_A_element(n_mail).begin();ieint!=ieintfin;ieint++,ifint++)
                    cout << " (" << (*ieint) << ", "<<(*ifint)<<") ";
                  cout << "\n liste des grandeurs particulieres actuellement a sortir:   ";
                  List_io < TypeQuelconque >::iterator iet,ietfin = (tab_A_element_TypeQuelconque_retenu_pourSM(n_mail)).end();
                  for (iet=(tab_A_element_TypeQuelconque_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
                    cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
                  cout << endl;
                };
             // on affiche les différentes grandeurs possibles
             cout << "\n maillage nb : " << n_mail ;
             cout << "\n la liste des grandeurs  disponibles est la suivante : ";
             List_io < TypeQuelconque >::iterator iet,ietfin = (tab_A_element_TypeQuelconque(n_mail)).end();
             for (iet=(tab_A_element_TypeQuelconque(n_mail)).begin();iet!=ietfin;iet++)
                        cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
             cout << "\n";
             cout << "\n grandeurs que vous voulez visualiser                         ( rep : grandeurs?)"
                  << "\n REMARQUE : il faut donner uniquement un jeu de grandeurs                        "
                  << "\n definies  au meme point d'integration                                           "
                  << "\n effacer la liste actuelle                                    (rep : ef)         "
                  << "\n toutes les grandeurs :                                       (rep : to)         "
                  << "\n                                               (pour terminer tapez : fin (ou f))";
             rep = "";
             while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
               { cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
                 if (rep == "to")
                  // cas de toutes les grandeurs
                  {List_io<TypeQuelconque>& tpg_ret = (tab_A_element_TypeQuelconque_retenu_pourSM(n_mail)); // pour simplifier
                   List_io<TypeQuelconque>& tpg = (tab_A_element_TypeQuelconque(n_mail)); // pour simplifier
                   List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
                   for (ite = tab_A_element_TypeQuelconque(n_mail).begin();ite != itefin; ite++)
                        if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
                          { tpg_ret.push_back(*ite);
                            // on enregistre également le EnumTypeQuelconque associé qui définit le point d'integ où est calculé la grandeur
                            // particulière
                            li_enu_quelconque.push_back((*ite).EnuTypeQuelconque().EnumTQ());
                           };
                  }
                 else if (TypeQuelconque_enum_etendu::VerifExistence(rep) ) // vérif que c'est une grandeur possible
                   { // maintenant on vérifie qu'elle appartient à la liste des grandeurs disponibles
                     TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
                     List_io<TypeQuelconque>& tpg_ret = (tab_A_element_TypeQuelconque_retenu_pourSM(n_mail)); // pour simplifier
                     List_io<TypeQuelconque>& tpg = (tab_A_element_TypeQuelconque(n_mail)); // pour simplifier
                     if (find(tpg.begin(),tpg.end(),a) != tpg.end())
                      { // il existe -> enregistrement
                        List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                        // s'il n'existe pas déjà on l'enregistre vraiment
                        if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                          { tpg_ret.push_back(*il);
                            // on enregistre l'enum quelconque associé qui définit le point d'integ où est calculé la grandeur
                            // particulière
                            li_enu_quelconque.push_back((*il).EnuTypeQuelconque().EnumTQ());
                           };
                       }
                     else
                      { cout << "\n erreur, grandeur non disponible !, recommencez ";};
                   }
                 else if (rep == "ef")
                  { // on efface la liste
                    (tab_A_element_TypeQuelconque_retenu_pourSM(n_mail)).clear();
                  }
                 else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                  cout << " erreur de syntaxe  recommencez ";
               };
           }; //-- fin du choix sur le fait qu'il existe ou non des grandeurs quelconques
         };
         // -------------- on s'occupe maintenant des références associées pour le calcul des sommes moy... -----------------
         {cout << "\n -------- definition des references de aretes d'elements ---------";
          // cas des références de arêtes d'élément
          if ((tab_nomDeRef_A_E_SM(n_mail)).size() != 0)
             { cout << "\n liste actuelle de reference de aretes d'elements : (nom refFE et num integ) ";
               List_io <BlocScal >::iterator ieint1,ieintfin1 = (tab_nomDeRef_A_E_SM(n_mail)).end();
               for (ieint1=(tab_nomDeRef_A_E_SM(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
                 cout << (*ieint1).NomRef() << " "<< (int) ((*ieint1).Val()) << " ";
               cout << endl;
             };
          // cas des références de point d'intégration d'arêtes d'élément
          if ((tab_nomDeRef_A_ptinteg_SM(n_mail)).size() != 0)
             { cout << "\n liste actuelle de reference de pt d'integration d'aretes d'element:  (nom refApti) ";
               List_io <string >::iterator ieint1,ieintfin1 = (tab_nomDeRef_A_ptinteg_SM(n_mail)).end();
               for (ieint1=(tab_nomDeRef_A_ptinteg_SM(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
                 cout << (*ieint1) << " ";
               cout << endl;
             };
          cout    << "\n choix d'une reference d'aretes d'element (avec 1 ou tous les pti)   -> (choix : refAE)"
                  << "\n (dans ce dernier cas il faut que toutes les aretes aient de meme type nbpti)           "
                  << "\n choix d'une reference de point d'integration d'aretes d'element     -> (choix : refApti)"
                  << "\n donnez le type de choix puis les infos correspondantes                            "
                  << "\n choix de tous les ref d'aretes d'elements                            -> (choix : torefAE)"
                  << "\n choix de tous les ref de pti d'aretes                                -> (choix : torefApti)"
                  << "\n effacer la liste actuelle des references d'aretes                    ->  (rep : efrefA) "
                  << "\n afficher la liste des references d'aretes existantes                 ->  (rep : affrefA) "
                  << "\n effacer la liste actuelle des references de pt integ d'aretes        ->  (rep : efrefApti) "
                  << "\n afficher la liste des references de pt integ d'aretes existantes     ->  (rep : affrefApti) "
                  << "\n                                                             (tapez fin pour finir(ou f))";
          string rep = "";
          // -- début boucle choix position sur element
          while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
           { cout << "\n choix ? ";rep = lect_return_defaut(false,"f");
             if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f")) break;
             // def du conteneur des numéros que l'on cherche
             // comme on peut en définir plusieurs d'un coup (par exemple tous les pti d'une arête d'élément) on utilise une liste
             list <Maillage::NBelemFAEtptInteg> list_nut; // à chaque passage elle est initialisée et donc vide au début
             Maillage::NBelemFAEtptInteg nut; // idem, initialisé à chaque passage
             if (rep == "refAE")
               { string nom_ref;
                 cout << "\n nom de la reference ? ";
                 nom_ref= lect_chaine();
                 // vérif que la référence existe
                 if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 4))
                   { cout << "\n erreur de nom (** "<< nom_ref << " **)  donne ne correspond pas a une reference d'aretes d'element correcte ";}
                 else
                   { // choix du point d'intégration, ici on ne va pas utiliser la liste list_nut, mais une liste particulière
                     string repo;
                     cout << " numero d'un point d'integration ou: -1 pour tous les pti ? ";
                     repo= lect_chaine(); nut.nbPtInteg = ChangeEntier(repo);
                     if (nut.nbPtInteg != -1) // cas d'un seul pti
                      {// on vérifie que ce point d'intégration est valide pour tous les arêtes de la référence
                       bool veriflocal = true;
                       //List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_A_E_SM(n_mail).end();
                       
                       // --- cas des types quelconques aux arêtes d'éléments
                       {List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
                        // boucle sur les grandeurs retenus
                        for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
                         { // recup de la reference correspondant au mot cle
                           const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                           const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'élément
                           int taillen=reff.Taille(); // nombre d'éléments dans la référence
                           for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                            { nut.nbElem = reff.NumeroElem(ielem);
                              nut.nbFA  = reff.NumeroFA(ielem);
                              Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
                              if (!ele.AreteExiste(nut.nbFA))
                               {cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                     << " du maillage "<< n_mail << " !!!" << flush ;
                                veriflocal = false;
                               }
                              else
                               {const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
                                int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
                                // vérification que le  point d'intégration est possible
                                if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
                                 { cout << "\n le numero de pti " << nut.nbPtInteg
                                        << " pour la grandeur  " << NomTypeQuelconque((*ite)) << " n'est pas valide  "
                                        << " pour l'arete " << nut.nbFA << "pour l'element "
                                        << nut.nbElem << " du maillage " << n_mail
                                        << ", car l'arete ne comporte que " << max_pti << " pti possible(s) "
                                        << " !!!! " << flush;
                                   veriflocal = false;
                                 };
                               };
                            }; //-- fin de la boucle sur les éléments de la référence
                         }; //-- fin de la boucle sur les grandeurs retenus
                       };
                       // --- on enregistre si la vérification a été ok
                       if (veriflocal)
                         { tab_nomDeRef_A_E_SM(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
                           tab_nomDeRef_A_E_SM(n_mail).sort(); // on ordonne
                           tab_nomDeRef_A_E_SM(n_mail).unique();// on supprime les doublons
                         };
                      }
                     else  // cas de tous les pti
                      { // il faut d'abord que l'on vérifie que tous les pti pour tous les arêtes d'élément sont valides
                        // .. on commence par tester si une première arête d'élément existe vraiment et si oui, on récupère le nb de pti associé
                        bool veriflocal = true;
                        int nbpti = 0; // init-> ensuite sera == au nombre de pti pour chaque élément
                        { // on encapsule pour pas de redondance de nom
                          const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                          const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'élément
                          int taillen=reff.Taille(); // nombre d'éléments dans la référence
                          if (taillen < 1) {veriflocal = false;} // cas d'une ref vide, on ne peut pas aller plus loin
                          else
                           {nut.nbElem = reff.NumeroElem(1);
                            nut.nbFA = reff.NumeroFA(1);
                            if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
                             {if (nut.nbElem < 0)
                                { cout << "\n le numero d'element (ici"<<nut.nbElem<<") doit etre superieur a 0 !!!";};
                              if (nut.nbElem > lesMail->Nombre_element(n_mail))
                                { cout << "\n chois non valide, le numero d'element (ici"<<nut.nbElem<<") doit etre inferieur ou egal "
                                       << "   au nombre total d'element du maillage ("<<lesMail->Nombre_element(n_mail)<<") !!!";
                                };
                              veriflocal = false;
                             }
                            else // sinon c'est ok, on continue au niveau des pti
                             {Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
                              // test si l'arête de l'élément  existe
                              if (!ele.AreteExiste(nut.nbFA))
                               {cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                     << " du maillage "<< n_mail << " !!!" << flush ;
                                veriflocal = false;
                               }
                              else
                               {const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
                                int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
                                List_io < TypeQuelconque >& li_quelc = tab_A_element_TypeQuelconque_retenu_pourSM(n_mail);
                                // on regarde si les listes ne sont pas toutes vides
                                if ((li_quelc.empty())&&(li_enu_quelconque.empty()))
                                  {// toutes les listes sont vides, on ne pourra pas aller plus loin
                                   veriflocal = false;
                                  }
                                else // sinon on peut continuer
                                  {nbpti = max_pti;};
                               };
                             }
                           };
                        };
                        // .. puis on balaie l'ensemble des arêtes et l'ensemble des pti
                        if (veriflocal)
                          {//List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_A_E_SM(n_mail).end();
                       
                           // --- cas des types quelconques aux arêtes d'éléments
                           {List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
                            // boucle sur les grandeurs retenus
                            for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
                             { // recup de la reference correspondant au mot cle
                               const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                               const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'élément
                               int taillen=reff.Taille(); // nombre d'éléments dans la référence
                               for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                                { nut.nbElem = reff.NumeroElem(ielem);
                                  nut.nbFA = reff.NumeroFA(ielem);
                                  Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
                                  if (!ele.AreteExiste(nut.nbFA))
                                   {cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                         << " du maillage "<< n_mail
                                         << " ceci pour la reference "<< reff.Nom()
                                         << " !!!" << flush ;
                                    veriflocal = false;
                                   }
                                  else
                                   {const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
                                    int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
                                    
                                    // vérification que l'on a le même nombre de pti
                                    if (max_pti != nbpti)
                                     { cout << "\n ---> traitement de la reference: "<<refi.Nom()<<" : ";
                                       cout << "\n l'arete "<<nut.nbFA<<" de l'element "<<nut.nbElem << " du maillage " << n_mail
                                            << " contient "<<max_pti<< " pti , alors qu'il en faudrait: "<<nbpti
                                            << "\n les faces sont donc differentes, on ne peut pas utiliser cette reference !! "
                                            << flush;
                                       veriflocal = false;
                                     };
                                    if (!veriflocal) break;
                                   };
                                }; //-- fin de la boucle sur les éléments de la référence
                               if (!veriflocal) break;
                             }; //-- fin de la boucle sur les ddl retenus
                           };
                          };
                       
                        // arrivée ici, si tout est ok on enregistre
                        if (veriflocal)
                            { nut.nbPtInteg = -1;
                              tab_nomDeRef_A_E_SM(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
                              tab_nomDeRef_A_E_SM(n_mail).sort(); // on ordonne
                              tab_nomDeRef_A_E_SM(n_mail).unique();// on supprime les doublons
                            };
                      };
                   }; // fin du choix du point d'intégration et de l'enregistrement
               }
             else if (rep == "refApti")
               { string nom_ref;
                 cout << "\n nom de la reference ? ";nom_ref= lect_chaine();
                 // vérif que la référence existe
                 if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 8))
                   { cout << "\n erreur de nom (** "<< nom_ref << " **)  donne ne correspond pas a une reference de point d'integration "
                          << " d'arete d'element correcte ";}
                 else
                   { // on vérifie que le choix est valide
                     bool veriflocal = true;
                     // --- cas des types quelconques aux éléments
                     {List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
                      // boucle sur les grandeurs retenus
                      for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
                       { // recup de la reference correspondant au mot cle
                         const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
                         const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref de pti d'arêtes d'élément
                         int taillen=reff.Taille(); // nombre d'éléments dans la référence
                         for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les arêtes de la référence
                          { nut.nbElem = reff.NumeroElem(ielem);
                            nut.nbFA = reff.NumeroFA(ielem);
                            nut.nbPtInteg = reff.NumeroPti(ielem);
                            
                            Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
                            if (!ele.AreteExiste(nut.nbFA))
                             {cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                   << " du maillage "<< n_mail
                                   << " ceci pour la reference "<< reff.Nom()
                                   << " !!!" << flush ;
                              veriflocal = false;
                             }
                            else
                             { const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
                               int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
                               // vérification que le  point d'intégration est possible
                               if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
                                { cout << "\n le numero de pti " << nut.nbPtInteg
                                       << " pour la grandeur  " << NomTypeQuelconque((*ite)) << " n'est pas valide  "
                                       << " pour l'arete' " << nut.nbFA << "pour l'element "
                                       << nut.nbElem << " du maillage " << n_mail
                                       << ", car l'arete ne comporte que " << max_pti << " pti possible(s) "
                                       << " !!!! " << flush;
                                  veriflocal = false;
                                };
                             };
                          }; //-- fin de la boucle sur les éléments de la référence
                       }; //-- fin de la boucle sur les grandeurs retenus
                     };
                    
                     // on enregistre si la vérification a été ok
                     if (veriflocal)
                       { tab_nomDeRef_A_ptinteg_SM(n_mail).push_back(nom_ref);
                         tab_nomDeRef_A_ptinteg_SM(n_mail).sort(); // on ordonne
                         tab_nomDeRef_A_ptinteg_SM(n_mail).unique();// on supprime les doublons
                       };
                   }; // fin de la vérification
                }
             else if (rep == "torefAE")
               { // on va balayer toutes les références
                 const Reference* refi = lesRef->Init_et_Premiere();
                 list <string> inter;
                 while (refi != NULL)
                  { if (refi->Indic() == 4)
                      inter.push_back(refi->Nom());
                    refi = lesRef->Reference_suivante();
                  };
                 // maintenant on va indiquer les pti
                 // choix du point d'intégration, ici on ne va pas utiliser la liste list_nut, mais une liste particulière
                 string repo;
                 cout << " numero d'un point d'integration ou: -1 pour tous les pti ? ";
                 repo= lect_chaine(); nut.nbPtInteg = ChangeEntier(repo);
                 list <string>::iterator il,ilfin=inter.end();
                 if (nut.nbPtInteg != -1) // cas d'un seul pti
                   { bool veriflocal = true;
                     for (il = inter.begin();il != ilfin; il++)
                        {// on vérifie que ce point d'intégration est valide pour toutes les arêtes d'éléments de la référence
                         // --- cas des types quelconques aux arêtes d'éléments
                         {List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
                          // boucle sur les grandeurs retenus
                          for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
                           { // recup de la reference correspondant au mot cle
                             const Reference& refi = lesRef->Trouve((*il),n_mail);
                             const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'élément
                             int taillen=reff.Taille(); // nombre d'éléments dans la référence
                             for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                              { nut.nbElem = reff.NumeroElem(ielem);
                                nut.nbFA  = reff.NumeroFA(ielem);
                                Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
                                if (!ele.AreteExiste(nut.nbFA))
                                 {cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                       << " du maillage "<< n_mail
                                       << " ceci pour la reference " << reff.Nom()
                                       << " !!!" << flush ;
                                  veriflocal = false;
                                 }
                                else
                                 {const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
                                  int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
                                  // vérification que le  point d'intégration est possible
                                  if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
                                   { cout << "\n le numero de pti " << nut.nbPtInteg
                                          << " pour la grandeur  " << NomTypeQuelconque((*ite)) << " n'est pas valide  "
                                          << " pour l'arete " << nut.nbFA << "pour l'element "
                                          << nut.nbElem << " du maillage " << n_mail
                                          << ", car l'arete ne comporte que " << max_pti << " pti possible(s) "
                                          << " !!!! " << flush;
                                     veriflocal = false;
                                   };
                                 };
                              }; //-- fin de la boucle sur les éléments de la référence
                           }; //-- fin de la boucle sur les ddl retenus
                         };
                        };
                     // --- on enregistre si la vérification a été ok
                     if (veriflocal)
                      for (il = inter.begin();il != ilfin; il++)
                        { tab_nomDeRef_A_E_SM(n_mail).push_back(BlocScal((*il),nut.nbPtInteg));
                           tab_nomDeRef_A_E_SM(n_mail).sort(); // on ordonne
                           tab_nomDeRef_A_E_SM(n_mail).unique();// on supprime les doublons
                         };
                     }
                 else  // cas de tous les pti
                   { bool veriflocal = true;
                     for (il = inter.begin();il != ilfin; il++)
                        { // il faut d'abord que l'on vérifie que tous les pti pour tous les éléments sont valides
                          // .. on commence par tester si une première arête d'élément existe vraiment et si oui, on récupère le nb de pti associé
                          int nbpti = 0; // init-> ensuite sera == au nombre de pti pour chaque élément
                          { // on encapsule pour pas de redondance de nom
                            const Reference& refi = lesRef->Trouve((*il),n_mail);
                            const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'élément
                            int taillen=reff.Taille(); // nombre d'éléments dans la référence
                            if (taillen < 1) {veriflocal = false;} // cas d'une ref vide, on ne peut pas aller plus loin
                            else
                             {nut.nbElem = reff.NumeroElem(1);
                              nut.nbFA = reff.NumeroFA(1);
                              if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
                               {if (nut.nbElem < 0)
                                  { cout << "\n le numero d'element doit etre superieur a 0 !!!";};
                                if (nut.nbElem > lesMail->Nombre_element(n_mail))
                                  { cout << "\n chois non valide, le numero d'element doit etre inferieur ou egal "
                                         << "   au nombre total d'element du maillage !!!";
                                  };
                                veriflocal = false;
                               }
                              else // sinon c'est ok, on continue au niveau des pti
                               {Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
                                // test si l'arete de l'élément  existe
                                if (!ele.AreteExiste(nut.nbFA))
                                 {cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                       << " du maillage "<< n_mail << " !!!" << flush ;
                                  veriflocal = false;
                                 }
                                else
                                 {const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
                                  int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
                                  List_io < TypeQuelconque >& li_quelc = tab_A_element_TypeQuelconque_retenu_pourSM(n_mail);
                                  // on regarde si les listes ne sont pas toutes vides
                                  if ((li_quelc.empty())&&(li_enu_quelconque.empty()))
                                    {// toutes les listes sont vides, on ne pourra pas aller plus loin
                                     veriflocal = false;
                                    }
                                  else // sinon on peut continuer
                                    {nbpti = max_pti;};
                                 };
                               };
                             };
                          };
                          // .. puis on balaie l'ensemble des éléments et l'ensemble des pti
                          if (veriflocal)
                            {// --- cas des types quelconques aux arêtes d'éléments
                             {List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
                              // boucle sur les grandeurs retenus
                              for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
                               { // recup de la reference correspondant au mot cle
                                 const Reference& refi = lesRef->Trouve((*il),n_mail);
                                 const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'élément
                                 int taillen=reff.Taille(); // nombre d'éléments dans la référence
                                 for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                                  {nut.nbElem = reff.NumeroElem(ielem);
                                   nut.nbFA = reff.NumeroFA(ielem);
                                   Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
                                   const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
                                   if (!ele.AreteExiste(nut.nbFA))
                                    {cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                          << " du maillage "<< n_mail
                                          << " ceci pour la reference " << reff.Nom()
                                          << " !!!" << flush ;
                                     veriflocal = false;break;
                                    }
                                   else
                                    {int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
                                     // vérification que l'on a le même nombre de pti
                                     if (max_pti != nbpti)
                                      { cout << "\n ---> traitement de la reference: "<<refi.Nom()<<" : ";
                                        cout << "\n l'arete "<<nut.nbFA<<" de l'element "<<nut.nbElem << " du maillage " << n_mail
                                             << " contient "<<max_pti<< " pti , alors qu'il en faudrait: "<<nbpti
                                             << "\n les aretes sont donc differentes, on ne peut pas utiliser cette reference !! "
                                             << flush;
                                        veriflocal = false;
                                      };
                                     if (!veriflocal) break;
                                    };
                                  }; //-- fin de la boucle sur les éléments de la référence
                                 if (!veriflocal) break;
                               }; //-- fin de la boucle sur les ddl retenus
                             };
                            };
                        };
                     // arrivée ici, si tout est ok on enregistre
                     if (veriflocal)
                      for (il = inter.begin();il != ilfin; il++)
                         { nut.nbPtInteg = -1;
                           tab_nomDeRef_A_E_SM(n_mail).push_back(BlocScal((*il),nut.nbPtInteg));
                           tab_nomDeRef_A_E_SM(n_mail).sort(); // on ordonne
                           tab_nomDeRef_A_E_SM(n_mail).unique();// on supprime les doublons
                         };
                   };
               }
             else if (rep == "torefApti")
               { // on va balayer tous les références
                 const Reference* refi = lesRef->Init_et_Premiere();
                 while (refi != NULL)
                  { if (refi->Indic() == 8)
                     { // on vérifie que le choix est valide
                       bool veriflocal = true;
                      
                       // --- cas des types quelconques aux arêtes d'éléments
                       {List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
                        // boucle sur les ddl retenus
                        for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
                         { // recup de la reference correspondant au mot cle
                           const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref d'arêtes d'élément
                           int taillen=reff.Taille(); // nombre d'éléments dans la référence
                           for (int ielem=1;ielem<=taillen;ielem++)  // on boucle sur les éléments de la référence
                            { nut.nbElem = reff.NumeroElem(ielem);
                              nut.nbFA = reff.NumeroFA(ielem);
                              nut.nbPtInteg = reff.NumeroPti(ielem);
                              
                              Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
                              if (!ele.AreteExiste(nut.nbFA))
                               {cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
                                     << " du maillage "<< n_mail
                                     << " ceci pour la reference " << reff.Nom()
                                     << " !!!" << flush ;
                                veriflocal = false;
                               }
                              else
                               { const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
                                 int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
                                 // vérification que le  point d'intégration est possible
                                 if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
                                  { cout << "\n le numero de pti " << nut.nbPtInteg
                                         << " pour la grandeur  " << NomTypeQuelconque((*ite)) << " n'est pas valide  "
                                         << " pour l'arete " << nut.nbFA << "pour l'element "
                                         << nut.nbElem << " du maillage " << n_mail
                                         << ", car l'arete ne comporte que " << max_pti << " pti possible(s) "
                                         << " !!!! " << flush;
                                    veriflocal = false;
                                  };
                               };
                            }; //-- fin de la boucle sur les éléments de la référence
                         }; //-- fin de la boucle sur les ddl retenus
                       };
                      
                       // on enregistre si la vérification a été ok
                       if (veriflocal)
                         { tab_nomDeRef_A_ptinteg_SM(n_mail).push_back(refi->Nom());
                           tab_nomDeRef_A_ptinteg_SM(n_mail).sort(); // on ordonne
                           tab_nomDeRef_A_ptinteg_SM(n_mail).unique();// on supprime les doublons
                         };
                     }; // fin de la vérification
                    refi = lesRef->Reference_suivante();
                  };
               }
             else if (rep == "efrefA")
              { // on efface la liste des références d'éléments et la liste de pt d'integ associée
                (tab_nomDeRef_A_E_SM(n_mail)).clear();
              }
             else if (rep == "affrefA")
              { // affichage de la liste des références d'éléments enregistrées dans les maillages
                cout << "\n liste des references d'aretes d'elements ";
                if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
                const Reference* reff =NULL; bool prempass = true;
                do {
                     if (prempass)
                       { reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
                     else
                       { reff = lesRef->Reference_suivante();} // récup de la ref courante
                     // sortie de la ref si c'est le bon maillage, et si c'est une ref d'arêtes d'élément
                     if (reff != NULL)
                        if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 4)) cout << reff->Nom() << " ";
                     prempass = false;
                   } while (reff != NULL);
              }
             else if (rep == "efrefApti")
              { // on efface la liste des références de pt d'integ d'arêtes d'éléments
                (tab_nomDeRef_A_ptinteg_SM(n_mail)).clear();
              }
             else if (rep == "affrefApti")
              { // affichage de la liste des références de pti enregistrées dans les maillages
                cout << "\n liste des references de pt integ d'aretes d'elements ";
                if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
                const Reference* reff =NULL; bool prempass = true;
                do {
                   if (prempass)
                     { reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
                   else
                     { reff = lesRef->Reference_suivante();} // récup de la ref courante
                   // sortie de la ref si c'est le bon maillage, et si c'est une ref d'arêtes d'élément
                   if (reff != NULL)
                      if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 8)) cout << reff->Nom() << " ";
                   prempass = false;
                    } while (reff != NULL);
              }
             else
              { cout << "\n reponse non valide, recommencez " << endl;
              };
           };  // -- fin boucle choix
         };
        
       }; //-- fin de la boucle sur les maillages
  };

// entrée du choix pour les moyennes sommes etc. sur ref N
void Choix_grandeurs_maple::Entree_somme_moy_N(string& rep)
  { // cas de grandeurs aux noeuds, on boucle sur les maillages
    //int dim = ParaGlob::Dimension();
    cout << "\n --- somme, moyenne, max, min etc. sur des references de noeuds ---";
    // on récupère la liste des maillages à visualiser
    const list <int>& list_mail = choix_mail->List_choisit();
    list<int>::const_iterator ilm,ilmfin=list_mail.end();
    int taille_list_maille = list_mail.size();
    if (list_mail.size() == 0)
      { cout << "\n aucun maillage n'est definit ! , il faut commencer par definir les maillages pour"
             << " lesquels on veut une sortie ";
        return;
      };
    // on balaie les différents maillages
    for (ilm = list_mail.begin();ilm!=ilmfin;ilm++)
       {int n_mail = abs(*ilm); // numéro du maillage  
        // -- boucle sur les maillages
        // affichage du nom du maillages s'il y en a plusieurs
        if (taille_list_maille > 1)
          cout << "\n ======>>>>>   maillage : " << lesMail->NomMaillage(n_mail);

        // -------------- cas des ddl principaux définis aux noeuds -----------------
        {cout << "\n -------- cas des ddl principaux definis aux noeuds ---------";
         // on affiche la liste actuelle des grandeurs si elle n'est pas vide
         if ((tabnoeud_type_ddl_retenu_pourSM(n_mail)).size())
           { cout << "\n liste des grandeurs actuellement a sortir:   ";  
             List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabnoeud_type_ddl_retenu_pourSM(n_mail)).end();
             for (iet=(tabnoeud_type_ddl_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
                 cout << (*iet) << " " ;
             }
         // on affiche les différentes grandeurs possibles
         cout << "\n maillage nb : " << n_mail ;
         cout << "\n la liste des grandeurs disponibles est la suivante : ";
         List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabnoeud_type_ddl(n_mail)).end();
         for (iet=(tabnoeud_type_ddl(n_mail)).begin();iet!=ietfin;iet++)
                cout << (*iet) << " " ;
                //      if ((*iet).Nom_vide()) cout << Nom_ddl((*iet).Enum()) << " "; else  cout << (*iet).Nom() << " ";
         cout << "\n donnez la ou les grandeurs que vous voulez traiter   (rep grandeurs?)   "
              << "\n ou toutes les grandeurs sans les reactions            (rep : to)         "
              << "\n ou toutes les grandeurs                               (rep : tr)         "
              << "\n effacer la liste actuelle                             (rep : ef)         "
              << "\n                                       (pour terminer tapez : fin (ou f)) ";
         rep = "";
         while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
            { cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
              if (rep == "to")
              // cas de toutes les grandeurs sans les réactions
              {List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddl(n_mail).end();
               for (ite = tabnoeud_type_ddl(n_mail).begin();ite != itefin; ite++)
                 if ( !Ddl_reaction((*ite).Enum()))
                       tabnoeud_type_ddl_retenu_pourSM(n_mail).push_back(*ite);
               tabnoeud_type_ddl_retenu_pourSM(n_mail).sort(); // on ordonne
               tabnoeud_type_ddl_retenu_pourSM(n_mail).unique();// on supprime les doublons
               }  
              else if (rep == "tr")
              // cas de toutes les grandeurs avec les réactions
              {List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddl(n_mail).end();
               for (ite = tabnoeud_type_ddl(n_mail).begin();ite != itefin; ite++)
                       tabnoeud_type_ddl_retenu_pourSM(n_mail).push_back(*ite);
               tabnoeud_type_ddl_retenu_pourSM(n_mail).sort(); // on ordonne
               tabnoeud_type_ddl_retenu_pourSM(n_mail).unique();// on supprime les doublons
              }
              else if (ExisteEnum_ddl(rep))
               { // on vérifie qu'il appartiend à la liste des ddl proposés
                 Enum_ddl enume=Id_nom_ddl (rep);
                 Ddl_enum_etendu enu_etendu(enume);
                 if (Ddl_enum_etendu::Existe_dans_la_liste(tabnoeud_type_ddl(n_mail),enu_etendu))
                     { (tabnoeud_type_ddl_retenu_pourSM(n_mail)).push_back(enu_etendu);
                       tabnoeud_type_ddl_retenu_pourSM(n_mail).sort(); // on ordonne
                       (tabnoeud_type_ddl_retenu_pourSM(n_mail)).unique(); // supprime le doublon si nécessaire
                      }
                 else     
                   cout << " erreur de choix de ddl, celui choisit n'appartient pas a la liste propose";
               }
              else if (rep == "ef") 
               { // on efface la liste
                 (tabnoeud_type_ddl_retenu_pourSM(n_mail)).clear();
                }
              else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
               cout << " erreur de syntaxe dans le ddl! recommencez ";
            };
                  
        };
        // -------------- cas des ddl étendus définis aux noeuds -----------------
        {cout << "\n -------- cas des ddl etendus definis aux noeuds ---------";
         // on affiche la liste actuelle des grandeurs si elle n'est pas vide
         if ((tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail)).size())
            { cout << "\n liste des grandeurs actuellement a sortir:   ";  
              List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail)).end();
              for (iet=(tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
                cout << (*iet) << " " ;
            };
         // on affiche les différentes grandeurs possibles
         cout << "\n maillage nb : " << n_mail ;
         cout << "\n la liste des grandeurs disponibles est la suivante : ";
         List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabnoeud_type_ddlEtendu(n_mail)).end();
         for (iet=(tabnoeud_type_ddlEtendu(n_mail)).begin();iet!=ietfin;iet++)
              cout << (*iet) << " " ;
         cout << "\n donnez la ou les grandeurs que vous voulez visualiser (rep grandeurs?)   "
              << "\n ou toutes les grandeurs sans les reactions            (rep : to)         "
              << "\n ou toutes les grandeurs                               (rep : tr)         "
              << "\n effacer la liste actuelle                             (rep : ef)         "
              << "\n                                       (pour terminer tapez : fin (ou f)) ";
         rep = "";
         while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
          {cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
           if (rep == "to")
              // cas de toutes les grandeurs sans les réactions
              {List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddlEtendu(n_mail).end();
               for (ite = tabnoeud_type_ddlEtendu(n_mail).begin();ite != itefin; ite++)
                 if ( !Ddl_reaction((*ite).Enum()))
                       tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).push_back(*ite);
               tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).sort(); // on ordonne
               tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).unique();// on supprime les doublons
              }
           else if (rep == "tr")
              // cas de toutes les grandeurs avec les réactions
              {List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddlEtendu(n_mail).end();
               for (ite = tabnoeud_type_ddlEtendu(n_mail).begin();ite != itefin; ite++)
                       tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).push_back(*ite);
               tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).sort(); // on ordonne
               tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).unique();// on supprime les doublons
              }
           else if (Ddl_enum_etendu::VerifExistence(rep))
                { // on vérifie qu'il appartiend à la liste des ddl étendus proposés
                  Ddl_enum_etendu enu_etendu(rep);
                  if (Ddl_enum_etendu::Existe_dans_la_liste(tabnoeud_type_ddlEtendu(n_mail),enu_etendu))
                      { (tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail)).push_back(enu_etendu);
                        tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).sort(); // on ordonne
                        (tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail)).unique(); // supprime le doublon si nécessaire
                       }
                  else     
                    cout << " erreur de choix de ddl, celui choisit n'appartient pas a la liste propose";
                }
            else if (rep == "ef") 
                { // on efface la liste
                  (tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail)).clear();
                }
            else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                cout << " erreur de syntaxe dans le ddl! recommencez ";
          };
        };
        // -------------- cas des grandeurs quelconques définis aux noeuds -----------------
        {cout << "\n -------- cas des grandeurs quelconques definies aux noeuds ---------";
         // dans le cas où aucune grandeur particulière sont défini on passe
         if (   ((tabnoeud_TypeQuelconque(n_mail)).size() == 0)
           && (listeVecGlobbal.size() == 0))
           { cout << "\n aucune grandeur particuliere n'est definit, donc aucune proposition ";}
         else
           { // def d'une liste de travail, pour vérifier que tous les grandeurs particuliers sont relatives
             // à un même point d'intégration
             List_io < Ddl_enum_etendu > li_ddl; 
             // on affiche la liste actuelle des grandeurs enregistrées
             if ((tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)).size())
                { cout << "\n liste des grandeurs particulieres actuellement a sortir:   ";  
                  List_io < TypeQuelconque >::iterator iet,ietfin = (tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)).end();
                  for (iet=(tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
                    cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
                  cout << endl;  
                };
             // on affiche les différentes grandeurs possibles
             cout << "\n maillage nb : " << n_mail ;
             cout << "\n la liste des grandeurs particulieres disponibles est la suivante : ";
             // tout d'abord celles venant du maillage
             {List_io < TypeQuelconque >::iterator iet,ietfin = (tabnoeud_TypeQuelconque(n_mail)).end();
              for (iet=(tabnoeud_TypeQuelconque(n_mail)).begin();iet!=ietfin;iet++)
                        cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
             };
             // puis celles venant de l'algorithme
             {List_io < TypeQuelconque >::iterator iet,ietfin = listeVecGlobbal.end();
              List_io<TypeQuelconque>& tpg = (tabnoeud_TypeQuelconque(n_mail));
              for (iet=listeVecGlobbal.begin();iet!=ietfin;iet++)
                  { if ( find(tpg.begin(),tpg.end(),(*iet)) == tpg.end()) // on ne sort que si ça n'a pas déjà été sorti
                        cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
                  };
             };
             cout << "\n";
             cout << "\n grandeurs que vous voulez visualiser                         (rep : grandeurs?)"
                  << "\n effacer la liste actuelle                                    (rep : ef)         "
                  << "\n toutes les grandeurs :                                       (rep : to)         "
                  << "\n                                               (pour terminer tapez : fin (ou f))";
             rep = "";
             while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                { cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
                  // -- cas de toutes les grandeurs
                  if (rep == "to")
                   {// tout d'abord celles venant du maillage
                    {List_io<TypeQuelconque>& tpg_ret = (tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)); // pour simplifier
                     List_io<TypeQuelconque>& tpg = (tabnoeud_TypeQuelconque(n_mail)); // pour simplifier
                     List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
                     for (ite = tabnoeud_TypeQuelconque(n_mail).begin();ite != itefin; ite++)
                         if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
                           { tpg_ret.push_back(*ite);};
                    };
                    // puis celles venant de l'algorithme
                    {List_io<TypeQuelconque>& tpg_ret = (tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)); // pour simplifier
                     List_io<TypeQuelconque>& tpg = listeVecGlobbal; // pour simplifier
                     List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
                     for (ite = listeVecGlobbal.begin();ite != itefin; ite++)
                         if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
                           { tpg_ret.push_back(*ite);
                             listeVecGlobbal_retenu.push_back(*ite); // sert pour ajouter les conteneurs aux noeuds
                           };
                     // on sort un message pour indiquer que les grandeurs globales ne seront
                     // disponible qu'au fil du calcul
                     {cout << "\n ---- attention, les grandeurs suivantes ne sont disponibles qu'au fil du calcul ----";
                      List_io < TypeQuelconque >::iterator iet,ietfin = listeVecGlobbal.end();
                      for (iet=listeVecGlobbal.begin();iet!=ietfin;iet++)
                           cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
                     };
                    };
                   }  
                  // -- cas d'une grandeur particulière
                  else if (TypeQuelconque_enum_etendu::VerifExistence(rep) ) // vérif que c'est une grandeur possible
                   {// maintenant on vérifie qu'elle appartient à la liste des grandeurs disponibles
                    TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
                    bool trouve=false; // init pour le message d'erreur
                    // tout d'abord vérif pour celles venant du maillage
                    {List_io<TypeQuelconque>& tpg_ret = (tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)); // pour simplifier
                     List_io<TypeQuelconque>& tpg = (tabnoeud_TypeQuelconque(n_mail)); // pour simplifier
                     if (find(tpg.begin(),tpg.end(),a) != tpg.end())
                     { // il existe -> enregistrement
                       List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                       // s'il n'existe pas déjà on l'enregistre vraiment
                       if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                         { tpg_ret.push_back(*il);};
                       trouve = true; // on a bien trouvé une grandeur
                     };
                    };
                    // puis  vérif pour celles venant de l'algorithme
                    {List_io<TypeQuelconque>& tpg_ret = (tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)); // pour simplifier
                     List_io<TypeQuelconque>& tpg = listeVecGlobbal; // pour simplifier
                     if (find(tpg.begin(),tpg.end(),a) != tpg.end())
                     { // il existe -> enregistrement
                       List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                       // s'il n'existe pas déjà on l'enregistre vraiment
                       if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                         { tpg_ret.push_back(*il);
                           listeVecGlobbal_retenu.push_back(*il); // sert pour ajouter les conteneurs aux noeuds
                         };
                       trouve = true; // on a bien trouvé une grandeur
                       // on sort un message pour indiquer que la grandeur globale ne sera
                       // disponible qu'au fil du calcul
                       {cout << "\n ---- attention, la grandeur suivante ne sera disponible qu'au fil du calcul ----";
                        cout << "\n " << ((*il).EnuTypeQuelconque().NomPlein()) ;
                       };
                     };
                    };
                    if (!trouve)
                     { cout << "\n erreur, grandeur non disponible !, recommencez ";};
                   }
                  // -- cas où on veut effacer la liste
                  else if (rep == "ef") 
                   {(tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)).clear();
                    listeVecGlobbal_retenu.clear();
                   }
                  // -- cas fin
                  else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
                   cout << " erreur de syntaxe  recommencez ";
                };
             // affichage des infos actuellement enregistrées
             if ( (tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)).size() != 0)
               { cout << "\n liste des grandeurs particulieres enregistrees:   ";  
                 List_io < TypeQuelconque >::iterator iet,ietfin = (tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)).end();
                 for (iet=(tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
                     cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
                 cout << endl;  
               }
             else
               { cout << "\n aucune grandeur enregistree ! \n "; };
           }; //-- fin du choix sur le fait qu'il existe ou non des grandeurs particulières pour le maillage
        };

        // -------------- on s'occupe maintenant des références associées -----------------
        {cout << "\n -------- definition des references de noeuds ---------";
         // choix des références des noeuds, on affiche la liste actuelle
         if ((tab_nomDeRef_SM(n_mail)).size() != 0)
          { cout << "\n liste actuelle des reference de noeuds a traiter:   ";
            List_io <string >::iterator ieint1,ieintfin1 = (tab_nomDeRef_SM(n_mail)).end();
            for (ieint1=(tab_nomDeRef_SM(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
              cout << *ieint1 << " ";
            cout << endl;  
          };
         // questions
         cout << "\n choix des references de noeuds a traiter "
              << "\n nouvelle reference de liste de noeuds                      (rep  : neref)"
              << "\n effacer la liste actuelle des references de noeuds          (rep : efref) "
              << "\n afficher la liste des references de noeuds existants        (rep : affref) "                    
              << "\n                                                (pour finir tapez : fin (ou f))";
         rep = "";
         while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
         { cout << "\n choix ? ";rep = lect_return_defaut(false,"f");
           bool verif = true; // pour la vérification du numéro du noeud
           int nu=0 ; // le numéro de noeud
           if (rep =="neref")
             { string nom_ref;
               cout << "\n nom de la reference ? ";nom_ref= lect_chaine();
               // vérif que la référence existe
               if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 1))
                 { cout << "\n erreur de nom donne (** "<< nom_ref << " **)  ne correspond pas a une reference de noeud correcte ";}
               else // on enregistre
                 { const ReferenceNE & ref =((ReferenceNE &) lesRef->Trouve(nom_ref,n_mail)); // pour simplifier
                   if (ref.Taille() == 0)
                     { cout << "\n il n'y a aucun noeud dans la ref (** "<< nom_ref << " **)  on n'en tient pas compte ";}
                   else
                     {tab_nomDeRef_SM(n_mail).push_back(nom_ref);
                      tab_nomDeRef_SM(n_mail).sort(); // on ordonne
                      tab_nomDeRef_SM(n_mail).unique();// on supprime les doublons
                      nu = ref.Numero(1); // servira ensuite pour la vérif de ddl
                     };
                 };
               verif = false; // pour ne pas enregistrer de numéro dans la liste de noeud car ici c'est 
                              // la liste de référence de noeud qui est en cause
             }
           else if (rep == "efref")
            { // on efface la liste des références de noeuds
              (tab_nomDeRef_SM(n_mail)).clear();
              verif = false;                                                                
            }
           else if (rep == "affref")
            { // affichage de la liste des références enregistrées dans les maillages
              cout << "\n liste des references de noeuds ";
              if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
              const Reference* reff =NULL; bool prempass = true;
              do { 
                 if (prempass)
                   { reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
                 else
                   { reff = lesRef->Reference_suivante();} // récup de la ref courante  
                 // sortie de la ref si c'est le bon maillage, et si c'est une ref de noeud
                 if (reff != NULL)
                    if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 1)) cout << reff->Nom() << " ";
                 prempass = false; 
                  } while (reff != NULL);
               verif = false;    
            }
           else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
             { cout << " erreur de syntaxe on attendait on a lue: " << rep << " ! recommencez ";verif = false;};
           // vérif que le numéro est acceptable et enregistrement
           if ((nu>0)&&(nu<=lesMail->Nombre_noeud(n_mail))) 
            { // on vérifie que les ddls à sortir sont bien présent pour ce noeud
              List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabnoeud_type_ddl_retenu_pourSM(n_mail).end();
              for (ienu = tabnoeud_type_ddl_retenu_pourSM(n_mail).begin();ienu!=ienufin;ienu++)
                {if ( (!(lesMail->Noeud_LesMaille(n_mail,nu).Existe_ici((*ienu).Enum())))  // cas où le ddl principal n'existe pas
                     && (!(lesMail->Noeud_LesMaille(n_mail,nu).Existe_ici_ddlEtendu((*ienu))))) // cas où le ddl étendu n'existe pas
                  {cout << "\n attention le ddl " << Nom_ddl((*ienu).Enum()) << " n'existe pas pour le noeud " 
                        << nu << " du maillage " << n_mail 
                        << "\n il y aura 0 en sortie ! ";
                   verif = true;     
                   } 
                 } 
            };
         }
        };
       }// -- fin de la boucle sur les maillages
  }; // -- fin du cas des ddl principaux aux noeuds

 
// sortie pour les moyennes sommes etc. sur ref N
void Choix_grandeurs_maple::Sortie_somme_moy_N(ostream &sort,Charge* charge,bool unseul_incre)
{ // on boucle sur les maillages
  int nb_maillage = tabnoeud_type_ddl.Taille();
  for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
    {
     // ---- préparation des conteneurs de sortie
     int NB_ref = tab_nomDeRef_SM(n_mail).size(); // = le nombre de ref
     // on ne continue que s'il existe des ref
     if (NB_ref)
      {
       // les ddl étendue des grandeurs principales -> grandeurs scalaires
       List_io < Ddl_enum_etendu > &type_ddl_retenu_pourSM = tabnoeud_type_ddl_retenu_pourSM(n_mail);
       int nb_ddl = type_ddl_retenu_pourSM.size();
       // on veut : (1) la somme, (2) la moyenne, (3) le max, (4) le min, (5) le max des | | , (6) le min des | |
       // tab_tab_pour_ddl_etendu(i)(j)(k) : la grandeur k pour le ddl etendu j de la ref i
       // tab_tab_pour_MAXI_ddl_etendu(i)(j)(k) : k= 1 -> le numéro du noeud pour le max
       //                                         k= 2 -> le numéro du noeud pour le min
       //                                         k= 3 -> le numéro du noeud pour le max des | |
       //                                         k= 4 -> le numéro du noeud pour le min des | |
       Tableau <double > t6(6); t6(4)=t6(6)=ConstMath::tresgrand; // on met les mini très grand
       Tableau <Tableau <double > > toto6(nb_ddl,t6);
       Tableau < Tableau <Tableau <double > > > tab_tab_pour_ddl(NB_ref,toto6);
       Tableau <Tableau <int > > titi4(nb_ddl,4);
       Tableau < Tableau <Tableau <int > > > tab_tab_pour_MAXI_ddl(NB_ref,titi4);
       
       // idem pour les ddl étendus pour les grandeurs étendues -> grandeurs scalaires
       List_io < Ddl_enum_etendu > &type_ddlEtendu_retenu_pourSM = tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail);
       int nb_ddl_etendu = type_ddlEtendu_retenu_pourSM.size();
       Tableau <Tableau <double > > toto66(nb_ddl_etendu,t6);
       Tableau < Tableau <Tableau <double > > > tab_tab_pour_ddl_etendu(NB_ref,toto66);
       Tableau <Tableau <int > > titi44(nb_ddl_etendu,4);
       Tableau < Tableau <Tableau <int > > > tab_tab_pour_MAXI_ddl_etendu(NB_ref,titi44);

       // pour les grandeurs quelconques, on ne considère que la somme et la moyenne des grandeurs brutes
       List_io < TypeQuelconque > &TypeQuelconque_retenu_pourSM = tabnoeud_TypeQuelconque_retenu_pourSM(n_mail);
       int nb_TypeQuelconque = TypeQuelconque_retenu_pourSM.size();
       Tableau < Tableau <double > > tab_inter(nb_TypeQuelconque); // pour le dimensionnement final
       // on dimensionne en fonction de la taille de la grandeur quelconque
       {List_io<TypeQuelconque>::iterator ienu,ienufin=TypeQuelconque_retenu_pourSM.end();
        int num_enu = 1;
        for (ienu = TypeQuelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
           {int nb_val = (*ienu).NbMaxiNumeroOrdre();
            Tableau <double > & inter = tab_inter(num_enu);
            inter.Change_taille(nb_val);
           };
       };
       Tableau < Tableau <Tableau <double > > >  tab_tab_pour_Quelconque(NB_ref,tab_inter);
       Tableau < int > tab_ref_taille(NB_ref);
       
       // ---- on balaie les références de listes de noeuds pour récupérer les informations
       int num_ref=1;
       List_io <string >::iterator idl,idlfin= tab_nomDeRef_SM(n_mail).end();
       for (idl=tab_nomDeRef_SM(n_mail).begin();idl!=idlfin;idl++,num_ref++)
        { Tableau <Tableau <double > > & tab_pour_ddl = tab_tab_pour_ddl(num_ref);
          Tableau <Tableau <int > > & tab_pour_MAXI_ddl = tab_tab_pour_MAXI_ddl(num_ref);
          Tableau <Tableau <double > > & tab_pour_ddl_etendu = tab_tab_pour_ddl_etendu(num_ref);
          Tableau <Tableau <int > > & tab_pour_MAXI_ddl_etendu = tab_tab_pour_MAXI_ddl_etendu(num_ref);
          Tableau <Tableau <double > >  & tab_pour_Quelconque = tab_tab_pour_Quelconque(num_ref);
          // 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();
          tab_ref_taille(num_ref)=taillen; // on stocke pour les moyennes

          for (int inoeu=1;inoeu<=taillen;inoeu++)  // on boucle sur  les noeuds
           { Noeud& noe=lesMail->Noeud_LesMaille(n_mail,inoeu);
             // .... concernant les ddl principaux .....
             if (!type_ddl_retenu_pourSM.empty())
              {List_io<Ddl_enum_etendu>::iterator ienu,ienufin=type_ddl_retenu_pourSM.end();
               int num_enu = 1;
               for (ienu = type_ddl_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
                 { double val_a_sortir=0.;
                   double val_init=0.; // ne sert pas, on le laisse au cas où
                   Tableau <double > &  pour_ddl = tab_pour_ddl(num_enu);
                   Tableau <int >  & pour_MAXI_ddl = tab_pour_MAXI_ddl(num_enu);
                   switch(type_sortie_ddl_retenue)
                    { case 0: // cas où on ne considère que la grandeur
                       {bool asortir = true;
                        if (!noe.Existe_ici((*ienu).Enum()))
                             { asortir=false; 
                        #ifdef MISE_AU_POINT  // on regarde si la grandeur existe
                               if (ParaGlob::NiveauImpression() >= 4)
                                 {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());};
                         };
                        break;
                       }
                      case 1: // cas où on ne considère que la variation de la grandeur entre 0 et tdt ou t
                       {bool asortir = true;
                          if (!noe.Existe_ici((*ienu).Enum()))
                           { asortir=false; 
                        #ifdef MISE_AU_POINT  // on regarde si la grandeur existe
                             if (ParaGlob::NiveauImpression() >= 4)
                               {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());};
                          };
                        break;
                       }
                      case 2: // cas où on  sort les grandeurs à 0 et à tdt ou t
                       {bool asortir = true;
                          if (!noe.Existe_ici((*ienu).Enum()))
                           { asortir=false; 
                        #ifdef MISE_AU_POINT  // on regarde si la grandeur existe
                             if (ParaGlob::NiveauImpression() >= 4)
                              {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());};
                         };
                        break;
                       }
                    }; // fin du switch sur type_sortie_ddl_retenue

                   // le calcul des grandeurs
                   pour_ddl(1) += val_a_sortir;
                   pour_ddl(2) += 1.; // on s'en sert ici comme compteur
                   int num_noeud = noe.Num_Mail();
                   if (pour_ddl(3) < val_a_sortir)
                    { pour_ddl(3) = val_a_sortir;
                      pour_MAXI_ddl(1) = num_noeud;
                    };
                   if (pour_ddl(4) > val_a_sortir)
                    { pour_ddl(4) = val_a_sortir;
                      pour_MAXI_ddl(2) = num_noeud;
                    };
                   if (Dabs(pour_ddl(5)) < Dabs(val_a_sortir))
                    { pour_ddl(5) = val_a_sortir;
                      pour_MAXI_ddl(3) = num_noeud;
                    };
                   if (Dabs(pour_ddl(6)) > Dabs(val_a_sortir))
                    { pour_ddl(6) = val_a_sortir;
                      pour_MAXI_ddl(4) = num_noeud;
                    };
                 };
              };
            
             // .... concernant les ddl étendus .....
             if (!type_ddlEtendu_retenu_pourSM.empty())
              {List_io<Ddl_enum_etendu>::iterator ienu,ienufin=type_ddlEtendu_retenu_pourSM.end();
               int num_enu = 1;
               for (ienu = type_ddlEtendu_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
                  {double val_a_sortir=0.; 
                   Tableau <double > &  pour_ddl_etendu = tab_pour_ddl_etendu(num_enu);
                   Tableau <int >  & pour_MAXI_ddl_etendu = tab_pour_MAXI_ddl_etendu(num_enu);
                   #ifdef MISE_AU_POINT  // on regarde si la grandeur existe
                    if (!noe.Existe_ici_ddlEtendu((*ienu))) 
                      { if (ParaGlob::NiveauImpression() >= 4)
                          {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();}
                    // le calcul des grandeurs
                    pour_ddl_etendu(1) += val_a_sortir;
                    pour_ddl_etendu(2) += 1.; // on s'en sert ici comme compteur
                    int num_noeud = noe.Num_Mail();
                    if (pour_ddl_etendu(3) < val_a_sortir)
                     { pour_ddl_etendu(3) = val_a_sortir;
                       pour_MAXI_ddl_etendu(1) = num_noeud;
                     };
                    if (pour_ddl_etendu(4) > val_a_sortir)
                     { pour_ddl_etendu(4) = val_a_sortir;
                       pour_MAXI_ddl_etendu(2) = num_noeud;
                     };
                    if (Dabs(pour_ddl_etendu(5)) < Dabs(val_a_sortir))
                     { pour_ddl_etendu(5) = val_a_sortir;
                       pour_MAXI_ddl_etendu(3) = num_noeud;
                     };
                    if (Dabs(pour_ddl_etendu(6)) > Dabs(val_a_sortir))
                     { pour_ddl_etendu(6) = val_a_sortir;
                       pour_MAXI_ddl_etendu(4) = num_noeud;
                     };
                   };
              };
            
             // .... concernant les grandeurs quelconque aux noeud .....
             if (!TypeQuelconque_retenu_pourSM.empty())
              {List_io<TypeQuelconque>::iterator ienu,ienufin=TypeQuelconque_retenu_pourSM.end();
               int num_enu = 1;
               for (ienu = TypeQuelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
                 {
                   int nb_val = (*ienu).NbMaxiNumeroOrdre();
                   Tableau <double >  &  pour_Quelconque = tab_pour_Quelconque(num_enu);
                   // 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() >= 4)
                          {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
                   for (int i=1;i<= nb_val;i++)
                    {if (noe.Existe_ici(enuq))
                      { const TypeQuelconque& grand_quelconque_noe = noe.Grandeur_quelconque(enuq);
                        pour_Quelconque(i) += grand_quelconque_noe.GrandeurNumOrdre(i);
                      };
                     // dans le cas où la grandeur n'existe pas on ne fait rien
                    };
                  };
              };
            
           };
        };

       // ---- on écrit les informations
       
       // écriture du temps que si il y a des ref 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
       int nbdigit = ParaGlob::NbdigdoGR();
       if ((NB_ref != 0) && ((!unseul_incre) || (style_de_sortie==1)))
         { sort << setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
       else if (NB_ref != 0)
         // ici on écrit une fois le temps en commentaire
         { sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
       
       for (int num_ref=1;num_ref <= NB_ref; num_ref++)
       {
       // ... les ddl de base
        {Tableau <Tableau <double > > & tab_pour_ddl = tab_tab_pour_ddl(num_ref);
         Tableau <Tableau <int > > & tab_pour_MAXI_ddl = tab_tab_pour_MAXI_ddl(num_ref);
         for (int num_ddl = 1; num_ddl <= nb_ddl; num_ddl++)
          { Tableau <double > &  pour_ddl = tab_pour_ddl(num_ddl);
            Tableau <int >  & pour_MAXI_ddl = tab_pour_MAXI_ddl(num_ddl);
            // calcul finale de la moyenne
            pour_ddl(2) = pour_ddl(1) / pour_ddl(2);
            sort << setprecision(nbdigit)
                 << pour_ddl(1) << " " << pour_ddl(2) << " "
                 << pour_ddl(3) << " " << pour_MAXI_ddl(1) << " "
                 << pour_ddl(4) << " " << pour_MAXI_ddl(2) << " "
                 << pour_ddl(5) << " " << pour_MAXI_ddl(3) << " "
                 << pour_ddl(6) << " " << pour_MAXI_ddl(4) << " ";
          };
        };
       // ... les ddl étendues
        {Tableau <Tableau <double > > & tab_pour_ddl_etendu = tab_tab_pour_ddl_etendu(num_ref);
         Tableau <Tableau <int > > & tab_pour_MAXI_ddl_etendu = tab_tab_pour_MAXI_ddl_etendu(num_ref);
         for (int num_ddl = 1; num_ddl <= nb_ddl_etendu; num_ddl++)
          { Tableau <double > &  pour_ddl_etendu = tab_pour_ddl_etendu(num_ddl);
            Tableau <int >  & pour_MAXI_ddl_etendu = tab_pour_MAXI_ddl_etendu(num_ddl);
            // calcul finale de la moyenne
            pour_ddl_etendu(2) = pour_ddl_etendu(1) / pour_ddl_etendu(2);
            sort << setprecision(nbdigit)
                 << pour_ddl_etendu(1) << " " << pour_ddl_etendu(2) << " "
                 << pour_ddl_etendu(3) << " " << pour_MAXI_ddl_etendu(1) << " "
                 << pour_ddl_etendu(4) << " " << pour_MAXI_ddl_etendu(2) << " "
                 << pour_ddl_etendu(5) << " " << pour_MAXI_ddl_etendu(3) << " "
                 << pour_ddl_etendu(6) << " " << pour_MAXI_ddl_etendu(4) << " ";
          };
        };
       // ... les grandeurs quelconques
        {Tableau <Tableau <double > > & tab_pour_Quelconque = tab_tab_pour_Quelconque(num_ref);
         for (int num_val = 1; num_val <= nb_TypeQuelconque; num_val++)
          { Tableau <double > &  pour_Quelconque = tab_pour_Quelconque(num_val);
            int taille = pour_Quelconque.Taille();
            sort << setprecision(nbdigit);
            // on sort les sommes
            for (int i=1;i<=taille;i++)
              sort << pour_Quelconque(i) << " ";
            // puis les moyennes
            int nb_pt = tab_ref_taille(num_ref);
            for (int i=1;i<=taille;i++)
              sort << (pour_Quelconque(i)/nb_pt) << " ";
          };
        };
       }; // fin de la boucle sur les références
     };
    };
     
};

// sortie pour les moyennes sommes etc. sur ref E
void Choix_grandeurs_maple::Sortie_somme_moy_E(ostream &sort,Charge* charge,bool unseul_incre)
{ // on boucle sur les maillages
  int nb_maillage = tabelement_type_ddl.Taille();
  for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
    {
     // ---- préparation des conteneurs de sortie
     int NB_ref_E = tab_nomDeRef_E_SM(n_mail).size(); // = le nombre de ref
     int NB_ref_pti = tab_nomDeRef_ptinteg_SM(n_mail).size(); // pour les pti
     int NB_ref = NB_ref_E + NB_ref_pti;
     // on ne continue que s'il existe des ref
     if (NB_ref)
      {
       // les ddl étendue des grandeurs principales -> grandeurs scalaires
       List_io < Ddl_enum_etendu > &type_ddl_retenu_pourSM = tabelement_type_ddl_retenu_pourSM(n_mail);
       int nb_ddl = type_ddl_retenu_pourSM.size();
       // on veut : (1) la somme,        (2) la moyenne,
       //           (3) le max,          (4) le min,
       //           (5) le max des | | , (6) le min des | |
       
       // tab_tab_pour_ddl_etendu(i)(j)(k) : la grandeur k pour le ddl etendu j de la ref i
       // tab_tab_pour_MAXI_ddl_etendu(i)(j)(k) : k= 1 -> le numéro de l'element pour le max
       //                                         k= 2 -> le numéro de l'element pour le min
       //                                         k= 3 -> le numéro de l'element pour le max des | |
       //                                         k= 4 -> le numéro de l'element pour le min des | |
       //                                         k= 5 -> le numéro du pti pour le max
       //                                         k= 6 -> le numéro du pti pour le min
       //                                         k= 7 -> le numéro du pti pour le max des | |
       //                                         k= 8 -> le numéro du pti pour le min des | |
       Tableau <double > t6(6); t6(4)=t6(6)=ConstMath::tresgrand; // on met les mini très grand
       Tableau <Tableau <double > > toto6(nb_ddl,t6);
       Tableau < Tableau <Tableau <double > > > tab_tab_pour_ddl(NB_ref,toto6);
       Tableau <Tableau <int > > titi8(nb_ddl,8);
       Tableau < Tableau <Tableau <int > > > tab_tab_pour_MAXI_ddl(NB_ref,titi8);
       
       // idem pour les grandeurs quelconques, on ne considère que la somme et la moyenne des grandeurs brutes
       List_io < TypeQuelconque > & element_quelconque_retenu_pourSM = tabelement_typeParti_retenu_pourSM(n_mail);
       int nb_TypeQuelconque = element_quelconque_retenu_pourSM.size();
       Tableau < Tableau <double > > tab_inter_Q(nb_TypeQuelconque); // pour le dimensionnement final
       // on dimensionne en fonction de la taille de la grandeur quelconque
       {List_io<TypeQuelconque>::iterator ienu,ienufin=element_quelconque_retenu_pourSM.end();
        int num_enu = 1;
        for (ienu = element_quelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
           {int nb_val = (*ienu).NbMaxiNumeroOrdre();
            Tableau <double > & inter = tab_inter_Q(num_enu);
            inter.Change_taille(nb_val);
           };
       };
       Tableau < Tableau <Tableau <double > > >  tab_tab_pour_Quelconque(NB_ref,tab_inter_Q);
       Tableau < int >  tab_nb_pour_Quelconque(NB_ref); // la taille de la somme

       // pour les grandeurs évoluées, on ne considère que la somme et la moyenne des grandeurs brutes
       List_io < TypeQuelconque > &element_evoluee_retenu_pourSM = tabelement_evoluee_retenu_pourSM(n_mail);
       int nb_TypeEvolue = element_evoluee_retenu_pourSM.size();
       Tableau < Tableau <double > > tab_inter(nb_TypeEvolue); // pour le dimensionnement final
       // on dimensionne en fonction de la taille de la grandeur quelconque
       {List_io<TypeQuelconque>::iterator ienu,ienufin=element_evoluee_retenu_pourSM.end();
        int num_enu = 1;
        for (ienu = element_evoluee_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
           {int nb_val = (*ienu).NbMaxiNumeroOrdre();
            Tableau <double > & inter = tab_inter(num_enu);
            inter.Change_taille(nb_val);
           };
       };
       Tableau < Tableau <Tableau <double > > >  tab_tab_pour_Evoluee(NB_ref,tab_inter);
       Tableau < int > tab_ref_taille(NB_ref);
       Tableau < int >  tab_nb_pour_Evoluee(NB_ref); // la taille de la somme

       // ---- on balaie les références de listes des elements pour récupérer les informations
       List_io <BlocScal >::iterator idl = tab_nomDeRef_E_SM(n_mail).begin();
       List_io < string >::iterator idl_Rpti = tab_nomDeRef_ptinteg_SM(n_mail).begin();
       
       for (int num_ref=1;num_ref <= NB_ref; num_ref++)
        { Tableau <Tableau <double > > & tab_pour_ddl = tab_tab_pour_ddl(num_ref);
          Tableau <Tableau <int > > & tab_pour_MAXI_ddl = tab_tab_pour_MAXI_ddl(num_ref);
          Tableau <Tableau <double > > & tab_pour_Quelconque = tab_tab_pour_Quelconque(num_ref);
          int   & nb_pour_Quelconque = tab_nb_pour_Quelconque(num_ref); // la taille de la somme

          Tableau <Tableau <double > >  & tab_pour_Evoluee = tab_tab_pour_Evoluee(num_ref);
          int   & nb_pour_Evoluee = tab_nb_pour_Evoluee(num_ref); // la taille de la somme
         
          // recup de la reference correspondant au mot cle
          const Reference  * refi=NULL; // init
          int taillen=0; // init
          bool en_refN=true; // pour savoir ensuite si on est en refN ou refAF
          if (num_ref < NB_ref_E+1)
           { refi = &(lesRef->Trouve((*idl).NomRef(),n_mail));
             const ReferenceNE& reff_E = ((ReferenceNE &) *refi); // transfo en ref d'élément
             taillen=reff_E.Taille();
             tab_ref_taille(num_ref)=taillen; // on stocke pour les moyennes
           }
          else // ils s'agit d'une ref de pti
           { refi = &(lesRef->Trouve((*idl_Rpti),n_mail));
             const ReferenceAF & reff_AF = ((ReferenceAF &) *refi); // transfo en ref d'élément
             taillen=reff_AF.Taille();
             tab_ref_taille(num_ref)=taillen; // on stocke pour les moyennes
             en_refN=false;
           };
          for (int i_ele=1;i_ele<=taillen;i_ele++)  // on boucle sur  les elements
           {
             int nbElem = 0; // init
             int nbPtInteg = 0; // init
             if (en_refN)
              { const ReferenceNE& reff = ((ReferenceNE &) *refi); // transfo en ref d'élément
                nbElem = reff.Numero(i_ele);
                nbPtInteg = (*idl).Val();
              }
             else // ils s'agit d'une ref de pti
              { const ReferenceAF & reff = ((ReferenceAF &) *refi);
                nbElem = reff.NumeroElem(i_ele);
                nbPtInteg = reff.NumeroFA(i_ele);
              };
             Element& ele = lesMail->Element_LesMaille(n_mail,nbElem);
////-----debug
//if (ele.Num_elt() == 449)
//   cout << "\n nb_elem "<< flush ;
////----fin debug
             // .... concernant les ddl principaux .....
             if (!type_ddl_retenu_pourSM.empty())
              {List_io<Ddl_enum_etendu>::iterator ienu=type_ddl_retenu_pourSM.begin();
               //List_io<Ddl_enum_etendu>::iterator ienufin=type_ddl_retenu_pourSM.end();
               // maintenant il y a deux cas, soit on travaille avec un seul pti soit
               // on considère tous les pti, on va faire une boucle par défaut
               int min_pti=nbPtInteg; int max_pti = nbPtInteg;
               if (nbPtInteg == -1)
                {min_pti = 1;
                 max_pti = ele.NbPtInteg((*ienu).Enum());
                };
               
               for (int ipti = min_pti;ipti <= max_pti;ipti++)
                {
                 // on récupère directement toutes les grandeurs
                 Tableau <double> tab= ele.Valeur_a_diff_temps
                                       (absolue,TEMPS_tdt,type_ddl_retenu_pourSM,ipti);
                 // on fait le traitement
                 int nb_val_plus_un = 1+tab.Taille(); // normalement == type_ddl_retenu_pourSM.size()
                 #ifdef MISE_AU_POINT
                 if (tab.Taille() !=  type_ddl_retenu_pourSM.size())
                    { cout << "\n**** pb dans le calcul  Sortie_somme_moy_E( les resultats ne seront pas exploitables" << endl ;
                    };
                 #endif
                 for (int num_enu = 1 ;num_enu < nb_val_plus_un;num_enu++)
                   { Tableau <double > &  pour_ddl = tab_pour_ddl(num_enu);
                     Tableau <int >  & pour_MAXI_ddl = tab_pour_MAXI_ddl(num_enu);

                     // le calcul des grandeurs
                     double val_a_sortir=tab(num_enu);// pour simplifier
                     pour_ddl(1) += val_a_sortir;
                     pour_ddl(2) += 1.; // on s'en sert ici comme compteur
////-----debug
//if ((ele.Num_elt() == 449)&& (ipti == 5) )
//   cout << "\n nb_elem pour_ddl(3)= "<< pour_ddl(3) << " val_a_sortir= " << val_a_sortir << flush ;
////----fin debug

                     int num_element = ele.Num_elt();
                     if (pour_ddl(3) < val_a_sortir)
                      { pour_ddl(3) = val_a_sortir;
                        pour_MAXI_ddl(1) = num_element;
                        pour_MAXI_ddl(5) = ipti;
                      };
                     if (pour_ddl(4) > val_a_sortir)
                      { pour_ddl(4) = val_a_sortir;
                        pour_MAXI_ddl(2) = num_element;
                        pour_MAXI_ddl(6) = ipti;
                      };
                     if (Dabs(pour_ddl(5)) < Dabs(val_a_sortir))
                      { pour_ddl(5) = val_a_sortir;
                        pour_MAXI_ddl(3) = num_element;
                        pour_MAXI_ddl(7) = ipti;
                      };
                     if (Dabs(pour_ddl(6)) > Dabs(val_a_sortir))
                      { pour_ddl(6) = val_a_sortir;
                        pour_MAXI_ddl(4) = num_element;
                        pour_MAXI_ddl(8) = ipti;
                      };
                   };
                };
              };
            
             // .... concernant les grandeurs particulières .....
             if (!element_quelconque_retenu_pourSM.empty())
              {List_io<TypeQuelconque>::iterator jquefin=element_quelconque_retenu_pourSM.end();
               List_io<TypeQuelconque>::iterator jque,jque_deb=element_quelconque_retenu_pourSM.begin();
               if (jque_deb !=  jquefin) // c'est a dire: cas où existe une grandeur
                {// maintenant il y a deux cas, soit on travaille avec un seul pti soit
                 // on considère tous les pti, on va faire une boucle par défaut
                 int min_pti=nbPtInteg; int max_pti = nbPtInteg;
                 if (nbPtInteg == -1)
                  {min_pti = 1;
                   max_pti = ele.NbPtInteg((*jque_deb).Enum());
                  };
                 
                 for (int ipti = min_pti;ipti <= max_pti;ipti++)
                  {// puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
                   // on récupère ainsi d'un coup toutes les valeurs
                                  // puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
                   ele.Grandeur_particuliere(absolue,element_quelconque_retenu_pourSM,ipti);
                   // on transfert dans le tableau
                   int num_enu = 1;
                   for (jque=jque_deb;jque!=jquefin;jque++,num_enu++)
                     {int nb_val = (*jque).NbMaxiNumeroOrdre();
                      Tableau <double >  &  pour_Quelconque = tab_pour_Quelconque(num_enu);
                      for (int i=1;i<= nb_val;i++)
                         pour_Quelconque(i) += (*jque).GrandeurNumOrdre(i);
                     };
                   // on incrément le compteur de somme
                   nb_pour_Quelconque++;
                  };
                };
               };
            
             // .... concernant les grandeurs évoluées aux element .....
             if (!element_evoluee_retenu_pourSM.empty())
              {List_io<TypeQuelconque>::iterator jquefin=element_evoluee_retenu_pourSM.end();
               List_io<TypeQuelconque>::iterator jque,jque_deb=element_evoluee_retenu_pourSM.begin();
               if (jque_deb !=  jquefin) // c'est a dire: cas où existe une grandeur
                {// maintenant il y a deux cas, soit on travaille avec un seul pti soit
                 // on considère tous les pti, on va faire une boucle par défaut
                 int min_pti=nbPtInteg; int max_pti = nbPtInteg;
                 if (nbPtInteg == -1)
                  {min_pti = 1;
                   max_pti = ele.NbPtInteg((*jque_deb).Enum());
                  };
                 
                 for (int ipti = min_pti;ipti <= max_pti;ipti++)
                  {// puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
                   // on récupère ainsi d'un coup toutes les valeurs
                   ele.ValTensorielle_a_diff_temps(absolue,TEMPS_tdt,element_evoluee_retenu_pourSM,ipti);
                   // on transfert dans le tableau
                   int num_enu = 1;
                   for (jque=jque_deb;jque!=jquefin;jque++,num_enu++)
                     {int nb_val = (*jque).NbMaxiNumeroOrdre();
                      Tableau <double >  &  pour_Evoluee = tab_pour_Evoluee(num_enu);
                      for (int i=1;i<= nb_val;i++)
                         pour_Evoluee(i) += (*jque).GrandeurNumOrdre(i);
                     };
                   // on incrément le compteur de somme
                   nb_pour_Evoluee++;
                  };
                };
               };
            
           };
          // --- incrémentation des pointeurs de ref ---
          if (en_refN)  {idl++;}
          else          { idl_Rpti++;};
        };

       // ---- on écrit les informations
       
       // écriture du temps que si il y a des ref 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
       int nbdigit = ParaGlob::NbdigdoGR();
       if ((NB_ref != 0) && ((!unseul_incre) || (style_de_sortie==1)))
         { sort << setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
       else if (NB_ref != 0)
         // ici on écrit une fois le temps en commentaire
         { sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
       
       for (int num_ref=1;num_ref <= NB_ref; num_ref++)
       {
       // ... les ddl de base
        {Tableau <Tableau <double > > & tab_pour_ddl = tab_tab_pour_ddl(num_ref);
         Tableau <Tableau <int > > & tab_pour_MAXI_ddl = tab_tab_pour_MAXI_ddl(num_ref);
         for (int num_ddl = 1; num_ddl <= nb_ddl; num_ddl++)
          { Tableau <double > &  pour_ddl = tab_pour_ddl(num_ddl);
            Tableau <int >  & pour_MAXI_ddl = tab_pour_MAXI_ddl(num_ddl);
            // calcul finale de la moyenne
            pour_ddl(2) = pour_ddl(1) / pour_ddl(2);
            sort << setprecision(nbdigit)
                 << pour_ddl(1) << " " << pour_ddl(2) << " "
                 << pour_ddl(3) << " " << pour_MAXI_ddl(1) << " " << pour_MAXI_ddl(5) << " "
                 << pour_ddl(4) << " " << pour_MAXI_ddl(2) << " " << pour_MAXI_ddl(6) << " "
                 << pour_ddl(5) << " " << pour_MAXI_ddl(3) << " " << pour_MAXI_ddl(7) << " "
                 << pour_ddl(6) << " " << pour_MAXI_ddl(4) << " " << pour_MAXI_ddl(8) << " ";
          };
        };
       // ... les grandeurs quelconques
        {Tableau <Tableau <double > > & tab_pour_Quelconque = tab_tab_pour_Quelconque(num_ref);
         int   & nb_pour_Quelconque = tab_nb_pour_Quelconque(num_ref); // la taille de la somme
         for (int num_val = 1; num_val <= nb_TypeQuelconque; num_val++)
          { Tableau <double > &  pour_Quelconque = tab_pour_Quelconque(num_val);
            int taille = pour_Quelconque.Taille();
            sort << setprecision(nbdigit);
            // on sort les sommes
            for (int i=1;i<=taille;i++)
              sort << pour_Quelconque(i) << " ";
            // puis les moyennes
            for (int i=1;i<=taille;i++)
              sort << (pour_Quelconque(i)/nb_pour_Quelconque) << " ";
          };
        };
      // ... les grandeurs évoluées
        {Tableau <Tableau <double > > & tab_pour_Evoluee = tab_tab_pour_Evoluee(num_ref);
         int   & nb_pour_Evoluee = tab_nb_pour_Evoluee(num_ref); // la taille de la somme
         for (int num_val = 1; num_val <= nb_TypeEvolue; num_val++)
          { Tableau <double > &  pour_Evoluee = tab_pour_Evoluee(num_val);
            int taille = pour_Evoluee.Taille();
            sort << setprecision(nbdigit);
            // on sort les sommes
            for (int i=1;i<=taille;i++)
              sort << pour_Evoluee(i) << " ";
            // puis les moyennes
            for (int i=1;i<=taille;i++)
              sort << (pour_Evoluee(i)/nb_pour_Evoluee) << " ";
          };
        };
       }; // fin de la boucle sur les références
     };
    };
     
};
// sortie de l'entete pour les moyennes sommes etc. sur ref N
void Choix_grandeurs_maple::Sortie_entete_somme_moy_N(ostream &sort,int & num_col)
{ // on boucle sur les maillages
  int nb_maillage = tabnoeud_type_ddl.Taille();
  for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
    {// ---- préparation
     int NB_ref = tab_nomDeRef_SM(n_mail).size(); // = le nombre de ref
     int num_total_grandeur=0;
     // les ddl étendue des grandeurs principales -> grandeurs scalaires
     List_io < Ddl_enum_etendu > &type_ddl_retenu_pourSM = tabnoeud_type_ddl_retenu_pourSM(n_mail);
     int nb_ddl = type_ddl_retenu_pourSM.size();
     num_total_grandeur += nb_ddl*10;
     // idem pour les ddl étendus pour les grandeurs étendues -> grandeurs scalaires
     List_io < Ddl_enum_etendu > &type_ddlEtendu_retenu_pourSM = tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail);
     int nb_ddl_etendu = type_ddlEtendu_retenu_pourSM.size();
     num_total_grandeur += nb_ddl_etendu*10;
     // pour les grandeurs quelconques, on ne considère que la somme et la moyenne des grandeurs brutes
     List_io < TypeQuelconque > &TypeQuelconque_retenu_pourSM = tabnoeud_TypeQuelconque_retenu_pourSM(n_mail);
     //int nb_TypeQuelconque = TypeQuelconque_retenu_pourSM.size();
     // on dimensionne en fonction de la taille de la grandeur quelconque
     {List_io<TypeQuelconque>::iterator ienu,ienufin=TypeQuelconque_retenu_pourSM.end();
      int num_enu = 1;
      for (ienu = TypeQuelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
         {int nb_val = (*ienu).NbMaxiNumeroOrdre();
          num_total_grandeur += nb_val*2;
         };
     };
     
     if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
     else {sort << "\n# mesh_" << n_mail << " : "; };
     sort << NB_ref << " "<< num_total_grandeur*NB_ref << " ";
		   if (ParaGlob::Francais()) {sort << "  (nombre de ref de noeud et nombre total de grandeurs associees) ";	}
		   else {sort << "  (number of ref of node and global number of associated values ) ";	}
//     if ((NB_ref != 0)&&(type_ddl_retenu_pourSM.size()>1))
//		    {if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
//       else {sort << "\n# mesh_" << n_mail << " : "; };
//      }
     sort << "\n# ";
     if (NB_ref != 0)
            num_col++; // on passe l'affichage du temps 
     // puis les ref s'il y en a
     if (NB_ref != 0)
      {int num_ref=1;
       List_io <string >::iterator idl,idlfin= tab_nomDeRef_SM(n_mail).end();
       for (idl=tab_nomDeRef_SM(n_mail).begin();idl!=idlfin;idl++,num_ref++)
        {  sort << (*idl) << " "; // le nom de la ref
           // 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
           sort << "( "<<(reff.Taille()) << " ) "<< num_total_grandeur << " "; // le nombre de noeuds

           if (ParaGlob::Francais()) {sort << "  (ref, (nombre de noeuds) et nombre total de grandeurs associees) ";	}
           else                      {sort << "  (ref name, (number of nodes) and global number of associated values) ";	};

           // === les positions de chaque grandeurs ===
           
           //  --- les ddl principaux ----
           {List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabnoeud_type_ddl_retenu_pourSM(n_mail).end();
            for (ienu = tabnoeud_type_ddl_retenu_pourSM(n_mail).begin();ienu!=ienufin;ienu++)
             {string inter; // init
              switch (type_sortie_ddl_retenue)
               { case 0: case 2: // on ne sort pas les grandeurs à 0 moyennée
                  { inter = ((*ienu).Nom_plein());
                    break;
                  }
                 case 1:
                  { inter = ("delta_0_t_"+string((*ienu).Nom_plein()));
                    break;
                  }
               };
              // la sortie
              sort << "\n#["<<num_col<<"]"<< inter << "_sum ";num_col++; // la somme
              sort << " ["<<num_col<<"]"<< inter << "_moy ";num_col++; // la moyenne

              sort << " ["<<num_col<<"]"<< inter << "_max ";num_col++; // le max
              sort << " ["<<num_col<<"] num_noeud ";num_col++;                       //  le numéro du max

              sort << " ["<<num_col<<"]"<< inter << "_min ";num_col++; // le min
              sort << " ["<<num_col<<"] num_noeud ";num_col++;                       // le numéro du min
            
              sort << " ["<<num_col<<"]"<< inter << "_maxAbs ";num_col++; // le max de abs
              sort << " ["<<num_col<<"] num_noeud ";num_col++;                       //  le numéro du max

              sort << " ["<<num_col<<"]"<< inter << "_minAbs ";num_col++; // le min de abs
              sort << " ["<<num_col<<"] num_noeud ";num_col++;                       // le numéro du min
              
             };
           };
           //  --- les ddl étendus ----
           {List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).end();
            for (ienu = tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).begin();ienu!=ienufin;ienu++)
             {
               sort << "\n#["<<num_col<<"]"<< (*ienu).Nom_plein() << "_sum ";num_col++; // la somme
               sort << " ["<<num_col<<"]"<< (*ienu).Nom_plein() << "_moy ";num_col++; // la moyenne

               sort << " ["<<num_col<<"]"<< (*ienu).Nom_plein() << "_max ";num_col++; // le max
               sort << " ["<<num_col<<"] num_noeud ";num_col++;                       //  le numéro du max

               sort << " ["<<num_col<<"]"<< (*ienu).Nom_plein() << "_min ";num_col++; // le min
               sort << " ["<<num_col<<"] num_noeud ";num_col++;                       // le numéro du min
       
               sort << " ["<<num_col<<"]"<< (*ienu).Nom_plein() << "_maxAbs ";num_col++; // le max de abs
               sort << " ["<<num_col<<"] num_noeud ";num_col++;                       //  le numéro du max

               sort << " ["<<num_col<<"]"<< (*ienu).Nom_plein() << "_minAbs ";num_col++; // le min de abs
               sort << " ["<<num_col<<"] num_noeud ";num_col++;                       // le numéro du min
             
             };
           };
           //  --- les grandeurs quelconques ---
           {List_io<TypeQuelconque>::iterator iquefin=tabnoeud_TypeQuelconque_retenu_pourSM(n_mail).end();
            List_io<TypeQuelconque>::iterator ique,ique_deb=tabnoeud_TypeQuelconque_retenu_pourSM(n_mail).begin();
            for (ique = ique_deb;ique != iquefin;ique++)
              {sort << "\n#"; (*ique).Ecriture_entete_grandeur(sort);
               sort << " (somme) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
               num_col += (*ique).NbMaxiNumeroOrdre();
               sort << " (moyenne) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
               num_col += (*ique).NbMaxiNumeroOrdre();
               //sort << "\n#     ";
              };
           };
           //sort << " ;\n# ";
        };
       sort << " ;\n# ";
      };
   };
 
};
// sortie de l'entete pour les moyennes sommes etc. sur ref E
void Choix_grandeurs_maple::Sortie_entete_somme_moy_E(ostream &sort,int & num_col)
{ // on boucle sur les maillages
  int nb_maillage = tabelement_type_ddl.Taille();
  for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
    {// ---- préparation
     // ---- préparation des conteneurs de sortie
     int NB_ref_E = tab_nomDeRef_E_SM(n_mail).size(); // = le nombre de ref
     int NB_ref_pti = tab_nomDeRef_ptinteg_SM(n_mail).size(); // pour les pti
     int NB_ref = NB_ref_E + NB_ref_pti;
     int num_total_grandeur=0;
     // les ddl étendue des grandeurs principales -> grandeurs scalaires
     List_io < Ddl_enum_etendu > &type_ddl_retenu_pourSM = tabelement_type_ddl_retenu_pourSM(n_mail);
     int nb_ddl = type_ddl_retenu_pourSM.size();
     num_total_grandeur += nb_ddl*14;

     // pour les grandeurs quelconques, on ne considère que la somme et la moyenne des grandeurs brutes
     List_io < TypeQuelconque > &TypeQuelconque_retenu_pourSM = tabelement_typeParti_retenu_pourSM(n_mail);
     //int nb_TypeQuelconque = TypeQuelconque_retenu_pourSM.size();
     // on dimensionne en fonction de la taille de la grandeur quelconque
     {List_io<TypeQuelconque>::iterator ienu,ienufin=TypeQuelconque_retenu_pourSM.end();
      int num_enu = 1;
      for (ienu = TypeQuelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
         {int nb_val = (*ienu).NbMaxiNumeroOrdre();
          num_total_grandeur += nb_val*2;
         };
     };
     // pour les grandeurs évoluées, on ne considère que la somme et la moyenne des grandeurs brutes
     List_io < TypeQuelconque > &Type_evoluee_retenu_pourSM = tabelement_evoluee_retenu_pourSM(n_mail);
     //int nb_Type_evoluee = Type_evoluee_retenu_pourSM.size();
     // on dimensionne en fonction de la taille de la grandeur quelconque
     {List_io<TypeQuelconque>::iterator ienu,ienufin=Type_evoluee_retenu_pourSM.end();
      int num_enu = 1;
      for (ienu = Type_evoluee_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
         {int nb_val = (*ienu).NbMaxiNumeroOrdre();
          num_total_grandeur += nb_val*2;
         };
     };
     
     if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
     else {sort << "\n# mesh_" << n_mail << " : "; };
     sort << NB_ref << " "<< num_total_grandeur*NB_ref << " ";
		   if (ParaGlob::Francais()) {sort << "  (nombre de ref d'element et nombre total de grandeurs associees) ";	}
		   else {sort << "  (number of ref of element and global number of associated values ) ";	}
//     if ((NB_ref != 0)&&(type_ddl_retenu_pourSM.size()>1))
//		    {if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
//       else {sort << "\n# mesh_" << n_mail << " : "; };
//      }
     sort << "\n# ";
     if (NB_ref != 0)
            num_col++; // on passe l'affichage du temps 
     // puis les ref s'il y en a
     if (NB_ref != 0)
      {List_io <BlocScal >::iterator idl = tab_nomDeRef_E_SM(n_mail).begin();
       List_io < string >::iterator idl_Rpti = tab_nomDeRef_ptinteg_SM(n_mail).begin();
       
       for (int num_ref=1;num_ref <= NB_ref; num_ref++)
        {   string nom_ref; // init
            // recup de la reference correspondant au mot cle
            const Reference  * refi=NULL; // init
            int taillen=0; // init
            bool en_refN=true; // pour savoir ensuite si on est en refN ou refAF
            if (num_ref < NB_ref_E+1)
             { nom_ref = (*idl).NomRef();
               refi = &(lesRef->Trouve(nom_ref,n_mail));
               const ReferenceNE& reff_E = ((ReferenceNE &) *refi); // transfo en ref d'élément
               taillen=reff_E.Taille();
             }
            else // ils s'agit d'une ref de pti
             { nom_ref = (*idl_Rpti);
               refi = &(lesRef->Trouve(nom_ref,n_mail));
               const ReferenceAF & reff_AF = ((ReferenceAF &) *refi); // transfo en ref d'élément
               taillen=reff_AF.Taille();
               en_refN=false;
            };
           if (num_ref > 1) sort << "\n# ";
           sort << nom_ref << " "; // le nom de la ref
           sort << "( "<< taillen << " ) " << num_total_grandeur << " "; // le nombre d'éléments
           if (ParaGlob::Francais()) {sort << "  (ref, (nombre d'element), nombre total de valeurs ) ";	}
           else                      {sort << "  (ref name, (number of nodes) total number of values) ";	};

           // === les positions de chaque grandeurs ===
           
           //  --- les ddl principaux ----
           {List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabelement_type_ddl_retenu_pourSM(n_mail).end();
            for (ienu = tabelement_type_ddl_retenu_pourSM(n_mail).begin();ienu!=ienufin;ienu++)
             {string inter; // init
              switch (type_sortie_ddl_retenue)
               { case 0: case 2: // on ne sort pas les grandeurs à 0 moyennée
                  { inter = ((*ienu).Nom_plein());
                    break;
                  }
                 case 1:
                  { inter = ("delta_0_t_"+string((*ienu).Nom_plein()));
                    break;
                  }
               };
              // la sortie
              sort << "\n#["<<num_col<<"]"<< inter << "_sum ";num_col++; // la somme
              sort << " ["<<num_col<<"]"<< inter << "_moy ";num_col++; // la moyenne

              sort << " ["<<num_col<<"]"<< inter << "_max ";num_col++; // le max
              sort << " ["<<num_col<<"] num_element ";num_col++;                       //  le numéro du max
              sort << " ["<<num_col<<"] num_pti ";num_col++;                       //  le numéro du max

              sort << " ["<<num_col<<"]"<< inter << "_min ";num_col++; // le min
              sort << " ["<<num_col<<"] num_element ";num_col++;                       // le numéro du min
              sort << " ["<<num_col<<"] num_pti ";num_col++;                       //  le numéro du min
            
              sort << " ["<<num_col<<"]"<< inter << "_maxAbs ";num_col++; // le max de abs
              sort << " ["<<num_col<<"] num_element ";num_col++;                       //  le numéro du max
              sort << " ["<<num_col<<"] num_pti ";num_col++;                       //  le numéro du max

              sort << " ["<<num_col<<"]"<< inter << "_minAbs ";num_col++; // le min de abs
              sort << " ["<<num_col<<"] num_element ";num_col++;                       // le numéro du min
              sort << " ["<<num_col<<"] num_pti ";num_col++;                       //  le numéro du min
              
             };
           };
           //  --- les grandeurs quelconques ---
           {List_io<TypeQuelconque>::iterator iquefin=tabelement_typeParti_retenu_pourSM(n_mail).end();
            List_io<TypeQuelconque>::iterator ique,ique_deb=tabelement_typeParti_retenu_pourSM(n_mail).begin();
            for (ique = ique_deb;ique != iquefin;ique++)
              {sort << "\n#"; (*ique).Ecriture_entete_grandeur(sort);
               sort << " (somme) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
               num_col += (*ique).NbMaxiNumeroOrdre();
               sort << " (moyenne) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
               num_col += (*ique).NbMaxiNumeroOrdre();
               //sort << "\n#     ";
              };
           };
           //  --- les grandeurs évoluées ---
           {List_io<TypeQuelconque>::iterator iquefin=tabelement_evoluee_retenu_pourSM(n_mail).end();
            List_io<TypeQuelconque>::iterator ique,ique_deb=tabelement_evoluee_retenu_pourSM(n_mail).begin();
            for (ique = ique_deb;ique != iquefin;ique++)
              {sort << "\n#"; (*ique).Ecriture_entete_grandeur(sort);
               sort << " (somme) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
               num_col += (*ique).NbMaxiNumeroOrdre();
               sort << " (moyenne) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
               num_col += (*ique).NbMaxiNumeroOrdre();
               //sort << "\n#     ";
              };
           };

          // --- incrémentation des pointeurs de ref ---
          if (en_refN)  {idl++;}
          else          { idl_Rpti++;};
        };
       sort << " ;\n# ";
      };
   };
 
};

// sortie pour les moyennes sommes etc. sur ref de face E
void Choix_grandeurs_maple::Sortie_somme_moy_face_E(ostream &sort,Charge* charge,bool unseul_incre)
{ // on boucle sur les maillages
  int nb_maillage = tab_F_element_TypeQuelconque.Taille();
  for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
    {
     // ---- préparation des conteneurs de sortie
     int NB_ref_E = tab_nomDeRef_F_E_SM(n_mail).size(); // = le nombre de ref
     int NB_ref_pti = tab_nomDeRef_F_ptinteg_SM(n_mail).size(); // pour les pti
     int NB_ref = NB_ref_E + NB_ref_pti;
     // on ne continue que s'il existe des ref
     if (NB_ref)
      {
       // on veut : (1) la somme, (2) la moyenne, (3) le max, (4) le min, (5) le max des | | , (6) le min des | |
       // tab_tab_pour_ddl_etendu(i)(j)(k) : la grandeur k pour le ddl etendu j de la ref i
       // tab_tab_pour_MAXI_ddl_etendu(i)(j)(k) : k= 1 -> le numéro de l'element pour le max
       //                                         k= 2 -> le numéro de l'element pour le min
       //                                         k= 3 -> le numéro de l'element pour le max des | |
       //                                         k= 4 -> le numéro de l'element pour le min des | |
       //                                         k= 5 -> le numéro du pti pour le max
       //                                         k= 6 -> le numéro du pti pour le min
       //                                         k= 7 -> le numéro du pti pour le max des | |
       //                                         k= 8 -> le numéro du pti pour le min des | |
       
       // pour les grandeurs quelconques, on ne considère que la somme et la moyenne des grandeurs brutes
       List_io < TypeQuelconque > & element_quelconque_retenu_pourSM = tab_F_element_TypeQuelconque_retenu_pourSM(n_mail);
       int nb_TypeQuelconque = element_quelconque_retenu_pourSM.size();
       Tableau < Tableau <double > > tab_inter_Q(nb_TypeQuelconque); // pour le dimensionnement final
       // on dimensionne en fonction de la taille de la grandeur quelconque
       {List_io<TypeQuelconque>::iterator ienu,ienufin=element_quelconque_retenu_pourSM.end();
        int num_enu = 1;
        for (ienu = element_quelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
           {int nb_val = (*ienu).NbMaxiNumeroOrdre();
            Tableau <double > & inter = tab_inter_Q(num_enu);
            inter.Change_taille(nb_val);
           };
       };
       Tableau < Tableau <Tableau <double > > >  tab_tab_pour_Quelconque(NB_ref,tab_inter_Q);
       Tableau < int >  tab_nb_pour_Quelconque(NB_ref); // la taille de la somme

       Tableau < int > tab_ref_taille(NB_ref);

       // ---- on balaie les références de listes des elements pour récupérer les informations
       List_io <BlocScal >::iterator idl = tab_nomDeRef_F_E_SM(n_mail).begin();
       List_io < string >::iterator idl_Rpti = tab_nomDeRef_F_ptinteg_SM(n_mail).begin();
       
       for (int num_ref=1;num_ref <= NB_ref; num_ref++)
        { Tableau <Tableau <double > > & tab_pour_Quelconque = tab_tab_pour_Quelconque(num_ref);
          int   & nb_pour_Quelconque = tab_nb_pour_Quelconque(num_ref); // la taille de la somme
         
          // recup de la reference correspondant au mot cle
          const Reference  * refi=NULL; // init
          int taillen=0; // init
          bool en_refN=true; // pour savoir ensuite si on est refAF ou PtiAF
          if (num_ref < NB_ref_E+1)
           { refi = &(lesRef->Trouve((*idl).NomRef(),n_mail));
             const ReferenceAF& reff_E = ((ReferenceAF &) *refi); // transfo en ref de faces d'élément
             taillen=reff_E.Taille();
             tab_ref_taille(num_ref)=taillen; // on stocke pour les moyennes
           }
          else // ils s'agit d'une ref de pti de faces d'élément
           { refi = &(lesRef->Trouve((*idl_Rpti),n_mail));
             const ReferencePtiAF & reff_AF = ((ReferencePtiAF &) *refi); // transfo en ref de pti de face d'élément
             taillen=reff_AF.Taille();
             tab_ref_taille(num_ref)=taillen; // on stocke pour les moyennes
             en_refN=false;
           };
          int face = 0; // init
          for (int i_ele=1;i_ele<=taillen;i_ele++)  // on boucle sur  les elements
           {
             int nbElem = 0; // init
             int nbPtInteg = 0; // init
             if (en_refN)
              { const ReferenceAF& reff = ((ReferenceAF &) *refi); // transfo en ref d'élément
                nbElem = reff.NumeroElem(i_ele);
                face = reff.NumeroFA(i_ele);
                nbPtInteg = (*idl).Val();
              }
             else // ils s'agit d'une ref de pti
              { const ReferencePtiAF & reff = ((ReferencePtiAF &) *refi);
                nbElem = reff.NumeroElem(i_ele);
                face = reff.NumeroFA(i_ele);
                nbPtInteg = reff.NumeroPti(i_ele);
              };
             Element& ele = lesMail->Element_LesMaille(n_mail,nbElem);
            
             // .... concernant les grandeurs quelconque .....
             if (!element_quelconque_retenu_pourSM.empty())
              {List_io<TypeQuelconque>::iterator jquefin=element_quelconque_retenu_pourSM.end();
               List_io<TypeQuelconque>::iterator jque,jque_deb=element_quelconque_retenu_pourSM.begin();
               if (jque_deb !=  jquefin) // c'est a dire: cas où existe une grandeur
                {// maintenant il y a deux cas, soit on travaille avec un seul pti soit
                 // on considère tous les pti, on va faire une boucle par défaut
                 int min_pti=nbPtInteg; int max_pti = nbPtInteg;
                 if (nbPtInteg == -1)
                  {min_pti = 1;
                   const ElFrontiere* elf = ele.Frontiere_surfacique(face);
                   max_pti = elf->ElementGeometrique().Nbi();
                  };
                 
                 for (int ipti = min_pti;ipti <= max_pti;ipti++)
                  {// puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
                   // on récupère ainsi d'un coup toutes les valeurs
                   ele.Grandeur_particuliere_face(absolue,element_quelconque_retenu_pourSM,face,ipti);
                   // on transfert dans le tableau
                   int num_enu = 1;
                   for (jque=jque_deb;jque!=jquefin;jque++,num_enu++)
                     {int nb_val = (*jque).NbMaxiNumeroOrdre();
                      Tableau <double >  &  pour_Quelconque = tab_pour_Quelconque(num_enu);
                      for (int i=1;i<= nb_val;i++)
                         pour_Quelconque(i) += (*jque).GrandeurNumOrdre(i);
                     };
                   // on incrément le compteur de somme
                   nb_pour_Quelconque++;
                  };
                };
               };
            
            
           };
          // --- incrémentation des pointeurs de ref ---
          if (en_refN)  {idl++;}
          else          { idl_Rpti++;};
        };

       // ---- on écrit les informations
       
       // écriture du temps que si il y a des ref 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
       int nbdigit = ParaGlob::NbdigdoGR();
       if ((NB_ref != 0) && ((!unseul_incre) || (style_de_sortie==1)))
         { sort << setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
       else if (NB_ref != 0)
         // ici on écrit une fois le temps en commentaire
         { sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
       
       for (int num_ref=1;num_ref <= NB_ref; num_ref++)
        {// ... les grandeurs quelconques
         {Tableau <Tableau <double > > & tab_pour_Quelconque = tab_tab_pour_Quelconque(num_ref);
          int   & nb_pour_Quelconque = tab_nb_pour_Quelconque(num_ref); // la taille de la somme
          for (int num_val = 1; num_val <= nb_TypeQuelconque; num_val++)
           { Tableau <double > &  pour_Quelconque = tab_pour_Quelconque(num_val);
             int taille = pour_Quelconque.Taille();
             sort << setprecision(nbdigit);
             // on sort les sommes
             for (int i=1;i<=taille;i++)
               sort << pour_Quelconque(i) << " ";
             // puis les moyennes
             for (int i=1;i<=taille;i++)
               sort << (pour_Quelconque(i)/nb_pour_Quelconque) << " ";
           };
         };
        }; // fin de la boucle sur les références
     };
    };
     
};
// sortie pour les moyennes sommes etc. sur ref d'arête E
void Choix_grandeurs_maple::Sortie_somme_moy_arete_E(ostream &sort,Charge* charge,bool unseul_incre)
{ // on boucle sur les maillages
  int nb_maillage = tab_A_element_TypeQuelconque.Taille();
  for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
    {
     // ---- préparation des conteneurs de sortie
     int NB_ref_E = tab_nomDeRef_A_E_SM(n_mail).size(); // = le nombre de ref
     int NB_ref_pti = tab_nomDeRef_A_ptinteg_SM(n_mail).size(); // pour les pti
     int NB_ref = NB_ref_E + NB_ref_pti;
     // on ne continue que s'il existe des ref
     if (NB_ref)
      {
       // on veut : (1) la somme, (2) la moyenne, (3) le max, (4) le min, (5) le max des | | , (6) le min des | |
       // tab_tab_pour_ddl_etendu(i)(j)(k) : la grandeur k pour le ddl etendu j de la ref i
       // tab_tab_pour_MAXI_ddl_etendu(i)(j)(k) : k= 1 -> le numéro de l'element pour le max
       //                                         k= 2 -> le numéro de l'element pour le min
       //                                         k= 3 -> le numéro de l'element pour le max des | |
       //                                         k= 4 -> le numéro de l'element pour le min des | |
       //                                         k= 5 -> le numéro du pti pour le max
       //                                         k= 6 -> le numéro du pti pour le min
       //                                         k= 7 -> le numéro du pti pour le max des | |
       //                                         k= 8 -> le numéro du pti pour le min des | |
       
       // pour les grandeurs quelconques, on ne considère que la somme et la moyenne des grandeurs brutes
       List_io < TypeQuelconque > & element_quelconque_retenu_pourSM = tab_A_element_TypeQuelconque_retenu_pourSM(n_mail);
       int nb_TypeQuelconque = element_quelconque_retenu_pourSM.size();
       Tableau < Tableau <double > > tab_inter_Q(nb_TypeQuelconque); // pour le dimensionnement final
       // on dimensionne en fonction de la taille de la grandeur quelconque
       {List_io<TypeQuelconque>::iterator ienu,ienufin=element_quelconque_retenu_pourSM.end();
        int num_enu = 1;
        for (ienu = element_quelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
           {int nb_val = (*ienu).NbMaxiNumeroOrdre();
            Tableau <double > & inter = tab_inter_Q(num_enu);
            inter.Change_taille(nb_val);
           };
       };
       Tableau < Tableau <Tableau <double > > >  tab_tab_pour_Quelconque(NB_ref,tab_inter_Q);
       Tableau < int >  tab_nb_pour_Quelconque(NB_ref); // la taille de la somme

       Tableau < int > tab_ref_taille(NB_ref);

       // ---- on balaie les références de listes des elements pour récupérer les informations
       List_io <BlocScal >::iterator idl = tab_nomDeRef_A_E_SM(n_mail).begin();
       List_io < string >::iterator idl_Rpti = tab_nomDeRef_A_ptinteg_SM(n_mail).begin();
       
       for (int num_ref=1;num_ref <= NB_ref; num_ref++)
        { Tableau <Tableau <double > > & tab_pour_Quelconque = tab_tab_pour_Quelconque(num_ref);
          int   & nb_pour_Quelconque = tab_nb_pour_Quelconque(num_ref); // la taille de la somme
         
          // recup de la reference correspondant au mot cle
          const Reference  * refi=NULL; // init
          int taillen=0; // init
          bool en_refN=true; // pour savoir ensuite si on est en refN ou refAF
          if (num_ref < NB_ref_E+1)
           { refi = &(lesRef->Trouve((*idl).NomRef(),n_mail));
             const ReferenceAF& reff_E = ((ReferenceAF &) *refi); // transfo en ref de faces d'élément
             taillen=reff_E.Taille();
             tab_ref_taille(num_ref)=taillen; // on stocke pour les moyennes
           }
          else // ils s'agit d'une ref de pti de faces d'élément
           { refi = &(lesRef->Trouve((*idl_Rpti),n_mail));
             const ReferencePtiAF & reff_AF = ((ReferencePtiAF &) *refi); // transfo en ref de pti de face d'élément
             taillen=reff_AF.Taille();
             tab_ref_taille(num_ref)=taillen; // on stocke pour les moyennes
             en_refN=false;
           };
          int arete = 0; // init
          for (int i_ele=1;i_ele<=taillen;i_ele++)  // on boucle sur  les elements
           {
             int nbElem = 0; // init
             int nbPtInteg = 0; // init
             if (en_refN)
              { const ReferenceAF& reff = ((ReferenceAF &) *refi); // transfo en ref de face d'élément
                nbElem = reff.NumeroElem(i_ele);
                arete = reff.NumeroFA(i_ele);
                nbPtInteg = (*idl).Val();
              }
             else // ils s'agit d'une ref de pti d'arete
              { const ReferencePtiAF & reff = ((ReferencePtiAF &) *refi);
                nbElem = reff.NumeroElem(i_ele);
                arete = reff.NumeroFA(i_ele);
                nbPtInteg = reff.NumeroPti(i_ele);
              };
             Element& ele = lesMail->Element_LesMaille(n_mail,nbElem);
            
             // .... concernant les grandeurs quelconque .....
             if (!element_quelconque_retenu_pourSM.empty())
              {List_io<TypeQuelconque>::iterator jquefin=element_quelconque_retenu_pourSM.end();
               List_io<TypeQuelconque>::iterator jque,jque_deb=element_quelconque_retenu_pourSM.begin();
               if (jque_deb !=  jquefin) // c'est a dire: cas où existe une grandeur
                {// maintenant il y a deux cas, soit on travaille avec un seul pti soit
                 // on considère tous les pti, on va faire une boucle par défaut
                 int min_pti=nbPtInteg; int max_pti = nbPtInteg;
                 if (nbPtInteg == -1)
                  {min_pti = 1;
                   const ElFrontiere* elf = ele.Frontiere_lineique(arete);
                   max_pti = elf->ElementGeometrique().Nbi();
                  };
                 
                 for (int ipti = min_pti;ipti <= max_pti;ipti++)
                  {// puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
                   // on récupère ainsi d'un coup toutes les valeurs
                   ele.Grandeur_particuliere_arete(absolue,element_quelconque_retenu_pourSM,arete,ipti);
                   // on transfert dans le tableau
                   int num_enu = 1;
                   for (jque=jque_deb;jque!=jquefin;jque++,num_enu++)
                     {int nb_val = (*jque).NbMaxiNumeroOrdre();
                      Tableau <double >  &  pour_Quelconque = tab_pour_Quelconque(num_enu);
                      for (int i=1;i<= nb_val;i++)
                         pour_Quelconque(i) += (*jque).GrandeurNumOrdre(i);
                     };
                   // on incrément le compteur de somme
                   nb_pour_Quelconque++;
                  };
                };
               };
            
            
           };
          // --- incrémentation des pointeurs de ref ---
          if (en_refN)  {idl++;}
          else          { idl_Rpti++;};
        };

       // ---- on écrit les informations
       
       // écriture du temps que si il y a des ref 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
       int nbdigit = ParaGlob::NbdigdoGR();
       if ((NB_ref != 0) && ((!unseul_incre) || (style_de_sortie==1)))
         { sort << setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
       else if (NB_ref != 0)
         // ici on écrit une fois le temps en commentaire
         { sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
       
       for (int num_ref=1;num_ref <= NB_ref; num_ref++)
        {// ... les grandeurs quelconques
         {Tableau <Tableau <double > > & tab_pour_Quelconque = tab_tab_pour_Quelconque(num_ref);
          int   & nb_pour_Quelconque = tab_nb_pour_Quelconque(num_ref); // la taille de la somme
          for (int num_val = 1; num_val <= nb_TypeQuelconque; num_val++)
           { Tableau <double > &  pour_Quelconque = tab_pour_Quelconque(num_val);
             int taille = pour_Quelconque.Taille();
             sort << setprecision(nbdigit);
             // on sort les sommes
             for (int i=1;i<=taille;i++)
               sort << pour_Quelconque(i) << " ";
             // puis les moyennes
             for (int i=1;i<=taille;i++)
               sort << (pour_Quelconque(i)/nb_pour_Quelconque) << " ";
           };
         };
        }; // fin de la boucle sur les références
     };
    };
     
};
// sortie de l'entete pour les moyennes sommes etc. sur ref de face E
void Choix_grandeurs_maple::Sortie_entete_somme_moy_face_E(ostream &sort,int & num_col)
{ // on boucle sur les maillages
  int nb_maillage = tab_F_element_TypeQuelconque.Taille();
  for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
    {// ---- préparation
     // ---- préparation des conteneurs de sortie
     int NB_ref_E = tab_nomDeRef_F_E_SM(n_mail).size(); // = le nombre de ref
     int NB_ref_pti = tab_nomDeRef_F_ptinteg_SM(n_mail).size(); // pour les pti
     int NB_ref = NB_ref_E + NB_ref_pti;
     int num_total_grandeur=0;

     // pour les grandeurs quelconques, on ne considère que la somme et la moyenne des grandeurs brutes
     List_io < TypeQuelconque > &TypeQuelconque_retenu_pourSM = tab_F_element_TypeQuelconque_retenu_pourSM(n_mail);
     //int nb_TypeQuelconque = TypeQuelconque_retenu_pourSM.size();
     // on dimensionne en fonction de la taille de la grandeur quelconque
     {List_io<TypeQuelconque>::iterator ienu,ienufin=TypeQuelconque_retenu_pourSM.end();
      int num_enu = 1;
      for (ienu = TypeQuelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
         {int nb_val = (*ienu).NbMaxiNumeroOrdre();
          num_total_grandeur += nb_val*2;
         };
     };
     
     if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
     else {sort << "\n# mesh_" << n_mail << " : "; };
     sort << NB_ref << " "<< num_total_grandeur*NB_ref << " ";
     if (ParaGlob::Francais()) {sort << "  (nombre de ref de faces d'element et nombre total de grandeurs associees) "; }
     else {sort << "  (number of ref of element facets and global number of associated values ) "; }
//     if (NB_ref != 0)
//      {if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
//       else {sort << "\n# mesh_" << n_mail << " : "; };
//      }
     sort << "\n# ";
     if (NB_ref != 0)
            num_col++; // on passe l'affichage du temps
     // puis les ref s'il y en a
     if (NB_ref != 0)
      {List_io <BlocScal >::iterator idl = tab_nomDeRef_F_E_SM(n_mail).begin();
       List_io < string >::iterator idl_Rpti = tab_nomDeRef_F_ptinteg_SM(n_mail).begin();
       
       for (int num_ref=1;num_ref <= NB_ref; num_ref++)
        {   string nom_ref; // init
            // recup de la reference correspondant au mot cle
            const Reference  * refi=NULL; // init
            int taillen=0; // init
            bool en_refN=true; // pour savoir ensuite si on est refAF ou PtiAF
            if (num_ref < NB_ref_E+1)
             { nom_ref = (*idl).NomRef();
               refi = &(lesRef->Trouve(nom_ref,n_mail));
               const ReferenceAF& reff_E = ((ReferenceAF &) *refi); // transfo en ref d'élément
               taillen=reff_E.Taille();
             }
            else // ils s'agit d'une ref de pti de faces d'éléments
             { nom_ref = (*idl_Rpti);
               refi = &(lesRef->Trouve(nom_ref,n_mail));
               const ReferencePtiAF & reff_AF = ((ReferencePtiAF &) *refi); // transfo en ref d'élément
               taillen=reff_AF.Taille();
               en_refN=false;
            };
           if (num_ref > 1) sort << "\n# ";
           sort << nom_ref << " "; // le nom de la ref
           sort << "( "<< taillen << " ) " << num_total_grandeur << " "; // le nombre d'éléments
           if (ParaGlob::Francais()) {sort << "  (ref, (nombre de face d'element), nombre total de valeurs ) "; }
           else                      {sort << "  (ref name, (number of element facet) total number of values) "; };

           // === les positions de chaque grandeurs ===
           
           //  --- les grandeurs quelconques ---
           {List_io<TypeQuelconque>::iterator iquefin=tab_F_element_TypeQuelconque_retenu_pourSM(n_mail).end();
            List_io<TypeQuelconque>::iterator ique,ique_deb=tab_F_element_TypeQuelconque_retenu_pourSM(n_mail).begin();
            for (ique = ique_deb;ique != iquefin;ique++)
              {sort << "\n#"; (*ique).Ecriture_entete_grandeur(sort);
               sort << " (somme) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
               num_col += (*ique).NbMaxiNumeroOrdre();
               sort << " (moyenne) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
               num_col += (*ique).NbMaxiNumeroOrdre();
               //sort << "\n#     ";
              };
           };

          // --- incrémentation des pointeurs de ref ---
          if (en_refN)  {idl++;}
          else          { idl_Rpti++;};
        };
       sort << " ;\n# ";
      };
   };
 
};
// sortie de l'entete pour les moyennes sommes etc. sur ref d'arête E
void Choix_grandeurs_maple::Sortie_entete_somme_moy_arete_E(ostream &sort,int & num_col)
{ // on boucle sur les maillages
  int nb_maillage = tab_A_element_TypeQuelconque.Taille();
  for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
    {// ---- préparation
     // ---- préparation des conteneurs de sortie
     int NB_ref_E = tab_nomDeRef_A_E_SM(n_mail).size(); // = le nombre de ref
     int NB_ref_pti = tab_nomDeRef_A_ptinteg_SM(n_mail).size(); // pour les pti
     int NB_ref = NB_ref_E + NB_ref_pti;
     int num_total_grandeur=0;

     // pour les grandeurs quelconques, on ne considère que la somme et la moyenne des grandeurs brutes
     List_io < TypeQuelconque > &TypeQuelconque_retenu_pourSM = tab_A_element_TypeQuelconque_retenu_pourSM(n_mail);
     //int nb_TypeQuelconque = TypeQuelconque_retenu_pourSM.size();
     // on dimensionne en fonction de la taille de la grandeur quelconque
     {List_io<TypeQuelconque>::iterator ienu,ienufin=TypeQuelconque_retenu_pourSM.end();
      int num_enu = 1;
      for (ienu = TypeQuelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
         {int nb_val = (*ienu).NbMaxiNumeroOrdre();
          num_total_grandeur += nb_val*2;
         };
     };
     
     if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
     else {sort << "\n# mesh_" << n_mail << " : "; };
     sort << NB_ref << " "<< num_total_grandeur*NB_ref << " ";
     if (ParaGlob::Francais()) {sort << "  (nombre de ref d'arete d'element et nombre total de grandeurs associees) "; }
     else {sort << "  (number of ref of element edges and global number of associated values ) "; }
//     if (NB_ref != 0)
//      {if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
//       else {sort << "\n# mesh_" << n_mail << " : "; };
//      }
     sort << "\n# ";
     if (NB_ref != 0)
            num_col++; // on passe l'affichage du temps
     // puis les ref s'il y en a
     if (NB_ref != 0)
      {List_io <BlocScal >::iterator idl = tab_nomDeRef_A_E_SM(n_mail).begin();
       List_io < string >::iterator idl_Rpti = tab_nomDeRef_A_ptinteg_SM(n_mail).begin();
       
       for (int num_ref=1;num_ref <= NB_ref; num_ref++)
        {   string nom_ref; // init
            // recup de la reference correspondant au mot cle
            const Reference  * refi=NULL; // init
            int taillen=0; // init
            bool en_refN=true; // pour savoir ensuite si on est refAF ou PtiAF
            if (num_ref < NB_ref_E+1)
             { nom_ref = (*idl).NomRef();
               refi = &(lesRef->Trouve(nom_ref,n_mail));
               const ReferenceAF& reff_E = ((ReferenceAF &) *refi); // transfo en ref d'élément
               taillen=reff_E.Taille();
             }
            else // ils s'agit d'une ref de pti d'arete d'éléments
             { nom_ref = (*idl_Rpti);
               refi = &(lesRef->Trouve(nom_ref,n_mail));
               const ReferencePtiAF & reff_AF = ((ReferencePtiAF &) *refi); // transfo en ref d'aretes d'élément
               taillen=reff_AF.Taille();
               en_refN=false;
            };
           if (num_ref > 1) sort << "\n# ";
           sort << nom_ref << " "; // le nom de la ref
           sort << "( "<< taillen << " ) " << num_total_grandeur << " "; // le nombre d'éléments
           if (ParaGlob::Francais()) {sort << "  (ref, (nombre de arete d'element), nombre total de valeurs ) "; }
           else                      {sort << "  (ref name, (number of edges) total number of values) "; };

           // === les positions de chaque grandeurs ===
           
           //  --- les grandeurs quelconques ---
           {List_io<TypeQuelconque>::iterator iquefin=tab_F_element_TypeQuelconque_retenu_pourSM(n_mail).end();
            List_io<TypeQuelconque>::iterator ique,ique_deb=tab_F_element_TypeQuelconque_retenu_pourSM(n_mail).begin();
            for (ique = ique_deb;ique != iquefin;ique++)
              {sort << "\n#"; (*ique).Ecriture_entete_grandeur(sort);
               sort << " (somme) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
               num_col += (*ique).NbMaxiNumeroOrdre();
               sort << " (moyenne) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
               num_col += (*ique).NbMaxiNumeroOrdre();
               //sort << "\n#     ";
              };
           };

          // --- incrémentation des pointeurs de ref ---
          if (en_refN)  {idl++;}
          else          { idl_Rpti++;};
        };
       sort << " ;\n# ";
      };
   };
 
};




   
