// FICHIER : VariablesExporter.cc
// CLASSE : VariablesExporter

// 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 "VariablesExporter.h"
# include <iostream>
using namespace std;  //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
#include <stdio.h>
#include <vector>
#include "List_io.h"
#include "CharUtil.h"
#include "TypeQuelconqueParticulier.h"
#include "Banniere.h"
#include "ReferenceNE.h"
#include "ReferenceAF.h"


// ------------ classes conteneur ----------------
// ======== A_un_NE ============

// classe conteneur de base pour noeud et élément

ostream & operator << ( ostream & sort,const  VariablesExporter::A_un_NE & a)
{ sort << a.nom_var;
  if (a.nom_mail != "")
         {sort << " nom_mail= "<< a.nom_mail;};
  sort << " ref_ " << a.ref ;

  return sort;
};

// lecture
istream & operator >> ( istream & ent, VariablesExporter::A_un_NE & a)
{ string toto;
  ent >> a.nom_var >> toto;
  // lecture éventuelle d'un nom de maillage
  if (toto == "nom_mail=")
   {ent >> a.nom_mail >> toto;}
  else if (toto == "ref_")
   {a.nom_mail ="";}
  else
   {cout << "\n *** erreur de syntaxe en lecture d'une variable utilisateur,"
         << " on attendait soit la chaine de characteres: nom_mail= ou soit ref_ "
         << " et on a lu: "<< toto << " !!"
         << endl;
    Sortie(1);
   } ;
  // fin de la lecture
  ent >> a.ref ;
  // vérif il faut que les 3 premiers caractères de a.nom_var soit un V__
  if (!((a.nom_var[0]== 'V')&&(a.nom_var[1]== '_')&&(a.nom_var[2]== '_')))
   { cout << "\n *** erreur de syntaxe en lecture d'une variable utilisateur,"
          << " les 3 premieres lettres "
          << " devraientt etre un 'V__' et on a lu: "<<a.nom_var << " !!"
          << endl;
     Sortie(1);
   };
  
//  // on vérifie également qu'il s'agit bien d'une ref de noeud ou d'élément
//  if ((a.ref[0] != 'N') && (a.ref[0] != 'E'))
//   { cout << "\n *** erreur de syntaxe en lecture d'une reference de noeud ou d'element,"
//          << " la premiere lettre  "
//          << " devraientt etre N ou E et on a lu: "<<a.ref << " !!"
//          << endl;
//     Sortie(1);
//   };

  return ent;
};

VariablesExporter::A_un_NE::A_un_NE () : // constructeur par défaut
     ref(""), nom_mail(), nom_var("_"){};
// constructeur fonction de toutes les grandeurs
VariablesExporter::A_un_NE::A_un_NE
     (string ref_noeEle,string nom_mail_,string nom_var_) :
      ref(ref_noeEle), nom_mail(nom_mail_)
      , nom_var(nom_var_) {};
// constructeur de copie
VariablesExporter::A_un_NE::A_un_NE (const A_un_NE& a) :
      ref(a.ref)
      ,nom_mail(a.nom_mail), nom_var(a.nom_var) {};
// destructeur
VariablesExporter::A_un_NE::~A_un_NE()
   {};
         
// opérateurs
VariablesExporter::A_un_NE& VariablesExporter::A_un_NE::operator=
     (const VariablesExporter::A_un_NE& a)
          {ref=a.ref;
           nom_mail=a.nom_mail; nom_var=a.nom_var;
           return (*this);
          };
          
bool VariablesExporter::A_un_NE::operator== (const A_un_NE& a) const
    {if ((ref==a.ref) && (nom_var==a.nom_var) )
       return true;
     else
       return false;
    };

bool VariablesExporter::A_un_NE::operator< (const A_un_NE& a) const
  {if (nom_mail != a.nom_mail)
     { return (nom_mail < a.nom_mail);}
   else // cas nom_mail = a.nom_mail
    { if (ref != a.ref)
        {return (ref < a.ref);}
      else //cas nom_mail = a.nom_mail et ref = a.ref
        {if (nom_var != a.nom_var)
           {return (nom_var < a.nom_var);}
         else // cas où tout est égal on n'est pas inférieur
           {return false;}
        };
     };
  };

bool VariablesExporter::A_un_NE::operator<= (const A_un_NE& a) const
  {if (nom_mail != a.nom_mail)
     { return (nom_mail <= a.nom_mail);}
   else // nom_mail = a.nom_mail
    { if (ref != a.ref)
        {return (ref <= a.ref);}
    else //cas nom_mail = a.nom_mail et ref = a.ref
        {if (nom_var != a.nom_var)
          {return (nom_var <= a.nom_var);}
         else // cas où tout est égal on n'est pas inférieur
             {return true;};
        };
     };
  };

bool VariablesExporter::A_un_NE::operator> (const A_un_NE& a) const
  {if (nom_mail != a.nom_mail)
     { return (nom_mail > a.nom_mail);}
   else // cas nom_mail = a.nom_mail
    { if (ref != a.ref)
      {return (ref > a.ref);}
    else //cas nom_mail = a.nom_mail et ref = a.ref
      {if (nom_var != a.nom_var)
        {return (nom_var > a.nom_var);}
       else // cas où tout est égal on n'est pas supérieur
           {return false;};
      };
     };
  };


bool VariablesExporter::A_un_NE::operator>= (const A_un_NE& a) const
  {if (nom_mail != a.nom_mail)
     { return (nom_mail >= a.nom_mail);}
   else // cas nom_mail = a.nom_mail
    { if (ref != a.ref)
      {return (ref >= a.ref);}
    else //cas nom_mail = a.nom_mail et ref = a.ref
      {if (nom_var != a.nom_var)
        {return (nom_var >= a.nom_var);}
       else // cas où tout est égal
           {return true;};
      };
     };
  };

// affichage
void VariablesExporter::A_un_NE::Affiche()
 { cout << "\n Variable utilisateur: " << nom_var
        << " au_noeud_ref: " << ref
        << " maillage: " << nom_mail;
 };

// ======== Ddl_a_un_noeud ============

// classe conteneur pour un ddl à un noeud
ostream & operator << ( ostream & sort,const  VariablesExporter::Ddl_a_un_noeud & a)
{ sort << "\n   Ddl_noeud_ " << a.nom_var;
  if (a.nom_mail != "")
    {sort << " nom_mail= "<< a.nom_mail;};
    
  sort << " ref_ " << a.ref_num_NE << " ddl_ " << a.enu
       << " temps_ " << a.temps;
       

  return sort;
};

istream & operator >> ( istream & ent, VariablesExporter::Ddl_a_un_noeud & a)
{// lecture du type et vérification
  string nomtype; ent >> nomtype;
  if (nomtype != "Ddl_noeud_")
    { cout << "\n *** erreur en lecture: on attendait le mot cle Ddl_noeud_ et on a lue "
           << nomtype
           << "\n operator >> ( istream & ent, VariablesExporter::Ddl_a_un_noeud(...";
      Sortie(1);
      return ent;
    };
  // lecture
  string toto;
  ent >> a.nom_var >> toto;
  // lecture éventuelle d'un nom de maillage
  if (toto == "nom_mail=")
   {ent >> a.nom_mail >> toto;}
  else if (toto == "ref_")
   {a.nom_mail ="";}
  else
   {cout << "\n *** erreur de syntaxe en lecture d'une variable utilisateur de type ddl,"
         << " on attendait soit la chaine de characteres: nom_mail= ou soit ref_ "
         << " et on a lu: "<< toto << " !!"
         << endl;
    Sortie(1);
   } ;
  // fin de la lecture
  ent >> a.ref_num_NE >> toto >> a.enu >> toto >>  a.temps;
      
  // vérif il faut que les 3 premiers caractères de a.nom_var soit un V__
  if (!((a.nom_var[0]== 'V')&&(a.nom_var[1]== '_')&&(a.nom_var[2]== '_')))
   { cout << "\n *** erreur de syntaxe en lecture d'une variable utilisateur de type ddl,"
          << " les 3 premieres lettres "
          << " devraientt etre un 'V__' et on a lu: "<<a.nom_var << " !!"
          << endl;
     Sortie(1);
   };
 // on vérifie également qu'il s'agit bien d'une ref de noeud
 if (a.ref_num_NE[0] != 'N')
  { cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
         << " erreur de syntaxe en lecture d'une reference de noeud ,"
         << " la premiere lettre  "
         << " devraientt etre N et on a lu: "<<a.ref_num_NE << " !!"
         << endl;
    Sortie(1);
  };

  return ent;
};

VariablesExporter::Ddl_a_un_noeud::Ddl_a_un_noeud () : // constructeur par défaut
     enu(),ref_num_NE(""), nom_mail(), nom_var("_"), temps() {};
// constructeur fonction de toutes les grandeurs
VariablesExporter::Ddl_a_un_noeud::Ddl_a_un_noeud
     (Ddl_enum_etendu e,string ref_noeud,string nom_mail_,string nom_var_, Enum_dure tps) :
          enu(),ref_num_NE(ref_noeud), nom_mail(nom_mail_)
          , nom_var(nom_var_),temps(tps) {};
// constructeur de copie
VariablesExporter::Ddl_a_un_noeud::Ddl_a_un_noeud (const Ddl_a_un_noeud& a) :
          enu(a.enu),ref_num_NE(a.ref_num_NE)
          ,nom_mail(a.nom_mail), nom_var(a.nom_var),temps(a.temps) {};
// destructeur
VariablesExporter::Ddl_a_un_noeud::~Ddl_a_un_noeud()
   {};
         
// opérateurs
VariablesExporter::Ddl_a_un_noeud& VariablesExporter::Ddl_a_un_noeud::operator=
     (const VariablesExporter::Ddl_a_un_noeud& a)
          {enu=a.enu; ref_num_NE=a.ref_num_NE;
           nom_mail=a.nom_mail; nom_var=a.nom_var;temps = a.temps;
           return (*this);
          };
          
bool VariablesExporter::Ddl_a_un_noeud::operator== (const Ddl_a_un_noeud& a) const
    {if ((enu==a.enu)  && (ref_num_NE==a.ref_num_NE)
        && (nom_var==a.nom_var) && (temps == a.temps))
       return true;
     else
       return false;
    };

bool VariablesExporter::Ddl_a_un_noeud::operator< (const Ddl_a_un_noeud& a) const
{if (enu != a.enu)
  { return (enu < a.enu);}
 else // cas enu = a.enu
  {if (nom_mail != a.nom_mail)
     { return (nom_mail < a.nom_mail);}
   else // cas enu = a.enu et nom_mail = a.nom_mail
    { if (ref_num_NE != a.ref_num_NE)
        {return (ref_num_NE < a.ref_num_NE);}
      else //cas enu = a.enu et nom_mail = a.nom_mail et num_NE = a.num_NE
        {if (nom_var != a.nom_var)
           {return (nom_var < a.nom_var);}
         else //cas enu = a.enu et nom_mail = a.nom_mail et num_NE = a.num_NE
              // et nom_var == a.nom_var
           {if (temps != a.temps)
             {return (temps < a.temps);}
            else // cas où tout est égal on n'est pas inférieur
             {return false;}
           }
        };
     };
  };
};

bool VariablesExporter::Ddl_a_un_noeud::operator<= (const Ddl_a_un_noeud& a) const
{if (enu != a.enu)
  { return (enu <= a.enu);}
 else // cas enu = a.enu
  {if (nom_mail != a.nom_mail)
     { return (nom_mail <= a.nom_mail);}
   else // cas enu = a.enu et nom_mail = a.nom_mail
    { if (ref_num_NE != a.ref_num_NE)
        {return (ref_num_NE <= a.ref_num_NE);}
    else //cas enu = a.enu et nom_mail = a.nom_mail et ref_num_NE = a.ref_num_NE
        {if (nom_var != a.nom_var)
          {return (nom_var <= a.nom_var);}
         else //cas enu = a.enu et nom_mail = a.nom_mail et ref_num_NE = a.ref_num_NE
              // et nom_var == a.nom_var
           {if (temps != a.temps)
             {return (temps <= a.temps);}
            else // cas où tout est égal on n'est pas inférieur
             {return true;};
           };
        };
     };
  };
};

bool VariablesExporter::Ddl_a_un_noeud::operator> (const Ddl_a_un_noeud& a) const
{if (enu != a.enu)
  { return (enu > a.enu);}
 else // cas enu = a.enu
  {if (nom_mail != a.nom_mail)
     { return (nom_mail > a.nom_mail);}
   else // cas enu = a.enu et nom_mail = a.nom_mail
    { if (ref_num_NE != a.ref_num_NE)
      {return (ref_num_NE > a.ref_num_NE);}
    else //cas enu = a.enu et nom_mail = a.nom_mail et ref_num_NE = a.ref_num_NE
      {if (nom_var != a.nom_var)
        {return (nom_var > a.nom_var);}
       else //cas enu = a.enu et nom_mail = a.nom_mail et ref_num_NE = a.ref_num_NE
            // et nom_var == a.nom_var
         {if (temps != a.temps)
           {return (temps <= a.temps);}
          else // cas où tout est égal on n'est pas supérieur
           {return false;};
         };
      };
     };
  };
};


bool VariablesExporter::Ddl_a_un_noeud::operator>= (const Ddl_a_un_noeud& a) const
{if (enu != a.enu)
  { return (enu >= a.enu);}
 else // cas enu = a.enu
  {if (nom_mail != a.nom_mail)
     { return (nom_mail >= a.nom_mail);}
   else // cas enu = a.enu et nom_mail = a.nom_mail
    { if (ref_num_NE != a.ref_num_NE)
      {return (ref_num_NE >= a.ref_num_NE);}
    else //cas enu = a.enu et nom_mail = a.nom_mail et ref_num_NE = a.ref_num_NE
      {if (nom_var != a.nom_var)
        {return (nom_var >= a.nom_var);}
       else //cas enu = a.enu et nom_mail = a.nom_mail et ref_num_NE = a.ref_num_NE
            // et nom_var == a.nom_var
         {if (temps != a.temps)
           {return (temps <= a.temps);}
          else // cas où tout est égal
           {return true;};
         };
      };
     };
  };
};

// affichage
void VariablesExporter::Ddl_a_un_noeud::Affiche()
 { cout << "\n Variable utilisateur: " << nom_var
        << "ddl " << enu.Nom_plein()
        << " au_noeud_ref: " << ref_num_NE
        << " maillage: " << nom_mail
        << " temps= " << temps;
 };
 
// ======== Ddl_etendu_a_un_noeud ============

// classe conteneur pour un ddl étendu à un noeud
ostream & operator << ( ostream & sort,const  VariablesExporter::Ddl_etendu_a_un_noeud & a)
{ // récup du pointeur de la classe mère
  const VariablesExporter::A_un_NE* aA = a.PointeurClass_const();
  // sortie
  sort << "\n   Ddl_etendu_a_un_noeud_ ";
  sort << *aA; // la classe mère
  sort << " ddl_etendu_ "<< a.Enu_const() << " ";
  // retour
  return sort;
};

istream & operator >> ( istream & ent, VariablesExporter::Ddl_etendu_a_un_noeud & a)
{ // récup du pointeur de la classe mère
  VariablesExporter::A_un_NE* aA = a.PointeurClass();
  // lecture du type et vérification
  string nomtype,toto; ent >> nomtype ;
  if (nomtype != "Ddl_etendu_a_un_noeud_")
    { cout << "\n *** erreur en lecture: on attendait le mot cle Ddl_etendu_a_un_noeud_ et on a lue "
           << nomtype
           << "\n operator >> ( istream & ent, VariablesExporter::Ddl_etendu_a_un_noeud(...";
      Sortie(1);
      return ent;
    };
 // lecture de la partie mère
 ent >> *aA;
 // on vérifie également qu'il s'agit bien d'une ref de noeud
 if (aA->Ref_NE()[0] != 'N')
  { cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
         << " erreur de syntaxe en lecture d'une reference de noeud ,"
         << " la premiere lettre  "
         << " devraientt etre N et on a lu: "<<aA->Ref_NE() << " !!"
         << endl;
    Sortie(1);
  };
 // lecture du ddl étendu
 ent >> toto >> a.enu ;

  return ent;
};

VariablesExporter::Ddl_etendu_a_un_noeud::Ddl_etendu_a_un_noeud () : // constructeur par défaut
     A_un_NE(),enu() {};
// constructeur fonction de toutes les grandeurs
VariablesExporter::Ddl_etendu_a_un_noeud::Ddl_etendu_a_un_noeud
     (Ddl_enum_etendu e,string ref_noeud,string nom_mail_,string nom_var_) :
          A_un_NE(ref_noeud,nom_mail_,nom_var_)
          ,enu(e)
            {};
// constructeur de copie
VariablesExporter::Ddl_etendu_a_un_noeud::Ddl_etendu_a_un_noeud (const Ddl_etendu_a_un_noeud& a) :
          A_un_NE(a)
          ,enu(a.enu)
            {};
// destructeur
VariablesExporter::Ddl_etendu_a_un_noeud::~Ddl_etendu_a_un_noeud()
   {};
         
// opérateurs
VariablesExporter::Ddl_etendu_a_un_noeud& VariablesExporter::Ddl_etendu_a_un_noeud::operator=
     (const VariablesExporter::Ddl_etendu_a_un_noeud& a)
          {enu = a.enu;
           *(this->PointeurClass()) = *(a.PointeurClass_const());
           return (*this);
          };
          
bool VariablesExporter::Ddl_etendu_a_un_noeud::operator== (const Ddl_etendu_a_un_noeud& a) const
    {if ((enu ==a.enu)
         && (*(this->PointeurClass_const()) == *(a.PointeurClass_const())))
       return true;
     else
       return false;
    };

bool VariablesExporter::Ddl_etendu_a_un_noeud::operator< (const Ddl_etendu_a_un_noeud& a) const
{if (enu != a.enu)
  { return (enu < a.enu);}
 else // cas enu = a.enu
  {return (*(this->PointeurClass_const()) < *(a.PointeurClass_const()));}
};

bool VariablesExporter::Ddl_etendu_a_un_noeud::operator<= (const Ddl_etendu_a_un_noeud& a) const
{if (enu != a.enu)
  { return (enu <= a.enu);}
 else // cas enu = a.enu
  {return (*(this->PointeurClass_const()) <=  *(a.PointeurClass_const()));}
};

bool VariablesExporter::Ddl_etendu_a_un_noeud::operator> (const Ddl_etendu_a_un_noeud& a) const
{if (enu != a.enu)
  { return (enu > a.enu);}
 else // cas enu = a.enu
  {return (*(this->PointeurClass_const()) > *(a.PointeurClass_const()));}
};


bool VariablesExporter::Ddl_etendu_a_un_noeud::operator>= (const Ddl_etendu_a_un_noeud& a) const
{if (enu != a.enu)
  { return (enu >= a.enu);}
 else // cas enu = a.enu
  {return (*(this->PointeurClass_const()) >= *(a.PointeurClass_const()));}
};

// affichage
void VariablesExporter::Ddl_etendu_a_un_noeud::Affiche()
 { A_un_NE::Affiche();
   cout << " Ddl_etendu_a_un_noeud_  "  << Enu() ;
 };
 
// ======== Quelconque_a_un_noeud ============

// classe conteneur pour une grandeur quelconque à un noeud
ostream & operator << ( ostream & sort,const  VariablesExporter::Quelconque_a_un_noeud & a)
{ // récup du pointeur de la classe mère
  const VariablesExporter::A_un_NE* aA = a.PointeurClass_const();
  // récup de l'énuméré du type quelconque
  const TypeQuelconque_enum_etendu& quelc = a.Quelc_const();
  // sortie
  sort << "\n   Quelconque_a_un_noeud_ " ;
  sort << *aA; // la classe mère
  sort << " grandeur_quelconque_ " << quelc.NomPlein() << " composante: " << a.num_ordre << " ";
  // retour
  return sort;
};

istream & operator >> ( istream & ent, VariablesExporter::Quelconque_a_un_noeud & a)
{ // récup du pointeur de la classe mère
  VariablesExporter::A_un_NE* aA = a.PointeurClass();
  // lecture du type et vérification
  string nomtype,toto; ent >> nomtype ;
  if (nomtype != "Quelconque_a_un_noeud_")
    { cout << "\n *** erreur en lecture: on attendait le mot cle Quelconque_a_un_noeud_ et on a lue "
           << nomtype
           << "\n operator >> ( istream & ent, VariablesExporter::Quelconque_a_un_noeud(...";
      Sortie(1);
      return ent;
    };
  // lecture de la partie mère
  ent >> *aA;
  // on vérifie également qu'il s'agit bien d'une ref de noeud
  if (aA->Ref_NE()[0] != 'N')
   { cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
          << " erreur de syntaxe en lecture d'une reference de noeud ,"
          << " la premiere lettre  "
          << " devraientt etre N et on a lu: "<<aA->Ref_NE() << " !!"
          << endl;
     Sortie(1);
   };
  // lecture de la grandeur quelconque
  string nom_quelc;
  ent >> toto >> nom_quelc;
  a.quelc = TypeQuelconque_enum_etendu(nom_quelc);
  
  ent >> toto >> a.num_ordre;
  return ent;
};

VariablesExporter::Quelconque_a_un_noeud::Quelconque_a_un_noeud () : // constructeur par défaut
     A_un_NE(),quelc() {};
// constructeur fonction de toutes les grandeurs
VariablesExporter::Quelconque_a_un_noeud::Quelconque_a_un_noeud
     (TypeQuelconque_enum_etendu e,string ref_noeud,string nom_mail_,string nom_var_,int num_ord) :
          A_un_NE(ref_noeud,nom_mail_,nom_var_) 
          ,quelc(e),num_ordre(num_ord)
            {};
// constructeur de copie
VariablesExporter::Quelconque_a_un_noeud::Quelconque_a_un_noeud (const Quelconque_a_un_noeud& a) :
          A_un_NE(a)
          ,quelc(a.quelc),num_ordre(a.num_ordre)
            {};
// destructeur
VariablesExporter::Quelconque_a_un_noeud::~Quelconque_a_un_noeud()
   {};
         
// opérateurs
VariablesExporter::Quelconque_a_un_noeud& VariablesExporter::Quelconque_a_un_noeud::operator=
     (const VariablesExporter::Quelconque_a_un_noeud& a)
          {quelc = a.quelc;num_ordre = a.num_ordre;
           *(this->PointeurClass()) = *(a.PointeurClass_const());
           return (*this);
          };
          
bool VariablesExporter::Quelconque_a_un_noeud::operator== (const Quelconque_a_un_noeud& a) const
    {if ((quelc==a.quelc) && (num_ordre == a.num_ordre)
         && (*(this->PointeurClass_const()) == *(a.PointeurClass_const())))
       return true;
     else
       return false;
    };

bool VariablesExporter::Quelconque_a_un_noeud::operator< (const Quelconque_a_un_noeud& a) const
{if (quelc != a.quelc)
  { return (quelc < a.quelc);}
 else // cas quelc = a.quelc
  {if (num_ordre != a.num_ordre)
    {return (num_ordre < a.num_ordre); }
   else
    {return (*(this->PointeurClass_const()) < *(a.PointeurClass_const()));}
  };
};

bool VariablesExporter::Quelconque_a_un_noeud::operator<= (const Quelconque_a_un_noeud& a) const
{if (quelc != a.quelc)
  { return (quelc <= a.quelc);}
 else // cas quelc = a.quelc
  {if (num_ordre != a.num_ordre)
    {return (num_ordre <= a.num_ordre); }
   else
    {return (*(this->PointeurClass_const()) <=  *(a.PointeurClass_const()));}
  };
};

bool VariablesExporter::Quelconque_a_un_noeud::operator> (const Quelconque_a_un_noeud& a) const
{if (quelc != a.quelc)
  { return (quelc > a.quelc);}
 else // cas quelc = a.quelc
  {if (num_ordre != a.num_ordre)
    {return (num_ordre > a.num_ordre); }
   else
    {return (*(this->PointeurClass_const()) > *(a.PointeurClass_const()));}
  };
};


bool VariablesExporter::Quelconque_a_un_noeud::operator>= (const Quelconque_a_un_noeud& a) const
{if (quelc != a.quelc)
  { return (quelc >= a.quelc);}
 else // cas quelc = a.quelc
  {if (num_ordre != a.num_ordre)
    {return (num_ordre >= a.num_ordre); }
   else
    {return (*(this->PointeurClass_const()) >= *(a.PointeurClass_const()));}
  };
};

// affichage
void VariablesExporter::Quelconque_a_un_noeud::Affiche()
 { A_un_NE::Affiche();
   cout << " quelconque_a_un_noeud_  "  << quelc.NomPlein()
        << " composante: " << num_ordre ;
 };

// ======== A_un_E ============

// classe conteneur pour un élément
ostream & operator << ( ostream & sort,const  VariablesExporter::A_un_E & a)
{ // récup du pointeur de la classe mère
  const VariablesExporter::A_un_NE* aA = a.PointeurClass_const();
  // sortie
  sort << *aA; // la classe mère
  sort << " absolu_ " << a.absolu
       << " num_pti_ " << a.num_pti
       << " ";
  // retour
  return sort;
};

istream & operator >> ( istream & ent, VariablesExporter::A_un_E & a)
{ // récup du pointeur de la classe mère
  VariablesExporter::A_un_NE* aA = a.PointeurClass();
  // lecture du type et vérification
  // lecture de la partie mère
  ent >> *aA ;
  // on vérifie également qu'il s'agit bien d'une ref d'élément
  if (aA->Ref_NE()[0] != 'E')
   { cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
          << " erreur de syntaxe en lecture d'une reference d'element ,"
          << " la premiere lettre  "
          << " devraientt etre E et on a lu: "<<aA->Ref_NE() << " !!"
          << endl;
     Sortie(1);
   };
  string toto;
  ent >> toto;
  // lecture éventuelle du paramètre absolu
  if (toto == "absolu_")
   {ent >> a.absolu >> toto;}
  else if (toto == "num_pti_")
   {a.absolu = 1;}
  else
   {cout << "\n *** erreur de syntaxe en lecture d'une variable utilisateur,"
         << " on attendait soit la chaine de characteres: absolu_ ou soit num_pti_ "
         << " et on a lu: "<< toto << " !!"
         << endl;
    Sortie(1);
   } ;
  // fin de la lecture
  ent >>  a.num_pti ;

  return ent;
};

VariablesExporter::A_un_E::A_un_E () : // constructeur par défaut
     A_un_NE(),num_pti(0),absolu(1) {};
// constructeur fonction de toutes les grandeurs
VariablesExporter::A_un_E::A_un_E
     (int absolu_,string  ref
     ,string nom_mail_,string nom_var_,int nbpti) :
          A_un_NE(ref,nom_mail_,nom_var_)
          ,num_pti(nbpti),absolu(absolu_)
            {};
// constructeur de copie
VariablesExporter::A_un_E::A_un_E (const A_un_E& a) :
          A_un_NE(a)
          ,num_pti(a.num_pti),absolu(a.absolu)
            {};
// destructeur
VariablesExporter::A_un_E::~A_un_E()
   {};
         
// opérateurs
VariablesExporter::A_un_E& VariablesExporter::A_un_E::operator=
     (const VariablesExporter::A_un_E& a)
          {num_pti=a.num_pti;
           absolu = a.absolu;
           *(this->PointeurClass()) = *(a.PointeurClass_const());
           return (*this);
          };
          
bool VariablesExporter::A_un_E::operator== (const A_un_E& a) const
    {if (((num_pti==a.num_pti)&&(absolu ==a.absolu)
         && (*(this->PointeurClass_const()) == *(a.PointeurClass_const())))
        )
       return true;
     else
       return false;
    };

bool VariablesExporter::A_un_E::operator< (const A_un_E& a) const
{ if (num_pti != a.num_pti)
      {return (num_pti < a.num_pti);}
    else //  num_pti == a.num_pti
      {if (absolu != a.absolu)
         {return (absolu < a.absolu);}
       else
        {return (*(this->PointeurClass_const()) < *(a.PointeurClass_const()));}
      }
  };

bool VariablesExporter::A_un_E::operator<= (const A_un_E& a) const
  { if (num_pti != a.num_pti)
        {return (num_pti <= a.num_pti);}
      else // num_pti == a.num_pti
        {if (absolu != a.absolu)
          {return (absolu <= a.absolu);}
         else
          {return (*(this->PointeurClass_const()) <=  *(a.PointeurClass_const()));}
        }
    };

bool VariablesExporter::A_un_E::operator> (const A_un_E& a) const
  { if (num_pti != a.num_pti)
        {return (num_pti > a.num_pti);}
      else // num_pti == a.num_pti
        {if (absolu != a.absolu)
          {return (absolu > a.absolu);}
         else
          {return (*(this->PointeurClass_const()) > *(a.PointeurClass_const()));}
        };
    };


bool VariablesExporter::A_un_E::operator>= (const A_un_E& a) const
  { if (num_pti != a.num_pti)
        {return (num_pti >= a.num_pti);}
      else // temps == a.temps et num_pti == a.num_pti
        {if (absolu != a.absolu)
          {return (absolu >= a.absolu);}
         else
          {return (*(this->PointeurClass_const()) >= *(a.PointeurClass_const()));}
        }
    };

// affichage
void VariablesExporter::A_un_E::Affiche()
 { A_un_NE::Affiche();
   cout << " absolu= " << absolu
        << " num_pti= " << num_pti << " ";
 };

// ======== Ddl_a_un_element ============

// classe conteneur pour un ddl à un élément
ostream & operator << ( ostream & sort,const  VariablesExporter::Ddl_a_un_element & a)
{ // récup du pointeur de la classe mère
  const VariablesExporter::A_un_E* aA = a.PointeurClass_E_const();
  // sortie
  sort << "\n   Ddl_a_un_element_ ";
  sort << *aA; // la classe mère
  sort << " temps_ " << a.temps
       << " ddl_ "<< a.enu  << " ";
  // retour
  return sort;
};

istream & operator >> ( istream & ent, VariablesExporter::Ddl_a_un_element & a)
{ // récup du pointeur de la classe mère
  VariablesExporter::A_un_E* aA = a.PointeurClass_E();
  // lecture du type et vérification
  string nomtype,toto; ent >> nomtype ;
  if (nomtype != "Ddl_a_un_element_")
    { cout << "\n *** erreur en lecture: on attendait le mot cle Ddl_a_un_element_ et on a lue "
           << nomtype
           << "\n operator >> ( istream & ent, VariablesExporter::Ddl_a_un_element(...";
      Sortie(1);
      return ent;
    };
  // lecture de la partie mère
  ent >> *aA;
  // on vérifie également qu'il s'agit bien d'une ref d'élément
  if (aA->Ref_NE()[0] != 'E')
   { cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
          << " erreur de syntaxe en lecture d'une reference d'element ,"
          << " la premiere lettre  "
          << " devraientt etre E et on a lu: "<<aA->Ref_NE() << " !!"
          << endl;
     Sortie(1);
   };
  // lecture du ddl étendu
  ent >> toto >> a.temps >> toto >> a.enu ;

  return ent;
};

VariablesExporter::Ddl_a_un_element::Ddl_a_un_element () : // constructeur par défaut
     A_un_E(),enu(),temps() {};
// constructeur fonction de toutes les grandeurs
VariablesExporter::Ddl_a_un_element::Ddl_a_un_element
     (int absolu_,Ddl_enum_etendu e,string ref_NE
     ,string nom_mail_,Enum_dure tps,string nom_var_,int nbpti) :
          A_un_E(absolu_,ref_NE,nom_mail,nom_var,nbpti)
          ,enu(e),temps(tps)
            {};
// constructeur de copie
VariablesExporter::Ddl_a_un_element::Ddl_a_un_element (const Ddl_a_un_element& a) :
          A_un_E(a)
          ,enu(a.enu),temps(a.temps)
            {};
// destructeur
VariablesExporter::Ddl_a_un_element::~Ddl_a_un_element()
   {};
         
// opérateurs
VariablesExporter::Ddl_a_un_element& VariablesExporter::Ddl_a_un_element::operator=
     (const VariablesExporter::Ddl_a_un_element& a)
    {enu = a.enu;temps=a.temps;
     *(this->PointeurClass()) = *(a.PointeurClass_E_const());
     return (*this);
    };
          
bool VariablesExporter::Ddl_a_un_element::operator== (const Ddl_a_un_element& a) const
   {if ((enu ==a.enu) && (temps == a.temps)
         && (*(this->PointeurClass_E_const()) == *(a.PointeurClass_E_const())))
       return true;
     else
       return false;
    };

bool VariablesExporter::Ddl_a_un_element::operator< (const Ddl_a_un_element& a) const
{if (enu != a.enu)
  { return (enu < a.enu);}
 else // cas enu = a.enu
  {if (temps != a.temps)
    {return (temps < a.temps);}
   else
    {return (*(this->PointeurClass_E_const()) < *(a.PointeurClass_E_const()));}
  };
};

bool VariablesExporter::Ddl_a_un_element::operator<= (const Ddl_a_un_element& a) const
{if (enu != a.enu)
  { return (enu <= a.enu);}
 else // cas enu = a.enu
  {if (temps != a.temps)
   {return (temps <= a.temps);}
   else
   {return (*(this->PointeurClass_E_const()) <=  *(a.PointeurClass_E_const()));}
  };
};

bool VariablesExporter::Ddl_a_un_element::operator> (const Ddl_a_un_element& a) const
{if (enu != a.enu)
  { return (enu > a.enu);}
 else // cas enu = a.enu
  {if (temps != a.temps)
   {return (temps > a.temps);}
   else
   {return (*(this->PointeurClass_E_const()) > *(a.PointeurClass_E_const()));}
  };
};


bool VariablesExporter::Ddl_a_un_element::operator>= (const Ddl_a_un_element& a) const
{if (enu != a.enu)
  { return (enu >= a.enu);}
 else // cas enu = a.enu
  {if (temps != a.temps)
   {return (temps >= a.temps);}
   else
   {return (*(this->PointeurClass_E_const()) >= *(a.PointeurClass_E_const()));}
  };
};

// affichage
void VariablesExporter::Ddl_a_un_element::Affiche()
 { A_un_E::Affiche();
   cout << " Ddl_a_un_element_  "  << Enu() << " temps_ " << temps ;
 };

// ======== TypeQuelconque_a_un_element ============
// classe conteneur pour les grandeurs particulières à un élément
ostream & operator << ( ostream & sort,const  VariablesExporter::TypeQuelconque_a_un_element & a)
{ // récup du pointeur de la classe mère
  const VariablesExporter::A_un_E* aA = a.PointeurClass_Quelc_const();
  // récup de l'énuméré du type quelconque
  const TypeQuelconque_enum_etendu& quelc = a.Quelc_const();
  // sortie
  sort << *aA; // la classe mère
  sort << " grandeur_quelconque_ " << quelc.NomPlein() << " composante: " << a.num_ordre << " ";
  // retour
  return sort;
};

istream & operator >> ( istream & ent, VariablesExporter::TypeQuelconque_a_un_element & a)
{ // récup du pointeur de la classe mère
  VariablesExporter::A_un_E* aA = a.PointeurClass_Quelc();
  // lecture de la partie mère
  ent >> *aA;
  // on vérifie également qu'il s'agit bien d'une ref d'élément
  if (aA->Ref_NE()[0] != 'E')
   { cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
          << " erreur de syntaxe en lecture d'une reference d'element ,"
          << " la premiere lettre  "
          << " devraientt etre E et on a lu: "<<aA->Ref_NE() << " !!"
          << endl;
     Sortie(1);
   };
  // lecture de la grandeur quelconque
  string toto,nom_quelc;
  ent >> toto >> nom_quelc;
  a.quelc = TypeQuelconque_enum_etendu(nom_quelc);
  
  ent >> toto >> a.num_ordre;

  return ent;
};

VariablesExporter::TypeQuelconque_a_un_element::TypeQuelconque_a_un_element () : // constructeur par défaut
     A_un_E(),quelc() {};
// constructeur fonction de toutes les grandeurs
VariablesExporter::TypeQuelconque_a_un_element::TypeQuelconque_a_un_element
     (int absolu_,TypeQuelconque_enum_etendu e,string ref_NE
     ,string nom_mail_,Enum_dure tps,string nom_var_,int nbpti,int num_ord) :
          A_un_E(absolu_,ref_NE,nom_mail,nom_var,nbpti)
          ,quelc(e),num_ordre(num_ord)
            {};
// constructeur de copie
VariablesExporter::TypeQuelconque_a_un_element::TypeQuelconque_a_un_element (const TypeQuelconque_a_un_element& a) :
          A_un_E(a)
          ,quelc(a.quelc),num_ordre(a.num_ordre)
            {};
// destructeur
VariablesExporter::TypeQuelconque_a_un_element::~TypeQuelconque_a_un_element()
   {};
         
// opérateurs
VariablesExporter::TypeQuelconque_a_un_element& VariablesExporter::TypeQuelconque_a_un_element::operator=
     (const VariablesExporter::TypeQuelconque_a_un_element& a)
    {quelc = a.quelc;num_ordre = a.num_ordre;
     *(this->PointeurClass()) = *(a.PointeurClass_E_const());
     return (*this);
    };
          
bool VariablesExporter::TypeQuelconque_a_un_element::operator== (const TypeQuelconque_a_un_element& a) const
    {if ((quelc ==a.quelc)&& (num_ordre == a.num_ordre)
         && (*(this->PointeurClass_E_const()) == *(a.PointeurClass_E_const())))
       return true;
     else
       return false;
    };

bool VariablesExporter::TypeQuelconque_a_un_element::operator< (const TypeQuelconque_a_un_element& a) const
{if (quelc != a.quelc)
  { return (quelc < a.quelc);}
 else // cas quelc = a.quelc
  {if (num_ordre != a.num_ordre)
    {return (num_ordre < a.num_ordre); }
   else
    {return (*(this->PointeurClass_E_const()) < *(a.PointeurClass_E_const()));}
  };
};

bool VariablesExporter::TypeQuelconque_a_un_element::operator<= (const TypeQuelconque_a_un_element& a) const
{if (quelc != a.quelc)
  { return (quelc <= a.quelc);}
 else // cas quelc = a.quelc
  {if (num_ordre != a.num_ordre)
    {return (num_ordre <= a.num_ordre); }
   else
    {return (*(this->PointeurClass_E_const()) <=  *(a.PointeurClass_E_const()));}
  };
};

bool VariablesExporter::TypeQuelconque_a_un_element::operator> (const TypeQuelconque_a_un_element& a) const
{if (quelc != a.quelc)
  { return (quelc > a.quelc);}
 else // cas quelc = a.quelc
  {if (num_ordre != a.num_ordre)
    {return (num_ordre > a.num_ordre); }
   else
    {return (*(this->PointeurClass_E_const()) > *(a.PointeurClass_E_const()));}
  };
};


bool VariablesExporter::TypeQuelconque_a_un_element::operator>= (const TypeQuelconque_a_un_element& a) const
{if (quelc != a.quelc)
  { return (quelc >= a.quelc);}
 else // cas enu = a.enu
  {if (num_ordre != a.num_ordre)
    {return (num_ordre >= a.num_ordre); }
   else
    {return (*(this->PointeurClass_E_const()) >= *(a.PointeurClass_E_const()));}
  };
};

// ======== TypeParticulier_a_un_element ============

// classe conteneur pour les grandeurs particulières à un élément
ostream & operator << ( ostream & sort,const  VariablesExporter::TypeParticulier_a_un_element & a)
{ // récup du pointeur de la classe mère
  const VariablesExporter::TypeQuelconque_a_un_element* aA = a.PointeurClass_Quelc_const();
  // récup de l'énuméré du type quelconque
  const TypeQuelconque_enum_etendu& quelc = a.Quelc_const();
  // sortie
  sort << "\n   Particulier_a_un_element_ ";
  sort << *aA; // la classe mère
  // retour
  return sort;
};

istream & operator >> ( istream & ent, VariablesExporter::TypeParticulier_a_un_element & a)
{ // récup du pointeur de la classe mère
  VariablesExporter::TypeQuelconque_a_un_element* aA = a.PointeurClass_Quelc();
  // lecture du type et vérification
  string nomtype,toto; ent >> nomtype ;
  if (nomtype != "Particulier_a_un_element_")
    { cout << "\n *** erreur en lecture: on attendait le mot cle Particulier_a_un_element_ et on a lue "
           << nomtype
           << "\n operator >> ( istream & ent, VariablesExporter::Particulier_a_un_element_(...";
      Sortie(1);
      return ent;
    };
 // lecture de la partie mère
 ent >> *aA;
 // on vérifie également qu'il s'agit bien d'une ref d'élément
 if (aA->Ref_NE()[0] != 'E')
  { cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
         << " erreur de syntaxe en lecture d'une reference d'element ,"
         << " la premiere lettre  "
         << " devraientt etre E et on a lu: "<<aA->Ref_NE() << " !!"
         << endl;
    Sortie(1);
  };

  return ent;
};

// affichage
void VariablesExporter::TypeParticulier_a_un_element::Affiche()
 { A_un_E::Affiche();
   cout << " grandeur_particuliere_a_un_element_  "  << quelc.NomPlein()
        << " composante: " << num_ordre ;
 };
// ======== TypeEvoluee_a_un_element ============

// classe conteneur pour les grandeurs évoluées à un élément
ostream & operator << ( ostream & sort,const  VariablesExporter::TypeEvoluee_a_un_element & a)
{ // récup du pointeur de la classe mère
  const VariablesExporter::TypeQuelconque_a_un_element* aA = a.PointeurClass_Quelc_const();
  // récup de l'énuméré du type quelconque
  const TypeQuelconque_enum_etendu& quelc = a.Quelc_const();
  // sortie
  sort << "\n   Evoluee_a_un_element_ ";
  sort << *aA; // la classe mère
  // retour
  return sort;
};

istream & operator >> ( istream & ent, VariablesExporter::TypeEvoluee_a_un_element & a)
{ // récup du pointeur de la classe mère
  VariablesExporter::TypeQuelconque_a_un_element* aA = a.PointeurClass_Quelc();
  // lecture du type et vérification
  string nomtype,toto; ent >> nomtype ;
  if (nomtype != "Evoluee_a_un_element_")
    { cout << "\n *** erreur en lecture: on attendait le mot cle Evoluee_a_un_element_ et on a lue "
           << nomtype
           << "\n operator >> ( istream & ent, VariablesExporter::TypeEvoluee_a_un_element(...";
      Sortie(1);
      return ent;
    };
  // lecture de la partie mère
  ent >> *aA;
 // on vérifie également qu'il s'agit bien d'une ref d'élément
 if (aA->Ref_NE()[0] != 'E')
  { cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
         << " erreur de syntaxe en lecture d'une reference d'element ,"
         << " la premiere lettre  "
         << " devraientt etre E et on a lu: "<<aA->Ref_NE() << " !!"
         << endl;
    Sortie(1);
  };

  return ent;
};

// affichage
void VariablesExporter::TypeEvoluee_a_un_element::Affiche()
 { A_un_E::Affiche();
   cout << " grandeur_Evoluee_a_un_element_  "  << quelc.NomPlein()
        << " composante: " << num_ordre ;
 };

// ======== TypeQuelconque_a_Face_arete ============

// classe conteneur pour un TypeQuelconque à une face ou arête
ostream & operator << ( ostream & sort,const  VariablesExporter::TypeQuelconque_a_Face_arete & a)
{ // récup du pointeur de la classe mère
  const VariablesExporter::TypeQuelconque_a_un_element* aA = a.PointeurClass_Quelc_const();
  // sortie
  sort << *aA; // la classe mère
  // num FA
  sort << " num_FA_ "<< a.Num_FA_const() << " ";
  // retour
  return sort;
};

istream & operator >> ( istream & ent, VariablesExporter::TypeQuelconque_a_Face_arete & a)
{ // récup du pointeur de la classe mère
  VariablesExporter::TypeQuelconque_a_un_element* aA = a.PointeurClass_Quelc();
  // lecture de la partie mère
  ent >> *aA;
  // num FA
  string toto;
  ent >> toto >> a.Num_FA() ;

  return ent;
};


VariablesExporter::TypeQuelconque_a_Face_arete::TypeQuelconque_a_Face_arete () : // constructeur par défaut
     TypeQuelconque_a_un_element(),num_FA() {};
// constructeur fonction de toutes les grandeurs
VariablesExporter::TypeQuelconque_a_Face_arete::TypeQuelconque_a_Face_arete
     (int absolu_,TypeQuelconque_enum_etendu e,string ref_element
     ,string nom_mail_,int nbFA, Enum_dure tps,string nom_var_,int nbpti,int num_ord) :
          TypeQuelconque_a_un_element(absolu_,e,ref_element,nom_mail,tps,nom_var,nbpti,num_ord)
          ,num_FA(nbFA)
            {};
// constructeur de copie
VariablesExporter::TypeQuelconque_a_Face_arete::TypeQuelconque_a_Face_arete (const TypeQuelconque_a_Face_arete& a) :
          TypeQuelconque_a_un_element(a)
          ,num_FA(a.num_FA)
            {};
// destructeur
VariablesExporter::TypeQuelconque_a_Face_arete::~TypeQuelconque_a_Face_arete()
   {};
         
// opérateurs
VariablesExporter::TypeQuelconque_a_Face_arete& VariablesExporter::TypeQuelconque_a_Face_arete::operator=
     (const VariablesExporter::TypeQuelconque_a_Face_arete& a)
    {num_FA = a.num_FA;
     *(this->PointClass_QuelcFA()) = *(a.PointClass_QuelcFA_const());
     return (*this);
    };
          
bool VariablesExporter::TypeQuelconque_a_Face_arete::operator== (const TypeQuelconque_a_Face_arete& a) const
    {if ((num_FA ==a.num_FA)
         && (*(this->PointClass_QuelcFA_const()) == *(a.PointClass_QuelcFA_const())))
       return true;
     else
       return false;
    };

bool VariablesExporter::TypeQuelconque_a_Face_arete::operator< (const TypeQuelconque_a_Face_arete& a) const
{if (num_FA != a.num_FA)
  { return (num_FA < a.num_FA);}
 else // cas num_FA = a.num_FA
  {return (*(this->PointClass_QuelcFA_const()) < *(a.PointClass_QuelcFA_const()));}
};

bool VariablesExporter::TypeQuelconque_a_Face_arete::operator<= (const TypeQuelconque_a_Face_arete& a) const
{if (num_FA != a.num_FA)
  { return (num_FA <= a.num_FA);}
 else // cas num_FA = a.num_FA
  {return (*(this->PointClass_QuelcFA_const()) <=  *(a.PointClass_QuelcFA_const()));}
};

bool VariablesExporter::TypeQuelconque_a_Face_arete::operator> (const TypeQuelconque_a_Face_arete& a) const
{if (num_FA != a.num_FA)
  { return (num_FA > a.num_FA);}
 else // cas num_FA = a.num_FA
  {return (*(this->PointClass_QuelcFA_const()) > *(a.PointClass_QuelcFA_const()));}
};


bool VariablesExporter::TypeQuelconque_a_Face_arete::operator>= (const TypeQuelconque_a_Face_arete& a) const
{if (num_FA != a.num_FA)
  { return (num_FA >= a.num_FA);}
 else // cas num_FA = a.num_FA
  {return (*(this->PointClass_QuelcFA_const()) >= *(a.PointClass_QuelcFA_const()));}
};

// ======== TypeQuelc_face_a_un_element ============

// classe conteneur pour les grandeurs quelconque à une face d'élément
ostream & operator << ( ostream & sort,const  VariablesExporter::TypeQuelc_face_a_un_element & a)
{ // récup du pointeur de la classe mère
  const VariablesExporter::TypeQuelconque_a_Face_arete* aA = a.PointClass_QuelcFA_const();
  // sortie
  sort << "\n   Quelconque_face_element_ ";
  sort << *aA; // la classe mère
  // retour
  return sort;
};

istream & operator >> ( istream & ent, VariablesExporter::TypeQuelc_face_a_un_element & a)
{ // récup du pointeur de la classe mère
  VariablesExporter::TypeQuelconque_a_Face_arete* aA = a.PointClass_QuelcFA();
  // lecture du type et vérification
  string nomtype,toto; ent >> nomtype ;
  if (nomtype != "Quelconque_face_element_")
    { cout << "\n *** erreur en lecture: on attendait le mot cle Quelconque_face_element_ et on a lue "
           << nomtype
           << "\n operator >> ( istream & ent, VariablesExporter::TypeQuelc_face_a_un_element(...";
      Sortie(1);
      return ent;
    };
  // lecture de la partie mère
  ent >> *aA;
 // on vérifie également qu'il s'agit bien d'une ref d'élément
 if (aA->Ref_NE()[0] != 'E')
  { cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
         << " erreur de syntaxe en lecture d'une reference d'element ,"
         << " la premiere lettre  "
         << " devraientt etre E et on a lu: "<<aA->Ref_NE() << " !!"
         << endl;
    Sortie(1);
  };

  return ent;
};

// affichage
void VariablesExporter::TypeQuelc_face_a_un_element::Affiche()
 { cout << (*this) ;
 };
 
// ======== TypeQuelc_arete_a_un_element ============

// classe conteneur pour les grandeurs quelconque à une arete d'élément
ostream & operator << ( ostream & sort,const  VariablesExporter::TypeQuelc_arete_a_un_element & a)
{ // récup du pointeur de la classe mère
  const VariablesExporter::TypeQuelconque_a_Face_arete* aA = a.PointClass_QuelcFA_const();
  // sortie
  sort << "\n   Quelconque_arete_element_ ";
  sort << *aA; // la classe mère
  // retour
  return sort;
};

istream & operator >> ( istream & ent, VariablesExporter::TypeQuelc_arete_a_un_element & a)
{ // récup du pointeur de la classe mère
  VariablesExporter::TypeQuelconque_a_Face_arete* aA = a.PointClass_QuelcFA();
  // lecture du type et vérification
  string nomtype,toto; ent >> nomtype ;
  if (nomtype != "Quelconque_arete_element_")
    { cout << "\n *** erreur en lecture: on attendait le mot cle Quelconque_arete_element_ et on a lue "
           << nomtype
           << "\n operator >> ( istream & ent, VariablesExporter::TypeQuelc_arete_a_un_element(...";
      Sortie(1);
      return ent;
    };
  // lecture de la partie mère
  ent >> *aA;
  // on vérifie également qu'il s'agit bien d'une ref d'élément
  if (aA->Ref_NE()[0] != 'E')
   { cout << "\n *** lecture de la variable utilisateur: " << a.nom_var
          << " erreur de syntaxe en lecture d'une reference d'element ,"
          << " la premiere lettre  "
          << " devraientt etre E et on a lu: "<<aA->Ref_NE() << " !!"
          << endl;
     Sortie(1);
   };

  return ent;
};

// affichage
void VariablesExporter::TypeQuelc_arete_a_un_element::Affiche()
 { cout << (*this) ;
 };
 
// ======== TypeQuelc_Une_composante_Grandeur_globale ============

// classe conteneur pour une composante de grandeur globale
ostream & operator << ( ostream & sort,const  VariablesExporter::TypeQuelc_Une_composante_Grandeur_globale & a)
{ // sortie
  sort << "\n   Une_composante_Grandeur_globale_ ";
  sort << a.var.nom1 << " " << a.var.nom2 << " composante: " << a.var.n << " ";
  // retour
  return sort;
};

istream & operator >> ( istream & ent, VariablesExporter::TypeQuelc_Une_composante_Grandeur_globale & a)
{ // lecture du type et vérification
  string nomtype,toto; ent >> nomtype ;
  if (nomtype != "Une_composante_Grandeur_globale_")
    { cout << "\n *** erreur en lecture: on attendait le mot cle Une_composante_Grandeur_globale_ et on a lue "
           << nomtype
           << "\n operator >> ( istream & ent, VariablesExporter::TypeQuelc_Une_composante_Grandeur_globale(...";
      Sortie(1);
      return ent;
    };
  // lecture des infos
  ent >> a.var.nom1 >> a.var.nom2 >> toto >> a.var.n;
  // vérif il faut que les 3 premiers caractères de a.nom_var soit un VR_
  if (!((a.var.nom1[0]== 'V')&&(a.var.nom1[1]== 'R')&&(a.var.nom1[2]== '_')))
   { cout << "\n *** erreur de syntaxe en lecture d'une variable utilisateur,"
          << " les 3 premieres lettres "
          << " devraientt etre un 'VR_' et on a lu: "<<a.var.nom1 << " !!"
          << endl;
     Sortie(1);
   };
  
  if (toto != "composante:")
    { cout << "\n *** erreur en lecture: on attendait le mot cle composante: et on a lue "
           << toto
           << "\n operator >> ( istream & ent, VariablesExporter::TypeQuelc_Une_composante_Grandeur_globale(...";
      Sortie(1);
      return ent;
    };

  return ent;
};

// affichage
void VariablesExporter::TypeQuelc_Une_composante_Grandeur_globale::Affiche()
 { cout << (*this) ;
 };

//--------------------------- VariablesExporter --------------

// CONSTRUCTEURS :
		
// Constructeur par defaut
VariablesExporter::VariablesExporter ():
  li_Q(),li_nom()
  // ----- les variables
  // -> noeuds
  ,list_noeud_type_ddl()
  ,list_noeud_type_ddlEtendu()
  ,list_noeud_type_quelconque()

  // -> éléments
  ,list_element_type_ddl()
  ,list_element_type_particulier(),list_quelc_element_type_particulier()
  ,list_element_type_evoluee()
  ,list_quelc_element_type_evoluee()

  // -> face d'éléments
  ,list_face_element_type_quelc()
  ,list_quelc_face_element_type_quelc()

  // -> arête d'éléments
  ,list_arete_element_type_quelc()
  ,list_quelc_arete_element_type_quelc()
  
  // -> une composante d'une variable globale de type multidimentionnel
  ,list_var_glob_sur_grandeur_globale()
  
  ,initiaConteneurQuelconque(false)

  {
  };


// Constructeur de copie,
VariablesExporter::VariablesExporter (const VariablesExporter& a):
  li_Q(a.li_Q),li_nom(a.li_nom)
  // ----- les variables
  // -> noeuds
  ,list_noeud_type_ddl(a.list_noeud_type_ddl)
  ,list_noeud_type_ddlEtendu(a.list_noeud_type_ddlEtendu)
  ,list_noeud_type_quelconque(a.list_noeud_type_quelconque)

  // -> éléments
  ,list_element_type_ddl(a.list_element_type_ddl)
  ,list_element_type_particulier(a.list_element_type_particulier)
  ,list_quelc_element_type_particulier(a.list_quelc_element_type_particulier)
  ,list_element_type_evoluee(a.list_element_type_evoluee)
  ,list_quelc_element_type_evoluee(a.list_quelc_element_type_evoluee)

  // -> face d'éléments
  ,list_face_element_type_quelc(a.list_face_element_type_quelc)
  ,list_quelc_face_element_type_quelc(a.list_quelc_face_element_type_quelc)

  // -> arête d'éléments
  ,list_arete_element_type_quelc(a.list_arete_element_type_quelc)
  ,list_quelc_arete_element_type_quelc(a.list_quelc_arete_element_type_quelc)

  // -> une composante d'une variable globale de type multidimentionnel
  ,list_var_glob_sur_grandeur_globale(a.list_var_glob_sur_grandeur_globale)

  ,initiaConteneurQuelconque(a.initiaConteneurQuelconque)
  {
  };
		


VariablesExporter::~VariablesExporter()
// Destructeur
{
 };

// lecture
void VariablesExporter::LectureVariablesExporter(UtilLecture * entreePrinc)
{  if (ParaGlob::NiveauImpression() >= 5) cout << " debut de lecture des constantes et variables a exporter globalement "  << endl;
   // 1) cas des constantes
   LecConstantesUtilisateur(*entreePrinc);
   LecVariablesUtilisateur(*entreePrinc);

};
     

    
// affichage et definition interactive des commandes 
// cas = 1: interactif complet
// cas = 2: entrée uniquement de noms de fichier
void VariablesExporter::Info_commande_VariablesExporters(UtilLecture * entreePrinc)
 {  Info_commande_ConstantesUtilisateur(entreePrinc);
    Info_commande_VariablesUtilisateur(entreePrinc);
 };
		
// insertion des constantes et variables utilisateurs vers globales
void VariablesExporter::InsertConstVarUtilisateur_dans_globale()
 {InsertConstUtilisateur_dans_globale();
  Insert_VarUtilisateur_dans_globale();
 };



// initialisation des conteneurs quelconques
// création des conteneurs aux noeuds s'il s'agit d'une variable
// associée à un vecteur global (au sens des algorithmes globaux)
void VariablesExporter::InitialisationConteneursQuelconques(LesMaillages& lesMail
              ,const List_io < TypeQuelconque >& listeVecGlob,const LesReferences& lesRef)
 { if (!initiaConteneurQuelconque)
    { // on commence par récupérer les conteneurs disponibles
      // on se met en absolu par défaut -> le conteneur le + grand
      // ---> pourrait poser pb, si ensuite le conteneur diminue !! à surveiller !
      bool absolu = true;
      Tableau <List_io < TypeQuelconque > > tabelement_typeParti
           (lesMail.Les_type_de_donnees_particulieres_par_element(absolu));
      // idem mais sous forme de grandeurs évoluées
      Tableau <List_io < TypeQuelconque > > tabelement_evoluee
           (lesMail.Les_type_de_donnees_evolues_internes_par_element(absolu));
    
      // pour les faces et arêtes
      Tableau <List_io < TypeQuelconque > >tab_F_element_TypeQuelconque
           (lesMail.Les_type_de_donnees_evolues_internes_par_face_element(absolu));
      Tableau <List_io < TypeQuelconque > > tab_A_element_TypeQuelconque
           (lesMail.Les_type_de_donnees_evolues_internes_par_arete_element(absolu));

      // on passe en revue les grandeurs pour définir les conteneurs associés
      // --- cas des grandeurs particulières aux pti d'élément
      {list_quelc_element_type_particulier.clear(); // init
       List_io < TypeParticulier_a_un_element >::iterator
                         il,ilfin=list_element_type_particulier.end();
       for (il = list_element_type_particulier.begin(); il != ilfin;il++)
        {// on vérifie qu'elle appartient à la liste des grandeurs disponibles
         int n_mail = 1; // init par défaut
         if ((*il).Nom_mail() != "")
           n_mail = lesMail.NumMaillage((*il).Nom_mail());
         TypeQuelconque a((*il).Quelc_const()); // création d'un type quelconque sans grandeur
         List_io<TypeQuelconque>& tpg = (tabelement_typeParti(n_mail)); // pour simplifier
         if (find(tpg.begin(),tpg.end(),a) != tpg.end())
          { // il existe -> enregistrement
            List_io<TypeQuelconque>::iterator it = find(tpg.begin(),tpg.end(),a); // récup du réel type
            list_quelc_element_type_particulier.push_back(*it);
           }
         else
          { cout << "\n *** erreur dans l'initialisation de la variable utilisateur "
                 << (*il).Nom_var() << " la grandeur associee " << (*il).Quelc_const().NomPlein()
                 << " n'existe pas !! "
                 << "\n VariablesExporter::InitialisationConteneursQuelconques(..." << flush;
            (*il).Affiche();
            Sortie(1);
          };
        };
      };
      
      // --- cas des grandeurs évoluées aux pti d'élément
      {list_quelc_element_type_evoluee.clear(); // init
       List_io < TypeEvoluee_a_un_element >::iterator
                         il,ilfin=list_element_type_evoluee.end();
       for (il = list_element_type_evoluee.begin(); il != ilfin;il++)
        {// on vérifie qu'elle appartient à la liste des grandeurs disponibles
         int n_mail = 1; // init par défaut
         if ((*il).Nom_mail() != "")
           n_mail = lesMail.NumMaillage((*il).Nom_mail());
         TypeQuelconque a((*il).Quelc_const()); // création d'un type quelconque sans grandeur
         List_io<TypeQuelconque>& tpg = (tabelement_typeParti(n_mail)); // pour simplifier
         if (find(tpg.begin(),tpg.end(),a) != tpg.end())
          { // il existe -> enregistrement
            List_io<TypeQuelconque>::iterator it = find(tpg.begin(),tpg.end(),a); // récup du réel type
            list_quelc_element_type_evoluee.push_back(*it);
           }
         else
          { cout << "\n *** erreur dans l'initialisation de la variable utilisateur "
                 << (*il).Nom_var() << " la grandeur associee " << (*il).Quelc_const().NomPlein()
                 << " n'existe pas !! "
                 << "\n VariablesExporter::InitialisationConteneursQuelconques(..." << flush;
            (*il).Affiche();
            Sortie(1);
          };
        };
      };
       
     // --- cas des grandeurs quelconques aux pti de faces d'élément
     {list_quelc_face_element_type_quelc.clear(); // init
      List_io < TypeQuelc_face_a_un_element >::iterator
                        il,ilfin=list_face_element_type_quelc.end();
      for (il = list_face_element_type_quelc.begin(); il != ilfin;il++)
       {// on vérifie qu'elle appartient à la liste des grandeurs disponibles
        int n_mail = 1; // init par défaut
        if ((*il).Nom_mail() != "")
          n_mail = lesMail.NumMaillage((*il).Nom_mail());
        TypeQuelconque a((*il).Quelc_const()); // création d'un type quelconque sans grandeur
        List_io<TypeQuelconque>& tpg = (tab_F_element_TypeQuelconque(n_mail)); // pour simplifier
        if (find(tpg.begin(),tpg.end(),a) != tpg.end())
         { // il existe -> enregistrement
           List_io<TypeQuelconque>::iterator it = find(tpg.begin(),tpg.end(),a); // récup du réel type
           list_quelc_face_element_type_quelc.push_back(*it);
          }
        else
         { cout << "\n *** erreur dans l'initialisation de la variable utilisateur "
                << (*il).Nom_var() << " la grandeur associee " << (*il).Quelc_const().NomPlein()
                << " n'existe pas !! "
                << "\n VariablesExporter::InitialisationConteneursQuelconques(..." << flush;
           (*il).Affiche();
           Sortie(1);
         };
       };
     };
       
     // --- cas des grandeurs quelconques aux pti d'arêtes d'élément
     {list_quelc_arete_element_type_quelc.clear(); // init
      List_io < TypeQuelc_arete_a_un_element >::iterator
                        il,ilfin=list_arete_element_type_quelc.end();
      for (il = list_arete_element_type_quelc.begin(); il != ilfin;il++)
       {// on vérifie qu'elle appartient à la liste des grandeurs disponibles
        int n_mail = 1; // init par défaut
        if ((*il).Nom_mail() != "")
          n_mail = lesMail.NumMaillage((*il).Nom_mail());
        TypeQuelconque a((*il).Quelc_const()); // création d'un type quelconque sans grandeur
        List_io<TypeQuelconque>& tpg = (tab_A_element_TypeQuelconque(n_mail)); // pour simplifier
        if (find(tpg.begin(),tpg.end(),a) != tpg.end())
         { // il existe -> enregistrement
           List_io<TypeQuelconque>::iterator it = find(tpg.begin(),tpg.end(),a); // récup du réel type
           list_quelc_arete_element_type_quelc.push_back(*it);
          }
        else
         { cout << "\n *** erreur dans l'initialisation de la variable utilisateur "
                << (*il).Nom_var() << " la grandeur associee " << (*il).Quelc_const().NomPlein()
                << " n'existe pas !! "
                << "\n VariablesExporter::InitialisationConteneursQuelconques(..." << flush;
           (*il).Affiche();
           Sortie(1);
         };
       };
     };
     
     // --- traitement particulier pour les noeuds
     {// dans le cas où il y a des vecteurs globaux qui ont été retenus,
      // il faut définir  aux noeuds des conteneurs adéquates
      if ((listeVecGlob.size() != 0) && (list_noeud_type_quelconque.size() != 0))
        { // on boucle sur les var de noeud: a priori c'est le nombre le plus petit
          List_io <Quelconque_a_un_noeud>::iterator il,ilfin=list_noeud_type_quelconque.end();
          for(il= list_noeud_type_quelconque.begin();il != ilfin; il++)
           {// on boucle sur les vecteurs globaux pour savoir s'il y en a un qui correspond
            List_io < TypeQuelconque >::const_iterator it,itfin = listeVecGlob.end();
            for (it=listeVecGlob.begin();it != itfin;it++)
             {//cout << "\n (*it) "<<(*it).EnuTypeQuelconque().NomPlein()
              //     << " *il "<< (*il).Quelc().NomPlein() << flush;
             
              if ((*it).EnuTypeQuelconque() == (*il).Quelc())
                { // récup de la reférence
                  const string * point_mail = NULL;
                  if ((*il).Nom_mail_const() != "")
                    point_mail = &((*il).Nom_mail_const());
                  const ReferenceNE & ref =
                  ((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
                  int ne = ref.Numero(1); // le num du noeud: uniquement le premier
                  int nmail = 1;
                  if ((*il).Nom_mail() != "")
                    nmail = lesMail.NumMaillage((*il).Nom_mail());
                  Noeud * noo = & lesMail.Noeud_LesMaille(nmail,ne);
                  noo->AjoutUnTypeQuelconque(*it);
                };
             };
           };
        };
     };

    initiaConteneurQuelconque=true; // pour une initialisation unique
    }
 
 };

// insertion et stockage des variables au niveau de ParaGlob
void VariablesExporter::Insert_VarUtilisateur_dans_globale()

{
  // --- cas des ddl aux noeuds: list_noeud_type_ddl
  {List_io < Ddl_a_un_noeud >::iterator il,ilfin=list_noeud_type_ddl.end();
   for (il=list_noeud_type_ddl.begin();il != ilfin;il++)
    { Ddl_a_un_noeud& dan = *il; // pour simplifier
      // on regarde si la grandeur existe déjà
      const void* pointe =  (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
      if (pointe != NULL)
       {cout << "\n *** pb dans dans la def de la variable utilisateur globale  "<< dan.Nom_var()
                 << " elle existe deja  !! , ce n'est pas normal "
                 << "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
                 << endl;
          Sortie(1);
       }
      else // sinon c'est ok, on la défini
       {// on crée un conteneur d'un double
        double val=0;
        Grandeur_scalaire_double grand_courant(val);
        switch (dan.Temps())
         {case TEMPS_0 :
            {TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0,NU_DDL,grand_courant);
             ParaGlob::param->Ajout_grandeur_consultable(&typQ1,dan.Nom_var());
             break;
            }
          case TEMPS_t :
           {TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_T,NU_DDL,grand_courant);
            ParaGlob::param->Ajout_grandeur_consultable(&typQ1,dan.Nom_var());
            break;
           }
          case TEMPS_tdt :
              {TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT,NU_DDL,grand_courant);
               ParaGlob::param->Ajout_grandeur_consultable(&typQ1,dan.Nom_var());
               break;
              }
          default :
           cout << "\nErreur : valeur incorrecte du temps pour une variable ddl globale !\n";
           cout << "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(... \n";
           Sortie(1);
         };
       };
    };
  };
  
  // --- cas des ddl étendus aux noeuds: list_noeud_type_ddlEtendu
  {List_io < Ddl_etendu_a_un_noeud >::iterator il,ilfin=list_noeud_type_ddlEtendu.end();
   for (il=list_noeud_type_ddlEtendu.begin();il != ilfin;il++)
    { Ddl_etendu_a_un_noeud& dan = *il; // pour simplifier
      // on regarde si la grandeur existe déjà
      const void* pointe =  (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
      if (pointe != NULL)
       {cout << "\n *** pb dans dans la def de la variable utilisateur globale  "<< dan.Nom_var()
                 << " elle existe deja  !! , ce n'est pas normal "
                 << "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
                 << endl;
          Sortie(1);
       }
      else // sinon c'est ok, on la défini
       {// on crée un conteneur d'un double
        double val=0;
        Grandeur_scalaire_double grand_courant(val);
        TypeQuelconque typQ1(UN_DDL_ENUM_ETENDUE,NU_DDL,grand_courant);
        ParaGlob::param->Ajout_grandeur_consultable(&typQ1,dan.Nom_var());
       };
    };
  };
  
  // --- cas des grandeurs quelconques aux noeuds: list_noeud_type_quelconque
  {List_io < Quelconque_a_un_noeud >::iterator il,ilfin=list_noeud_type_quelconque.end();
   for (il=list_noeud_type_quelconque.begin();il != ilfin;il++)
    { Quelconque_a_un_noeud& dan = *il; // pour simplifier
      // on regarde si la grandeur existe déjà
      const void* pointe =  (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
      if (pointe != NULL)
       {cout << "\n *** pb dans dans la def de la variable utilisateur globale  "<< dan.Nom_var()
                 << " elle existe deja  !! , ce n'est pas normal "
                 << "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
                 << endl;
          Sortie(1);
       }
      else // sinon c'est ok, on la défini
       {// on insert un conteneur double associé
        VariablesExporter::InsertCompGrandeurQuelc(dan.Nom_var(),dan.Quelc_const());
       };
    };
  };

 // --- cas des ddl pur à un pti d'élément : list_element_type_ddl
 {List_io < Ddl_a_un_element >::iterator il,ilfin=list_element_type_ddl.end();
  for (il=list_element_type_ddl.begin();il != ilfin;il++)
   { Ddl_a_un_element& dan = *il; // pour simplifier
     // on regarde si la grandeur existe déjà
     const void* pointe =  (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
     if (pointe != NULL)
      {cout << "\n *** pb dans dans la def de la variable utilisateur globale  "<< dan.Nom_var()
                << " elle existe deja  !! , ce n'est pas normal "
                << "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
                << endl;
         Sortie(1);
      }
     else // sinon c'est ok, on la défini
      {// on crée un conteneur d'un double
       double val=0;
       Grandeur_scalaire_double grand_courant(val);
       switch (dan.Temps())
        {case TEMPS_0 :
           {TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0,NU_DDL,grand_courant);
            ParaGlob::param->Ajout_grandeur_consultable(&typQ1,dan.Nom_var());
            break;
           }
         case TEMPS_t :
          {TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_T,NU_DDL,grand_courant);
           ParaGlob::param->Ajout_grandeur_consultable(&typQ1,dan.Nom_var());
           break;
          }
         case TEMPS_tdt :
             {TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT,NU_DDL,grand_courant);
              ParaGlob::param->Ajout_grandeur_consultable(&typQ1,dan.Nom_var());
              break;
             }
         default :
          cout << "\nErreur : valeur incorrecte du temps pour une variable ddl globale !\n";
          cout << "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(... \n";
          Sortie(1);
        };
      };
   };
 };
 
 // --- cas des grandeurs particulières aux éléments: list_element_type_particulier
 {List_io < TypeParticulier_a_un_element >::iterator il,ilfin=list_element_type_particulier.end();
  for (il=list_element_type_particulier.begin();il != ilfin;il++)
   { TypeParticulier_a_un_element& dan = *il; // pour simplifier
     // on regarde si la grandeur existe déjà
     const void* pointe =  (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
     if (pointe != NULL)
      {cout << "\n *** pb dans dans la def de la variable utilisateur globale  "<< dan.Nom_var()
                << " elle existe deja  !! , ce n'est pas normal "
                << "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
                << endl;
         Sortie(1);
      }
     else // sinon c'est ok, on la défini
      {// on insert un conteneur double associé
       VariablesExporter::InsertCompGrandeurQuelc(dan.Nom_var(),dan.Quelc_const());
      };
   };
 };

 // --- cas des grandeurs évoluées aux éléments: list_element_type_evoluee
 {List_io < TypeEvoluee_a_un_element >::iterator il,ilfin=list_element_type_evoluee.end();
  for (il=list_element_type_evoluee.begin();il != ilfin;il++)
   { TypeEvoluee_a_un_element& dan = *il; // pour simplifier
     // on regarde si la grandeur existe déjà
     const void* pointe =  (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
     if (pointe != NULL)
      {cout << "\n *** pb dans dans la def de la variable utilisateur globale  "<< dan.Nom_var()
                << " elle existe deja  !! , ce n'est pas normal "
                << "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
                << endl;
         Sortie(1);
      }
     else // sinon c'est ok, on la défini
      {// on insert un conteneur double associé
       VariablesExporter::InsertCompGrandeurQuelc(dan.Nom_var(),dan.Quelc_const());
      };
   };
 };
 
 // --- cas des grandeurs quelconques aux pti de faces d'éléments: list_face_element_type_quelc
 {List_io < TypeQuelc_face_a_un_element >::iterator il,ilfin=list_face_element_type_quelc.end();
  for (il=list_face_element_type_quelc.begin();il != ilfin;il++)
   { TypeQuelc_face_a_un_element& dan = *il; // pour simplifier
     // on regarde si la grandeur existe déjà
     const void* pointe =  (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
     if (pointe != NULL)
      {cout << "\n *** pb dans dans la def de la variable utilisateur globale  "<< dan.Nom_var()
                << " elle existe deja  !! , ce n'est pas normal "
                << "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
                << endl;
         Sortie(1);
      }
     else // sinon c'est ok, on la défini
      {// on insert un conteneur double associé
       VariablesExporter::InsertCompGrandeurQuelc(dan.Nom_var(),dan.Quelc_const());
      };
   };
 };
 
 // --- cas des grandeurs quelconques aux pti d'arête d'éléments: list_arete_element_type_quelc
 {List_io < TypeQuelc_arete_a_un_element >::iterator il,ilfin=list_arete_element_type_quelc.end();
  for (il=list_arete_element_type_quelc.begin();il != ilfin;il++)
   { TypeQuelc_arete_a_un_element& dan = *il; // pour simplifier
     // on regarde si la grandeur existe déjà
     const void* pointe =  (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
     if (pointe != NULL)
      {cout << "\n *** pb dans dans la def de la variable utilisateur globale  "<< dan.Nom_var()
                << " elle existe deja  !! , ce n'est pas normal "
                << "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
                << endl;
         Sortie(1);
      }
     else // sinon c'est ok, on la défini
      {// on insert un conteneur double associé
       VariablesExporter::InsertCompGrandeurQuelc(dan.Nom_var(),dan.Quelc_const());
      };
   };
 };
 
 // --- cas d'une  composante d'une variable globale de type multidimentionnel
 {List_io <TypeQuelc_Une_composante_Grandeur_globale >::iterator
      il,ilfin=list_var_glob_sur_grandeur_globale.end();
  for (il=list_var_glob_sur_grandeur_globale.begin();il != ilfin;il++)
   { TypeQuelc_Une_composante_Grandeur_globale& dan = *il; // pour simplifier
     // on regarde si la grandeur existe déjà
     const void* pointe =  (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
     if (pointe != NULL)
      {cout << "\n *** pb dans dans la def de la variable utilisateur globale  "<< dan.Nom_var()
                << " elle existe deja  !! , ce n'est pas normal "
                << "\n VariablesExporter::Insert_VarUtilisateur_dans_globale(..."
                << endl;
         Sortie(1);
      }
     else // sinon c'est ok, on la défini
      {// on insert un conteneur double nommé et indicé associé
       double val=0;
       Grandeur_Double_Nommer_indicer grand_courant(dan.Nom_grandeur_globale(),val,dan.Indice_const());
       TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT,NU_DDL,grand_courant);
       ParaGlob::param->Ajout_grandeur_consultable(&typQ1,dan.Nom_var());
      };
   };
 };

 };

// Affiche l'ensemble des variables et constantes utilisateur
void VariablesExporter::Affiche () const
{ cout << "\n\t\t*** constantes et Variables exportees globalement ***\n\n";
  // -- cas des Constantes utilisateurs ---
  cout << "\n ===constantes_utilisateur==== ";
  { List_io < Ddl_a_un_noeud >::const_iterator it, itfin = list_noeud_type_ddl.end();
    List_io < string >::const_iterator il = li_nom.begin();
    for (it = list_noeud_type_ddl.begin();it != itfin; it++,il++)
      cout << "\n  double_ " << (*il) ;
  };

  // -- cas des variables utilisateurs ---
  cout << "\n ===variables_utilisateur==== ";
  { List_io < Ddl_a_un_noeud >::const_iterator it, itfin = list_noeud_type_ddl.end();
    for (it = list_noeud_type_ddl.begin();it != itfin; it++)
      cout << (*it);
  };
 // -- cas des ddl étendu aux noeuds ---
 { List_io < Ddl_etendu_a_un_noeud >::const_iterator it, itfin = list_noeud_type_ddlEtendu.end();
   for (it = list_noeud_type_ddlEtendu.begin();it != itfin; it++)
      cout << (*it);
 };
 // -- cas des grandeurs quelconques aux noeuds ---
 { List_io < Quelconque_a_un_noeud >::const_iterator it, itfin = list_noeud_type_quelconque.end();
   for (it = list_noeud_type_quelconque.begin();it != itfin; it++)
      cout << (*it);
 };
 // -- cas des ddl aux pti d'éléments ---
 { List_io < Ddl_a_un_element >::const_iterator it, itfin = list_element_type_ddl.end();
   for (it = list_element_type_ddl.begin();it != itfin; it++)
      cout << (*it);
 };
 // -- cas des grandeurs particulières aux pti d'éléments ---
 { List_io < TypeParticulier_a_un_element >::const_iterator it, itfin = list_element_type_particulier.end();
   for (it = list_element_type_particulier.begin();it != itfin; it++)
      cout << (*it);
 };
 // -- cas des grandeurs évoluées aux pti d'éléments ---
 { List_io < TypeEvoluee_a_un_element >::const_iterator it, itfin = list_element_type_evoluee.end();
   for (it = list_element_type_evoluee.begin();it != itfin; it++)
      cout << (*it);
 };
 // -- cas des grandeurs quelconques aux pti de faces d'éléments ---
 { List_io < TypeQuelc_face_a_un_element >::const_iterator it, itfin = list_face_element_type_quelc.end();
   for (it = list_face_element_type_quelc.begin();it != itfin; it++)
      cout << (*it);
 };
 // -- cas des grandeurs quelconques aux pti d'arête d'éléments ---
 { List_io < TypeQuelc_arete_a_un_element >::const_iterator it, itfin = list_arete_element_type_quelc.end();
   for (it = list_arete_element_type_quelc.begin();it != itfin; it++)
      cout << (*it);
 };
 // -- cas d'une composante d'une variable globale de type multidimentionnel ---
 { List_io < TypeQuelc_Une_composante_Grandeur_globale >::const_iterator it, itfin = list_var_glob_sur_grandeur_globale.end();
   for (it = list_var_glob_sur_grandeur_globale.begin();it != itfin; it++)
      cout << (*it);
 };

};



// Surcharge de l'operateur = : realise l'egalite entre deux instances
VariablesExporter&
VariablesExporter::operator= (VariablesExporter& a)
{ li_Q=a.li_Q; li_nom=a.li_nom;
 // ----- les variables
 // -> noeuds
 list_noeud_type_ddl = a.list_noeud_type_ddl;
 list_noeud_type_ddlEtendu=a.list_noeud_type_ddlEtendu;
 list_noeud_type_quelconque = a.list_noeud_type_quelconque;

 // -> éléments
 list_element_type_ddl = a.list_element_type_ddl;
 list_element_type_particulier = a.list_element_type_particulier;
 list_quelc_element_type_particulier = a.list_quelc_element_type_particulier;
 list_element_type_evoluee = a.list_element_type_evoluee;
 list_quelc_element_type_evoluee = a.list_quelc_element_type_evoluee;
 
 // -> face d'éléments
 list_face_element_type_quelc = a.list_face_element_type_quelc;
 list_quelc_face_element_type_quelc = a.list_quelc_face_element_type_quelc;

 // -> arête d'éléments
 list_arete_element_type_quelc = a.list_arete_element_type_quelc;
 list_quelc_arete_element_type_quelc = a.list_quelc_arete_element_type_quelc;
 
 // -> une composante d'une variable globale de type multidimentionnel
 list_var_glob_sur_grandeur_globale = a.list_var_glob_sur_grandeur_globale;

 return (*this);
};

// test si toutes les informations des maillages sont completes
// = true -> complet
// = false -> incomplet
bool VariablesExporter::Complet_VariablesExporter(const LesReferences& lesRef)
  { bool res = true; // init
  
    // ***vérifier que toutes les variables ont des noms différents
    // a priori c'est ok vu que la vérif est déjà effectuée à la lecture
    
    // on va vérifier que toutes les références sont correctes
    // --- cas des ddl aux noeuds
    {List_io < Ddl_a_un_noeud >::iterator il,ilfin = list_noeud_type_ddl.end();
     for (il = list_noeud_type_ddl.begin();il != ilfin;il++)
      {Ddl_a_un_noeud& dan = *il; // pour simplifier
         
       // récup de la reférence
       const string * point_mail = NULL;
       if ((*il).Nom_mail_const() != "")
         point_mail = &((*il).Nom_mail_const());
       const ReferenceNE & ref =
       ((ReferenceNE &) lesRef.Trouve((*il).Ref_Num_NE(),point_mail));
       // on vérifie qu'il s'agit d'une ref de noeud
       if (ref.Indic() != 1)
        { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
               << " n'est pas associee a une reference de noeud "
               << " revoir la mise en donnees ! ";
          if (ParaGlob::NiveauImpression() >= 2)
            dan.Affiche();
          Sortie(1);
        };
       // on vérifie qu'il n'y a qu'un seule numéro de noeud
       if (ref.Taille() != 1)
         { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
                << " est  associee a une reference qui  comporte "
                << ref.Taille() << " noeud(s) alors qu'il ne faut qu'un seul noeud !"
                << " revoir la mise en donnees ! ";
           if (ParaGlob::NiveauImpression() >= 2)
             dan.Affiche();
           Sortie(1);
         };
       };
    };
        
    // --- cas des ddl étendus aux noeuds
    {List_io < Ddl_etendu_a_un_noeud >::iterator il,ilfin = list_noeud_type_ddlEtendu.end();
     for (il = list_noeud_type_ddlEtendu.begin();il != ilfin;il++)
      {Ddl_etendu_a_un_noeud& dan = *il; // pour simplifier
       // récup de la reférence
       const string * point_mail = NULL;
       if ((*il).Nom_mail_const() != "")
         point_mail = &((*il).Nom_mail_const());
       const ReferenceNE & ref =
       ((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
       // on vérifie qu'il s'agit d'une ref de noeud
       if (ref.Indic() != 1)
        { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
               << " n'est pas associee a une reference de noeud "
               << " revoir la mise en donnees ! ";
          if (ParaGlob::NiveauImpression() >= 2)
            dan.Affiche();
          Sortie(1);
        };
       // on vérifie qu'il n'y a qu'un seule numéro de noeud
       if (ref.Taille() != 1)
        { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
               << " est  associee a une reference qui  comporte "
               << ref.Taille() << " noeud(s) alors qu'il ne faut qu'un seul noeud !"
               << " revoir la mise en donnees ! ";
          if (ParaGlob::NiveauImpression() >= 2)
            dan.Affiche();
          Sortie(1);
        };
      };
    };

    // --- cas des grandeurs quelconques aux noeuds
    {List_io < Quelconque_a_un_noeud >::iterator il,ilfin = list_noeud_type_quelconque.end();
     for (il = list_noeud_type_quelconque.begin();il != ilfin;il++)
      {Quelconque_a_un_noeud& dan = *il; // pour simplifier
       // récup de la reférence
       const string * point_mail = NULL;
       if ((*il).Nom_mail_const() != "")
         point_mail = &((*il).Nom_mail_const());
       const ReferenceNE & ref =
       ((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
       // on vérifie qu'il s'agit d'une ref de noeud
       if (ref.Indic() != 1)
        { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
               << " n'est pas associee a une reference de noeud "
               << " revoir la mise en donnees ! ";
          if (ParaGlob::NiveauImpression() >= 2)
            dan.Affiche();
          Sortie(1);
        };
       // on vérifie qu'il n'y a qu'un seule numéro de noeud
       if (ref.Taille() != 1)
        { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
               << " est  associee a une reference qui  comporte "
               << ref.Taille() << " noeud(s) alors qu'il ne faut qu'un seul noeud !"
               << " revoir la mise en donnees ! ";
          if (ParaGlob::NiveauImpression() >= 2)
            dan.Affiche();
          Sortie(1);
        };
      };
    };

    // --- cas des ddl aux pti d'élément
    {List_io < Ddl_a_un_element >::iterator il,ilfin = list_element_type_ddl.end();
     for (il = list_element_type_ddl.begin();il != ilfin;il++)
      {Ddl_a_un_element& dan = *il; // pour simplifier
       // récup de la reférence
       const string * point_mail = NULL;
       if ((*il).Nom_mail_const() != "")
         point_mail = &((*il).Nom_mail_const());
       const ReferenceNE & ref =
       ((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
       // on vérifie qu'il s'agit d'une ref d'élément
       if (ref.Indic() != 2)
        { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
               << " n'est pas associee a une reference d'element' "
               << " revoir la mise en donnees ! ";
          if (ParaGlob::NiveauImpression() >= 2)
            dan.Affiche();
          Sortie(1);
        };
       // on vérifie qu'il n'y a qu'un seule numéro d'élément
       if (ref.Taille() != 1)
        { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
               << " est  associee a une reference qui comporte "
               << ref.Taille() << " element(s) alors qu'il ne faut qu'un seul element !"
               << " revoir la mise en donnees ! ";
          if (ParaGlob::NiveauImpression() >= 2)
            dan.Affiche();
          Sortie(1);
        };
      };
    };
       
       // --- cas des grandeurs particulières aux pti d'élément
       {List_io < TypeParticulier_a_un_element >::iterator il,ilfin
                    = list_element_type_particulier.end();
        List_io < TypeQuelconque >::iterator it = list_quelc_element_type_particulier.begin();
        // on balaie la liste avec les conteneurs associés
        for (il = list_element_type_particulier.begin();il != ilfin;il++,it++)
         {TypeParticulier_a_un_element& dan = *il; // pour simplifier
          // récup de la reférence
          const string * point_mail = NULL;
          if ((*il).Nom_mail_const() != "")
            point_mail = &((*il).Nom_mail_const());
          const ReferenceNE & ref =
          ((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
          // on vérifie qu'il s'agit d'une ref d'élément
          if (ref.Indic() != 2)
           { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
                  << " n'est pas associee a une reference d'element' "
                  << " revoir la mise en donnees ! ";
             if (ParaGlob::NiveauImpression() >= 2)
               dan.Affiche();
             Sortie(1);
           };
          // on vérifie qu'il n'y a qu'un seule numéro d'élément
          if (ref.Taille() != 1)
           { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
                  << " est  associee a une reference qui comporte "
                  << ref.Taille() << " element(s) alors qu'il ne faut qu'un seul element !"
                  << " revoir la mise en donnees ! ";
             if (ParaGlob::NiveauImpression() >= 2)
               dan.Affiche();
             Sortie(1);
           };
         };
       };
       
       // --- cas des grandeurs évoluées aux pti d'élément
       {List_io < TypeEvoluee_a_un_element >::iterator il,ilfin
                    = list_element_type_evoluee.end();
        List_io < TypeQuelconque >::iterator it = list_quelc_element_type_evoluee.begin();
        // on balaie la liste avec les conteneurs associés
        for (il = list_element_type_evoluee.begin();il != ilfin;il++,it++)
         {TypeEvoluee_a_un_element& dan = *il; // pour simplifier
          // récup de la reférence
          const string * point_mail = NULL;
          if ((*il).Nom_mail_const() != "")
            point_mail = &((*il).Nom_mail_const());
          const ReferenceNE & ref =
          ((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
          // on vérifie qu'il s'agit d'une ref d'élément
          if (ref.Indic() != 2)
           { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
                  << " n'est pas associee a une reference d'element' "
                  << " revoir la mise en donnees ! ";
             if (ParaGlob::NiveauImpression() >= 2)
               dan.Affiche();
             Sortie(1);
           };
          // on vérifie qu'il n'y a qu'un seule numéro d'élément
          if (ref.Taille() != 1)
           { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
                  << " est  associee a une reference qui comporte "
                  << ref.Taille() << " element(s) alors qu'il ne faut qu'un seul element !"
                  << " revoir la mise en donnees ! ";
             if (ParaGlob::NiveauImpression() >= 2)
               dan.Affiche();
             Sortie(1);
           };
         };
       };
       
       // --- cas des grandeurs quelconques aux pti de faces d'élément
       {List_io < TypeQuelc_face_a_un_element >::iterator il,ilfin
                    = list_face_element_type_quelc.end();
        List_io < TypeQuelconque >::iterator it = list_quelc_face_element_type_quelc.begin();
        // on balaie la liste avec les conteneurs associés
        for (il = list_face_element_type_quelc.begin();il != ilfin;il++,it++)
         {TypeQuelc_face_a_un_element& dan = *il; // pour simplifier
          // récup de la reférence
          const string * point_mail = NULL;
          if ((*il).Nom_mail_const() != "")
            point_mail = &((*il).Nom_mail_const());
          const ReferenceNE & ref =
          ((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
          // on vérifie qu'il s'agit d'une ref d'élément
          if (ref.Indic() != 2)
           { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
                  << " n'est pas associee a une reference d'element' "
                  << " revoir la mise en donnees ! ";
             if (ParaGlob::NiveauImpression() >= 2)
               dan.Affiche();
             Sortie(1);
           };
          // on vérifie qu'il n'y a qu'un seule numéro d'élément
          if (ref.Taille() != 1)
           { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
                  << " est  associee a une reference qui comporte "
                  << ref.Taille() << " element(s) alors qu'il ne faut qu'un seul element !"
                  << " revoir la mise en donnees ! ";
             if (ParaGlob::NiveauImpression() >= 2)
               dan.Affiche();
             Sortie(1);
           };
         };
       };
       
       // --- cas des grandeurs quelconques aux pti d'arêtes d'élément
       {List_io < TypeQuelc_arete_a_un_element >::iterator il,ilfin
                    = list_arete_element_type_quelc.end();
        List_io < TypeQuelconque >::iterator it = list_quelc_arete_element_type_quelc.begin();
        // on balaie la liste avec les conteneurs associés
        for (il = list_arete_element_type_quelc.begin();il != ilfin;il++,it++)
         {TypeQuelc_arete_a_un_element& dan = *il; // pour simplifier
          // récup de la reférence
          const string * point_mail = NULL;
          if ((*il).Nom_mail_const() != "")
            point_mail = &((*il).Nom_mail_const());
          const ReferenceNE & ref =
          ((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
          // on vérifie qu'il s'agit d'une ref d'élément
          if (ref.Indic() != 2)
           { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
                  << " n'est pas associee a une reference d'un element' "
                  << " revoir la mise en donnees ! ";
             if (ParaGlob::NiveauImpression() >= 2)
               dan.Affiche();
             Sortie(1);
           };
          // on vérifie qu'il n'y a qu'un seule numéro d'élément
          if (ref.Taille() != 1)
           { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
                  << " est  associee a une reference qui comporte "
                  << ref.Taille() << " element(s) alors qu'il ne faut qu'un seul element !"
                  << " revoir la mise en donnees ! ";
             if (ParaGlob::NiveauImpression() >= 2)
               dan.Affiche();
             Sortie(1);
           };
         };
       };
       
       // ----- cas une composante d'une variable globale de type multidimentionnel
       // rien à faire, c'est fait à l'appel de la variable globale (cf. ParaGlob)

  
    // retour
    return res;
  };
	    


// mises à jour de constantes globales définies par l'utilisateur
// permet de changer les valeurs, lors d'une suite .info par exemple
void VariablesExporter::MiseAjourConstantesUtilisateur(UtilLecture& lec)
   { if (strstr(lec.tablcar,"Mise_A_jour_Constantes_utilisateurs_")!=NULL)
         { lec.NouvelleDonnee(); // on se positionne sur le premier enreg
           // on lit tant que l'on ne rencontre pas la ligne contenant
           // "fin_Mise_A_jour_Constantes_utilisateurs_"
           while (strstr(lec.tablcar,"fin_Mise_A_jour_Constantes_utilisateurs_")==0)
            {// lecture d'un mot clé
             string nom;
             *(lec.entree) >> nom;
        
             if ((lec.entree)->rdstate() == 0)
                {} // lecture normale
             #ifdef ENLINUX
             else  if ((lec.entree)->fail())
              // on a atteind la fin de la ligne et on appelle un nouvel enregistrement
               {   lec.NouvelleDonnee();  // lecture d'un nouvelle enregistrement
                   *(lec.entree) >> nom;
               }
             #else
             else  if ((lec.entree)->eof())
               // la lecture est bonne mais on a atteind la fin de la ligne
               { if(nom != "fin_Mise_A_jour_Constantes_utilisateurs_")
                   {lec.NouvelleDonnee(); *(lec.entree) >> nom;};
               }
             #endif
             else // cas d'une erreur de lecture
              { cout << "\n erreur de lecture inconnue  ";
                lec.MessageBuffer("** erreur en lecture pour la mise a jour des constantes utilisateur **");
                throw (UtilLecture::ErrNouvelleDonnee(-1));
                Sortie(1);
              };
        
             // en fonction du type de donnée on modifie
             if (nom == "double_")
              { string nom_constante; double val;
                *(lec.entree) >> nom_constante >> val;
               
                // on récupère le pointeur correspondant à la grandeur
                const void* pointe =  (ParaGlob::param->GrandeurGlobal(nom_constante));
                if (pointe != NULL)
                 {TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
                  if ((gr_quelc->Grandeur_pointee()->Type_structure_grandeurAssocie()==TYPE_SIMPLE)
                      && (gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere()==PARTICULIER_SCALAIRE_DOUBLE)
                     )
                       {Grandeur_scalaire_double& gr
                             = *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
                        // on met à jour la grandeur
                        *(gr.ConteneurDouble()) = val;
                       }
                  else // sinon pb
                       { cout << "\n *** pb dans dans la mise a jour de la constante globale "<< nom_constante
                                << " le conteneur lu " << nom << " n'est pas d'un type correct !! "
                                << "\n Projet::MiseAjourConstantesUtilisateur(..."
                                <<endl;
                         Sortie(1);
                       };
                  }
                else // sinon pb
                   { cout << "\n *** erreur dans dans la mise a jour de la constante globale "<< nom_constante
                            << " la variable n'existe pas !! "
                            << "\n Projet::MiseAjourConstantesUtilisateur(..."
                            <<endl;
                     Sortie(1);
                   };
              }
//             else if (nom == "int_")
//              { string nom_constante; int val;
//                *(lec.entree) >> nom_constante >> val;
//
//                // on récupère le pointeur correspondant à la grandeur
//                const void* pointe =  (ParaGlob::param->GrandeurGlobal(nom_constante));
//                if (pointe != NULL)
//                 {TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
//                  if ((gr_quelc->Grandeur_pointee()->Type_structure_grandeurAssocie()==TYPE_SIMPLE)
//                      && (gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere()==PARTICULIER_SCALAIRE_ENTIER)
//                     )
//                       {Grandeur_scalaire_entier& gr
//                             = *((Grandeur_scalaire_entier*) gr_quelc->Grandeur_pointee()); // pour simplifier
//                        // on met à jour la grandeur
//                        *(gr.ConteneurEntier()) = val;
//                       }
//                  else // sinon pb
//                       { cout << "\n *** pb dans dans la mise a jour de la constante globale "<< nom_constante
//                                << " le conteneur lu " << nom << " n'est pas d'un type correct !! "
//                                << "\n Projet::MiseAjourConstantesUtilisateur(..."
//                                <<endl;
//                         Sortie(1);
//                       };
//                  }
//                else // sinon pb
//                   { cout << "\n *** erreur dans dans la mise a jour de la constante globale "<< nom_constante
//                            << " la variable n'existe pas !! "
//                            << "\n Projet::MiseAjourConstantesUtilisateur(..."
//                            <<endl;
//                     Sortie(1);
//                   };
//
//              }
             else if(nom != "fin_Mise_A_jour_Constantes_utilisateurs_")
              {cout << "\n erreur de lecture pour la mise a jour de constantes  "
                    << " on a lu " << nom << " ??? ";
               if (ParaGlob::NiveauImpression()>3)
                  cout << "\n Projet::MiseAjourConstantesUtilisateur(... " << endl ;
               throw (UtilLecture::ErrNouvelleDonnee(-1));
               Sortie(1);
              };
        
            }; //-- fin du while
           lec.NouvelleDonnee(); // on prépare la nouvelle lecture
         };
    };

 // renseigne les variables définies par l'utilisateur
 // via les valeurs calculées par Herezh
 void VariablesExporter::RenseigneVarUtilisateur(LesMaillages& lesMail,const LesReferences& lesRef)
  {
    // --- cas des ddl aux noeuds
    {List_io < Ddl_a_un_noeud >::iterator il,ilfin = list_noeud_type_ddl.end();
     for (il = list_noeud_type_ddl.begin();il != ilfin;il++)
      {Ddl_a_un_noeud& dan = *il; // pour simplifier
       // récup du conteneur global
       const void* pointe =  (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
       TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
       Grandeur_scalaire_double& gr
       = *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
       // récup de la valeur demandée au niveau des noeuds
       int n_mail = 1; // init par défaut
       if ((*il).Nom_mail() != "")
         n_mail = lesMail.NumMaillage((*il).Nom_mail());
         
       // récup de la reférence
       const string * point_mail = NULL;
       if ((*il).Nom_mail_const() != "")
         point_mail = &((*il).Nom_mail_const());
       const ReferenceNE & ref =
       ((ReferenceNE &) lesRef.Trouve((*il).Ref_Num_NE(),point_mail));
       int ne = ref.Numero(1); // le num du noeud: uniquement le premier
       Noeud& noe = lesMail.Noeud_LesMaille(n_mail,ne);
       if (!noe.Existe_ici((dan.Enu()).Enum()))
           { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
                  << " ne peut pas etre renseignee car le ddl "
                  << dan.Enu().Nom_plein() << " n'est pas disponible !!! ";
             if (ParaGlob::NiveauImpression() >= 2)
               dan.Affiche();
             Sortie(1);
           };
       switch (dan.Temps())
         { case TEMPS_0 :
             (*(gr.ConteneurDouble())) = noe.Valeur_0((dan.Enu()).Enum());break;
           case TEMPS_t :
             (*(gr.ConteneurDouble())) = noe.Valeur_t((dan.Enu()).Enum());break;
           case TEMPS_tdt :
             (*(gr.ConteneurDouble())) = noe.Valeur_tdt((dan.Enu()).Enum());break;
         };
      };
    };
    
   // --- cas des ddl étendus aux noeuds
   {List_io < Ddl_etendu_a_un_noeud >::iterator il,ilfin = list_noeud_type_ddlEtendu.end();
    for (il = list_noeud_type_ddlEtendu.begin();il != ilfin;il++)
     {Ddl_etendu_a_un_noeud& dan = *il; // pour simplifier
      // récup du conteneur global
      const void* pointe =  (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
      TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
      Grandeur_scalaire_double& gr
      = *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
      // récup de la valeur demandée au niveau des noeuds
      int n_mail = 1; // init par défaut
      if ((*il).Nom_mail() != "")
        n_mail = lesMail.NumMaillage((*il).Nom_mail());
      // récup de la reférence
      const string * point_mail = NULL;
      if ((*il).Nom_mail_const() != "")
        point_mail = &((*il).Nom_mail_const());
      const ReferenceNE & ref =
      ((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
      int ne = ref.Numero(1); // le num du noeud: uniquement le premier
      Noeud& noe = lesMail.Noeud_LesMaille(n_mail,ne);
//      Noeud& noe = lesMail.Noeud_LesMaille(n_mail,dan.Num_NE());
      if (!noe.Existe_ici_ddlEtendu((dan.Enu())))
         { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
                << " ne peut pas etre renseignee car le ddl etendu "
                << dan.Enu().Nom_plein() << " n'est pas disponible !!! ";
           if (ParaGlob::NiveauImpression() >= 2)
             dan.Affiche();
           Sortie(1);
         };
      (*(gr.ConteneurDouble())) = noe.DdlEtendue(dan.Enu()).ConstValeur();
     };
   };

    // --- cas des grandeurs quelconques aux noeuds
    {List_io < Quelconque_a_un_noeud >::iterator il,ilfin = list_noeud_type_quelconque.end();
     for (il = list_noeud_type_quelconque.begin();il != ilfin;il++)
      {Quelconque_a_un_noeud& dan = *il; // pour simplifier
       // récup du conteneur global
       const void* pointe =  (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
       TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
       Grandeur_scalaire_double& gr
       = *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
       // récup de la valeur demandée au niveau des noeuds
       int n_mail = 1; // init par défaut
       if ((*il).Nom_mail() != "")
         n_mail = lesMail.NumMaillage((*il).Nom_mail());
       // récup de la reférence
       const string * point_mail = NULL;
       if ((*il).Nom_mail_const() != "")
         point_mail = &((*il).Nom_mail_const());
       const ReferenceNE & ref =
       ((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
       int ne = ref.Numero(1); // le num du noeud: uniquement le premier
       Noeud& noe = lesMail.Noeud_LesMaille(n_mail,ne);
//       Noeud& noe = lesMail.Noeud_LesMaille(n_mail,dan.Num_NE());
       
       // le conteneur au noeud
       const TypeQuelconque_enum_etendu& type_quel = dan.Quelc_const(); // la grandeur constante
       if( noe.Existe_ici(type_quel))
         {const TypeQuelconque& grand_quelconque_noe = noe.Grandeur_quelconque(dan.Quelc_const());
       // l'affectation
          (*(gr.ConteneurDouble())) = grand_quelconque_noe.Const_Grandeur_pointee()->GrandeurNumOrdre(dan.Num_ordre());
         }
       else
       { cout << "\n *** erreur la variable utilisateur " << dan.Nom_var()
              << " ne peut pas etre renseignee car la grandeur "
              << type_quel.NomPlein() << " n'est pas disponible !!! ";
         if (ParaGlob::NiveauImpression() >= 2)
           dan.Affiche();
         Sortie(1);
       };
      };
    };

   // --- cas des ddl aux pti d'élément
   {List_io < Ddl_a_un_element >::iterator il,ilfin = list_element_type_ddl.end();
    for (il = list_element_type_ddl.begin();il != ilfin;il++)
     {Ddl_a_un_element& dan = *il; // pour simplifier
      // récup du conteneur global
      const void* pointe =  (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
      TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
      Grandeur_scalaire_double& gr
      = *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
      // récup de la valeur demandée au niveau du pti d'élément
      int n_mail = 1; // init par défaut
      if ((*il).Nom_mail() != "")
        n_mail = lesMail.NumMaillage((*il).Nom_mail());
      // récup de la reférence
      const string * point_mail = NULL;
      if ((*il).Nom_mail_const() != "")
        point_mail = &((*il).Nom_mail_const());
      const ReferenceNE & ref =
      ((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
      int ne = ref.Numero(1); // le num du noeud: uniquement le premier
      Element& ele = lesMail.Element_LesMaille(n_mail,ne);
      List_io<Ddl_enum_etendu> inter; inter.push_back(dan.Enu());
      Tableau <double> tab= ele.Valeur_a_diff_temps(dan.Absolue_const(),dan.Temps_const(),inter,dan.NBpti_const());
      (*(gr.ConteneurDouble())) = tab(1);
     };
   };
   
   // --- cas des grandeurs particulières aux pti d'élément
   {List_io < TypeParticulier_a_un_element >::iterator il,ilfin
                = list_element_type_particulier.end();
    List_io < TypeQuelconque >::iterator it = list_quelc_element_type_particulier.begin();
    // on balaie la liste avec les conteneurs associés
    for (il = list_element_type_particulier.begin();il != ilfin;il++,it++)
     {TypeParticulier_a_un_element& dan = *il; // pour simplifier
      // récup du conteneur global
      const void* pointe =  (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
      TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
      Grandeur_scalaire_double& gr
      = *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
      // récup de la valeur demandée au niveau du pti d'élément
      int n_mail = 1; // init par défaut
      if ((*il).Nom_mail() != "")
        n_mail = lesMail.NumMaillage((*il).Nom_mail());
      // récup de la reférence
      const string * point_mail = NULL;
      if ((*il).Nom_mail_const() != "")
        point_mail = &((*il).Nom_mail_const());
      const ReferenceNE & ref =
      ((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
      int ne = ref.Numero(1); // le num du noeud: uniquement le premier
      Element& ele = lesMail.Element_LesMaille(n_mail,ne);
      List_io<TypeQuelconque> inter; inter.push_back((*it)); // il y a une recopie
      ele.Grandeur_particuliere(dan.Absolue_const(),inter,dan.NBpti_const());
      // le résultat est dans inter, pas dans (*it)
      // affectation
      (*(gr.ConteneurDouble())) = (*inter.begin()).GrandeurNumOrdre(dan.Num_ordre());
     };
   };
   
   // --- cas des grandeurs évoluées aux pti d'élément
   {List_io < TypeEvoluee_a_un_element >::iterator il,ilfin
                = list_element_type_evoluee.end();
    List_io < TypeQuelconque >::iterator it = list_quelc_element_type_evoluee.begin();
    // on balaie la liste avec les conteneurs associés
    for (il = list_element_type_evoluee.begin();il != ilfin;il++,it++)
     {TypeEvoluee_a_un_element& dan = *il; // pour simplifier
      // récup du conteneur global
      const void* pointe =  (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
      TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
      Grandeur_scalaire_double& gr
      = *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
      // récup de la valeur demandée au niveau du pti d'élément
      int n_mail = 1; // init par défaut
      if ((*il).Nom_mail() != "")
        n_mail = lesMail.NumMaillage((*il).Nom_mail());
      // récup de la reférence
      const string * point_mail = NULL;
      if ((*il).Nom_mail_const() != "")
        point_mail = &((*il).Nom_mail_const());
      const ReferenceNE & ref =
      ((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
      int ne = ref.Numero(1); // le num du noeud: uniquement le premier
      Element& ele = lesMail.Element_LesMaille(n_mail,ne);
      List_io<TypeQuelconque> inter; inter.push_back((*it)); // il y a une recopie
      ele.Grandeur_particuliere(dan.Absolue_const(),inter,dan.NBpti_const());
      // le résultat est dans inter, pas dans (*it)
      // affectation
      (*(gr.ConteneurDouble())) = (*inter.begin()).GrandeurNumOrdre(dan.Num_ordre());
     };
   };
   
   // --- cas des grandeurs quelconques aux pti de faces d'élément
   {List_io < TypeQuelc_face_a_un_element >::iterator il,ilfin
                = list_face_element_type_quelc.end();
    List_io < TypeQuelconque >::iterator it = list_quelc_face_element_type_quelc.begin();
    // on balaie la liste avec les conteneurs associés
    for (il = list_face_element_type_quelc.begin();il != ilfin;il++,it++)
     {TypeQuelc_face_a_un_element& dan = *il; // pour simplifier
      // récup du conteneur global
      const void* pointe =  (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
      TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
      Grandeur_scalaire_double& gr
      = *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
      // récup de la valeur demandée au niveau du pti d'élément
      int n_mail = 1; // init par défaut
      if ((*il).Nom_mail() != "")
        n_mail = lesMail.NumMaillage((*il).Nom_mail());
      // récup de la reférence
      const string * point_mail = NULL;
      if ((*il).Nom_mail_const() != "")
        point_mail = &((*il).Nom_mail_const());
      const ReferenceNE & ref =
      ((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
      int ne = ref.Numero(1); // le num du noeud: uniquement le premier
      Element& ele = lesMail.Element_LesMaille(n_mail,ne);
      List_io<TypeQuelconque> inter; inter.push_back((*it)); // il y a une recopie
      ele.Grandeur_particuliere_face(dan.Absolue_const(),inter,dan.Num_FA_const(),dan.NBpti_const());
      // le résultat est dans inter, pas dans (*it)
      // affectation
      (*(gr.ConteneurDouble())) = (*inter.begin()).GrandeurNumOrdre(dan.Num_ordre());
     };
   };
   
   // --- cas des grandeurs quelconques aux pti d'arêtes d'élément
   {List_io < TypeQuelc_arete_a_un_element >::iterator il,ilfin
                = list_arete_element_type_quelc.end();
    List_io < TypeQuelconque >::iterator it = list_quelc_arete_element_type_quelc.begin();
    // on balaie la liste avec les conteneurs associés
    for (il = list_arete_element_type_quelc.begin();il != ilfin;il++,it++)
     {TypeQuelc_arete_a_un_element& dan = *il; // pour simplifier
      // récup du conteneur global
      const void* pointe =  (ParaGlob::param->GrandeurGlobal(dan.Nom_var()));
      TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
      Grandeur_scalaire_double& gr
      = *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
      // récup de la valeur demandée au niveau du pti d'élément
      int n_mail = 1; // init par défaut
      if ((*il).Nom_mail() != "")
        n_mail = lesMail.NumMaillage((*il).Nom_mail());
      // récup de la reférence
      const string * point_mail = NULL;
      if ((*il).Nom_mail_const() != "")
        point_mail = &((*il).Nom_mail_const());
      const ReferenceNE & ref =
      ((ReferenceNE &) lesRef.Trouve((*il).Ref_NE(),point_mail));
      int ne = ref.Numero(1); // le num du noeud: uniquement le premier
      Element& ele = lesMail.Element_LesMaille(n_mail,ne);
      List_io<TypeQuelconque> inter; inter.push_back((*it)); // il y a une recopie
      ele.Grandeur_particuliere_arete(dan.Absolue_const(),inter,dan.Num_FA_const(),dan.NBpti_const());
      // le résultat est dans inter, pas dans (*it)
      // affectation
      (*(gr.ConteneurDouble())) = (*inter.begin()).GrandeurNumOrdre(dan.Num_ordre());
     };
   };
   
   // ----- cas une composante d'une variable globale de type multidimentionnel
   // rien à faire, c'est fait à l'appel de la variable globale (cf. ParaGlob)

  };



//----- lecture écriture de base info -----
//   lecture base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void VariablesExporter::Lecture_base_info(ifstream& entr,const int cas)
{switch (cas)
  { case 1 : // ------- on récupère tout -------------------------
    {
	    break;
	   }
    case  2 : // ----------- lecture uniquement de se qui varie --------------------
    {
	    break;
    }
    default :
	    { cout << "\nErreur : valeur incorrecte du type de lecture !\n";
	      cout << "VariablesExporter::Lecture_base_info(ofstream& sort,int cas)"
			         << " cas= " << cas << endl;
	      Sortie(1);
	    };
  };
};
        
//   écriture base info   
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void VariablesExporter::Ecriture_base_info(ofstream& sort,const int cas)
{switch (cas)
  { case 1 : // ------- on sauvegarde tout -------------------------
    {
     // -- cas des Constantes utilisateurs ---
     sort << "\n ===constantes_utilisateur==== ";
     { List_io < Ddl_a_un_noeud >::const_iterator it, itfin = list_noeud_type_ddl.end();
       List_io < string >::const_iterator il = li_nom.begin();
       for (it = list_noeud_type_ddl.begin();it != itfin; it++,il++)
         sort << "\n  double_ " << (*il) ;
     };

     // -- cas des variables utilisateurs ---
     sort << "\n ===variables_utilisateur==== ";
     { List_io < Ddl_a_un_noeud >::const_iterator it, itfin = list_noeud_type_ddl.end();
       for (it = list_noeud_type_ddl.begin();it != itfin; it++)
         sort << (*it);
     };
    // -- cas des ddl étendu aux noeuds ---
    { List_io < Ddl_etendu_a_un_noeud >::const_iterator it, itfin = list_noeud_type_ddlEtendu.end();
      for (it = list_noeud_type_ddlEtendu.begin();it != itfin; it++)
         sort << (*it);
    };
    // -- cas des grandeurs quelconques aux noeuds ---
    { List_io < Quelconque_a_un_noeud >::const_iterator it, itfin = list_noeud_type_quelconque.end();
      for (it = list_noeud_type_quelconque.begin();it != itfin; it++)
         sort << (*it);
    };
    // -- cas des ddl aux pti d'éléments ---
    { List_io < Ddl_a_un_element >::const_iterator it, itfin = list_element_type_ddl.end();
      for (it = list_element_type_ddl.begin();it != itfin; it++)
         sort << (*it);
    };
    // -- cas des grandeurs particulières aux pti d'éléments ---
    { List_io < TypeParticulier_a_un_element >::const_iterator it, itfin = list_element_type_particulier.end();
      for (it = list_element_type_particulier.begin();it != itfin; it++)
         sort << (*it);
    };
    // -- cas des grandeurs évoluées aux pti d'éléments ---
    { List_io < TypeEvoluee_a_un_element >::const_iterator it, itfin = list_element_type_evoluee.end();
      for (it = list_element_type_evoluee.begin();it != itfin; it++)
         sort << (*it);
    };
    // -- cas des grandeurs quelconques aux pti de faces d'éléments ---
    { List_io < TypeQuelc_face_a_un_element >::const_iterator it, itfin = list_face_element_type_quelc.end();
      for (it = list_face_element_type_quelc.begin();it != itfin; it++)
         sort << (*it);
    };
    // -- cas des grandeurs quelconques aux pti d'arête d'éléments ---
    { List_io < TypeQuelc_arete_a_un_element >::const_iterator it, itfin = list_arete_element_type_quelc.end();
      for (it = list_arete_element_type_quelc.begin();it != itfin; it++)
         sort << (*it);
    };
     // -- cas d'une composante d'une variable globale de type multidimentionnel ---
    { List_io < TypeQuelc_Une_composante_Grandeur_globale >::const_iterator it, itfin = list_var_glob_sur_grandeur_globale.end();
      for (it = list_var_glob_sur_grandeur_globale.begin();it != itfin; it++)
         sort << (*it);
    };
    
	    break;
	    }
    case  2 : // ----------- sauvegarde uniquement de se qui varie --------------------
    {
     
     break;
     }
    default :
	    { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
       cout << "VariablesExporter::Ecriture_base_info(ofstream& sort,int cas)"
			         << " cas= " << cas << endl;
	      Sortie(1);
	    };
  };
};
	    
// sortie du schemaXML: en fonction de enu
void VariablesExporter::SchemaXML_VariablesExporters(UtilLecture * entreePrinc,const Enum_IO_XML enu)
 {
// switch (enu)
//    {case XML_TYPE_GLOBAUX:
//     { // cas des classes de base
//       DeuxEntiers toto;
//       toto.SchemaXML_DeuxEntiers(sort,enu);
//       break;
//      }
//     case XML_IO_POINT_INFO:
//      {// cas de def de  LesMaillages
//       sort  << "\n      <xs:element name=\"LesMaillages\" >"
//             << "\n        <xs:complexType>"
//             << "\n          <xs:annotation>"
//             << "\n            <xs:documentation> une suite de maillages </xs:documentation>"
//             << "\n          </xs:annotation>"
//             << "\n          <xs:sequence>"
//             << "\n            <xs:element name=\"Maillage\" type=\"Maillage\" "
//             << "\n                        minOccurs=\"1\" maxOccurs=\"unbounded\" />"
//             << "\n          </xs:sequence>"
//             << "\n        </xs:complexType>"
//             << "\n      </xs:element>";
//     // def de Maillage
////     SchemaXML_Maillage(sort,niveau);
//         break;
//      }
//    };
 };

 // -- def de constantes utilisateur pour une sortie sur un fichier de commande
 void VariablesExporter::Info_commande_ConstantesUtilisateur(UtilLecture * entreePrinc)
  { cout << "\n definition de constante(s) utilisateur (defaut 0 c-a-d non) : 1 (c-a-d oui) ?  ";
    string rep;bool choix_valide=false;

    while (!choix_valide)
     { rep = "_";
       // procédure de lecture avec prise en charge d'un retour chariot
       rep = lect_return_defaut(true,"0");
       if (rep.size()==0)
          {rep = "0";
           cout << "--> valeur: 0 ";
          };
     
       if (rep == "1") {  choix_valide=true;}
       else if (rep == "0") {choix_valide=true;}
       else if (rep == "f") {choix_valide=true;}
       else if (rep == "fin_prog") Sortie(1);
       else { cout << "\n Erreur on attendait 0 ou 1 ou f !!, redonnez une bonne valeur"
                   << "\n ou taper fin_prog pour arreter le programme ";
              choix_valide=false;
            }
       };
    // écriture
    ofstream & sort = *(entreePrinc->Commande_pointInfo()); // pour simplifier
    // affichage de la banniere sur la sortie passée en argument
    Banniere::Sortie_banniere( sort);
    // puis affichage de la version
    ParaGlob::Sortie_Version(sort); sort << "\n \n";
    sort << "\n#######################################################################"
         << "\n#                       fichier de commande                           #"
         << "\n \n \n"
         << "#     --- commentaire sur l'objet du travail ???"
         << "\n \n \n"
         <<  endl;
   
    // maintenant on regarde s'il faut des constantes utilisateurs
    try
     {if (rep == "1")
       {sort << "\n#------------------------------------------------------------------"
             << "\n Constantes_utilisateurs_ ";
        while (choix_valide)
           { rep = "_";string nom;double val;
             cout << "\n nom de la variable ? (ou f ou 0 (defaut)) ";
             nom = lect_return_defaut(false,"f");
             if ((nom != "f")&&(nom != "0"))
              { cout << "\n valeur ? ";val=lect_double();
                cout << "\n constante lue : "<< "C__"+nom << "  "<< val << flush;
                choix_valide = true;
                sort << "\n  double_ " << "C__"+nom << "  "<< val << flush;
              }
             else {choix_valide = false;};
           };
        sort << "\n fin_Constantes_utilisateurs_  \n" << flush;
       };
    }
   catch (ErrSortieFinale)
        // cas d'une direction voulue vers la sortie
        // on relance l'interuption pour le niveau supérieur
      { ErrSortieFinale toto;
        throw (toto);
      }
   catch (...)
    {cout << "\n *** erreur en definition des constantes utilisateurs ! stop " << flush;
     Sortie(1);
    };
   
   };

// -- def de variables utilisateur pour une sortie sur un fichier de commande
void VariablesExporter::Info_commande_VariablesUtilisateur(UtilLecture * entreePrinc)
{ cout << "\n definition de variable(s) utilisateur (defaut 0 c-a-d non) : 1 (c-a-d oui) ?  ";
  string rep;bool choix_valide=false;

  while (!choix_valide)
   { rep = "_";
     // procédure de lecture avec prise en charge d'un retour chariot
     rep = lect_return_defaut(true,"0");
     if (rep.size()==0)
        {rep = "0";
         cout << "--> valeur: 0 ";
        };
   
     if (rep == "1") { choix_valide=true;}
     else if (rep == "0") {choix_valide=true;}
     else if (rep == "f") {choix_valide=true;}
     else if (rep == "fin_prog") Sortie(1);
     else { cout << "\n Erreur on attendait 0 ou 1 ou f !!, redonnez une bonne valeur"
                 << "\n ou taper fin_prog pour arreter le programme ";
            choix_valide=false;
          }
    };
  // écriture
  ofstream & sort = *(entreePrinc->Commande_pointInfo()); // pour simplifier
 
  // maintenant on regarde s'il faut des variables utilisateurs
  try
   {choix_valide=false;
    if (rep == "1")
     {sort << "\n#------------------------------------------------------------------"
           << "\n Variables_utilisateurs_ ";
      while (!choix_valide)
         { rep = "_";string nom;
           cout << "\n ddl aux noeuds                       -> rep : noe ?"
                << "\n ddl etendu aux noeuds                -> rep : net ?"
                << "\n grandeur particuliere aux noeuds     -> rep : nop ?"
                << "\n grandeurs generique aux elements     -> rep : ele "
                << "\n grandeurs particulieres aux elements -> rep : elp "
                << "\n grandeurs tensorielles aux elements  -> rep : elt "
                << "\n grandeurs aux faces d'elements       -> rep : elF "
                << "\n grandeurs aux aretes d'elements      -> rep : elA "
                << "\n une composante de grandeur globale   -> rep : cgl "
                << "\n  pour arreter les questions (defaut) -> rep : fin (ou f) ";

           if (ParaGlob::Francais())
            {cout << "\n reponse ? ";}else {cout << "\n answer ? ";}
           rep = lect_return_defaut(false,"f");
           cout << " rep lue: "<< rep << " ";
           if (rep == "noe")
             { // cas d'un ddl à un noeud
               Ddl_a_un_noeud dan;
               cout << "\n nom du maillage (defaut aucun) ? ";
               dan.Nom_mail() = lect_return_defaut(false,"aucun");
               cout << " val lue: "<< dan.Nom_mail();
               if (dan.Nom_mail() == "aucun")
                {dan.Nom_mail() = "";}
               cout << "\n ddl (defaut X1) ? ";
               dan.Enu() = lect_return_defaut(false,"X1");
               cout << " ddl lu: "<< dan.Enu();
               cout << "\n reference du noeud (defaut N_1) ? ";
               dan.Ref_Num_NE() = lect_return_defaut(false,"N_1");
               cout << " val lue: "<< dan.Ref_Num_NE();
               dan.Nom_var() = Lect_interactive_nom_var();
               cout << "\n le temps ou est evalue la variable (defaut: TEMPS_0) ? ";
               dan.Temps() = Id_nom_dure(lect_return_defaut(false,"TEMPS_0"));
               cout << " temps lu "<< Nom_dure(dan.Temps());
               // on a toutes les infos, on peut enregistrer
               sort << dan << flush;
               list_noeud_type_ddl.push_back(dan);
              }
           else if (rep == "net")
             { // cas d'un ddl étendu à un noeud
               Ddl_etendu_a_un_noeud dan;
               cout << "\n nom du maillage (defaut aucun) ? ";
               dan.Nom_mail() = lect_return_defaut(false,"aucun");
               cout << " val lue: "<< dan.Nom_mail();
               if (dan.Nom_mail() == "aucun")
                {dan.Nom_mail() = "";}
               cout << "\n ddl etendu (defaut Masse_diago_noeud) ? ";
//               string nom_ddl(lect_return_defaut(false,"Masse_diago_noeud"));
               dan.Enu() = lect_return_defaut(false,"Masse_diago_noeud");
               cout << " ddl etendu lu: "<< dan.Enu();
               cout << "\n reference du noeud (defaut N_1) ? ";
               dan.Ref_NE() = lect_return_defaut(false,"N_1");
               cout << " val lue: "<< dan.Ref_NE();
               dan.Nom_var() = Lect_interactive_nom_var();
               // on a toutes les infos, on peut enregistrer
               sort << dan << flush;
               list_noeud_type_ddlEtendu.push_back(dan);
              }
           else if (rep == "nop")
             { Quelconque_a_un_noeud dan;
               cout << "\n nom du maillage (defaut aucun) ? ";
               dan.Nom_mail() = lect_return_defaut(false,"aucun");
               cout << " val lue: "<< dan.Nom_mail();
               if (dan.Nom_mail() == "aucun")
                {dan.Nom_mail() = "";}
               cout << "\n grandeur (defaut POSITION_GEOMETRIQUE) ? ";
               dan.Quelc() = lect_return_defaut(false,"POSITION_GEOMETRIQUE");
               cout << " lu: "<< dan.Quelc().NomPlein();
               cout << "\n reference du noeud (defaut N_1) ? ";
               dan.Ref_NE() = lect_return_defaut(false,"N_1");
               cout << " val lue: "<< dan.Ref_NE();
               dan.Nom_var() = Lect_interactive_nom_var();
               cout << "\n le num d'ordre (ex: num de la composante, defaut 1) ?";
               dan.Num_ordre() = ChangeEntier(lect_return_defaut(false,"1"));
               cout << " val lue: "<<dan.Num_ordre();
               // on a toutes les infos, on peut enregistrer
               sort << dan << flush;
               list_noeud_type_quelconque.push_back(dan);              }
           else if (rep == "ele")
             { // cas d'un ddl à un pti d'élément
               Ddl_a_un_element dan;
               cout << "\n nom du maillage (defaut aucun) ? ";
               dan.Nom_mail() = lect_return_defaut(false,"aucun");
               cout << " val lue: "<< dan.Nom_mail();
               if (dan.Nom_mail() == "aucun")
                {dan.Nom_mail() = "";}
               cout << "\n grandeur (defaut SIG11) ? ";
               dan.Enu() = lect_return_defaut(false,"SIG11");
               cout << " ddl lu: "<< dan.Enu();
               cout << "\n reference de l'element (defaut E_1) ? ";
               dan.Ref_NE() = lect_return_defaut(false,"E_1");
               cout << " val lue: "<< dan.Ref_NE();
               dan.Nom_var() = Lect_interactive_nom_var();
               cout << "\n le temps ou est evalue la variable (defaut: TEMPS_0) ? ";
               dan.Temps() = Id_nom_dure(lect_return_defaut(false,"TEMPS_0"));
               cout << " temps lu "<< Nom_dure(dan.Temps());
               cout << "\n le numero du point d'integration (defaut: 1) ? ";
               dan.NBpti() = ChangeEntier(lect_return_defaut(false,"1"));
               cout << "\n en absolu (defaut rep 1) ou en local (rep 0) ? ";
               dan.Absolue() = ChangeEntier(lect_return_defaut(false,"1"));
               // on a toutes les infos, on peut enregistrer
               sort << dan << flush;
               list_element_type_ddl.push_back(dan);
              }
          else if (rep == "elp")
            { // cas d'une grandeur particulière à un pti d'élément
              TypeParticulier_a_un_element dan;
              cout << "\n nom du maillage (defaut aucun) ? ";
              dan.Nom_mail() = lect_return_defaut(false,"aucun");
              cout << " val lue: "<< dan.Nom_mail();
              if (dan.Nom_mail() == "aucun")
               {dan.Nom_mail() = "";}
              cout << "\n grandeur (defaut POSITION_GEOMETRIQUE) ? ";
              dan.Quelc() = lect_return_defaut(false,"POSITION_GEOMETRIQUE");
              cout << " lu: "<< dan.Quelc().NomPlein();
              cout << "\n reference de l'element (defaut E_1) ? ";
              dan.Ref_NE() = lect_return_defaut(false,"E_1");
              cout << " val lue: "<< dan.Ref_NE();
              dan.Nom_var() = Lect_interactive_nom_var();
              cout << "\n le num d'ordre (ex: num de la composante, defaut 1) ?";
              dan.Num_ordre() = ChangeEntier(lect_return_defaut(false,"1"));
              cout << " val lue: "<<dan.Num_ordre();
              cout << "\n le numero du point d'integration (defaut: 1) ? ";
              dan.NBpti() = ChangeEntier(lect_return_defaut(false,"1"));
              cout << "\n en absolu (defaut rep 1) ou en local (rep 0) ? ";
              dan.Absolue() = ChangeEntier(lect_return_defaut(false,"1"));
              // on a toutes les infos, on peut enregistrer
              sort << dan << flush;
              list_element_type_particulier.push_back(dan);
             }
          else if (rep == "elt")
            { // cas d'une grandeur tensorielle à un pti d'élément
              TypeEvoluee_a_un_element dan;
              cout << "\n nom du maillage (defaut aucun) ? ";
              dan.Nom_mail() = lect_return_defaut(false,"aucun");
              cout << " val lue: "<< dan.Nom_mail();
              if (dan.Nom_mail() == "aucun")
               {dan.Nom_mail() = "";}
              cout << "\n grandeur (defaut DEF_PRINCIPALES) ? ";
              dan.Quelc() = lect_return_defaut(false,"DEF_PRINCIPALES");
              cout << " lu: "<< dan.Quelc().NomPlein();
              cout << "\n reference de l'element (defaut E_1) ? ";
              dan.Ref_NE() = lect_return_defaut(false,"E_1");
              cout << " val lue: "<< dan.Ref_NE();
              dan.Nom_var() = Lect_interactive_nom_var();
              cout << "\n le num d'ordre (ex: num de la composante, defaut 1) ?";
              dan.Num_ordre() = ChangeEntier(lect_return_defaut(false,"1"));
              cout << " val lue: "<<dan.Num_ordre();
              cout << "\n le numero du point d'integration (defaut: 1) ? ";
              dan.NBpti() = ChangeEntier(lect_return_defaut(false,"1"));
              cout << "\n en absolu (defaut rep 1) ou en local (rep 0) ? ";
              dan.Absolue() = ChangeEntier(lect_return_defaut(false,"1"));
              // on a toutes les infos, on peut enregistrer
              sort << dan << flush;
              list_element_type_evoluee.push_back(dan);
             }
          else if (rep == "elF")
            { // cas d'une grandeur quelconque à un pti de face d'élément
              TypeQuelc_face_a_un_element dan;
              cout << "\n nom du maillage (defaut aucun) ? ";
              dan.Nom_mail() = lect_return_defaut(false,"aucun");
              cout << " val lue: "<< dan.Nom_mail();
              if (dan.Nom_mail() == "aucun")
               {dan.Nom_mail() = "";}
              cout << "\n grandeur (defaut NN_SURF_t0) ? ";
              dan.Quelc() = lect_return_defaut(false,"NN_SURF_t0");
              cout << " lu: "<< dan.Quelc().NomPlein();
              cout << "\n numero de la face relativement a l'element (defaut 1) ? ";
              dan.Num_FA() = ChangeEntier(lect_return_defaut(false,"1"));
              cout << " val lue: "<< dan.Num_FA();
              cout << "\n reference de l'element (defaut E_1) ? ";
              dan.Ref_NE() = lect_return_defaut(false,"E_1");
              cout << " val lue: "<< dan.Ref_NE();
              dan.Nom_var() = Lect_interactive_nom_var();
              cout << "\n le num d'ordre (ex: num de la composante, defaut 1) ?";
              dan.Num_ordre() = ChangeEntier(lect_return_defaut(false,"1"));
              cout << " val lue: "<<dan.Num_ordre();
              cout << "\n le numero du pti de la face (defaut: 1) ? ";
              dan.NBpti() = ChangeEntier(lect_return_defaut(false,"1"));
              cout << "\n en absolu (defaut rep 1) ou en local (rep 0) ? ";
              dan.Absolue() = ChangeEntier(lect_return_defaut(false,"1"));
              // on a toutes les infos, on peut enregistrer
              sort << dan << flush;
              list_face_element_type_quelc.push_back(dan);
             }
          else if (rep == "elA")
            { // cas d'une grandeur quelconque à un pti d'arête d'élément
              TypeQuelc_arete_a_un_element dan;
              cout << "\n nom du maillage (defaut aucun) ? ";
              dan.Nom_mail() = lect_return_defaut(false,"aucun");
              cout << " val lue: "<< dan.Nom_mail();
              if (dan.Nom_mail() == "aucun")
               {dan.Nom_mail() = "";}
              cout << "\n grandeur (defaut POSITION_GEOMETRIQUE) ? ";
              dan.Quelc() = lect_return_defaut(false,"POSITION_GEOMETRIQUE");
              cout << " lu: "<< dan.Quelc().NomPlein();
              cout << "\n numero de l'arete relativement a l'element (defaut 1) ? ";
              dan.Num_FA() = ChangeEntier(lect_return_defaut(false,"1"));
              cout << " val lue: "<< dan.Num_FA();
              cout << "\n reference de l'element (defaut E_1) ? ";
              dan.Ref_NE() = lect_return_defaut(false,"E_1");
              cout << " val lue: "<< dan.Ref_NE();
              dan.Nom_var() = Lect_interactive_nom_var();
              cout << "\n le num d'ordre (ex: num de la composante, defaut 1) ?";
              dan.Num_ordre() = ChangeEntier(lect_return_defaut(false,"1"));
              cout << " val lue: "<<dan.Num_ordre();
              cout << "\n le numero du pti de la face (defaut: 1) ? ";
              dan.NBpti() = ChangeEntier(lect_return_defaut(false,"1"));
              cout << "\n en absolu (defaut rep 1) ou en local (rep 0) ? ";
              dan.Absolue() = ChangeEntier(lect_return_defaut(false,"1"));
              // on a toutes les infos, on peut enregistrer
              sort << dan << flush;
              list_arete_element_type_quelc.push_back(dan);
             }
          else if (rep == "cgl")
            { // cas d'une composante d'une variable globale de type multidimentionnel
              TypeQuelc_Une_composante_Grandeur_globale dan;
              cout << "\n grandeur globale (defaut statistique_N_tout_ddl_etendu_X1) ? ";
              dan.Nom_grandeur_globale() = lect_return_defaut(false,"statistique_N_tout_ddl_etendu_X1");
              cout << " lu: "<< dan.Nom_grandeur_globale();

              dan.Nom_var() = Lect_interactive_nom_var_relais();
              cout << "\n le num de la composante ( defaut 1) ?";
              dan.Indice() = ChangeEntier(lect_return_defaut(false,"1"));
              cout << " val lue: "<<dan.Indice();
              // on a toutes les infos, on peut enregistrer
              sort << dan << flush;
              list_var_glob_sur_grandeur_globale.push_back(dan);
             }


           else if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f"))
              {choix_valide = true;}
           else
             {if (ParaGlob::Francais()) {cout << "\n choix non valide, recommencez !";}
              else {cout << "\n the choice is not valide, starts again ! ";};
              choix_valide = false;
             };
         };
      sort << "\n fin_Variables_utilisateurs_  \n" << flush;
     };
  }
 catch (ErrSortieFinale)
      // cas d'une direction voulue vers la sortie
      // on relance l'interuption pour le niveau supérieur
    { ErrSortieFinale toto;
      throw (toto);
    }
 catch (...)
  {cout << "\n *** erreur en definition des Variables utilisateurs ! stop " << flush;
   Sortie(1);
  };
 
 };

// lecture de constantes globales définies par l'utilisateur
// ramène la liste des constantes sous la forme de conteneur de type quelconque
// et la liste de leurs noms
// NB: la liste est tout d'abord vidée avant d'être éventuellement remplie
void VariablesExporter::LecConstantesUtilisateur(UtilLecture& lec)
   { // on initialise à liste
     li_Q.clear();li_nom.clear();
     // on regarde s'il y a des constantes à lire
     if (strstr(lec.tablcar,"Constantes_utilisateurs_")!=NULL)
         { lec.NouvelleDonnee(); // on se positionne sur le premier enreg
           // on lit tant que l'on ne rencontre pas la ligne contenant "fin_Constantes_utilisateurs_"
           while (strstr(lec.tablcar,"fin_Constantes_utilisateurs_")==0)
            {// lecture d'un mot clé
             string nom;
             *(lec.entree) >> nom;
        
             if ((lec.entree)->rdstate() == 0)
                {} // lecture normale
             #ifdef ENLINUX
             else  if ((lec.entree)->fail())
              // on a atteind la fin de la ligne et on appelle un nouvel enregistrement
               {   lec.NouvelleDonnee();  // lecture d'un nouvelle enregistrement
                   *(lec.entree) >> nom;
               }
             #else
             else  if ((lec.entree)->eof())
               // la lecture est bonne mais on a atteind la fin de la ligne
               { if(nom != "fin_Constantes_utilisateurs_")
                   {lec.NouvelleDonnee(); *(lec.entree) >> nom;};
               }
             #endif
             else // cas d'une erreur de lecture
              { cout << "\n erreur de lecture inconnue  ";
                lec.MessageBuffer("** erreur en lecture des constantes utilisateur **");
                throw (UtilLecture::ErrNouvelleDonnee(-1));
                Sortie(1);
              };
        
             // en fonction du type de donnée on lit, crée et stock
             if (nom == "double_")
              { string nom_constante; double val=0.;
                *(lec.entree) >> nom_constante >> val;
                // il faut que les 3 premiers caractères de nom_constante soit un C__
                if (!((nom_constante[0]== 'C')&&(nom_constante[1]== '_')&&(nom_constante[2]== '_')))
                 { cout << "\n erreur de syntaxe en lecture d'une constante de type double, les 3 premieres lettres "
                        << " devraientt etre un 'C__' et on a lu: "<<nom_constante << " !!"
                        << endl;
                   Sortie(1);
                 }
                else // sinon c'est ok
                 {// on crée le conteneur
                  Grandeur_scalaire_double grand_courant(val);
                  TypeQuelconque typQ1(GENERIQUE_UNE_CONSTANTE_GLOB_DOUBLE_UTILISATEUR,NU_DDL,grand_courant);
                  // stockage
                  li_Q.push_back(typQ1); li_nom.push_back(nom_constante);
                 };
              }
//             else if (nom == "int_")
//              { string nom_constante; int val;
//                *(lec.entree) >> nom_constante >> val;
//                // il faut que le premier caractère de nom_constante soit un $
//                if (nom_constante[0]!= '$')
//                 { cout << "\n erreur de syntaxe en lecture d'une constante de type int, la premiere lettre "
//                        << " devrait etre un '$' et on a lu: "<<nom_constante[0] << " !!"
//                        << endl;
//                   Sortie(1);
//                 }
//                else // sinon c'est ok
//                 {// on crée le conteneur
//                  Grandeur_scalaire_entier grand_courant(val);
//                  TypeQuelconque typQ1(GENERIQUE_UNE_CONSTANTE_GLOB_INT_UTILISATEUR,NU_DDL,grand_courant);
//                  // stockage
//                  li_Q.push_back(typQ1); li_nom.push_back(nom_constante);
//                 };
//              }
             else if(nom != "fin_Constantes_utilisateurs_")
              {cout << "\n erreur de lecture du type de constante  "
                    << " on a lu " << nom << ", type qui n'est pas etre pris en compte...";
               if (ParaGlob::NiveauImpression()>3)
                  cout << "\n Projet::LecConstantesUtilisateur(... " << endl ;
               throw (UtilLecture::ErrNouvelleDonnee(-1));
               Sortie(1);
              };
        
            }; //-- fin du while
           lec.NouvelleDonnee(); // on prépare la nouvelle lecture
         };
    };

// lecture éventuelle des variables globales définies par l'utilisateur
void VariablesExporter::LecVariablesUtilisateur(UtilLecture& lec)
   { // on initialise les conteneurs
     // -> noeuds
     list_noeud_type_ddl.clear();
     list_noeud_type_ddlEtendu.clear();
     list_noeud_type_quelconque.clear();

     // -> éléments
     list_element_type_ddl.clear();
     list_element_type_particulier.clear();
     list_element_type_evoluee.clear();

     // -> face d'éléments
     list_face_element_type_quelc.clear();

     // -> arête d'éléments
     list_arete_element_type_quelc.clear();

     // on regarde s'il y a des variables à lire
     if (strstr(lec.tablcar,"Variables_utilisateurs_")!=NULL)
         { lec.NouvelleDonnee(); // on se positionne sur le premier enreg
           // on lit tant que l'on ne rencontre pas la ligne contenant "fin_Variables_utilisateurs_"
           while (strstr(lec.tablcar,"fin_Variables_utilisateurs_")==0)
            {// choix en fonction du type de variable
            
             string nom;
        
             if ((lec.entree)->rdstate() == 0)
                {} // lecture normale
             #ifdef ENLINUX
             else  if ((lec.entree)->fail())
              // on a atteind la fin de la ligne et on appelle un nouvel enregistrement
               {   lec.NouvelleDonnee();  // lecture d'un nouvelle enregistrement
                   *(lec.entree) >> nom;
               }
             #else
             else  if ((lec.entree)->eof())
               // la lecture est bonne mais on a atteind la fin de la ligne
               { if(nom != "fin_Variables_utilisateurs_")
                   {lec.NouvelleDonnee(); };
               }
             #endif
             else // cas d'une erreur de lecture
              { cout << "\n erreur de lecture inconnue  ";
                lec.MessageBuffer("** erreur en lecture des constantes utilisateur **");
                throw (UtilLecture::ErrNouvelleDonnee(-1));
                Sortie(1);
              };
        
             // en fonction du type de donnée on lit, crée et stock
             if (strstr(lec.tablcar,"Ddl_noeud_") != 0)
              { Ddl_a_un_noeud dan;
                *(lec.entree) >> dan;
                // on vérifie que la variable lue n'existe pas déjà
                VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
                // stockage
                list_noeud_type_ddl.push_back(dan);
               }
             else if (strstr(lec.tablcar,"Ddl_etendu_a_un_noeud_") != 0)
              { Ddl_etendu_a_un_noeud dan;
                *(lec.entree) >> dan;
                // on vérifie que la variable lue n'existe pas déjà
                VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
                // stockage
                list_noeud_type_ddlEtendu.push_back(dan);
               }
             else if (strstr(lec.tablcar,"Quelconque_a_un_noeud_") != 0)
              { Quelconque_a_un_noeud dan;
                *(lec.entree) >> dan;
                // on vérifie que la variable lue n'existe pas déjà
                VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
                // stockage
                list_noeud_type_quelconque.push_back(dan);
               }
             else if (strstr(lec.tablcar,"Ddl_a_un_element_") != 0)
              { Ddl_a_un_element dan;
                *(lec.entree) >> dan;
                // on vérifie que la variable lue n'existe pas déjà
                VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
                // stockage
                list_element_type_ddl.push_back(dan);
               }
             else if (strstr(lec.tablcar,"Particulier_a_un_element_") != 0)
              { TypeParticulier_a_un_element dan;
                *(lec.entree) >> dan;
                // on vérifie que la variable lue n'existe pas déjà
                VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
                // stockage
                list_element_type_particulier.push_back(dan);
               }
             else if (strstr(lec.tablcar,"Evoluee_a_un_element_") != 0)
              { TypeEvoluee_a_un_element dan;
                *(lec.entree) >> dan;
                // on vérifie que la variable lue n'existe pas déjà
                VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
                // stockage
                list_element_type_evoluee.push_back(dan);
               }
             else if (strstr(lec.tablcar,"Quelconque_face_element_") != 0)
              { TypeQuelc_face_a_un_element dan;
                *(lec.entree) >> dan;
                // on vérifie que la variable lue n'existe pas déjà
                VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
                // stockage
                list_face_element_type_quelc.push_back(dan);
               }
             else if (strstr(lec.tablcar,"Quelconque_arete_element_") != 0)
              { TypeQuelc_arete_a_un_element dan;
                *(lec.entree) >> dan;
                // on vérifie que la variable lue n'existe pas déjà
                VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
                // stockage
                list_arete_element_type_quelc.push_back(dan);
               }
             else if (strstr(lec.tablcar,"Une_composante_Grandeur_globale_") != 0)
              { TypeQuelc_Une_composante_Grandeur_globale dan;
                *(lec.entree) >> dan;
                // on vérifie que la variable lue n'existe pas déjà
                VariablesExporter::VerifNomVariable(dan.Nom_var(),true);
                // stockage
                list_var_glob_sur_grandeur_globale.push_back(dan);
               }

             else if( strstr(lec.tablcar,"fin_Variables_utilisateurs_")
                     && strstr(lec.tablcar,"Quelconque_arete_element_")
                     && strstr(lec.tablcar,"Quelconque_face_element_")
                     && strstr(lec.tablcar,"Evoluee_a_un_element_")
                     && strstr(lec.tablcar,"Particulier_a_un_element_")
                     && strstr(lec.tablcar,"Ddl_a_un_element_")
                     && strstr(lec.tablcar,"Quelconque_a_un_noeud_")
                     && strstr(lec.tablcar,"Ddl_etendu_a_un_noeud_")
                     && strstr(lec.tablcar,"Ddl_noeud_")
                     && strstr(lec.tablcar,"Une_composante_Grandeur_globale_")
                    )
              {cout << "\n erreur de lecture du type de variable  "
                    << " on a lu " << nom << ", type qui n'est pas etre pris en compte...";
               if (ParaGlob::NiveauImpression()>3)
                  cout << "\n Projet::LecVariablesUtilisateur(... " << endl ;
               throw (UtilLecture::ErrNouvelleDonnee(-1));
               Sortie(1);
              };
        
            }; //-- fin du while
           lec.NouvelleDonnee(); // on prépare la nouvelle lecture
         };
    };

// insertion des constantes utilisateur dans les variables globales
void VariablesExporter::InsertConstUtilisateur_dans_globale()
   { // on passe en revue tous les éléments de la liste
     list<TypeQuelconque>::iterator il,ilfin = li_Q.end();
     list<string>::const_iterator inom= li_nom.begin();
     for (il = li_Q.begin();il != ilfin;il++,inom++)
      { // on regarde si la grandeur n'existe pas déjà: si oui on couine
        const void* pointe =  (ParaGlob::param->GrandeurGlobal(*inom));
        if (pointe != NULL)
          {TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
           cout << "\n warning  *** la constante globale  "<< (*inom)
                 << " a deja ete definie ! =>  " << (*(gr_quelc->Grandeur_pointee()));
           cout << "\n on remplace par sa nouvelle valeur: => " << (*((*il).Grandeur_pointee()));
           ParaGlob::param->Suppression_grandeur_consultable(*inom); // suppression
           // puis on ajoute
           ParaGlob::param->Ajout_grandeur_consultable(&(*il),*inom);
          }
        else // sinon on ajoute simplement
          {ParaGlob::param->Ajout_grandeur_consultable(&(*il),*inom);};
      };
   };

// vérification que 2 nom de variables ne soient pas identique
// si avec_sortie = true -> arrêt
// si avec_sortie = false -> retour du test: true si c'est ok
//                           false si pb
bool VariablesExporter::VerifNomVariable(const string& nom,bool avec_sortie) const
 { // -- cas des ddl aux noeuds ---
   { List_io < Ddl_a_un_noeud >::const_iterator it, itfin = list_noeud_type_ddl.end();
     for (it = list_noeud_type_ddl.begin();it != itfin; it++)
     if ((*it).Nom_var_const() == nom)
       { cout << "\n *** erreur en lecture d'une variable utilisateur: Ddl_a_un_noeud  "
              << " on a deja lue une variable de meme nom = "<< nom ;
         if (avec_sortie)
             {Sortie(1);}
         else {return false;};
       };
   };
  // -- cas des ddl étendu aux noeuds ---
  { List_io < Ddl_etendu_a_un_noeud >::const_iterator it, itfin = list_noeud_type_ddlEtendu.end();
    for (it = list_noeud_type_ddlEtendu.begin();it != itfin; it++)
    if ((*it).Nom_var_const() == nom)
      { cout << "\n *** erreur en lecture d'une variable utilisateur: Ddl_etendu_a_un_noeud  "
             << " on a deja lue une variable de meme nom = "<< nom ;
        if (avec_sortie)
            {Sortie(1);}
        else {return false;};
      };
  };
  // -- cas des grandeurs quelconques aux noeuds ---
  { List_io < Quelconque_a_un_noeud >::const_iterator it, itfin = list_noeud_type_quelconque.end();
    for (it = list_noeud_type_quelconque.begin();it != itfin; it++)
    if ((*it).Nom_var_const() == nom)
      { cout << "\n *** erreur en lecture d'une variable utilisateur: Quelconque_a_un_noeud  "
             << " on a deja lue une variable de meme nom = "<< nom ;
        if (avec_sortie)
            {Sortie(1);}
        else {return false;};
      };
  };
  // -- cas des ddl aux pti d'éléments ---
  { List_io < Ddl_a_un_element >::const_iterator it, itfin = list_element_type_ddl.end();
    for (it = list_element_type_ddl.begin();it != itfin; it++)
    if ((*it).Nom_var_const() == nom)
      { cout << "\n *** erreur en lecture d'une variable utilisateur: Ddl_a_un_element  "
             << " on a deja lue une variable de meme nom = "<< nom ;
        if (avec_sortie)
            {Sortie(1);}
        else {return false;};
      };
  };
  // -- cas des grandeurs particulières aux pti d'éléments ---
  { List_io < TypeParticulier_a_un_element >::const_iterator it, itfin = list_element_type_particulier.end();
    for (it = list_element_type_particulier.begin();it != itfin; it++)
    if ((*it).Nom_var_const() == nom)
      { cout << "\n *** erreur en lecture d'une variable utilisateur: TypeParticulier_a_un_element  "
             << " on a deja lue une variable de meme nom = "<< nom ;
        if (avec_sortie)
            {Sortie(1);}
        else {return false;};
      };
  };
  // -- cas des grandeurs évoluées aux pti d'éléments ---
  { List_io < TypeEvoluee_a_un_element >::const_iterator it, itfin = list_element_type_evoluee.end();
    for (it = list_element_type_evoluee.begin();it != itfin; it++)
    if ((*it).Nom_var_const() == nom)
      { cout << "\n *** erreur en lecture d'une variable utilisateur: TypeEvoluee_a_un_element  "
             << " on a deja lue une variable de meme nom = "<< nom ;
        if (avec_sortie)
            {Sortie(1);}
        else {return false;};
      };
  };
  // -- cas des grandeurs quelconques aux pti de faces d'éléments ---
  { List_io < TypeQuelc_face_a_un_element >::const_iterator it, itfin = list_face_element_type_quelc.end();
    for (it = list_face_element_type_quelc.begin();it != itfin; it++)
    if ((*it).Nom_var_const() == nom)
      { cout << "\n *** erreur en lecture d'une variable utilisateur: Quelconque_face_element_  "
             << " on a deja lue une variable de meme nom = "<< nom ;
        if (avec_sortie)
            {Sortie(1);}
        else {return false;};
      };
  };
  // -- cas des grandeurs quelconques aux pti d'arête d'éléments ---
  { List_io < TypeQuelc_arete_a_un_element >::const_iterator it, itfin = list_arete_element_type_quelc.end();
    for (it = list_arete_element_type_quelc.begin();it != itfin; it++)
    if ((*it).Nom_var_const() == nom)
      { cout << "\n *** erreur en lecture d'une variable utilisateur: Quelconque_arete_element_  "
             << " on a deja lue une variable de meme nom = "<< nom ;
        if (avec_sortie)
            {Sortie(1);}
        else {return false;};
      };
  };
  // -- cas d'une composante d'une variable globale de type multidimentionnel---
  { List_io < TypeQuelc_Une_composante_Grandeur_globale >::const_iterator it, itfin = list_var_glob_sur_grandeur_globale.end();
    for (it = list_var_glob_sur_grandeur_globale.begin();it != itfin; it++)
    if ((*it).Nom_var_const() == nom)
      { cout << "\n *** erreur en lecture d'une variable utilisateur: Une_composante_Grandeur_globale_  "
             << " on a deja lue une variable de meme nom = "<< nom ;
        if (avec_sortie)
            {Sortie(1);}
        else {return false;};
      };
  };

  // arrivée ici, cela veut dire que tout est ok
  return true;

 };

// lecture interactive du nom de la variable: hors variable relais
string VariablesExporter::Lect_interactive_nom_var()
 {  string no_user("");
    while(no_user.length()==0)
      { cout << "\n nom_utilisateur de la grandeur ? ";
        no_user = lect_return_defaut(false,"");
        if (no_user.length()==0)
          {cout << "\n vous devez donner un nom !! ";}
        else
         {// on complète éventuellement
          if (!((no_user[0]== 'V')&&(no_user[1]== '_')&&(no_user[2]== '_')))
             no_user = "V__" + no_user;
          // on teste s'il y en a deux identiques
          if (!VerifNomVariable(no_user,false))
            { cout << "\n ce nom de variable existe deja ! donner un autre ";
               no_user = "";
            };
         };
      };
  cout << " nom lu: "<< no_user;
  return no_user;
};

// lecture interactive du nom d'une variable relais
string VariablesExporter::Lect_interactive_nom_var_relais()
 {  string no_user("");
    while(no_user.length()==0)
      { cout << "\n nom_utilisateur de la grandeur ? ";
        no_user = lect_return_defaut(false,"");
        if (no_user.length()==0)
          {cout << "\n vous devez donner un nom !! ";}
        else
         {// on complète éventuellement
          if (!((no_user[0]== 'V')&&(no_user[1]== 'R') &&(no_user[2]== '_')))
             no_user = "VR_" + no_user;
          // on teste s'il y en a deux identiques
          if (!VerifNomVariable(no_user,false))
            { cout << "\n ce nom de variable existe deja ! donner un autre ";
               no_user = "";
            };
         };
      };
  cout << " nom lu: "<< no_user;
  return no_user;
};


    
// insertion d'une composante d'une grandeur quelconque en globale
// sous forme d'un double
void VariablesExporter::InsertCompGrandeurQuelc
              (const string& non_var,const TypeQuelconque_enum_etendu& enu)
  {// on crée un conteneur d'un double
   double val=0;
   Grandeur_scalaire_double grand_courant(val);
   // on récupère le temps
   EnumTypeQuelconque eTQ = enu.EnumTQ();
   Enum_dure temps = EnumTypeQuelconqueTemps(eTQ);
   
   switch (temps)
    {case TEMPS_0 :
       {TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_0,NU_DDL,grand_courant);
        ParaGlob::param->Ajout_grandeur_consultable(&typQ1,non_var);
        break;
       }
     case TEMPS_t :
      {TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_T,NU_DDL,grand_courant);
       ParaGlob::param->Ajout_grandeur_consultable(&typQ1,non_var);
       break;
      }
     case TEMPS_tdt :
         {TypeQuelconque typQ1(GENERIQUE_UNE_VARIABLE_GLOB_DOUBLE_UTILISATEUR_TDT,NU_DDL,grand_courant);
          ParaGlob::param->Ajout_grandeur_consultable(&typQ1,non_var);
          break;
         }
     default :
      cout << "\nErreur : valeur incorrecte du temps pour une variable ddl globale !\n";
      cout << "\n VariablesExporter::InsertCompGrandeurQuelc(... \n";
      Sortie(1);
    };
  };