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

#include "Isovaleurs_Gmsh.h"

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

// choix de l'isovaleur à visualiser calculée à partir des grandeurs évoluées aux points d'intégrations
void Isovaleurs_Gmsh::ChoixIsovaleur_tensorielle_ptinteg(const string& choix)
 { // tout d'abord on traite le cas de tous les isovaleurs
   if (choix=="to")
    { tabelement_evoluee_retenu = tabelement_evoluee;
      return;
    }
   else if (choix=="de")
    { // on prend le premier élément de chaque maillage et on statut en fonction de son type
      int nbmail = tabelement_evoluee.Taille();
      for (int imail = 1;imail<=nbmail;imail++)
       {List_io < TypeQuelconque >& element_evoluee = tabelement_evoluee(imail); // pour simplifier
        List_io < TypeQuelconque >& element_evoluee_retenu = tabelement_evoluee_retenu(imail); // pour simplifier
        List_io < TypeQuelconque >::iterator iq,iqfin=element_evoluee.end();
        List_io < TypeQuelconque >::iterator iqev,iqevfin;
        Element& ele = lesMail->Element_LesMaille(imail,1);
        Element::Signature signa =  ele.Signature_element();
        switch (signa.id_problem)
         {case MECA_SOLIDE_DEFORMABLE:
           {// c'est avec les types évoluées que l'on travaille, on sort la contrainte et la déformation courante
            // tout d'abord les grandeurs communes:
            //   a) on sort les contraintes 
            for (iq=element_evoluee.begin();iq!=iqfin;iq++) 
                      {if ((*iq).EnuTypeQuelconque()== CONTRAINTE_COURANTE) break;};
            if (iq != iqfin) 
             { // on enregistre s'il n'existe pas déjà
               iqevfin=element_evoluee_retenu.end();
               for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++) 
                      {if ((*iqev).EnuTypeQuelconque()== CONTRAINTE_COURANTE) break;};
               if (iqev == iqevfin)element_evoluee_retenu.push_back(*iq);
             };
            //   b) et les déformations
            for (iq=element_evoluee.begin();iq!=iqfin;iq++) 
                      {if ((*iq).EnuTypeQuelconque()== DEFORMATION_COURANTE) break;};
            if (iq != iqfin) 
             { // on enregistre s'il n'existe pas déjà
               iqevfin=element_evoluee_retenu.end();
               for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++) 
                      {if ((*iqev).EnuTypeQuelconque()== DEFORMATION_COURANTE) break;};
               if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
             }; 
            // puis choix en fonction de l'évolution temporelle
            switch  (Evolution_temporelle_du_calcul(ParaGlob::param->TypeCalcul_maitre()))
             { case DYNAMIQUE:
                { // on sort les vitesses de déformation 
                  for (iq=element_evoluee.begin();iq!=iqfin;iq++) 
                      {if ((*iq).EnuTypeQuelconque()== VITESSE_DEFORMATION_COURANTE) break;};
                  if (iq != iqfin) 
                   { // on enregistre s'il n'existe pas déjà
                     iqevfin=element_evoluee_retenu.end();
                     for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++) 
                            {if ((*iqev).EnuTypeQuelconque()== VITESSE_DEFORMATION_COURANTE) break;};
                     if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
                   }; 
                  break;
                }
               default: break; // sinon pour l'instant on ne fait rien
             };
             break;
           } //-- fin du cas MECA_SOLIDE_DEFORMABLE
          default: 
            cout << "\n pour l'instant pas de parametre par defaut pour les pt integ !! "
                 << "\n pour le type de problem : " << NomElemTypeProblem(signa.id_problem) 
                 << "\n on continue sur le cas general ";
          };
       }; //-- fin de la boucle sur les maillages 
      return;
     };  
   // maintenant on traite le cas interactif
   string rep;
   bool choix_valide = false;   
   cout << "\n  choix d'isovaleur (grandeurs evoluees) venant des pts d'integ a visualiser ";
   int nbmail = tabelement_evoluee.Taille();
   // update du tableau evolues à visualiser si nécessaire
   if (tabelement_evoluee_retenu.Taille() != nbmail)
       tabelement_evoluee_retenu.Change_taille(nbmail);
   for (int imail = 1;imail<=nbmail;imail++)
    {// on ne traite que s'il y a des grandeurs disponibles
     if (tabelement_evoluee(imail).size() != 0 )
     {choix_valide=false;
      while (!choix_valide) // premier while
      {try 
        { cout << "\n (0 ou f ou fin) fin choix grandeurs tensorielles ";
          cout << "\n listes de type de grandeur tensorielles a visualiser ";
          // affichage des grandeurs retenues si la liste n'est pas vide
          if ((tabelement_evoluee_retenu(imail)).size())
             { cout << "\n Maillage nb: " << imail << "\n  liste des types de grandeurs enregistres:   ";  
               List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_evoluee_retenu(imail)).end();
               for (iet=(tabelement_evoluee_retenu(imail)).begin();iet!=ietfin;iet++)
                 cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
               cout << endl;  
             };
          cout << "\n Maillage nb: " << imail << " liste des types de grandeurs tensorielles disponibles ";
          List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_evoluee(imail)).end();
          for (iet=(tabelement_evoluee(imail)).begin();iet!=ietfin;iet++)
                     cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
          // le menu
          cout << "\n donner la grandeur a visulaliser "
               << "\n (to) toutes les grandeurs "
               << "\n (de) les grandeurs par defaut"
               << "\n (une liste de grandeurs tensorielles) "
               << "\n (ef)               pour effacer la liste "
               << "\n (0 ou f ou fin)    fin choix grandeur tensorielle "
               << "\n reponse ?  ";
          rep = lect_return_defaut(false,"f");
          if (rep == "fin_prog") Sortie(1);
          if (rep == "to")
           {// cas de toutes les grandeurs
            tabelement_evoluee_retenu(imail) = tabelement_evoluee(imail);
            choix_valide=false;
           };
          // sinon
          if ((rep == "0") || (rep == "f") || (rep == "fin")) 
            {choix_valide=true;}
          else if (rep=="ef")
            { tabelement_evoluee_retenu(imail).erase(tabelement_evoluee_retenu(imail).begin(),
                      tabelement_evoluee_retenu(imail).end());
            }
          else if (rep=="de")
            {List_io < TypeQuelconque >& element_evoluee = tabelement_evoluee(imail); // pour simplifier
             List_io < TypeQuelconque >& element_evoluee_retenu = tabelement_evoluee_retenu(imail); // pour simplifier
             List_io < TypeQuelconque >::iterator iq,iqfin=element_evoluee.end();
             List_io < TypeQuelconque >::iterator iqev,iqevfin;
             Element& ele = lesMail->Element_LesMaille(imail,1);
             Element::Signature signa =  ele.Signature_element();
             switch (signa.id_problem)
             {case MECA_SOLIDE_DEFORMABLE:
               {// c'est avec les types évoluées que l'on travaille, on sort la contrainte et la déformation courante
                // tout d'abord les grandeurs communes:
                //   a) on sort les contraintes 
                for (iq=element_evoluee.begin();iq!=iqfin;iq++) 
                          {if ((*iq).EnuTypeQuelconque()== CONTRAINTE_COURANTE) break;};
                if (iq != iqfin) 
                 { // on enregistre s'il n'existe pas déjà
                   iqevfin=element_evoluee_retenu.end();
                   for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++) 
                      {if ((*iqev).EnuTypeQuelconque()== CONTRAINTE_COURANTE) break;};
                   if (iqev == iqevfin)element_evoluee_retenu.push_back(*iq);
                 };
                //   b) et les déformations
                for (iq=element_evoluee.begin();iq!=iqfin;iq++) 
                          {if ((*iq).EnuTypeQuelconque()== DEFORMATION_COURANTE) break;};
                if (iq != iqfin) 
                  { // on enregistre s'il n'existe pas déjà
                    iqevfin=element_evoluee_retenu.end();
                    for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++) 
                      {if ((*iqev).EnuTypeQuelconque()== DEFORMATION_COURANTE) break;};
                    if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
                  }; 
                // puis choix en fonction de l'évolution temporelle
                switch  (Evolution_temporelle_du_calcul(ParaGlob::param->TypeCalcul_maitre()))
                 { case DYNAMIQUE:
                    { // on sort les vitesses de déformation 
                      for (iq=element_evoluee.begin();iq!=iqfin;iq++) 
                          {if ((*iq).EnuTypeQuelconque()== VITESSE_DEFORMATION_COURANTE) break;};
                      if (iq != iqfin) 
                       { // on enregistre s'il n'existe pas déjà
                         iqevfin=element_evoluee_retenu.end();
                         for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++) 
                            {if ((*iqev).EnuTypeQuelconque()== VITESSE_DEFORMATION_COURANTE) break;};
                         if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
                       }; 
                      break;
                    }
                   default: break; // sinon pour l'instant on ne fait rien
                 };
                break;
               } //-- fin du cas MECA_SOLIDE_DEFORMABLE
              default: 
                  cout << "\n pour l'instant pas de parametre par defaut pour les pt integ !! "
                       << "\n pour le type de problem : " << NomElemTypeProblem(signa.id_problem) 
                       << "\n on continue sur le cas general ";
             };
           }
          else if (TypeQuelconque_enum_etendu::VerifExistence(rep) ) // vérif que c'est une grandeur possible
            { // maintenant on vérifie qu'elle appartient à la liste des grandeurs disponibles
              TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
              List_io<TypeQuelconque>& tpg_ret = (tabelement_evoluee_retenu(imail)); // pour simplifier
              List_io<TypeQuelconque>& tpg = (tabelement_evoluee(imail)); // pour simplifier
              if (find(tpg.begin(),tpg.end(),a) != tpg.end())
                { // il existe -> enregistrement
                  List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                  // s'il n'existe pas déjà on l'enregistre vraiment
                  if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                       tpg_ret.push_back(*il);
                }
              else
                { cout << "\n erreur, grandeur non disponible !, recommencez ";};
            };
        }
       catch (ErrSortieFinale)
            // cas d'une direction voulue vers la sortie
            // on relance l'interuption pour le niveau supérieur
          { ErrSortieFinale toto;
            throw (toto);
          }
       catch (...)// erreur en lecture
        {  cout << "\n Erreur dans la lecture evolues !!, "
                << "\n redonnez une bonne valeur"
                << "\n ou taper fin_prog pour arreter le programme";
           choix_valide=false;
        };
      }; //-- fin du premier while
      tabelement_evoluee_retenu(imail).sort(); // on ordonne
      tabelement_evoluee_retenu(imail).unique();// on supprime les doublons                           
     }; //-- fin de if (tabelement_typeParti(imail).size() != 0 )                          
    };//-- fin de la boucle sur les maillages  
 };  
  
// choix de l'isovaleur à visualiser calculée à partir des grandeurs quelconques aux points d'intégrations
void Isovaleurs_Gmsh::ChoixIsovaleur_quelc_ptinteg(const string& choix)
 { // tout d'abord on traite le cas de tous les isovaleurs
   if (choix=="to")
    { tabelement_typeParti_retenu = tabelement_typeParti;
      return;
     }
   else if (choix=="de")
    { // pour l'instant aucun éléments par défaut
      return;
     };  
   // maintenant on traite le cas interactif   
   bool choix_valide = false;
   string rep;
   cout << "\n  choix d'isovaleur venant des pts d'integ a visualiser (de type grandeurs particulieres) ";
   int nbmail = tabelement_typeParti.Taille();
   // update du tableau de ddl à visualiser si nécessaire
   if (tabelement_typeParti_retenu.Taille() != nbmail)
       tabelement_typeParti_retenu.Change_taille(nbmail);

   for (int imail = 1;imail<=nbmail;imail++)
    {// on ne traite que s'il y a des grandeurs disponibles
     if (tabelement_typeParti(imail).size() != 0 )
     {choix_valide=false;
      while (!choix_valide) // premier while
      {try 
        { cout << "\n (0 ou f ou fin) fin choix grandeurs particulieres ";
          cout << "\n listes de type de grandeur particuliere a visualiser ";
          // affichage des ddl retenues si la liste n'est pas vide
          if ((tabelement_typeParti_retenu(imail)).size())
                 { cout << "\n Maillage nb: " << imail << "\n  liste des types de grandeurs enregistres:   ";  
                   List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_typeParti_retenu(imail)).end();
                   for (iet=(tabelement_typeParti_retenu(imail)).begin();iet!=ietfin;iet++)
                     {cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
                     };
                   cout << endl;  
                  };
          cout << "\n Maillage nb: " << imail << " liste des types de grandeur particuliere disponibles ";
          List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_typeParti(imail)).end();
          for (iet=(tabelement_typeParti(imail)).begin();iet!=ietfin;iet++)
                     cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
          cout << "\n donner la grandeur particuliere a visualiser "
               << "\n (to) tous les grandeurs particulieres "
               << "\n ou une liste de grandeurs particulieres "
               << "\n (0 ou f ou fin) fin choix de grandeurs particulieres "
               << "\n reponse ?  ";
          rep = lect_return_defaut(false,"f");
          if (rep == "fin_prog") Sortie(1);
          if (rep == "to")
           {// cas de tous les ddl
            tabelement_typeParti_retenu(imail) = tabelement_typeParti(imail);
            choix_valide=false;
            };
          // sinon
          if ((rep == "0") || (rep == "f") || (rep == "fin")) 
              {choix_valide=true;}
          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(imail)); // pour simplifier
              List_io<TypeQuelconque>& tpg = (tabelement_typeParti(imail)); // pour simplifier
              if (find(tpg.begin(),tpg.end(),a) != tpg.end())
                { // il existe -> enregistrement
                  List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
                  // s'il n'existe pas déjà on l'enregistre vraiment
                  if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
                       tpg_ret.push_back(*il);
                  }
              else
                { cout << "\n erreur, grandeur non disponible !, recommencez ";};
             }
          }
        catch (ErrSortieFinale)
             // cas d'une direction voulue vers la sortie
             // on relance l'interuption pour le niveau supérieur
           { ErrSortieFinale toto;
             throw (toto);
           }
        catch (...)// erreur en lecture
          {  cout << "\n Erreur dans la lecture de grandeur particuliere !!, "
                  << "\n redonnez une bonne valeur"
                  << "\n ou taper fin_prog pour arreter le programme"; 
             choix_valide=false;
           }
      } //-- fin du premier while 
      tabelement_typeParti_retenu(imail).sort(); // on ordonne
      tabelement_typeParti_retenu(imail).unique();// on supprime les doublons 
      }; //-- fin de if (tabelement_typeParti(imail).size() != 0 )                          
     }//-- fin de la boucle sur les maillages   
  };
  
// initialisation de l'exécution du  transferts
void Isovaleurs_Gmsh::InitPremierIncrExecutionTransfertAuxNoeuds() 
 { // cas du premier incrément et que l'on veut un transfert
   // l'objectif est d'initialiser de manière a doc les noeuds (introduire les grandeurs)
   // on boucle sur les maillages
   int nb_mail=lesMail->NbMaillage();
   for (int imail=1;imail<=nb_mail;imail++)
    { lesMail->AjoutConteneurAuNoeud(imail,glob_elem_ddl_retenu,tab_quelconque);
    };
 };
      
// définition interactives des paramètres généraux des isovaleurs
void Isovaleurs_Gmsh::ParametresGeneraux(const string& )
 {  bool choix_val = false;
    bool fr = ParaGlob::Francais();
    if (fr)
			   {cout << "\n -- parametres generaux pour la sortie des isovaleurs ";}
    else
			   {cout << "\n -- definition of the main parameters for the isovalues ";}
			 string rep;
			 while (!choix_val)
     {try
       {if (fr)
         {cout << "\n (0 ou f ou fin) fin modif"
               << "\n (1) sortie des tenseurs dans le repere absolu (par defaut) "
               << "\n (2) sortie des tenseurs dans un repere ad hoc, qui depend du type d'element ";
          cout << "\n \n reponse ? ";
         }
        else
         {cout << "\n (0 or f or end) end of modif"
               << "\n (1) output of the tensor componants in the global frame (default) "
               << "\n (2) output of the tensor componants in a specific local frame, depending of the element ";
          cout << "\n \n answers ? ";
         };
			     rep = lect_return_defaut(false,"f");
			     // sinon
			     int num = ChangeEntier(rep);
			     if ((rep == "0")||(rep == "f")||(rep == "end"))
			       { choix_val=true; }
			     else
			       { // def du type de sortie
			         if (num == 1) { absolue = true;}
			         else if (num == 2) { absolue = false;}
			         else 
			          { if (fr)
                {cout << "\n Erreur on attendait un entier entre 0 et 1 ou 2!!, "
			                   << "\n redonnez une bonne valeur";
                }
               else
                {cout << "\n Error the answers is an int in the range of 0..2 !!, "
			                   << "\n try again ";
                };
			            choix_val=false;
			          };
			       };
       }
     catch (ErrSortieFinale)
          // cas d'une direction voulue vers la sortie
          // on relance l'interuption pour le niveau supérieur
        { ErrSortieFinale toto;
          throw (toto);
        }
     catch (...)// erreur de lecture
            {if (fr)
               {cout << "\n Erreur on attendait un des mots cles proposés !!, "
                     << "\n redonnez une bonne valeur"
                     << "\n ou taper fin_prog pour arreter le programme";
               }
             else
               {cout << "\n error, we expect one of the proposed keywords  !!, "
                     << "\n try again to give a right answer "
                     << "\n or write 'f' in order to stop this menu ";
               };
               choix_val=false;
            };
    }; //-- fin du while
		
   return;
  };


// ---- cas de l'ancien format ---------
// sortie d'une view pour un type quelconque simple !!, c'est-à-dire pas un tableau par exemple
// en fait ne concerne que les types scalaires, vectoriels, ou tensoriels
// dans le cas où le type simple provient d'un tableau
// numero donne un numéro de l'élément à sortir dans l'entête de la view si diff de 0
void Isovaleurs_Gmsh::SortirUneViewTypeQuelconque_old_format(ostream & sort,TypeQuelconque_enum_etendu enu
                 ,EnumType2Niveau  enuStructure, int numero
                 ,Tableau <List_io < bool >::iterator >& t_indic_sortie,int nbmail
                 ,const Tableau <int>& tab_mail,EnumTypeGrandeur enugrandeur,LesMaillages * lesMail,const int& incre)
 {  // def de l'entete
    string nom((enu.NomPlein()));
    EnteteView(sort,incre,nom,numero);

    // ramène le tableau t_Egmsh
    // t_Egmsh(im)(ie): donne pour le maillage im, et pour l'élément ie, le numéro gmsh de l'élément
    const Tableau < Tableau < int > >& t_Egmsh = mailInitial->TabEgmsh(); 
    // récup de la connection herezh->gmsh
    // t_GmshHer(i)(j) : donne pour le noeud j de l'élément i de gmsh, le numéro d'herezh  
    const Tableau < Tableau < int > >& tGmshHer = Visualisation_Gmsh::Tab_GmshHer(); 

    // on définit un cas du type de celui géré par gmsh
    int castype = 0; 
    switch (enugrandeur)
         { case SCALAIRE: case SCALAIRE_ENTIER: case SCALAIRE_DOUBLE:
               {castype=1;break;}
         	case COORDONNEE: case COORDONNEEB:  case COORDONNEEH:
              {castype=2;break;}  
         	case  TENSEURBB: case TENSEURHH: 
              {castype=3;break;}
//         	case CHAINE_CAR:  // pour l'instant on n'a pas de type quelconque  pour le type caractère donc on ne met rien
//              {castype=4;break;}
          default:
             cout << "\n ***** erreur en sortie de la grandeur quelconque " << (enu.NomPlein())
                  << " le type " << NomType2Niveau(enuStructure) << "n'est pas gere par gmsh, le fichier resultat "
                  << " ne sera donc pas exploitable !! on continue quand meme !!"; 
             return;      
         };          

        for (int im =1; im <= nbmail; im++)
         {// on ne continue que si la grandeur quelconque est à sortir
          if (*(t_indic_sortie(im)))
          	{int numMail = tab_mail(im);
             int nbmaxelem = lesMail->Nombre_element(numMail);
             int dcaN = mailInitial->DecalNumNoeud(numMail);
             for (int numElem = 1; numElem <= nbmaxelem; numElem++)
          	   {Element& elem  = lesMail->Element_LesMaille(numMail,numElem); // récup de l'élément
                Tableau<Noeud *>& t_n = elem.Tab_noeud();
                int num_elem_gmsh = t_Egmsh(im)(numElem);  // numéro de classement du type d'élément gmsh
               // -- sortie du type de valeur: scalaire, vecteur ou tenseur
   // ***** a complèter pour les éléments quadratiques incomplet et les autres non possibles *****
               switch (castype)
                  { case 1: {sort << "\n" << tabScalVecTensGmsh.scalar_pourView(num_elem_gmsh)<< "(";break;}  
                  	 case 2: {sort << "\n" << tabScalVecTensGmsh.vector_pourView(num_elem_gmsh)<< "(";break;}  
                  	 case 3: {sort << "\n" << tabScalVecTensGmsh.tensor_pourView(num_elem_gmsh)<< "(";break;}
                  	 case 4: {sort << "\n" << tabScalVecTensGmsh.text_pourView(num_elem_gmsh)<< "(";break;}
                  };          
               // -- sortie des coordonnées 
               // on considère le nombre de noeuds de la sortie gmsh, et non celui de l'élément (qui peut-être
               // plus grand dans le cas d'un sfe, ou plus petit dans le cas d'un quadratique incomplet !)
               int nbNmax = tGmshHer(num_elem_gmsh).Taille(); //t_n.Taille();
               for (int ino=1;ino<=nbNmax;ino++) // ino = numéro gmsh
                { int num_her = tGmshHer(num_elem_gmsh)(ino); // --> num HZpp
                  int num_N = t_n(num_her)->Num_noeud()+dcaN; // num global
                  SortieUseUneCoordonnee(incre,sort,(ino == nbNmax),num_N);
                };
               // -- sortie des grandeurs
               for (int ino=1;ino<=nbNmax;ino++)
                {int num_her = tGmshHer(num_elem_gmsh)(ino); // --> num HZpp
                 const TypeQuelconque& tyret =  t_n(num_her)->Grandeur_quelconque(enu); // récup de la grandeur
                 switch (castype)
                  { case 1: // cas d'une grandeur scalaire (mais qui peut venir d'un tableau)
                      { switch (enuStructure)
                             {case TYPE_SIMPLE:{tyret.Const_Grandeur_pointee()->Grandeur_brut(sort,ParaGlob::NbdigdoGR());
                                                break;};
                              case TABLEAU_T: {Tab_Grandeur_scalaire_double* t_grandeur =
                                                   ((Tab_Grandeur_scalaire_double*) tyret.Const_Grandeur_pointee());
                                               Grandeur_scalaire_double& grandeur =t_grandeur->Grandeur_scalaire_associee(numero); 
                                               grandeur.Grandeur_brut(sort,ParaGlob::NbdigdoGR());
                                               break;};
                              default:
                                cout << "\n -1- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
                                     << NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
                                     << " la sortie gmsh le fichier resultat  ne sera donc pas exploitable !! on continue quand meme !!"
                                     << "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque_old_format(...";
                             };
                         break;
                      }
                  	case 2: // cas d'une grandeur vectorielle à trois coordonnées, si il y en a moins, il y a des 0 à la place 
                      { const TypeQuelconque::Grandeur& grandeur=*(tyret.Const_Grandeur_pointee()); // pour simplifier
                        switch (enuStructure)
                             {case TYPE_SIMPLE:{sort << setprecision(ParaGlob::NbdigdoGR())
									                                            << grandeur.GrandeurNumOrdre(1)
                                                     <<", "<<grandeur.GrandeurNumOrdre(2) <<","
                                                     << grandeur.GrandeurNumOrdre(3) ;
                                                break;};
                              case TABLEAU_T: 
                                {Tab_Grandeur_Coordonnee* tab_coor = ((Tab_Grandeur_Coordonnee*) tyret.Const_Grandeur_pointee());
                                 int taille = tab_coor->Taille();
                                 // on boucle, et on sort  chaque coordonnée
                                 for (int i=1;i<=taille;i++)
                                   { const Grandeur_coordonnee&  coor = tab_coor->Grandeur_Coordonnee_associee(i);
                                     sort << setprecision(ParaGlob::NbdigdoGR())
												                              << coor.GrandeurNumOrdre(1) <<", "<<coor.GrandeurNumOrdre(2) <<"," 
                                          << coor.GrandeurNumOrdre(3) ;
                                 	 };
                                 break;
                                }
                              // pour l'instant il n'y a pas de tableau de coordonnée qui existe donc on ne met rien d'autre
                              default:
                                cout << "\n -2- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
                                     << NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
                                     << " la sortie gmsh le fichier resultat  ne sera donc pas exploitable !! on continue quand meme !!"
                                     << "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque_old_format(...";
                             };
                         break;
                      }
                  	case 3: // cas d'une grandeur tensorielle: forcément de dimension 9 (mais qui appartenir à un tableau
                       { const TypeQuelconque::Grandeur& grandeur=*(tyret.Const_Grandeur_pointee()); // pour simplifier
                         switch (enuStructure)
                           {case TYPE_SIMPLE:
                             { switch (grandeur.Type_grandeurAssocie())
                               { case TENSEURBB: 
                                   { const TenseurBB& t_BB =  ((Grandeur_TenseurBB*) &grandeur)->RefConteneurTenseur();
                                     Isovaleurs_Gmsh::SortieTenseurBB_ancien_format(sort,t_BB);
                                     break;                  
                                    }
                                 case TENSEURHH:
                                   { const TenseurHH& t_HH =  ((Grandeur_TenseurHH*) &grandeur)->RefConteneurTenseur();
                                     Isovaleurs_Gmsh::SortieTenseurHH_ancien_format(sort,t_HH);
                                     break;                  
                                    }
                                 default:
                                   cout << "\n -3- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
                                        << NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
                                        << " la sortie gmsh le fichier resultat  ne sera donc pas exploitable !! on continue quand meme !!"
                                        << "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque_old_format(...";
                                };
                               break;
                             }
                            case TABLEAU_T: 
                              {switch (grandeur.Type_grandeurAssocie())
                               {case TENSEURHH:
                                   { const Tab_Grandeur_TenseurHH* g_t_t_HH =  ((Tab_Grandeur_TenseurHH*) &grandeur);
                                     const Grandeur_TenseurHH& g_t_HH = g_t_t_HH->Grandeur_TenseurHH_associee(numero);
                                     const TenseurHH& t_HH =  g_t_HH.RefConteneurTenseur();
                                     Isovaleurs_Gmsh::SortieTenseurHH_ancien_format(sort,t_HH);
                                     break;                  
                                    }
                                // pour l'instant il n'y a que les tableaux de tenseurHH qui existent    
                                default:
                                   cout << "\n -4- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
                                        << NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
                                        << " la sortie gmsh le fichier resultat  ne sera donc pas exploitable !! on continue quand meme !!"
                                        << "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque_old_format(...";
                               };
                               break;
                              }

                            // pour l'instant il n'y a que les types simples et les tableaux qui sont pris en compte pour les tenseurs   
                            default:
                               cout << "\n -5- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
                                    << NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
                                    << " la sortie gmsh le fichier resultat  ne sera donc pas exploitable !! on continue quand meme !!"
                                    << "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque_old_format(...";
                           }; // fin du switch (enuStructure) pour les tenseurs
                         break;
                       } //-- fin du cas castype = 3 c-a-d des cas relatifs aux tenseurs 
                  }; //-- fin du switch (castype) 
                 // gestion des fins de ligne 
                 if (ino != nbNmax)  {sort <<", ";} 
                 else                {sort <<"};";};
              
                }; //-- fin de la boucle sur les noeuds de l'éléments
          	   }; //-- fin de la boucle sur les éléments
          	}; //-- fin du test if (*(t_indic_sortie(im))) 
         }; //-- fin de la boucle sur les maillage
        // fin de la view
        sort << "\n }; "; 
 };
// sortie d'une view pour un type quelconque simple !!, c'est-à-dire pas un tableau par exemple
// en fait ne concerne que les types scalaires, vectoriels, ou tensoriels
// dans le cas où le type simple provient d'un tableau
// numero donne un numéro de l'élément à sortir dans l'entête de la view si diff de 0
void Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(ostream & sort,TypeQuelconque& typ
                 ,EnumType2Niveau  enuStructure, int numero
                 ,Tableau <List_io < bool >::iterator >& t_indic_sortie,int nbmail
                 ,const Tableau <int>& tab_mail,EnumTypeGrandeur enugrandeur,LesMaillages * lesMail,const int& incre)
 {  	  
    // récup du temps actuel
    double temps_actuel = ParaGlob::Variables_de_temps().TempsCourant();
    TypeQuelconque_enum_etendu enu = typ.EnuTypeQuelconque();
    EnuTypeQuelParticulier enu_particulier
         =  typ.Const_Grandeur_pointee()->Type_enumGrandeurParticuliere();

    // on définit un cas du type de celui géré par gmsh
    int castype = 0;int NB_val = 0; 
    switch (enugrandeur)
      {case SCALAIRE: case SCALAIRE_ENTIER: case SCALAIRE_DOUBLE:
            {castype=1;NB_val=1;break;}
      	case COORDONNEE: case COORDONNEEB:  case COORDONNEEH:
           {castype=2;NB_val=3; break;}
       case BASE__H: // en fait une base est traite comme un ensemble de une grandeur
                     //  COORDONNEE par axe de la base
                     // donc arrivée ici on sort une grandeur COORDONNEE de numéro i
           {castype=5;NB_val=3;
            break;
           }
      	case  TENSEURBB: case TENSEURHH:
           {castype=3;NB_val=9;break;}
       case VECTEUR: // pas géré par gmsh directement
           {int nb_double = 0;
            switch (enuStructure)
              { case TYPE_SIMPLE:
                 {
                   if (enu_particulier == PARTICULIER_VECTEUR_NOMMER)
                     {Grandeur_Vecteur_Nommer* t_grandeur =
                           ((Grandeur_Vecteur_Nommer*) typ.Const_Grandeur_pointee());
                      nb_double = t_grandeur->ConteneurVecteur().Taille();
                      castype=4;
                     }
                    else if (enu_particulier == PARTICULIER_VECTEUR)
                     {Grandeur_Vecteur* t_grandeur =
                           ((Grandeur_Vecteur*) typ.Const_Grandeur_pointee());
                      nb_double = t_grandeur->ConteneurVecteur()->Taille();
                      castype=6;
                     }
                  break;
                 };
                case TABLEAU_T:
                 {
                   if (enu_particulier == PARTICULIER_TABLEAU_VECTEUR_NOMMER)
                     {Tab_Grandeur_Vecteur_Nommer* t_grandeur =
                           ((Tab_Grandeur_Vecteur_Nommer*) typ.Const_Grandeur_pointee());
                      Grandeur_Vecteur_Nommer& grn = (*t_grandeur)(numero);
                      nb_double = grn.ConteneurVecteur().Taille();
                      castype=4;
                     }
                    else if (enu_particulier == PARTICULIER_TABLEAU_VECTEUR)
                     {Tab_Grandeur_Vecteur* t_grandeur =
                           ((Tab_Grandeur_Vecteur*) typ.Const_Grandeur_pointee());
                      const Grandeur_Vecteur& grn = (*t_grandeur)(numero);
                      nb_double = grn.ConteneurVecteur_const().Taille();
                      castype=6;
                     }
                  break;
                 }
                default:
                 cout << "\n ***** erreur en sortie de la grandeur quelconque " << (enu.NomPlein()  )
                      << " le type " << NomType2Niveau(enuStructure) << "n'est pas gere par gmsh, le fichier resultat "
                      << " ne sera donc pas exploitable !! on continue quand meme !!";
                 return;
              };
            switch (nb_double)
              { case 1: NB_val=1; break;
                case 2: case 3: NB_val=3; break;
                case 4: case 5: case 6: NB_val=6; break;
                default: // cas non prévu pour l'instant dans gmsh
                 cout << "\n ***** erreur en sortie de la grandeur quelconque " << enu.NomPlein()
                      << " le type " << NomType2Niveau(enuStructure) << "n'est pas gere par gmsh, le fichier resultat "
                      << " ne sera donc pas exploitable !! on continue quand meme !!";
                 return;
             };
            break;
           }
//      	case CHAINE_CAR:  // pour l'instant on n'a pas de type quelconque  pour le type caractère donc on ne met rien
//           {castype=4;break;}
       default:
          cout << "\n ***** erreur en sortie de la grandeur quelconque " << enu.NomPlein()
               << " le type " << NomType2Niveau(enuStructure) << "n'est pas gere par gmsh, le fichier resultat "
               << " ne sera donc pas exploitable !! on continue quand meme !!"; 
          return;      
      };          
	   // def de l'entete
    string nom(enu.NomPlein());
	   if (numero != 0)
	   nom = nom + "_" + ChangeEntierSTring(numero);
	   EnteteNodeData(sort,incre,temps_actuel,nom,NB_val);

    // s'il faut sortir une grandeur nulle on la définie: a priori c'est une opération
    // qui est faite uniquement une fois pour chaque
    // type donc pas couteuse
    TypeQuelconque type_null(typ);
    // on initialise la grandeur par défaut
    type_null.Grandeur_pointee()->InitParDefaut();

    // -- sortie des grandeurs
    // on balaie les maillages
    for (int im =1; im <= nbmail; im++)
     { // on ne continue que si le maillage est à sortir
       // !!! en fait avec gmsh, et le nouveau format, il faut que l'on sorte toujours quelque chose, car le nombre de noeuds
       // est celui de l'ensemble des maillages présents, à moins que le maillage ne soit pas actif, là il n'y a pas de pb, mais
       // dans les autres cas, il faut que le nombre de valeurs = le nombre de noeuds, quelque soit les grandeurs. Donc l'idée
       // est de sortir une grandeur nulle, lorsque la grandeur n'est pas prévue pour ce maillage
       bool grandeur_prevu_en_sortie = (*(t_indic_sortie(im))); // drapeau utilisé en sortie
//       if (*(t_indic_sortie(im))) // première version
         {int numMail = tab_mail(im);
          int decal_noe = mailInitial->DecalNumNoeud(numMail);
          Tableau<Noeud *>& t_n = lesMail->Tab_noeud(numMail);
          int nbmaxinoeud = t_n.Taille();
          for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++) 
            { // recup du noeud
              Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
              sort << "\n" << noe.Num_noeud()+decal_noe << " " ;
              //--   les grandeurs
              // ici on va choisir entre le cas normal et le cas d'une grandeur nulle
              TypeQuelconque const *  typ_en_sortie = &type_null; // init à la valeur par défaut
              if (grandeur_prevu_en_sortie)
                typ_en_sortie = &(noe.Grandeur_quelconque(enu));
              // puis on sort la grandeur
              switch (castype)
                  { case 1: // cas d'une grandeur scalaire (mais qui peut venir d'un tableau)
                      { switch (enuStructure)
                          { case TYPE_SIMPLE:{typ_en_sortie->Const_Grandeur_pointee()->Grandeur_brut(sort,ParaGlob::NbdigdoGR());
                                              break;};
                            case TABLEAU_T: {Tab_Grandeur_scalaire_double* t_grandeur =
                                                 ((Tab_Grandeur_scalaire_double*) typ_en_sortie->Const_Grandeur_pointee());
                                             Grandeur_scalaire_double& grandeur =t_grandeur->Grandeur_scalaire_associee(numero); 
                                             grandeur.Grandeur_brut(sort,ParaGlob::NbdigdoGR());
                                             break;};
                            default:
                              cout << "\n -1- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
                                   << NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
                                   << " la sortie gmsh le fichier resultat  ne sera donc pas exploitable !! on continue quand meme !!"
                                   << "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(...";
                          };
                         break;
                      }
                  	 case 2: // cas d'une grandeur vectorielle à trois coordonnées, si il y en a moins, il y a des 0 à la place 
                      { const TypeQuelconque::Grandeur& grandeur=*(typ_en_sortie->Const_Grandeur_pointee()); // pour simplifier
                        switch (enuStructure)
                             {case TYPE_SIMPLE:{sort << setprecision(ParaGlob::NbdigdoGR())
									                          << grandeur.GrandeurNumOrdre(1) <<" "<<grandeur.GrandeurNumOrdre(2) <<" " 
                                                     << grandeur.GrandeurNumOrdre(3) ;
                                                break;};
                              case TABLEAU_T: 
                                {Tab_Grandeur_Coordonnee* tab_coor = ((Tab_Grandeur_Coordonnee*) typ_en_sortie->Const_Grandeur_pointee());
                                 // on sort  les coordonnées pour numéro
                                 const Grandeur_coordonnee&  coor = tab_coor->Grandeur_Coordonnee_associee(numero);
                                 sort << setprecision(ParaGlob::NbdigdoGR())
												                          << coor.GrandeurNumOrdre(1) <<"  "<<coor.GrandeurNumOrdre(2) <<" " 
                                      << coor.GrandeurNumOrdre(3) ;
                                 break;
                                }
                              // pour l'instant il n'y a pas de tableau de coordonnée qui existe donc on ne met rien d'autre
                              default:
                                cout << "\n -2- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
                                     << NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
                                     << " la sortie gmsh le fichier resultat  ne sera donc pas exploitable !! on continue quand meme !!"
                                     << "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(...";
                             };
                         break;
                      }
                  	 case 3: // cas d'une grandeur tensorielle: forcément de dimension 9 (mais qui appartenir à un tableau
                       { const TypeQuelconque::Grandeur& grandeur=*(typ_en_sortie->Const_Grandeur_pointee()); // pour simplifier
                         switch (enuStructure)
                           {case TYPE_SIMPLE:
                             { switch (grandeur.Type_grandeurAssocie())
                               { case TENSEURBB: 
                                   { const TenseurBB& t_BB =  ((Grandeur_TenseurBB*) &grandeur)->RefConteneurTenseur();
                                     Isovaleurs_Gmsh::SortieTenseurBB(sort,t_BB);
                                     break;                  
                                    }
                                 case TENSEURHH:
                                   { const TenseurHH& t_HH =  ((Grandeur_TenseurHH*) &grandeur)->RefConteneurTenseur();
                                     Isovaleurs_Gmsh::SortieTenseurHH(sort,t_HH);
                                     break;                  
                                    }
                                 default:
                                   cout << "\n -3- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
                                        << NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
                                        << " la sortie gmsh le fichier resultat  ne sera donc pas exploitable !! on continue quand meme !!"
                                        << "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(...";
                                };
                               break;
                             }
                            case TABLEAU_T: 
                              {switch (grandeur.Type_grandeurAssocie())
                               {case TENSEURHH:
                                   { const Tab_Grandeur_TenseurHH* g_t_t_HH =  ((Tab_Grandeur_TenseurHH*) &grandeur);
                                     const Grandeur_TenseurHH& g_t_HH = g_t_t_HH->Grandeur_TenseurHH_associee(numero);
                                     const TenseurHH& t_HH =  g_t_HH.RefConteneurTenseur();
                                     Isovaleurs_Gmsh::SortieTenseurHH(sort,t_HH);
                                     break;                  
                                    }
                                case TENSEURBB:
                                   { const Tab_Grandeur_TenseurBB* g_t_t_BB =  ((Tab_Grandeur_TenseurBB*) &grandeur);
                                     const Grandeur_TenseurBB& g_t_BB = g_t_t_BB->Grandeur_TenseurBB_associee(numero);
                                     const TenseurBB& t_BB =  g_t_BB.RefConteneurTenseur();
                                     Isovaleurs_Gmsh::SortieTenseurBB(sort,t_BB);
                                     break;
                                    }
                                // pour l'instant il n'y a que les tableaux de tenseurHH qui existent
                                default:
                                   cout << "\n -4- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
                                        << NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
                                        << " la sortie gmsh le fichier resultat  ne sera donc pas exploitable !! on continue quand meme !!"
                                        << "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(...";
                               };
                               break;
                              }

                            // pour l'instant il n'y a que les types simples et les tableaux qui sont pris en compte pour les tenseurs   
                            default:
                               cout << "\n -5- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
                                    << NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
                                    << " la sortie gmsh le fichier resultat  ne sera donc pas exploitable !! on continue quand meme !!"
                                    << "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(...";
                           }; // fin du switch (enuStructure) pour les tenseurs
                         break;
                       } //-- fin du cas castype = 3 c-a-d des cas relatifs aux tenseurs 
                    case 4: // cas d'une grandeur VECTEUR nommé que l'on gère comme un tableau de scalaires
                      { switch (enuStructure)
                          { case TYPE_SIMPLE:
                              {Grandeur_Vecteur_Nommer* t_grandeur =
                                    ((Grandeur_Vecteur_Nommer*) typ_en_sortie->Const_Grandeur_pointee());
                               Vecteur& vec = *((Vecteur*) &t_grandeur->ConteneurVecteur());
                               Isovaleurs_Gmsh::SortieVecteur(sort,vec);
                               break;
                              };
                            case TABLEAU_T:
                              {Tab_Grandeur_Vecteur_Nommer* t_grandeur =
                                   ((Tab_Grandeur_Vecteur_Nommer*) typ_en_sortie->Const_Grandeur_pointee());
                               Grandeur_Vecteur_Nommer& grn = (*t_grandeur)(numero);
                               const Vecteur& vec = *((const Vecteur*) &(grn.ConteneurVecteur()));
                               Isovaleurs_Gmsh::SortieVecteur(sort,vec);
                               break;
                              }
                            default:
                              cout << "\n -1- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
                                   << NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
                                   << " la sortie gmsh le fichier resultat  ne sera donc pas exploitable !! on continue quand meme !!"
                                   << "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(...";
                          };
                         break;
                      }
                    case 5: // cas d'une grandeur de type BaseH
                            // c'est géré comme une succession de vecteur à trois coordonnées, si il y en a moins, il y a des 0 à la place
                      { const TypeQuelconque::Grandeur& grandeur=*(typ_en_sortie->Const_Grandeur_pointee()); // pour simplifier
                        switch (enuStructure)
                             {case TYPE_SIMPLE:
                               { Grandeur_BaseH* base
                                       = ((Grandeur_BaseH*) typ_en_sortie->Const_Grandeur_pointee());
                                 // le numéro de sortie correspond au numéro de vecteur de base
                                 const BaseH& baH1 = base->RefConteneurBaseH();
                                 const Coordonnee& V =  baH1.Coordo(numero);
                                 V.Affiche(sort,ParaGlob::NbdigdoGR());
                                 // sur gmsh, il faut des vecteurs à 3 composantes
                                 switch (3 - V.Dimension())
                                   {case 0: // on ne fait rien
                                       break;
                                    case 1: // cas où il manque une composante
                                       sort << " 0 "; break;
                                    case 2: // il manque 2 composantes
                                       sort << " 0  0 "; break;
                                    case 3: // il manque 3  composantes... un peu étrange !!
                                       sort << " 0  0  0 "; break;
                                    default:
                                      cout << "\n *** erreur en sortie d'une grandeur Grandeur_BaseH "
                                           << " la dimension du vecteur de la base = " << V.Dimension()
                                           << " le resultat ne sera pas exploitable par gmsh !";
                                       break;
                                   };
                                 break;
                               };
                              case TABLEAU_T:
                                {Tab_Grandeur_BaseH* tab_base
                                       = ((Tab_Grandeur_BaseH*) typ_en_sortie->Const_Grandeur_pointee());
                                 // on va considérer que toutes les bases ont le même nombre de vecteur
                                 // correspondant à la dimension de l'espace de travail
                                 int nb_vect = ParaGlob::Dimension();
                                 // récup du numéro de l'axe
                                 int N_a = ((numero-1) % nb_vect) + 1 ;
                                 // récup du numéro dans le tableau de la base
                                 int n_dans_tab = ((numero-1) / nb_vect) + 1 ;
                                 // récup de la base
                                 Grandeur_BaseH& gr = (*tab_base)(n_dans_tab);
                                 const BaseH& baH1 = gr.RefConteneurBaseH();
                                 // récup des coordonnées du vecteur N_a
                                 const Coordonnee& V =  baH1.Coordo(N_a);
                                 V.Affiche(sort,ParaGlob::NbdigdoGR());
                                 // sur gmsh, il faut des vecteurs à 3 composantes
                                 switch (3 - V.Dimension())
                                   {case 0: // on ne fait rien
                                       break;
                                    case 1: // cas où il manque une composante
                                       sort << " 0 "; break;
                                    case 2: // il manque 2 composantes
                                       sort << " 0  0 "; break;
                                    case 3: // il manque 3  composantes... un peu étrange !!
                                       sort << " 0  0  0 "; break;
                                    default:
                                      cout << "\n *** erreur en sortie d'une grandeur Grandeur_BaseH "
                                           << " provenant d'un element de tableau: "<<n_dans_tab
                                           << " la dimension du vecteur de la base = " << V.Dimension()
                                           << " le resultat ne sera pas exploitable par gmsh !";
                                       break;
                                   };
                                 break;
                                }
                              // pour l'instant rien d'autre
                              default:
                                cout << "\n -2- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
                                     << NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
                                     << " la sortie gmsh le fichier resultat  ne sera donc pas exploitable !! on continue quand meme !!"
                                     << "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(...";
                             };
                         break;
                      }
                    case 6: // cas d'une grandeur VECTEUR que l'on gère comme un tableau de scalaires
                      { switch (enuStructure)
                          { case TYPE_SIMPLE:
                              {Grandeur_Vecteur* t_grandeur =
                                    ((Grandeur_Vecteur*) typ_en_sortie->Const_Grandeur_pointee());
                               const Vecteur& vec = *((Vecteur*) t_grandeur->ConteneurVecteur());
                               Isovaleurs_Gmsh::SortieVecteur(sort,vec);
                               break;
                              };
                            case TABLEAU_T:
                              {Tab_Grandeur_Vecteur* t_grandeur =
                                   ((Tab_Grandeur_Vecteur*) typ_en_sortie->Const_Grandeur_pointee());
                               Vecteur& vec = *((Vecteur*) &(*t_grandeur)(numero));

                               Isovaleurs_Gmsh::SortieVecteur(sort,vec);
                               break;
                              }
                            default:
                              cout << "\n -1- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
                                   << NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
                                   << " la sortie gmsh le fichier resultat  ne sera donc pas exploitable !! on continue quand meme !!"
                                   << "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(...";
                          };
                         break;
                      }
                  }; //-- fin du switch (castype)
            };
         };
	    };
	   // fin de la view
	   sort << "\n$EndNodeData \n"; 
 };
 
//--ancien format --// utilitaire pour la sortie d'un tenseur HH
// bool: indique s'il faut une virgule ou non après le dernier enreg
void Isovaleurs_Gmsh::SortieTenseurHH_ancien_format(ostream & sort,const TenseurHH& t_HH)
 { switch (Abs(t_HH.Dimension()))  
    {case 1: { sort << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,1) << ", ";
               for (int i=2;i<=9;i++) sort << " 0., "; // le reste en 0
               break;
             }
     case 2: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,1) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,2) << ", 0., "; 
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,2) << ", " ;
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(2,2) << ", ";
               sort <<  " 0., 0., 0., 0. "; 
               break;
              };
     case 3: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,1) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,2) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,3) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(2,1) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(2,2) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(2,3) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(3,1) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(3,2) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(3,3) ;
               break;
              };
     default: cout << "\n erreur !! Isovaleurs_Gmsh::SortieTenseurHH(.."; Sortie(1);         
   	};
 };
 
//-- ancien format // utilitaire pour la sortie d'un tenseur BB
// bool: indique s'il faut une virgule ou non après le dernier enreg
void Isovaleurs_Gmsh::SortieTenseurBB_ancien_format(ostream & sort,const TenseurBB& t_BB)
 { switch (Abs(t_BB.Dimension()))  
    {case 1: { sort << setw(ParaGlob::NbdigdoGR())  << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,1) << ", "; 
               for (int i=2;i<=9;i++) sort << " 0., "; // le reste en 0
               break;
             }
     case 2: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,1) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,2) << ", 0., "; 
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,2) << ", " ;
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(2,2) << ", ";
               sort <<  " 0., 0., 0., 0. "; 
               break;
              };
     case 3: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,1) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,2) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,3) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(2,1) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(2,2) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(2,3) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(3,1) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(3,2) << ", ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(3,3) ;
               break;
              };
     default: cout << "\n erreur !! Isovaleurs_Gmsh::SortieTenseurBB(.."; Sortie(1);         
   	};
 };
// utilitaire pour la sortie d'un tenseur HH
// bool: indique s'il faut une virgule ou non après le dernier enreg
void Isovaleurs_Gmsh::SortieTenseurHH(ostream & sort,const TenseurHH& t_HH)
 { switch (Abs(t_HH.Dimension()))  
    {case 1: { sort << setw(ParaGlob::NbdigdoGR())  << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,1) << " "; 
               for (int i=2;i<=9;i++) sort << " 0.  "; // le reste en 0
               break;
             }
     case 2: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,1) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,2) << "  0.  "; 
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,2) << "  " ;
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(2,2) << "  ";
               sort <<  " 0.  0.  0.  0. "; 
               break;
              };
     case 3: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,1) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,2) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,3) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(2,1) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(2,2) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(2,3) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(3,1) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(3,2) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(3,3) ;
               break;
              };
     default: cout << "\n erreur !! Isovaleurs_Gmsh::SortieTenseurHH(.."; Sortie(1);         
   	};
 };
 
// utilitaire pour la sortie d'un tenseur BB
// bool: indique s'il faut une virgule ou non après le dernier enreg
void Isovaleurs_Gmsh::SortieTenseurBB(ostream & sort,const TenseurBB& t_BB)
 { switch (Abs(t_BB.Dimension()))  
    {case 1: { sort << setw(ParaGlob::NbdigdoGR())  << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,1) << " "; 
               for (int i=2;i<=9;i++) sort << " 0. "; // le reste en 0
               break;
             }
     case 2: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,1) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,2) << " 0. "; 
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,2) << " " ;
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(2,2) << " ";
               sort <<  " 0. 0. 0. 0. "; 
               break;
              };
     case 3: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,1) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,2) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,3) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(2,1) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(2,2) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(2,3) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(3,1) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(3,2) << " ";
               sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(3,3) ;
               break;
              };
     default: cout << "\n erreur !! Isovaleurs_Gmsh::SortieTenseurBB(.."; Sortie(1);         
   	};
 };

// utilitaire pour une sortie de type Vecteur
void Isovaleurs_Gmsh::SortieVecteur(ostream & sort,const Vecteur& vec)
 {
   switch (vec.Taille())
     {case 1: // cas d'un équivalent scalaire
        sort << setprecision(ParaGlob::NbdigdoGR()) << vec(1) << " ";break;
      case 2: // là on fait un équivalent Coordonnees
        sort << setprecision(ParaGlob::NbdigdoGR())
             << vec(1) << " "<< vec(2) << " 0. ";break;
      case 3: // là on fait un équivalent Coordonnees
        sort << setprecision(ParaGlob::NbdigdoGR())
             << vec(1) << " "<< vec(2) << " "<< vec(3)<< " ";break;
      
      case 4: // là on fait un équivalent tenseur
        sort << setprecision(ParaGlob::NbdigdoGR())
             << vec(1) << " "<< vec(2) << " "<< vec(3)<< " "<< vec(4)
             << " 0 0 ";break;
      case 5: // là on fait un équivalent tenseur
        sort << setprecision(ParaGlob::NbdigdoGR())
             << vec(1) << " "<< vec(2) << " "<< vec(3)<< " "<< vec(4)
             << vec(5) << " 0 ";break;
      case 6: // là on fait un équivalent tenseur
        sort << setprecision(ParaGlob::NbdigdoGR())
             << vec(1) << " "<< vec(2) << " "<< vec(3)<< " "<< vec(4)
             << vec(5) << " "<< vec(6) << " ";break;
      default:
        cout << "\n nombre de composante du vecteur superieur a 6 "
             << " aucune sortie possible avec gmsh " ;
     };
 };


// initialisation les différentes listes internes qui globalisent tous les maillages
void Isovaleurs_Gmsh::GlobalisationListSurTousLesMaillagesPourLesNoeuds()
  { // on initialise toutes les listes globales
    glob_noe_ddl_retenu.clear();
    glob_noeud_ddl_etendu_retenu.clear();
    glob_noeud_evol_retenu.clear();
    glob_elem_ddl_retenu.clear();
    glob_elem_evol_retenu.clear();
    glob_elem_Parti_retenu.clear();
    // on passe en revue tous les maillages pour crées les listes globales des grandeurs 
    int nb_mail = tabnoeud_type_ddl_retenu.Taille(); // dim des maillages, via un tableau arbitraire
    for (int imail=1;imail<= nb_mail;imail++)
      { // on merge les listes (il faut qu'avant chaque merge, les listes soient ordonnées)
        // comme l'ordre merge ajoute les listes mais en détruisant la liste initiale, on crée une liste intermédiaire
        tabnoeud_type_ddl_retenu(imail).sort();
        List_io < Ddl_enum_etendu > interDddlenumetendu(tabnoeud_type_ddl_retenu(imail));        
        glob_noe_ddl_retenu.merge(interDddlenumetendu);

        tabnoeud_type_ddlEtendu_retenu(imail).sort();
        List_io < Ddl_enum_etendu > inter2Dddlenumetendu(tabnoeud_type_ddlEtendu_retenu(imail));
        glob_noeud_ddl_etendu_retenu.merge(inter2Dddlenumetendu);

        tabnoeud_evoluee_retenu(imail).sort();
        List_io < TypeQuelconque > internoeudevolretenu(tabnoeud_evoluee_retenu(imail));
//debug
//cout << "\n debug: Isovaleurs_Gmsh::GlobalisationListSurTousLesMaillagesPourLesNoeuds() ";
//cout << "\n list tabnoeud_evoluee_retenu("<<imail<<") "<< tabnoeud_evoluee_retenu(imail) << endl;
// fin debug
       
        glob_noeud_evol_retenu.merge(internoeudevolretenu);
        
        tabelement_type_ddl_retenu(imail).sort();
        List_io < Ddl_enum_etendu > interelemDddlenumetendu(tabelement_type_ddl_retenu(imail));
        glob_elem_ddl_retenu.merge(interelemDddlenumetendu);
        
        tabelement_evoluee_retenu(imail).sort();
        List_io < TypeQuelconque > interelemevolretenu(tabelement_evoluee_retenu(imail));
        glob_elem_evol_retenu.merge(interelemevolretenu);
        
        tabelement_typeParti_retenu(imail).sort();
        List_io < TypeQuelconque > interelempartiretenu(tabelement_typeParti_retenu(imail));        
        glob_elem_Parti_retenu.merge(interelempartiretenu);
        // on ordonne
        glob_noe_ddl_retenu.sort();
        glob_noeud_ddl_etendu_retenu.sort();
        glob_noeud_evol_retenu.sort();
        glob_elem_ddl_retenu.sort();
        glob_elem_evol_retenu.sort();
        glob_elem_Parti_retenu.sort();	
        // on supprime les doublons
        glob_noe_ddl_retenu.unique();
        glob_noeud_ddl_etendu_retenu.unique();
        glob_noeud_evol_retenu.unique();
        glob_elem_ddl_retenu.unique();
        glob_elem_evol_retenu.unique();
        glob_elem_Parti_retenu.unique();
    	};
    // pour le transfert des points d'intégration aux noeuds, on met à jour le tableau de pointeur global
    // ne concerne donc que les grandeurs quelconques définis aux noeuds
    if (glob_elem_evol_retenu.size()!=0) {tab_quelconque(1)= &glob_elem_evol_retenu;}
    else                                 {tab_quelconque(1)= NULL;};
    if (glob_elem_Parti_retenu.size()!=0){tab_quelconque(2)= &glob_elem_Parti_retenu;}
    else                                 {tab_quelconque(2)= NULL;};
    
    	
    // on définit les tableaux d'indicateurs de sortie de grandeurs
    for (int imai=1;imai<= nb_mail;imai++)
     { // initialisation des tableaux d'indicateurs
       List_io < bool >& g_noeud_type_ddl_asortir = t_g_noeud_ddl_asortir(imai); // pour simplifier
       g_noeud_type_ddl_asortir.clear();
       List_io < bool >& g_noeud_ddl_etendu_asortir = t_g_noeud_ddl_etendu_asortir(imai); // pour simplifier
       g_noeud_ddl_etendu_asortir.clear();
       List_io < bool >& g_noeud_evoluee_asortir = t_g_noeud_evoluee_asortir(imai); // pour simplifier
       g_noeud_evoluee_asortir.clear();
       List_io < bool >& g_element_ddl_asortir = t_g_elem_ddl_asortir(imai); // pour simplifier
       g_element_ddl_asortir.clear();
       List_io < bool >& g_element_evoluee_asortir = t_g_elem_evoluee_asortir(imai); // pour simplifier
       g_element_evoluee_asortir.clear();
       List_io < bool >& g_element_typeParti_asortir = t_g_elem_typeParti_asortir(imai); // pour simplifier
       g_element_typeParti_asortir.clear();
       // on passe en revue les grandeurs à sortir et on met à jour les indicateurs en conséquence

       // .. pour les ddl  aux noeuds 
      {List_io < Ddl_enum_etendu >& noeud_type_ddl_retenu = tabnoeud_type_ddl_retenu(imai); // pour simplifier
       List_io < Ddl_enum_etendu >::iterator i1,i1fin=glob_noe_ddl_retenu.end();
       for (i1=glob_noe_ddl_retenu.begin();i1!=i1fin;i1++)
         if (find(noeud_type_ddl_retenu.begin(),noeud_type_ddl_retenu.end(),(*i1)) == noeud_type_ddl_retenu.end())
               {g_noeud_type_ddl_asortir.push_back(false);} // cas où le ddl initial n'existe pas pour le maillage considéré
         else  {g_noeud_type_ddl_asortir.push_back(true);}; // cas où le ddl initial existe également pour le maillage considéré
      };

      {// .. pour les ddl étendues définis aux noeuds
       List_io < Ddl_enum_etendu >& noeud_type_ddlEtendu_retenu = tabnoeud_type_ddlEtendu_retenu(imai); // pour simplifier
       List_io < Ddl_enum_etendu >::iterator i1,i1fin=glob_noeud_ddl_etendu_retenu.end();
       for (i1=glob_noeud_ddl_etendu_retenu.begin();i1!=i1fin;i1++)
         if (find(noeud_type_ddlEtendu_retenu.begin(),noeud_type_ddlEtendu_retenu.end(),(*i1)) == noeud_type_ddlEtendu_retenu.end())
               {g_noeud_ddl_etendu_asortir.push_back(false);} // cas où le ddl étendu n'existe pas pour le maillage considéré
         else  {g_noeud_ddl_etendu_asortir.push_back(true);}; // cas où le ddl étendu existe également pour le maillage considéré
      };
      
      {// .. pour les types évoluées définis aux noeuds
       List_io < TypeQuelconque >& noeud_evoluee_retenu = tabnoeud_evoluee_retenu(imai); // pour simplifier
       List_io < TypeQuelconque >::iterator i1,i1fin=glob_noeud_evol_retenu.end();
       for (i1=glob_noeud_evol_retenu.begin();i1!=i1fin;i1++)
         if (find(noeud_evoluee_retenu.begin(),noeud_evoluee_retenu.end(),(*i1)) == noeud_evoluee_retenu.end())
               {g_noeud_evoluee_asortir.push_back(false);} // cas où le type évolué n'existe pas pour le maillage considéré
         else  {g_noeud_evoluee_asortir.push_back(true);}; // cas où le type évolué existe également pour le maillage considéré
      };

       // .. pour les ddl venant d'un transfert aux noeuds des grandeurs aux pt d'integ
       List_io < Ddl_enum_etendu >& element_type_ddl_retenu = tabelement_type_ddl_retenu(imai); // pour simplifier
       List_io < Ddl_enum_etendu >::iterator j1,j1fin=glob_elem_ddl_retenu.end();
       for (j1=glob_elem_ddl_retenu.begin();j1!=j1fin;j1++)
         if (find(element_type_ddl_retenu.begin(),element_type_ddl_retenu.end(),(*j1))== element_type_ddl_retenu.end())
               {g_element_ddl_asortir.push_back(false);} // cas où le ddl global n'existe pas pour le maillage considéré
         else  {g_element_ddl_asortir.push_back(true);}; // cas où le ddl global existe également pour le maillage considéré

       // .. pour les types évolulées venant d'un transfert aux noeuds des grandeurs aux pt d'integ
       List_io < TypeQuelconque >& element_evoluee_retenu = tabelement_evoluee_retenu(imai); // pour simplifier
       List_io < TypeQuelconque >::iterator k1,k1fin=glob_elem_evol_retenu.end();
       for (k1=glob_elem_evol_retenu.begin();k1!=k1fin;k1++)
         if (find(element_evoluee_retenu.begin(),element_evoluee_retenu.end(),(*k1))== element_evoluee_retenu.end())
               {g_element_evoluee_asortir.push_back(false);} // cas où le ddl évolué global n'existe pas pour le maillage considéré
         else  {g_element_evoluee_asortir.push_back(true);}; // cas où le ddl évolué global existe également pour le maillage considéré

       // .. pour les types particuliers aux elements venant d'un transfert aux noeuds
       List_io < TypeQuelconque >& element_typeParti_retenu = tabelement_typeParti_retenu(imai); // pour simplifier
       List_io < TypeQuelconque >::iterator m1,m1fin=glob_elem_Parti_retenu.end();
       for (m1=glob_elem_Parti_retenu.begin();m1!=m1fin;m1++)
         if (find(element_typeParti_retenu.begin(),element_typeParti_retenu.end(),(*m1))== element_typeParti_retenu.end())
               {g_element_typeParti_asortir.push_back(false);} // cas où le ddl évolué global n'existe pas pour le maillage considéré
         else  {g_element_typeParti_asortir.push_back(true);}; // cas où le ddl évolué global existe également pour le maillage considéré 
     };
	};

// vérification que le transfert peut se faire (pas de doublon de grandeurs)
void Isovaleurs_Gmsh::VerificationTransfertPossible_et_doublon()
 {  // l'objectif est de vérifier qu'il n'y a pas deux grandeurs identiques  au niveau des types quelconques et évoluées
    // (ce qui posera des pb au niveau des moyennes aux noeuds)
    int nb_mail = tabnoeud_type_ddl_retenu.Taille(); // dim des maillages, via un tableau arbitraire
    for (int imail=1;imail<= nb_mail;imail++)
      { List_io < TypeQuelconque >& element_evoluee_retenu =  tabelement_evoluee_retenu(imail); 
        List_io < TypeQuelconque >& element_typeParti_retenu = tabelement_typeParti_retenu(imail);
        List_io < TypeQuelconque >& noe_typeParti_retenu = tabnoeud_evoluee_retenu(imail);
        // on ordonne
        element_evoluee_retenu.sort();
        element_typeParti_retenu.sort();
        noe_typeParti_retenu.sort();
        // a priori il y a peut d'éléments donc on compare
        List_io < TypeQuelconque >::iterator i1,i1end = element_evoluee_retenu.end();
        i1=element_evoluee_retenu.begin();
        List_io < TypeQuelconque >::iterator j1,j1end = element_typeParti_retenu.end();
        j1=element_typeParti_retenu.begin();
        List_io < TypeQuelconque >::iterator k1,k1end = noe_typeParti_retenu.end();
        k1=noe_typeParti_retenu.begin();
        for (i1=element_evoluee_retenu.begin(); i1 != i1end; i1++)
          for (j1=element_typeParti_retenu.begin();j1 != j1end; j1++)
            for (k1=noe_typeParti_retenu.begin();k1 != k1end; k1++)
        	    { if ((*i1)==(*j1)) 
                {cout << "\n attention *** probleme concernant le transfert aux noeuds il ne faut pas avoir deux grandeurs identiques, or ici "
        	             << "\n on a la grandeurs : " << ((*i1).EnuTypeQuelconque().NomPlein()) << " en double !! "
        	             << "\n on supprime l'un d'eux ";
       	         element_typeParti_retenu.erase(j1);
        	       };
        	      if ((*i1)==(*k1))
                {cout << "\n attention *** probleme concernant le transfert aux noeuds il ne faut pas avoir deux grandeurs identiques, or ici "
        	             << "\n on a la grandeurs : " << ((*i1).EnuTypeQuelconque().NomPlein()) << " en double !! "
        	             << "\n on supprime l'un d'eux ";
       	         noe_typeParti_retenu.erase(k1);
        	       };
        	      if ((*j1)==(*k1))
                {cout << "\n attention *** probleme concernant le transfert aux noeuds il ne faut pas avoir deux grandeurs identiques, or ici "
        	             << "\n on a la grandeurs : " << ((*j1).EnuTypeQuelconque().NomPlein()) << " en double !! "
        	             << "\n on supprime l'un d'eux ";
       	         noe_typeParti_retenu.erase(k1);
        	       };
        	    };
      };

    // de plus, il ne faut pas qu'il y ait la même  grandeur de type évoluées définis aux noeuds, qui soit également définit pour le transfert
    // des pti aux noeud, ou en ddl pur
    // (cela posera des pb au niveau des moyennes aux noeuds, et de nom de fichier de sortie)
    for (int imail=1;imail<= nb_mail;imail++)
      { List_io < Ddl_enum_etendu >& noe_ddl_retenu =  tabnoeud_type_ddl_retenu(imail);
        List_io < Ddl_enum_etendu >& noe_ddlEtendu_retenu = tabnoeud_type_ddlEtendu_retenu(imail);
        List_io < Ddl_enum_etendu >& element_type_ddl_retenu = tabelement_type_ddl_retenu(imail);
        // on ordonne
        noe_ddl_retenu.sort();
        noe_ddlEtendu_retenu.sort();
        element_type_ddl_retenu.sort();
        // a priori il y a peu d'éléments donc on compare
        List_io < Ddl_enum_etendu >::iterator i1,i1end = noe_ddl_retenu.end();
        i1=noe_ddl_retenu.begin();
        List_io < Ddl_enum_etendu >::iterator j1,j1end = noe_ddlEtendu_retenu.end();
        j1=noe_ddlEtendu_retenu.begin();
        List_io < Ddl_enum_etendu >::iterator k1,k1end = element_type_ddl_retenu.end();
        k1=element_type_ddl_retenu.begin();
        for (i1=noe_ddl_retenu.begin(); i1 != i1end; i1++)
          for (j1=noe_ddlEtendu_retenu.begin();j1 != j1end; j1++)
           for (k1=element_type_ddl_retenu.begin();k1 != k1end; k1++)
        	{ if ((*i1)==(*j1)) 
        	   {cout << "\n attention *** probleme concernant le transfert aux noeuds il ne faut pas avoir deux grandeurs identiques, or ici "
        	         << "\n on a la grandeurs : " << (((*i1).Nom_vide()) ? Nom_ddl((*i1).Enum()) : (*i1).Nom() )
                  << " en double !! "
        	         << "\n on supprime l'un d'eux ";
       	        noe_ddlEtendu_retenu.erase(j1);
        	   };
        	  if ((*i1)==(*k1))
            {cout << "\n attention *** probleme concernant le transfert aux noeuds il ne faut pas avoir deux grandeurs identiques, or ici "
        	         << "\n on a la grandeurs : " << (((*i1).Nom_vide()) ? Nom_ddl((*i1).Enum()) : (*i1).Nom() )
                  << " en double !! "
        	         << "\n on supprime l'un d'eux ";
       	     element_type_ddl_retenu.erase(k1);
        	   };
        	  if ((*j1)==(*k1))
            {cout << "\n attention *** probleme concernant le transfert aux noeuds il ne faut pas avoir deux grandeurs identiques, or ici "
        	         << "\n on a la grandeurs : " << (((*j1).Nom_vide()) ? Nom_ddl((*j1).Enum()) : (*j1).Nom() )
                  << " en double !! "
        	         << "\n on supprime l'un d'eux ";
       	     element_type_ddl_retenu.erase(k1);
        	   };
        	};		
      };
  
 };
 
    //------------ méthodes utilitaires qui sont également utilisées par d'autres classes----

// numero: dans le cas où c'est une view pour un élément de tableau, donc de numéro numero
void Isovaleurs_Gmsh::EnteteView(ostream & sort,const int & incre, const string& nom,const int & numero ) const
 {  // def de l'entete
    sort << "\n\n View \""<< nom << " incre= " << incre ;
    if (numero != 0)
      sort << ",  NB tab  " << numero;
    sort <<"\" { ";
	};
    
// utilitaire pour la sortie de l'entête d'un bloc NodeData utilisé avec le nouveau format gmsh
// numero: dans le cas où c'est une view pour un élément de tableau, donc de numéro numero
void Isovaleurs_Gmsh::EnteteNodeData(ostream & sort,const int & incre, const double& temps
                   ,const string& nom,const int & nb_composante ) const
{	// dans le cas où l'incrément est supérieur à 1000000, on est dans un cas spécial de mode débug, pour lequel
  // le temps ne veut rien dire donc on a un traitement spécial
  if (incre < 1000000) // cas normal
		 {sort << "\n\n$NodeData \n1 \n\""<< nom
		       << "\"\n1 \n"<< temps << "\n3 \n"<< incre <<"\n"<< nb_composante <<"\n" 
         << mailInitial->Nb_total_noeud();
		 }
	 else 	// cas particulier début  
      {int compteur = incre % 1000000;
		     sort << "\n\n$NodeData \n1 \n\""<< nom 
		          << "\"\n1 \n"<< compteur << "\n3 \n"<< compteur <<"\n"<< nb_composante <<"\n"
		          << mailInitial->Nb_total_noeud();
		    }; 
};

// sortie de la def des coordonnées pour une view
void Isovaleurs_Gmsh::SortieDefCoordonnees_old_format(ostream & sort,const int & incre
                   ,int nbmail, const Tableau <int>& tab_mail,LesMaillages * lesMail) const
{   int dim = ParaGlob::Dimension();
    for (int im =1; im <= nbmail; im++)
      {int numMail = tab_mail(im);
       int nbmaxnoeud = lesMail->Nombre_noeud(numMail);
       int decalnoeud = mailInitial->DecalNumNoeud(numMail);
       // deux cas soit on applique une pseudo-homothetie ou non
       if (!((mailInitial->Considerer_homothetie()) && ((mailInitial->T_homothetie())(numMail))))
        {// cas sans homothetie : cas classique
         for (int ino = 1; ino <= nbmaxnoeud; ino++)
       	 {Noeud& noe = lesMail->Noeud_LesMaille(numMail, ino); // pour simplifier
       	  int num_noeud = ino + decalnoeud;
          const Coordonnee& co = noe.Coord2();
          sort << "\n"; 
          switch (dim) 
           { case 3: sort << "Z" << num_noeud <<"i"<<incre << " = " << co(3) << " ; ";
             case 2: sort << "Y" << num_noeud <<"i"<<incre << " = " << co(2) << " ; ";
             case 1: sort << "X" << num_noeud <<"i"<<incre << " = " << co(1) << " ; ";
            }; 
          // on remplie de 0, au cas où la dimension n'est pas 3  
          switch (dim) 
           { case 1: sort << "Y" << num_noeud <<"i"<<incre << " = 0 ; " ;
             case 2: sort << "Z" << num_noeud <<"i"<<incre << " = 0 ; " ;
            }; 
       	 };
			}
		 else // cas avec Homothetie 	
        {Coordonnee& orig = (mailInitial->T_orig())(numMail);           // pour simplifier
		  Coordonnee& fact_mult = (mailInitial->T_fact_mult())(numMail); // pour simplifier
         for (int ino = 1; ino <= nbmaxnoeud; ino++)
       	{ Noeud& noe = lesMail->Noeud_LesMaille(numMail, ino); // pour simplifier
       	  int num_noeud = ino + decalnoeud;
          const Coordonnee& co = noe.Coord2();
          const Coordonnee& co_0 = noe.Coord0();
			 Coordonnee delta_co = co-co_0; // calcul du déplacement
			 // on calcul les coordonnées initiale avec homothetie
			 Coordonnee A(co_0-orig); int dim = A.Dimension();
          switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
           { case 3: A(3) *= fact_mult(3);
             case 2: A(2) *= fact_mult(2);
             case 1: A(1) *= fact_mult(1);
            };
			 A +=orig;
			 // on rajoute le déplacement 
			 A += delta_co;			 
          sort << "\n"; 
          switch (dim) 
           { case 3: sort << "Z" << num_noeud <<"i"<<incre << " = " << A(3) << " ; ";
             case 2: sort << "Y" << num_noeud <<"i"<<incre << " = " << A(2) << " ; ";
             case 1: sort << "X" << num_noeud <<"i"<<incre << " = " << A(1) << " ; ";
            }; 
          // on remplie de 0, au cas où la dimension n'est pas 3  
          switch (dim) 
           { case 1: sort << "Y" << num_noeud <<"i"<<incre << " = 0 ; " ;
             case 2: sort << "Z" << num_noeud <<"i"<<incre << " = 0 ; " ;
            }; 
       	 };
		  }		  
       }; // fin de la boucle sur les maillage      
};

// sortie de l'utilisation d'une coordonnée
void Isovaleurs_Gmsh::SortieUseUneCoordonnee(int incre, ostream & sort,bool fin,int num_N) const
	{ sort << "X"<<num_N<<"i"<<incre << ",Y"<<num_N<<"i"<<incre << ",Z"<<num_N<<"i"<<incre;
	  if(fin) {sort << "){";}
	  else    {sort << ", ";}; 
	};               

// création de la liste des noms correspondants à tous les grandeurs à sortir
void Isovaleurs_Gmsh::CreatListNomsTousLesGrandeurs()
 {  // --cette création s'appuie sur  les listes globales, qui doivent donc être construite
    // on efface la liste existante
    nomsGrandeursSortie.clear();
    // !! normalement tous les noms sont différents, cela a été vérifié dans :
    //    Isovaleurs_Gmsh::VerificationTransfertPossible_et_doublon()
    
    // on passe en revue la liste des ddl aux noeuds
   {List_io < Ddl_enum_etendu >::iterator ili,ilifin=  glob_noe_ddl_retenu.end();
    for (ili=glob_noe_ddl_retenu.begin();ili != ilifin; ili++)
	     nomsGrandeursSortie.push_back(((*ili).Nom_plein()+"_ddl_noe"));
    };
    // .. pour les ddl étendues définis aux noeuds
   {List_io < Ddl_enum_etendu >::iterator ili,ilifin=  glob_noeud_ddl_etendu_retenu.end();
    for (ili=glob_noeud_ddl_etendu_retenu.begin();ili != ilifin; ili++)
	     nomsGrandeursSortie.push_back(((*ili).Nom_plein()+"_ddl_etendu_noe"));
    };
    // .. pour les types évoluées définis aux noeuds
   {List_io < TypeQuelconque >::iterator ili,ilifin=  glob_noeud_evol_retenu.end();
    for (ili=glob_noeud_evol_retenu.begin();ili != ilifin; ili++)
	      nomsGrandeursSortie.push_back( string(((*ili).EnuTypeQuelconque().NomPlein())+"_evolue_noe" ));
   };
    // .. pour les ddl venant d'un transfert aux noeuds des grandeurs aux pt d'integ
   {List_io < Ddl_enum_etendu >::iterator ili,ilifin = glob_elem_ddl_retenu.end();
    for (ili=glob_elem_ddl_retenu.begin();ili != ilifin; ili++)
	     nomsGrandeursSortie.push_back(((*ili).Nom_plein()+"_pti"));
   };
    // .. pour les types évoluées venant d'un transfert aux noeuds des grandeurs aux pt d'integ
   {List_io < TypeQuelconque >::iterator ipi,ipifin=glob_elem_evol_retenu.end();
    for (ipi=glob_elem_evol_retenu.begin();ipi != ipifin; ipi++)
        nomsGrandeursSortie.push_back(  string(((*ipi).EnuTypeQuelconque().NomPlein())+"_evolue_pti" ));
    // .. pour les types particuliers aux elements venant d'un transfert aux noeuds
    ipifin= glob_elem_Parti_retenu.end();
    for (ipi=glob_elem_Parti_retenu.begin();ipi != ipifin; ipi++)
       { // on traite le cas VECTEUR nommé d'une manière particulière
         TypeQuelconque& typ = (*ipi); // pour simplifier
         EnumTypeGrandeur enugrandeur = typ.EnuTypeGrandeur();
         EnumType2Niveau  enuStructure = typ.Const_Grandeur_pointee()->Type_structure_grandeurAssocie();
//         string sup="";// un string vide
//         if ((enuStructure == TYPE_SIMPLE) && (enugrandeur == VECTEUR))
//          {Grandeur_Vecteur_Nommer& t_grandeur =
//                                                 *((Grandeur_Vecteur_Nommer*) typ.Const_Grandeur_pointee());
//           sup += *(t_grandeur.Nom_ref());
//          };
//         string nom_s(typ.EnuTypeQuelconque().NomPlein());
//
         nomsGrandeursSortie.push_back(  string(((*ipi).EnuTypeQuelconque().NomPlein())+"_particulier_pti" ));       };
   };
        
//----- debug
//list <string>::iterator iti,itifin=nomsGrandeursSortie.end();
//cout << "\n la liste des noms ";
//for (iti=nomsGrandeursSortie.begin();iti != itifin;iti++)
//  cout << (*iti) << " ";
//cout << endl;  
//
//----- fin debug        
        
        
	};

// écriture des grandeurs aux noeuds au nouveau format
void Isovaleurs_Gmsh::EcritureAuxNoeuds(const Tableau <int>& tab_mail,LesMaillages * lesMail
                                        ,int incre,UtilLecture & entreePrinc)
{ // pour simplifier
  int nbmail = tab_mail.Taille();
  // ici l'objectif est de tout mettre dans un seul groupe de résultat de manière à pouvoir tout
  // visualiser en même temps 
  // on ne traite que s'il y a des ddl 
  bool atraiter = false;
  {if (   (glob_noe_ddl_retenu.size() != 0)
       || (glob_noeud_ddl_etendu_retenu.size() != 0)
       || (glob_noeud_evol_retenu.size() != 0) 
       || (glob_elem_ddl_retenu.size() != 0)  
       || (glob_elem_evol_retenu.size() != 0) 
       || (glob_elem_Parti_retenu.size() != 0)
      )
        atraiter = true;
   };
  if (atraiter)   
   {
     // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
	    double temps_actuel = ParaGlob::Variables_de_temps().TempsCourant();
     // a) cas des ddl initiaux définis aux noeuds
     // **(3mars2016) je retire l'incrément 0 qui est bancal, car ne représente pas l'état initial de la structure
     if ((glob_noe_ddl_retenu.size() != 0)&& (incre != 0))
     {// on utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
      // maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
      List_io < Ddl_enum_etendu >::iterator il,ilfin=glob_noe_ddl_retenu.end();
      Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
      Tableau <List_io < bool >::iterator > t_choix_var_ddl(nbmail);
      for (int im =1; im <= nbmail; im++)
         {t_indic_sortie(im)=t_g_noeud_ddl_asortir(im).begin();
			       t_choix_var_ddl(im)=choix_var_ddl(im).begin();
         };
      for (il=glob_noe_ddl_retenu.begin();il != ilfin;il++)
      { Enum_ddl ddl = (*il).Enum(); // récup du ddl de base
        Ddl_enum_etendu ddl_etendu = (*il); // le ddl étendue associé
        bool ddl_basique = (*il).Nom_vide();
        ostream &sort = entreePrinc.Sort_resultat_Gmsh(ddl_etendu.Nom_plein()+"_ddl_noe");
        // def de l'entete
        EnteteNodeData(sort,incre,temps_actuel,ddl_etendu.Nom_plein(),1);
        // -- sortie des grandeurs
        // on balaie les maillages
        for (int im =1; im <= nbmail; im++)
         {// on ne continue que si le maillage est à sortir
          // !!! en fait avec gmsh, et le nouveau format, il faut que l'on sorte toujours quelque chose, car le nombre de noeuds
          // est celui de l'ensemble des maillages présents, 
          bool grandeur_prevu_en_sortie = (*(t_indic_sortie(im))); // drapeau utilisé en sortie
          //if (*(t_indic_sortie(im)))
          	{int numMail = tab_mail(im);
             int decal_noe = mailInitial->DecalNumNoeud(numMail);
             Tableau<Noeud *>& t_n = lesMail->Tab_noeud(im);
             int nbmaxinoeud = t_n.Taille();
             for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++) 
              { // recup du noeud
                Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
                sort << "\n" << noe.Num_noeud()+decal_noe << " " ;
                //--   les grandeurs
                if (grandeur_prevu_en_sortie)
                 {bool varddl = *(t_choix_var_ddl(im)); // variation ou pas
                  // il y a un choix suivant que c'est un ddl de base ou un ddl étendu
                  if (ddl_basique)
                    { if (noe.Existe_ici(ddl)) 
                        { if (varddl) // cas de la variation
                            {sort << setprecision(ParaGlob::NbdigdoGR())
                                  << (noe.Valeur_tdt(ddl)-noe.Valeur_0(ddl));}
                          else 
                            { sort << setprecision(ParaGlob::NbdigdoGR()) << noe.Valeur_tdt(ddl) ;};
                        }
                      else  // si la valeur n'existe pas on sort 0  
                        {sort << 0. ;};
                    }	 
                  else // sinon c'est un ddl étendue	
                    { if (noe.Existe_ici_ddlEtendu(ddl_etendu)) 
                        { sort << setprecision(ParaGlob::NbdigdoGR())
                               << (noe.DdlEtendue(ddl_etendu).ConstValeur()) ;}
                      else  // si la valeur n'existe pas on sort 0  
                        {sort << 0 ;};
                    };
                 }
                else // cas d'une sortie non prévue, on sort quand même 0.
                 {sort << 0 ;};
              };
          	};
         };
        // fin de la view
        sort << "\n$EndNodeData \n"; 
        // mise à jour des pointeurs de choix
        for (int im =1; im <= nbmail; im++)
           {t_indic_sortie(im)++;t_choix_var_ddl(im)++;}
      }; //-- fin de la boucle sur les enum aux noeud
     }; //--// fin du test s'il y a des enum à sortir ou nom
     
     // a-1) cas des ddl étendues définis aux noeuds
     // **(3mars2016) je retire l'incrément 0 qui est bancal, car ne représente pas l'état initial de la structure     
     if ((glob_noeud_ddl_etendu_retenu.size() != 0) && (incre != 0))
     {// on utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
      // maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
      List_io < Ddl_enum_etendu >::iterator il,ilfin=glob_noeud_ddl_etendu_retenu.end();
      Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
      for (int im =1; im <= nbmail; im++)
         {t_indic_sortie(im)=t_g_noeud_ddl_etendu_asortir(im).begin();
         };
      for (il=glob_noeud_ddl_etendu_retenu.begin();il != ilfin;il++)
      { Enum_ddl ddl = (*il).Enum(); // récup du ddl de base
        Ddl_enum_etendu ddl_etendu = (*il); // le ddl étendue associé
        bool ddl_basique = (*il).Nom_vide();
        ostream &sort = entreePrinc.Sort_resultat_Gmsh((*il).Nom_plein()+"_ddl_etendu_noe");
        // def de l'entete
        EnteteNodeData(sort,incre,temps_actuel,(*il).Nom_plein(),1);
        // -- sortie des grandeurs
        // on balaie les maillages
        for (int im =1; im <= nbmail; im++)
         {// on ne continue que si le maillage est à sortir
          // !!! en fait avec gmsh, et le nouveau format, il faut que l'on sorte toujours quelque chose, car le nombre de noeuds
          // est celui de l'ensemble des maillages présents, 
          bool grandeur_prevu_en_sortie = (*(t_indic_sortie(im))); // drapeau utilisé en sortie
          //if (*(t_indic_sortie(im)))
          	{int numMail = tab_mail(im);
             int decal_noe = mailInitial->DecalNumNoeud(numMail);
             Tableau<Noeud *>& t_n = lesMail->Tab_noeud(im);
             int nbmaxinoeud = t_n.Taille();
             for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++) 
              { // recup du noeud
                Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
                sort << "\n" << noe.Num_noeud()+decal_noe << " " ;
                //--   les grandeurs
                if (grandeur_prevu_en_sortie)
                 {// il y a un choix suivant que c'est un ddl de base ou un ddl étendu
                  if (ddl_basique)
                    { if (noe.Existe_ici(ddl)) 
                        { sort << setprecision(ParaGlob::NbdigdoGR()) << noe.Valeur_tdt(ddl) ;}
                      else  // si la valeur n'existe pas on sort 0  
                        {sort << 0. ;};
                    }	 
                  else // sinon c'est un ddl étendue	
                    { if (noe.Existe_ici_ddlEtendu(ddl_etendu)) 
                        { sort << setprecision(ParaGlob::NbdigdoGR())
                               << (noe.DdlEtendue(ddl_etendu).ConstValeur()) ;}
                      else  // si la valeur n'existe pas on sort 0  
                        {sort << 0 ;};
                    };
                 }
                else // cas d'une sortie non prévue, on sort quand même 0.
                 {sort << 0 ;};
								 
              };
          	};
         };
        // fin de la view
        sort << "\n$EndNodeData \n"; 
        // mise à jour des pointeurs de choix
        for (int im =1; im <= nbmail; im++)
           {t_indic_sortie(im)++;}
      }; //-- fin de la boucle sur les enum aux noeud
     }; //--// fin du test s'il y a des enum à sortir ou nom

     // a-2) cas des types évoluées définis aux noeuds
     // **(3mars2016) je retire l'incrément 0 qui est bancal, car ne représente pas l'état initial de la structure     
     if ((glob_noeud_evol_retenu.size() != 0) && (incre != 0))    
     {// on utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
      // maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
      List_io < TypeQuelconque >::iterator il,ilfin=glob_noeud_evol_retenu.end();
      Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
      for (int im =1; im <= nbmail; im++)
         {t_indic_sortie(im)=t_g_noeud_evoluee_asortir(im).begin();
         };
//debug
//cout << "\n debug Isovaleurs_Gmsh::EcritureAuxNoeuds "
//     << "\n glob_noeud_evol_retenu "<< glob_noeud_evol_retenu << endl;
//fin debug
      for (il=glob_noeud_evol_retenu.begin();il != ilfin;il++)
       {TypeQuelconque& typ = (*il); // pour simplifier
        ostream &sort = entreePrinc.Sort_resultat_Gmsh((typ.EnuTypeQuelconque().NomPlein())+"_evolue_noe");
        // -- choix entre grandeur simple ou complexe
        EnumTypeGrandeur enugrandeur = typ.EnuTypeGrandeur();
        EnumType2Niveau  enuStructure = typ.Const_Grandeur_pointee()->Type_structure_grandeurAssocie();
        switch (enuStructure)
         { case TYPE_SIMPLE: 
          	{ // appel directe de la routine adoc
          	  int numero = 0;
             SortirUneViewTypeQuelconque(sort,typ,enuStructure,numero
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
             break;                       
          	}
           case TABLEAU_T:
          	{ // dans le cas d'un tableau on boucle sur les éléments du tableau
          	  switch (enugrandeur)
              { case TENSEURHH:
                 {Tab_Grandeur_TenseurHH& tab_tensHH =  *((Tab_Grandeur_TenseurHH*) typ.Const_Grandeur_pointee());
                  int taille = tab_tensHH.Taille();
                  // on boucle, et on sort  chaque tenseur
                  for (int i=1;i<=taille;i++)
                      SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
                  break; 
                 }
                case TENSEURBB:
                 {Tab_Grandeur_TenseurBB& tab_tensBB =  *((Tab_Grandeur_TenseurBB*) typ.Const_Grandeur_pointee());
                  int taille = tab_tensBB.Taille();
                  // on boucle, et on sort  chaque tenseur
                  for (int i=1;i<=taille;i++)
                      SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
                  break;
                 }
                case SCALAIRE: case SCALAIRE_ENTIER: case SCALAIRE_DOUBLE:
                 {Tab_Grandeur_scalaire_double& tab_Gdouble =  *((Tab_Grandeur_scalaire_double*) typ.Const_Grandeur_pointee());
                  int taille = tab_Gdouble.Taille();
                  // on boucle, et on sort  chaque scalaire
                  for (int i=1;i<=taille;i++)
                      SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
                  break; 
                  }
                case COORDONNEE: 
                 {Tab_Grandeur_Coordonnee& tab_coordonnee =  *((Tab_Grandeur_Coordonnee*) typ.Const_Grandeur_pointee());
                  int taille = tab_coordonnee.Taille();
                  // on boucle, et on sort  chaque coordonnée
                  for (int i=1;i<=taille;i++)
                      SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
                  break; 
                  }
                case VECTEUR:
                 {Tab_Grandeur_Vecteur& tab_vecteur =  *((Tab_Grandeur_Vecteur*) typ.Const_Grandeur_pointee());
                  int taille = tab_vecteur.Taille();
                  // on boucle, et on sort  chaque vecteur
                  for (int i=1;i<=taille;i++)
                      SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
                  break;
                  }
                default:
                   cout << "\n attention : cas de sortie de grandeur tableau non implantee (mais il suffit de le demander !!) "; 
                   typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
                   cout << "\n Isovaleurs_Gmsh::EcritureAuxNoeuds(... 4 ";    
              };//-- fin du  switch (enugrandeur)
              break;
          	}
           default:            
             cout << "\n attention : cas de sortie de grandeur de type secondaire " << NomType2Niveau(enuStructure) 
                  << " non implantee (mais il suffit de le demander !!) "; 
             typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
             cout << "\n Isovaleurs_Gmsh::EcritureAuxNoeuds(... 3 ";    
         }; 

        // mise à jour des pointeurs de choix
        for (int im =1; im <= nbmail; im++)
           t_indic_sortie(im)++;
          	
       }; //--// fin de la boucle sur les enum
     }; //--// fin du test s'il y a des enum à sortir ou nom

     // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
     // b) cas des ddl de base (simple) venant d'un transfert aux noeuds des grandeurs aux pt d'integ
     //    on ne sort que les incréments différents de 0, car pour l'incrément 0 pas de grandeurs licites aux pt integ
//debug
//cout << "\n debug Isovaleurs_Gmsh::EcritureAuxNoeuds "
//     << "\n glob_elem_ddl_retenu "<< glob_elem_ddl_retenu << endl;
//fin debug
     if ((glob_elem_ddl_retenu.size() != 0) && (incre != 0))    
     {// on utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
      // maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
      List_io < Ddl_enum_etendu >::iterator il,ilfin=glob_elem_ddl_retenu.end();
      Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
      for (int im =1; im <= nbmail; im++)
         t_indic_sortie(im)=t_g_elem_ddl_asortir(im).begin();
      
      for (il=glob_elem_ddl_retenu.begin();il != ilfin;il++)
       {Ddl_enum_etendu& ddlEtendu = (*il); // pour simplifier
        ostream *sorti; 
        // def de l'entete
        sorti = &(entreePrinc.Sort_resultat_Gmsh(ddlEtendu.Nom_plein()+"_pti"));
        EnteteNodeData(*sorti,incre,temps_actuel,ddlEtendu.Nom_plein(),1);
        ostream& sort = *sorti;      
        // -- sortie des grandeurs
        // on balaie les maillages
        
        for (int im =1; im <= nbmail; im++)
         {// on ne continue que si le ddl est à sortir
          // !!! en fait avec gmsh, et le nouveau format, il faut que l'on sorte toujours quelque chose, car le nombre de noeuds
          // est celui de l'ensemble des maillages présents, 
          bool grandeur_prevu_en_sortie = (*(t_indic_sortie(im))); // drapeau utilisé en sortie
          //if (*(t_indic_sortie(im)))
          	{int numMail = tab_mail(im);
            int decal_noe = mailInitial->DecalNumNoeud(numMail);
			         Tableau<Noeud *>& t_n = lesMail->Tab_noeud(numMail);
            int nbmaxinoeud = t_n.Taille();
            for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++) 
              { // recup du noeud
                Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
                sort << "\n" << noe.Num_noeud()+decal_noe << " " ;
                //--   les grandeurs
                if (grandeur_prevu_en_sortie)
                 {if (noe.Existe_ici_ddlEtendu(ddlEtendu)) 
                    { sort << setprecision(ParaGlob::NbdigdoGR()) << (noe.DdlEtendue(ddlEtendu).ConstValeur());}
                  else  // si la valeur n'existe pas on sort 0  
                    {sort << 0. ;};
                 }
                else // cas d'une sortie non prévue, on sort quand même 0.
                 {sort << 0 ;};
              };
          	};
         };
        // fin de la view
        sort << "\n$EndNodeData \n"; 
        // mise à jour des pointeurs de choix
        for (int im =1; im <= nbmail; im++)
           t_indic_sortie(im)++;
       }; //--// fin de la boucle sur les enum
     }; //--// fin du test d'existance d'énum à sortir venant d'un transfert aux noeuds des grandeurs aux pt d'integ

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

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

     // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
     // d) cas des types particuliers aux elements venant d'un transfert aux noeuds
     //    on ne sort que les incréments différents de 0, car pour l'incrément 0 pas de grandeurs licites aux pt integ
     if ((glob_elem_Parti_retenu.size() != 0) && (incre != 0))
     {// on utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
      // maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
      List_io < TypeQuelconque >::iterator il,ilfin=glob_elem_Parti_retenu.end();
      Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
      for (int im =1; im <= nbmail; im++)
         t_indic_sortie(im)=t_g_elem_typeParti_asortir(im).begin();
     
      for (il=glob_elem_Parti_retenu.begin();il != ilfin;il++)
       {TypeQuelconque& typ = (*il); // pour simplifier
        // -- choix entre grandeur simple ou complexe
        EnumTypeGrandeur enugrandeur = typ.EnuTypeGrandeur();
        EnumType2Niveau  enuStructure = typ.Const_Grandeur_pointee()->Type_structure_grandeurAssocie();
//        // traitement particulier pour VECTEUR
//        string sup="";// un string vide
//        if ((enuStructure == TYPE_SIMPLE) && (enugrandeur == VECTEUR))
//          {Grandeur_Vecteur_Nommer& t_grandeur =
//                                                 *((Grandeur_Vecteur_Nommer*) typ.Const_Grandeur_pointee());
//           sup += *(t_grandeur.Nom_ref());
//          };
//        ostream &sort = entreePrinc.Sort_resultat_Gmsh((typ.EnuTypeQuelconque().NomPlein())+sup+"_particulier_pti");
        ostream &sort = entreePrinc.Sort_resultat_Gmsh((typ.EnuTypeQuelconque().NomPlein())+"_particulier_pti");

        //  il faut combiner les deux types d'enu
        // compte tenu du fait que VECTEUR et TABLEAU_T sont traité de la même manière
        switch (enuStructure)
         { case TYPE_SIMPLE: 
          	{ if (enugrandeur != VECTEUR)
              {// appel directe de la routine adoc
          	    int numero = 0;
               SortirUneViewTypeQuelconque(sort,typ,enuStructure,numero
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
              }
             // sinon c'est un VECTEUR, on traite comme un tableau_T, donc on ne met pas de break;
             else
              {Grandeur_Vecteur_Nommer& t_grandeur =
                                                 *((Grandeur_Vecteur_Nommer*) typ.Const_Grandeur_pointee());
               Vecteur& vi = t_grandeur.ConteneurVecteur();
               int taille = vi.Taille();
               // on boucle, et on sort  chaque valeur
               for (int i=1;i<=taille;i++)
                  SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
                                       ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
              };
             break;
          	}
           case TABLEAU_T:
          	{ // dans le cas d'un tableau (ou d'un VECTEUR) on boucle sur les éléments du tableau
          	  switch (enugrandeur)
              { case TENSEURHH:
                 {Tab_Grandeur_TenseurHH& tab_tensHH =  *((Tab_Grandeur_TenseurHH*) typ.Const_Grandeur_pointee());
                  int taille = tab_tensHH.Taille();
                  // on boucle, et on sort  chaque tenseur
                  for (int i=1;i<=taille;i++)
                     SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
                  break; 
                 }
               case TENSEURBB:
                 {Tab_Grandeur_TenseurBB& tab_tensBB =  *((Tab_Grandeur_TenseurBB*) typ.Const_Grandeur_pointee());
                  int taille = tab_tensBB.Taille();
                  // on boucle, et on sort  chaque tenseur
                  for (int i=1;i<=taille;i++)
                     SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
                  break;
                 }
                case SCALAIRE: case SCALAIRE_ENTIER: case SCALAIRE_DOUBLE:
                 {Tab_Grandeur_scalaire_double& tab_Gdouble =  *((Tab_Grandeur_scalaire_double*) typ.Const_Grandeur_pointee());
                  int taille = tab_Gdouble.Taille();
                  // on boucle, et on sort  chaque scalaire
                  for (int i=1;i<=taille;i++)
                     SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
                  break; 
                  }
                case COORDONNEE: 
                 {Tab_Grandeur_Coordonnee& tab_coordonnee =  *((Tab_Grandeur_Coordonnee*) typ.Const_Grandeur_pointee());
                  int taille = tab_coordonnee.Taille();
                  // on boucle, et on sort  chaque scalaire
                  for (int i=1;i<=taille;i++)
                      SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
                  break; 
                  }
                case VECTEUR:
                 {Tab_Grandeur_Vecteur& tab_vecteur =  *((Tab_Grandeur_Vecteur*) typ.Const_Grandeur_pointee());
                  int taille = tab_vecteur.Taille();
                  // on boucle, et on sort  chaque scalaire
                  for (int i=1;i<=taille;i++)
                      SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
                  break;
                  }
                case BASE__H:
                 {Tab_Grandeur_BaseH& tab_base =  *((Tab_Grandeur_BaseH*) typ.Const_Grandeur_pointee());
                  int taille = tab_base.Taille();
                  if (taille > 0)
                   {// on va considérer que toutes les bases ont le même nombre de vecteur
                    Grandeur_BaseH& gr = tab_base(1);
                    const BaseH& baH1 = gr.RefConteneurBaseH();
                    int nb_vect = baH1.NbVecteur();
                    // on va traiter chaque vecteur de base comme une grandeur coordonnée
                    // on boucle, et on sort chaque base H
                    int indice_vecteur = 1; // le numéro du vecteur à sortir
                                          // par exemple si la base comporte 3 vecteurs, et qu'il y a 2 bases
                                          // a sortir cela fera au total 6 vecteurs : les 3 premiers pour la base1
                                          // les 3 suivants pour la base 2
                    for (int i=1;i<=taille;i++) // le compteur de base
                      for (int num_vec = 1; num_vec <= nb_vect; num_vec++,indice_vecteur++)
                        SortirUneViewTypeQuelconque(sort,typ,enuStructure,indice_vecteur
                                          ,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
                    };
                  break;
                  }
                default:
                   cout << "\n attention : cas de sortie de grandeur tableau non implantee (mais il suffit de le demander !!) "; 
                   typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
                   cout << "\n Isovaleurs_Gmsh::EcritureAuxNoeuds(... 1 ";    
              };//-- fin du  switch (enugrandeur)
              break;
          	}
           default:            
             cout << "\n attention : cas de sortie de grandeur de type secondaire " << NomType2Niveau(enuStructure) 
                  << " non implantee (mais il suffit de le demander !!) "; 
             typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
             cout << "\n Isovaleurs_Gmsh::EcritureAuxNoeuds(... 2 ";    
         }; 
          	
        // mise à jour des pointeurs de choix
        for (int im =1; im <= nbmail; im++)
           t_indic_sortie(im)++;

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

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

};

// gestion de l'accumulation due au passage des grandeurs choisies venant des éléments, aux noeuds, lorsque ces grandeurs sont
// directement diponibles aux noeuds
void Isovaleurs_Gmsh::Passage_grandeursRetenuesAuxNoeuds_elementsVersNoeuds()
{ int nb_maillage = tabnoeud_type_ddl.Taille();// def du nombre de maillage avec un tableau quelconque
  // dans le cas où les ddl récupérés des éléments sont visibles directement aux noeuds on les bascule
  // sur les noeuds, car il ne faut pas faire de transfert particulier
  for (int imail=1;imail<=nb_maillage;imail++)
    {  
      // on fait l'optimisation et le rangement 
      tabnoeud_evoluee_retenu(imail).sort();tabnoeud_evoluee_retenu(imail).unique();
      // on construit les tableaux a accumuler
     {List_io<Ddl_enum_etendu>& aaccum_ret = a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail); // pour simplifier
      List_io<Ddl_enum_etendu>& aaccum = a_accumuler_tabnoeud_type_ddlEtendu(imail); // pour simplifier
      aaccum_ret.clear();
      List_io<Ddl_enum_etendu>& tpg_ret = (tabnoeud_type_ddlEtendu_retenu(imail)); // pour simplifier
      List_io < Ddl_enum_etendu >::iterator iq,iqfin=tpg_ret.end();
      for (iq=tpg_ret.begin();iq!=iqfin;iq++)// on parcours la liste
       // si l'élément doit-être accumulé, on l'indique
       if (find(aaccum.begin(),aaccum.end(),(*iq)) != aaccum.end())
         aaccum_ret.push_back(*iq);// accumulation simple
      //on ordonne et supprime les doublons
      aaccum_ret.sort();aaccum_ret.unique();
     };
     
     {List_io<TypeQuelconque>& aaccum_ret = (a_accumuler_tabnoeud_evoluee_retenu(imail)); // pour simplifier
      List_io<TypeQuelconque>& aaccum = (a_accumuler_tabnoeud_evoluee(imail)); // pour simplifier
      aaccum_ret.clear();
      List_io<TypeQuelconque>& tpg_ret = (tabnoeud_evoluee_retenu(imail)); // pour simplifier
      List_io < TypeQuelconque >::iterator iq,iqfin=tpg_ret.end();
      for (iq=tpg_ret.begin();iq!=iqfin;iq++)// on parcours la liste
       // si l'élément doit-être accumulé, on l'indique
       if (find(aaccum.begin(),aaccum.end(),(*iq)) != aaccum.end())
         aaccum_ret.push_back(*iq);// accumulation simple
      //on ordonne et supprime les doublons
      aaccum_ret.sort();aaccum_ret.unique();
     };
     
////debug
//cout << "\n debug Isovaleurs_Gmsh::Passage_grandeursRetenuesAuxNoeuds_elementsVersNoeuds() "
//     << "\n 2: tabnoeud_type_ddlEtendu_retenu(imail) " << tabnoeud_type_ddlEtendu_retenu(imail)
//     << "\n 3: tabnoeud_evoluee_retenu(imail) "<<tabnoeud_evoluee_retenu(imail)<< endl;
////fin debug
      // on ajoute éventuellement des conteneurs ad hoc aux noeuds
      // une fois que ces conteneurs existent, ils sont remplit automatiquement par l'élément
      List_io < TypeQuelconque > litq; // une autre pour les quelconques
      Tableau <List_io < TypeQuelconque > * > tabQ(2); 
      tabQ(1)= &tabnoeud_evoluee_retenu(imail);tabQ(2)=&litq;
      // on est obligé d'utiliser un tableau dont le second terme est nul,
      // ceci pour pouvoir utiliser "AjoutConteneurAuNoeud" tel quel
      lesMail->AjoutConteneurAuNoeud(imail,tabnoeud_type_ddlEtendu_retenu(imail),tabQ);
    };
 };
 

// passage des grandeurs disponibles venant des éléments, aux noeuds, lorsque ces grandeurs sont
// directement diponibles aux noeuds
void Isovaleurs_Gmsh::Passage_grandeursDisponiblesAuxNoeuds_elementsVersNoeuds() 
{ int nb_maillage = tabnoeud_type_ddl.Taille();// def du nombre de maillage avec un tableau quelconque
  // dans le cas où les ddl récupérés des éléments sont visibles directement aux noeuds on les bascule
  // sur les noeuds, car il ne faut pas faire de transfert particulier
  for (int imail=1;imail<=nb_maillage;imail++)
    { 
     {List_io <Ddl_enum_etendu>& lis_sor = tabelement_type_ddl(imail); // pour simplifier
//debug
//cout << "\n debug Isovaleurs_Gmsh::Passage_grandeursDisponiblesAuxNoeuds_elementsVersNoeuds() "
//     << "\n tabelement_type_ddl_retenu(imail) " << tabelement_type_ddl_retenu(imail) << endl;
//fin debug
     
     
      List_io <Ddl_enum_etendu>::iterator ili,ilifin = lis_sor.end();
      List_io <List_io <Ddl_enum_etendu>::iterator> inter; // pour stocker les grandeurs à déplacer
      // on parcours d'abord la liste venant des éléments
      for (ili=lis_sor.begin();ili != ilifin;ili++)
        {
//debug
//if ((*ili).Nom() == "pression_ext")
// cout << "\n debug Isovaleurs_Gmsh::Passage_grandeursDisponiblesAuxNoeuds_elementsVersNoeuds() "
//      << "\n tabelement_type_ddl_retenu(imail) " << tabelement_type_ddl_retenu(imail) << endl;
//fin debug
         if ((Meme_famille((*ili).Enum(),X1)) // X1 est un ddl définit aux noeuds
             || ((*ili).Nom() == "pression_ext") // cas particuliers : def au pti, mais dispo tel quel au noeud
            )
            {inter.push_back(ili);tabnoeud_type_ddlEtendu(imail).push_back(*ili);
             // les grandeurs qui viennent des éléments sont visible par moyenne aux noeuds
             a_accumuler_tabnoeud_type_ddlEtendu(imail).push_back(*ili);
            };
        };
      // on supprime
      List_io <List_io <Ddl_enum_etendu>::iterator>::iterator ik,ikfin = inter.end();
      for (ik = inter.begin();ik!=ikfin;ik++)
        lis_sor.erase(*ik);
      tabnoeud_type_ddlEtendu_retenu(imail).sort();tabnoeud_type_ddlEtendu(imail).unique();
      a_accumuler_tabnoeud_type_ddlEtendu(imail).sort();
      a_accumuler_tabnoeud_type_ddlEtendu(imail).unique();
     };
      //.. idem pour les grandeurs évoluées ...
     {List_io <TypeQuelconque>& lis_sor = tabelement_evoluee(imail); // pour simplifier
      List_io <TypeQuelconque>::iterator ili,ilifin = lis_sor.end();
      List_io <List_io <TypeQuelconque>::iterator> inter; // pour stocker les grandeurs à déplacer
      // on parcours d'abord la liste venant des éléments
      for (ili=lis_sor.begin();ili != ilifin;ili++)
        if (Meme_famille((*ili).Enum(),X1)) // X1 est un ddl définit aux noeuds
            {inter.push_back(ili);tabnoeud_evoluee(imail).push_back(*ili);
             // les grandeurs qui viennent des éléments sont visible par moyenne aux noeuds
             a_accumuler_tabnoeud_evoluee(imail).push_back(*ili);
             };
      // on supprime
      List_io <List_io <TypeQuelconque>::iterator>::iterator ik,ikfin = inter.end();
      for (ik = inter.begin();ik!=ikfin;ik++)
        lis_sor.erase(*ik);
     };
      //.. idem pour les grandeurs particulières ...
     {List_io <TypeQuelconque>& lis_sor = tabelement_typeParti(imail); // pour simplifier
      List_io <TypeQuelconque>::iterator ili,ilifin = lis_sor.end();
      List_io <List_io <TypeQuelconque>::iterator> inter; // pour stocker les grandeurs à déplacer
      // on parcours d'abord la liste venant des éléments
      for (ili=lis_sor.begin();ili != ilifin;ili++)
        if (Meme_famille((*ili).Enum(),X1)) // X1 est un ddl définit aux noeuds
            {inter.push_back(ili);tabnoeud_evoluee(imail).push_back(*ili);
             // les grandeurs qui viennent des éléments sont visible par moyenne aux noeuds
             a_accumuler_tabnoeud_evoluee(imail).push_back(*ili);
             };
      // on supprime
      List_io <List_io <TypeQuelconque>::iterator>::iterator ik,ikfin = inter.end();
      for (ik = inter.begin();ik!=ikfin;ik++)
        lis_sor.erase(*ik);
     };
      // comme tabnoeud_evoluee est utilisé pour les éléments par les grandeurs évoluées et particulières
      // on fait l'optimisation et le rangement une seule fois à la fin
      tabnoeud_evoluee(imail).sort();tabnoeud_evoluee(imail).unique();
      a_accumuler_tabnoeud_evoluee(imail).sort();
      a_accumuler_tabnoeud_evoluee(imail).unique();
     
//debug
//cout << "\n debug Isovaleurs_Gmsh::Passage_grandeursDisponiblesAuxNoeuds_elementsVersNoeuds() "
//     << "\n 2: tabelement_type_ddl(imail) " << tabelement_type_ddl(imail)
//     << "\n 3: a_accumuler_tabnoeud_evoluee(imail) "<<a_accumuler_tabnoeud_evoluee(imail)<< endl;
//fin debug
    };
 };

// calcul des grandeurs aux noeuds, directement accessible des éléments 
void Isovaleurs_Gmsh::CalculAuxElemAuxNoeuds(const Tableau <int>& tab_mail,LesMaillages * lesMail)
{ // .. on initialise les conteneurs ..
  int nbmail = tab_mail.Taille();
  int cas=1; // par défaut on cumul et on moyenne simplement
  // pour utiliser la méthode InitUpdateAuNoeud, on doit construire tabQ a deux dim
  List_io < TypeQuelconque > litq; // une autre pour les quelconques
  Tableau <List_io < TypeQuelconque > * > tabQ(2); 
  tabQ(2)=&litq;
////debug
//cout << "\n debug Isovaleurs_Gmsh::CalculAuxElemAuxNoeuds(...) "
//     << "\n  a_accumuler_tabnoeud_evoluee_retenu(1) " << a_accumuler_tabnoeud_evoluee_retenu(1)
//     << "\n  a_accumuler_tabnoeud_type_ddlEtendu_retenu(1) "<<a_accumuler_tabnoeud_type_ddlEtendu_retenu(1)<< endl;
////fin debug

  for (int imail=1;imail<=nbmail;imail++)
    { tabQ(1) = &a_accumuler_tabnoeud_evoluee_retenu(imail);
      lesMail->InitUpdateAuNoeud(imail,a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail),tabQ,cas);
    };
 
  // accumulation aux noeuds de grandeurs venant de l'éléments vers ses noeuds (exemple la pression appliquée)
	 // autres que celles aux pti classiques, mais directements disponibles
  for (int imail=1;imail<=nbmail;imail++)
     lesMail->Accumul_aux_noeuds(imail,a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail)
                                 ,a_accumuler_tabnoeud_evoluee_retenu(imail),cas);
	 //  calcul des moyennes en chaque noeuds)
  tabQ.Change_taille(1);
  for (int imail=1;imail<=nbmail;imail++)
    { tabQ(1) = &a_accumuler_tabnoeud_evoluee_retenu(imail);
      lesMail->FinTransfertPtIntegAuNoeud(imail,a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail),tabQ,cas);
    };
		
};