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

#include "Fonction_nD.h"
#include <stdarg.h>     /* va_list, va_start, va_copy, va_arg, va_end */
#include "Enum_ddl.h"
#include "NevezTenseur.h"
#include "TypeQuelconqueParticulier.h"

// les différentes fonctions existantes
#include "F_nD_courbe1D.h"
#include "Fonc_scal_combinees_nD.h"
#include "Fonction_expression_litterale_nD.h"
#include "Fonction_externe_nD.h"
#include "MotCle.h"

// CONSTRUCTEURS :
// par défaut
Fonction_nD::Fonction_nD(string nom, EnumFonction_nD typ)
      : nom_variables(),t_inter_double()
      ,enu_variables_globale(),nom_ref(nom),typeFonction(typ)
      ,nom_variables_globales()
      ,tab_enu_etendu(),tab_enu_quelconque()
      ,equivalence_nom_enu_etendu_et_enu_quelconque(false)
      ,index_enu_etendu(),index_enu_quelconque()
      ,x_x_i(),x_glob(),xinter(NULL)
      ,depend_M(0),depend_Mt(0),depend_M0(0),depend_temps(0),permet_affichage(0)
      //------ grandeurs évoluées -------
      ,type_des_variables(),val_ddl_enum(),li_enu_etendu_scalaire()
      ,coor_ddl_enum(),num_dans_coor(),premier_famille_Coord()
      ,tens_ddl_enum(),ind_tens(),premier_famille_tenseur(),absolue(false)
      ,li_equi_Quel_evolue(),tab_equi_Coor(),tab_equi_tens()
      ,posi_ddl_enum(),tailles_tab()
      { // Contruction des index pour les grandeurs évoluées, ainsi que les conteneurs
// non car au début il n'y a rien comme variable !!
//        Fonction_nD::Construction_index_conteneurs_evoluees();
      };

// constructeur avec plus d'info
// dans le cas ou les variables sont associées à des types quelconques, par défaut on considère qu'il
// s'agit de conteneur d'un scalaire simple. Dans le cas contraire il faut utiliser
// Preparation_Grandeur_quelconque( pour spécifier les tailles réelles
Fonction_nD::Fonction_nD(const Tableau <string >& var, string nom, EnumFonction_nD typ )
      : nom_variables(var),t_inter_double(var.Taille())
      ,enu_variables_globale(),nom_ref(nom),typeFonction(typ)
      ,nom_variables_globales()
      ,tab_enu_etendu(),tab_enu_quelconque()
      ,equivalence_nom_enu_etendu_et_enu_quelconque(false)
      ,index_enu_etendu(),index_enu_quelconque()
      ,x_x_i(),x_glob(),xinter(NULL)
      ,depend_M(0),depend_Mt(0),depend_M0(0),depend_temps(0),permet_affichage(0)
      //------ grandeurs évoluées -------
      ,type_des_variables(),val_ddl_enum(),li_enu_etendu_scalaire()
      ,coor_ddl_enum(),num_dans_coor(),premier_famille_Coord()
      ,tens_ddl_enum(),ind_tens(),premier_famille_tenseur(),absolue(false)
      ,li_equi_Quel_evolue(),tab_equi_Coor(),tab_equi_tens()
      ,posi_ddl_enum(),tailles_tab()
      {// comme on a le tableau de variables, on tente une équivalence éventuelle
//       Fonction_nD::Construction_enu_etendu_et_quelconque();
       // Contruction des index pour les grandeurs évoluées, ainsi que les conteneurs
       Fonction_nD::Construction_index_conteneurs_evoluees();
      };

// def de tous les paramètres: utile pour être appelé par les classes dérivées
Fonction_nD::Fonction_nD
          ( string nom_ref_  // nom de ref de la fonction
           ,Tableau <string >& nom_variables_non_globales // les variables non globales
           ,Tableau <Enum_GrandeurGlobale >& enu_variables_globale_ // enu globaux
           ,Tableau <string >& nom_variables_globales_ // idem sous forme de strings
           ,EnumFonction_nD typ ) // le type de fonction
      : nom_variables(nom_variables_non_globales),t_inter_double(nom_variables_non_globales.Taille())
      ,enu_variables_globale(enu_variables_globale_),nom_ref(nom_ref_),typeFonction(typ)
      ,nom_variables_globales(nom_variables_globales_)
      ,tab_enu_etendu(),tab_enu_quelconque()
      ,equivalence_nom_enu_etendu_et_enu_quelconque(false)
      ,index_enu_etendu(),index_enu_quelconque()
      ,x_x_i(),x_glob(),xinter(NULL)
      ,depend_M(0),depend_Mt(0),depend_M0(0),depend_temps(0),permet_affichage(0)
      //------ grandeurs évoluées -------
      ,type_des_variables(),val_ddl_enum(),li_enu_etendu_scalaire()
      ,coor_ddl_enum(),num_dans_coor(),premier_famille_Coord()
      ,tens_ddl_enum(),ind_tens(),premier_famille_tenseur(),absolue(false)
      ,li_equi_Quel_evolue(),tab_equi_Coor(),tab_equi_tens()
      ,posi_ddl_enum(),tailles_tab()
      {// comme on a le tableau de variables, on tente une équivalence éventuelle
//       Fonction_nD::Construction_enu_etendu_et_quelconque();
       // Contruction des index pour les grandeurs évoluées, ainsi que les conteneurs
       Fonction_nD::Construction_index_conteneurs_evoluees();
      };


// de copie
Fonction_nD::Fonction_nD(const Fonction_nD& Co) :
   nom_variables(Co.nom_variables),t_inter_double(Co.t_inter_double)
   ,enu_variables_globale(Co.enu_variables_globale)
   ,nom_variables_globales(Co.nom_variables_globales)
   ,nom_ref(Co.nom_ref),typeFonction(Co.typeFonction)
   ,tab_enu_etendu(Co.tab_enu_etendu),tab_enu_quelconque(Co.tab_enu_quelconque)
   ,equivalence_nom_enu_etendu_et_enu_quelconque(Co.equivalence_nom_enu_etendu_et_enu_quelconque)
   ,index_enu_etendu(Co.index_enu_etendu),index_enu_quelconque(Co.index_enu_quelconque)
   ,x_x_i(Co.x_x_i),x_glob(Co.x_glob),xinter(NULL)
   ,depend_M(Co.depend_M),depend_Mt(Co.depend_Mt),depend_M0(Co.depend_M0)
   ,depend_temps(Co.depend_temps)
   //------ grandeurs évoluées -------
   ,type_des_variables(Co.type_des_variables),val_ddl_enum(Co.val_ddl_enum)
   ,li_enu_etendu_scalaire() // reconstruit avec les index
   ,coor_ddl_enum(Co.coor_ddl_enum),num_dans_coor(Co.num_dans_coor)
   ,premier_famille_Coord(Co.premier_famille_Coord)
   ,tens_ddl_enum(Co.tens_ddl_enum),ind_tens(Co.ind_tens)
   ,premier_famille_tenseur(Co.premier_famille_tenseur)
   ,absolue(Co.absolue)
   ,li_equi_Quel_evolue(),tab_equi_Coor(),tab_equi_tens() // est reconstruit ensuite
   ,posi_ddl_enum(Co.posi_ddl_enum),tailles_tab(Co.tailles_tab)
   ,permet_affichage(Co.permet_affichage)
     {if (Co.xinter != NULL)
       xinter = new Tableau <double >(*(Co.xinter));
      // comme on a le tableau de variables, on tente une équivalence éventuelle
//      Fonction_nD::Construction_enu_etendu_et_quelconque();
      // Contruction des index pour les grandeurs évoluées, ainsi que les conteneurs
      Fonction_nD::Construction_index_conteneurs_evoluees();
     };



 // DESTRUCTEUR :
 Fonction_nD::~Fonction_nD()
   {if (xinter != NULL)
      delete xinter;
    if (tens_ddl_enum.Taille() != 0)
     {int taille = tens_ddl_enum.Taille();
      for (int i=1; i<= taille; i++)
       if (tens_ddl_enum(i) != NULL)
        delete tens_ddl_enum(i);
     };
   };


    // METHODES PUBLIQUES :
    
    // ---------- non virtuelle ---------
 
 
//// complète les tableaux internes en fonction de la taille des conteneurs
//// associés aux types quelconques éventuelles
//// *** doit -être appelée s'il y a des grandeurs quelconque dont les conteneurs
//// sont associés à plusieurs scalaires
//void Fonction_nD::Preparation_Grandeur_quelconque(const Tableau <TypeQuelconque >& tqi)
// {// on parcourt la liste des enumérés de grandeurs quelconque
//  int tail = tab_enu_quelconque.Taille();
//  if (tqi.Taille() != tail)
//   { cout << "\n *** pb dans Fonction_nD::Preparation_Grandeur_quelconque( "
//          << " le tableau en parametre " << tqi.Taille()
//          << " n'a pas la meme taille que le nombre de grandeur quelconque  enregistrees "
//          << tail
//          << " on ne peut pas continuer  " <<endl;
//         Sortie(1);
//   };
//  // --- l'objectif est de dimensionner correctement le tableau de passage de réelles
//  //   x_x_i
//  int nb_scalaire_type_quelconque = 0; // init
//  for (int i=1;i<= tail; i++)
//   {nb_scalaire_type_quelconque += tqi(i).NbMaxiNumeroOrdre();
//    #ifdef MISE_AU_POINT
//    if ((tqi)(i).EnuTypeQuelconque() != tab_enu_quelconque(i))
//      { cout << "\n *** pb dans la preparation de l'utilisation de type quelconque "
//             << "  au niveau des parametres d'appel "
//             << "  la grandeur quelconque "<< i<< "correspondante a "
//             << NomTypeQuelconque((tqi)(i).EnuTypeQuelconque())
//             << " est differente de celle deja enregistree "
//             << NomTypeQuelconque(tab_enu_quelconque(i))
//             << " ce n'est pas normal !! ,  on arrete le calcul   "
//             << "\n Fonction_nD::Preparation_Grandeur_quelconque(..."<<endl;
//        Sortie(1);
//      };
//    #endif
//   };
//  // on dimensionne le tableau de passage
//  // chaque ddl est associé à un seul scalaire
//  x_x_i.Change_taille(nb_scalaire_type_quelconque+tab_enu_etendu.Taille());
// };



// calcul équivalent, mais pour des paramètres de type ddl enum étendu et/ou type quelconque
// pour que l'appel à cette méthode soit correcte, il faut que la dimension de t_enu + celle de tqi
// soit identique à celle du tableau Nom_variables() : en fait t_enu et tqi doivent représenter les variables
Tableau <double> & Fonction_nD::Valeur_FnD(Tableau <Ddl_etendu> * t_enu,Tableau <const TypeQuelconque * > * t_qi
                                           ,Tableau <int> * t_num_ordre)
  {// on se sert des tableaux d'adressage indirect pour remplir le tableau de passage
      // tab_enu_etendu(i) correspond à nom_variables(index_enu_etendu(i))
    // tab_enu_quelconque(i) correspond à nom_variables(index_enu_quelconque(i))
    // un tableau intermédiaire qui sert pour Valeur(Tableau <Ddl_etendu> ...
//    Tableau <double > x_x_i;
   #ifdef MISE_AU_POINT
   // on vérifie qu'il y a bien équivalence entre les variables
   if (!equivalence_nom_enu_etendu_et_enu_quelconque)
     { cout << "\n *** pb dans les parametres de passage pour l'appel de la fonction nD  "
            << "  les variables de passage ne sont pas tous des ddl etendue ou des grandeurs "
            << "  quelconque scalaire "
            << " ce n'est pas normal !! ,  on arrete le calcul   "
            << "\n Fonction_nD::Valeur(Tableau <Ddl_etendu>..."<<endl;
       Sortie(1);
     };
   
   #endif
 try
  {int tail_tab_enu_etendu = tab_enu_etendu.Taille();
   if (t_enu != NULL)
    {Tableau <Ddl_etendu>& tenu = *t_enu; // pour simplifier l'appel
     for (int i= 1; i<= tail_tab_enu_etendu;i++)
      {x_x_i(index_enu_etendu(i)) = tenu(i).Valeur();
     
      };
    };

   int tail_tab_enu_quelc = tab_enu_quelconque.Taille();
   if (t_qi != NULL)
    {Tableau <const TypeQuelconque * >& tqi = *t_qi; // pour simplifier l'appel
     for (int i= 1; i<= tail_tab_enu_quelc;i++)
      { x_x_i(index_enu_quelconque(i)) = tqi(i)->GrandeurNumOrdre(1);
        #ifdef MISE_AU_POINT
        int nb_scalaire_type_quelconque = tqi(i)->NbMaxiNumeroOrdre();
        if (nb_scalaire_type_quelconque != 1)
          { cout << "\n *** pb dans le nombre de parametre de passage pour l'appel de la fonction nD  "
                 << "  au niveau des parametres d'appel "
                 << "  la grandeur quelconque "<< i<< "correspondante a "
                 << (tqi)(i)->EnuTypeQuelconque().NomPlein()
                 << " n'est pas une grandeur scalaire "
                 << " ce n'est pas normal !! ,  on arrete le calcul   "
                 << "\n Fonction_nD::Valeur(Tableau <Ddl_etendu>..."<<endl;
            Sortie(1);
          };
        #endif
      };
    };
   // on peut maintenant appeler la fonction de base
   // avec que des scalaires
   #ifdef MISE_AU_POINT
   if (permet_affichage > 4)
    {cout << "\n retour fonction: "<<nom_ref<<" : ";
     Tableau <double> & inter = Valeur_FnD_interne(&x_x_i);
     int nb_val = inter.Taille();
     for (int i=1;i<=nb_val;i++)
       cout << " val("<<i<<")= "<<inter(i);
     if (permet_affichage > 5)
      {cout << "\n parametres d'appel: ";
       int nb_var = x_x_i.Taille();
       for (int j=1;j<=nb_var;j++)
         { cout << " para("<<j<<")= "<< x_x_i(j);}
      };
     return inter;
    }
   else
   #endif
   return Valeur_FnD_interne(&x_x_i);
  }
 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 \n Valeur_FnD(..."<<endl;
    this->Affiche();Sortie(1);
  };
 };

// ramène un pointeur sur la fonction correspondant au type de fonction passé en paramètre
Fonction_nD* Fonction_nD::New_Fonction_nD(string& nom,EnumFonction_nD typeFonction)
  {	// définition du pointeur de retour
    Fonction_nD* fonction;
    // choix en fonction du typeCourbe
    switch (typeFonction)
     {
      case FONCTION_EXPRESSION_LITTERALE_nD :
           fonction= new Fonction_expression_litterale_nD(nom); break;
      case FONCTION_COURBE1D : fonction= new F_nD_courbe1D(nom); break;
      case FONC_SCAL_COMBINEES_ND : fonction= new Fonc_scal_combinees_nD(nom); break;
      case FONCTION_EXTERNE_ND : fonction= new Fonction_externe_nD(nom); break;
      default :
          {  cout << "\nErreur : valeur incorrecte du type de Fonction_nD : "
            << typeFonction << "\n";
       cout << "\n New_Fonction_nD(EnumFonction_nD typeFonction) \n";
       Sortie(1);
        }
     };
	   return fonction;
  };
    
// ramène un pointeur sur une courbe copie de celle passée en paramètre
// IMPORTANT : il y a création d'une courbe (utilisation d'un new)
Fonction_nD* Fonction_nD::New_Fonction_nD(const Fonction_nD& Co)
  {	// définition du pointeur de retour
    Fonction_nD* fonction;
    // choix en fonction du typeFonction
    switch (Co.Type_Fonction())
      {
       case FONCTION_EXPRESSION_LITTERALE_nD : fonction= new Fonction_expression_litterale_nD( Co); break;
       case FONCTION_COURBE1D : fonction= new F_nD_courbe1D(Co); break;
       case FONC_SCAL_COMBINEES_ND : fonction= new Fonc_scal_combinees_nD(Co); break;
       case FONCTION_EXTERNE_ND : fonction= new Fonction_externe_nD(Co); break;
       default :
           {  cout << "\nErreur : valeur incorrecte du type de Fonction_nD : "
                   << Co.Type_Fonction() << "\n";
              cout << "\n New_Fonction_nD(const Fonction_nD& Co) \n";
              Sortie(1);
		         }
	     };
	   return fonction;
  };
    
// ramène la liste des identificateurs de courbes actuellement disponibles
list <EnumFonction_nD> Fonction_nD::Liste_Fonction_disponible()
  {	// définition de la liste de retour
    list <EnumFonction_nD> list_ret;
    // remplissage de la liste 
    list_ret.push_back(FONCTION_EXPRESSION_LITTERALE_nD);
    list_ret.push_back(FONCTION_COURBE1D);
    list_ret.push_back(FONC_SCAL_COMBINEES_ND);
    list_ret.push_back(FONCTION_EXTERNE_ND);
    // retour de la liste
	   return list_ret;
  };

 
// mise à jour des variables globales: en fonction de l'apparition de nouvelles variables
// globales en cours de calcul
// méthode interne: qui est utilisé par les fonctions dérivées pour la méthode:
// Mise_a_jour_variables_globales
// retourne false si rien n'a changé
bool Fonction_nD::Mise_a_jour_variables_globales_interne()
{// on passe en revue les variables normales et on regarde s'il s'agit de nouvelles variables globales
 int taille = nom_variables.Taille();
 list <string> li_variable; // liste de travail
 list <string> li_globale;  //   ""
 bool a_changer = false; // a priori rien ne change
 // maintenant on parcours les variables
 for (int i=1;i<=taille;i++)
  {if (ParaGlob::param->GrandeurGlobal(nom_variables(i)) != NULL)
    // il s'agit d'une variable globale
    {// on n'ajoute que si elle n'est pas déjà présente
     std::list <string>::iterator it
         = find (li_globale.begin(), li_globale.end(),nom_variables(i));
     if (it == li_globale.end())
       {li_globale.push_back(nom_variables(i));
       };
     // quelque soit le cas il faut valider
     a_changer=true;
    }
   else // sinon c'est toujours une variable
    li_variable.push_back(nom_variables(i));
  };
 // on met à jour les tableaux
 if (a_changer)
   {// on ajoute maintenant les variables globales déjà existantes
    int taille_globale = nom_variables_globales.Taille();  // Init_from_list
    for (int j=1;j<= taille_globale;j++)
      {// on n'ajoute que si elle n'est pas déjà présente
       list <string>::iterator it
         = find (li_globale.begin(), li_globale.end(),nom_variables_globales(j));
       if (it == li_globale.end())
          {li_globale.push_back(nom_variables_globales(j));}
      };
    // on met à jour les tableaux
    nom_variables.Init_from_list(li_variable);
    t_inter_double.Change_taille(nom_variables.Taille());
    // pour les variables globales on considère les points suivants:
    // leur nombre ne peut pas décroitre
    // l'ordre n'a pas vraiment d'importance
//    int taille_ajout = li_globale.size();
    int taille_finale = li_globale.size();
    if (taille_finale < nom_variables_globales.Taille())
     {cout << "\n erreur changement de taille des variables globales "
           << "\n Fonction_nD::Mise_a_jour_variables_globales_interne() "
           << endl;
      Sortie(1);
     };
    
    nom_variables_globales.Init_from_list(li_globale);

//    int taille_ini = nom_variables_globales.Taille();
//    nom_variables_globales.Change_taille(taille_ini+taille_ajout);
//    nom_variables_globales.Change_taille(taille_finale);
//    list <string>::iterator il,ilfin=li_globale.end();
//    int ip = 1; //taille_ini+1;
//    for (il = li_globale.begin();il != ilfin; il++,ip++)
//      nom_variables_globales(ip) = (*il);
//    nom_variables_globales.Init_from_list(li_globale);
   };
 // on met à jour le tableau d'échange interne : x_glob
 int nb_tot_glob = enu_variables_globale.Taille() + nom_variables_globales.Taille();
 x_glob.Change_taille(nb_tot_glob);
 
 // Contruction des index pour les grandeurs évoluées, ainsi que les conteneurs
 Fonction_nD::Construction_index_conteneurs_evoluees();
 return a_changer;
};
//    Tableau <string > nom_variables; //variables de la fonction, vu de l'extérieur
// 
//    Tableau <Enum_GrandeurGlobale > enu_variables_globale; //tableau des énumérés
//      // de variables globales
//      // éventuellement vide s'il ne sert pas
//    Tableau <string > nom_variables_globales; //tableau des énumérés


// 2) retourne une liste de nom correspondant aux noms de courbes dont dépend *this
list <string>& Fonction_nD::ListDependanceCourbes(list <string>& lico) const
   { // par défaut, ne dépend pas de fonctions, donc on ramène une liste vide
     // ce sera surchargé dans les classes qui elles éventuellement dépendent de quelque chose
     if (lico.size() != 0)
        lico.clear();
     return lico; 
   };

// 3) retourne une liste de nom correspondant aux noms de fonctions dont dépend *this
list <string>& Fonction_nD::ListDependanceFonctions(list <string>& lico) const
   { // par défaut, ne dépend pas de fonctions, donc on ramène une liste vide
     // ce sera surchargé dans les classes qui elles éventuellement dépendent de quelque chose
     if (lico.size() != 0)
        lico.clear();
     return lico; 
   };

    // ---------- METHODES PROTEGEES :-------------------
    
// ramène true si les variables de la classe mère sont complèté
bool Fonction_nD::Complet_var() const
  { bool ret = true;
    if (typeFonction == AUCUNE_FONCTION_nD) ret = false;
    if (nom_ref == "") ret = false;
    return ret;
   };
 
// définit le paramètre depend_M en fonction des nom_variables
// 3 indicateurs permettant de connaître rapidement si
// la fonction dépend de la position d'un point M à tdt, t et t=0
// 0 : la fonction ne dépend pas de la position d'un point M
//  non nul : la fonction dépend de la position d'un point M
// dans ce cas, une au moins un des nom_variables
// a un nom de la même famille que le ddl X1
// et depend_M =  nombre de composantes demandés (ne sert pas vraiment)
// si = -1 : cela signifie que la fonction dépend "que" de M
void Fonction_nD::Definition_depend_M()
 {// on parcours les noms des variables
  int taille = nom_variables.Taille();
  depend_M=0; // init a priori
  depend_Mt=0; // idem à t
  depend_M0 = 0; // idem à 0
  Ddl_enum_etendu d_X1_t = Ddl_enum_etendu(X1,"X1_t");
  Ddl_enum_etendu d_X1_t0 = Ddl_enum_etendu(X1,"X1_t0");
  if (permet_affichage > 6)
    cout << "\n == >>> Fonction_nD::Definition_depend_M ( fct= " << nom_ref << ") ";
  
  list<string> var_X_deja_enreg; // une liste de travail
  list<string> var_independante; // une liste de travail

  for (int i=1; i<= taille; i++)
   {// on ne traite que si la variable n'a pas déjà été traité
    if (find(var_independante.begin(),var_independante.end(),nom_variables(i)) == var_independante.end())
     {var_independante.push_back(nom_variables(i));
      if (ExisteEnum_ddl(nom_variables(i))) // on regarde s'il s'agit d'un ddl patenté
       {if (permet_affichage > 7)
          cout << "\n cas d'un ddl de base: nom_variables("<<i<<") = "<<nom_variables(i);
        if ( Meme_famille(Id_nom_ddl(nom_variables(i)),X1))
         // si c'est de la famille d'X1 c'est ok, on regarde s'il ne s'agit pas d'une variable
         // déjà consultée, car nom_variables peut contenir plusieurs fois la même variable
         {if (find(var_X_deja_enreg.begin(),var_X_deja_enreg.end(),nom_variables(i)) == var_X_deja_enreg.end())
            {depend_M += 1; // ok et la variable n'a pas été encore enregistrée
             if (permet_affichage > 7)
                cout << " depend_M += 1 ";
             var_X_deja_enreg.push_back(nom_variables(i));
            };
         };
       }
      // sinon on regarde s'il s'agit d'un ddl étendu relatif à t = 0 ou t
      else if (Ddl_enum_etendu::VerifExistence(nom_variables(i)))
       { if (permet_affichage > 7)
            cout << "\n cas d'un ddl etendu relatif a t=0 ou t : nom_variables("<<i<<") = "<<nom_variables(i);
         // on a un ddl enum
         Ddl_enum_etendu dd_et = Ddl_enum_etendu::RecupDdl_enum_etendu(nom_variables(i));
         if ( Ddl_enum_etendu::PremierDdlEnumEtenduFamille(dd_et) == d_X1_t)
             // si c'est de la famille d'X1_t c'est ok, on regarde s'il ne s'agit pas d'une variable
             // déjà consultée, car nom_variables peut contenir plusieurs fois la même variable
             {if (find(var_X_deja_enreg.begin(),var_X_deja_enreg.end(),nom_variables(i)) == var_X_deja_enreg.end())
                {depend_Mt += 1;
                 if (permet_affichage > 7)
                    cout << " depend_Mt += 1 ";
                 var_X_deja_enreg.push_back(nom_variables(i)); // on peut utiliser la même liste de travail
                }
             };
         if ( Ddl_enum_etendu::PremierDdlEnumEtenduFamille(dd_et) == d_X1_t0)
             // si c'est de la famille d'X1_t0 c'est ok, on regarde s'il ne s'agit pas d'une variable
             // déjà consultée, car nom_variables peut contenir plusieurs fois la même variable
             {if (find(var_X_deja_enreg.begin(),var_X_deja_enreg.end(),nom_variables(i)) == var_X_deja_enreg.end())
                {depend_M0 += 1;
                 if (permet_affichage > 7)
                    cout << " depend_M0 += 1 ";
                 var_X_deja_enreg.push_back(nom_variables(i)); // on peut utiliser la même liste de travail
                }
             };
       };
     }
   };
  // le nombre de variables indépendantes, car nom_variables peut contenir plusieurs fois la même variable
  int nb_var_inde = var_independante.size();
  if (permet_affichage > 6)
    cout << "\n nb de variables independantes : "<< nb_var_inde << " ";
  
  // maintenant si depend_M est > à la dimension => il n'y a pas qu'une dépendance à M
//  if ((depend_M <= ParaGlob::Dimension()) && (depend_M > 0))
  if ((depend_M <= taille) && (depend_M > 0))
    {// on vérifie que l'on n'a pas utilisé plus de composantes que la dimension
     if (depend_M <= ParaGlob::Dimension())
      {if (depend_M == nb_var_inde)
        depend_M = -1; // cas d'une dépendance stricte à M
      }
     else
      { cout << "\n **** erreur le nombre de composante de dependance a M_tdt "<<taille
              << " est plus grand que la dimension " << ParaGlob::Dimension()
              << " de l'espace !! "
              << "\n Fonction_nD::Definition_depend_M() "
              << endl;
         Sortie(1);
      };
    };
  if ((depend_Mt <= taille) && (depend_Mt > 0))
    {// on vérifie que l'on n'a pas utilisé plus de composantes que la dimension
     if (depend_Mt <= ParaGlob::Dimension())
      {if (depend_Mt == nb_var_inde)
         depend_Mt = -1;// cas d'une dépendance stricte à Mt
      }
     else
      { cout << "\n **** erreur le nombre de composante de dependance a M_t"<<taille
              << " est plus grand que la dimension " << ParaGlob::Dimension()
              << " de l'espace !! "
              << "\n Fonction_nD::Definition_depend_M() "
              << endl;
         Sortie(1);
      };
    };
  if ((depend_M0 <= taille) && (depend_M0 > 0))
    {// on vérifie que l'on n'a pas utilisé plus de composantes que la dimension
     if (depend_M0 <= ParaGlob::Dimension())
      {if (depend_M0 == nb_var_inde)
         depend_M0 = -1; // cas d'une dépendance stricte à M0
      }
     else
      { cout << "\n **** erreur le nombre de composante de dependance a M_t=0 : "<<taille
             << " est plus grand que la dimension " << ParaGlob::Dimension()
             << " de l'espace !! "
             << "\n Fonction_nD::Definition_depend_M() "
             << endl;
        Sortie(1);
      };
    };
  if (permet_affichage > 6)
   {cout << "\n == >>> Fonction_nD::Definition_depend_M : valeur des indicateurs finaux "
         << "\n pour memoire: = 0 -> la fct ne depend pas de la position "
         << " = -1 : la fct depend que de la position "
         << " > 0 : la fct depend de la position mais pas seulement "
         << "\n depend_M = " << depend_M << ",depend_Mt = " << depend_Mt
         << ", depend_M0 = " << depend_M0 << " ";
   };

 };

// définit le paramètre depend_temps en fonction des nom_variables
void Fonction_nD::Definition_depend_temps()
 {// on parcours les identifiants globaux
  int taille = enu_variables_globale.Taille();
  depend_temps=false; // init a priori
  // le temps est une grandeurs globales
  for (int i=1; i<= taille; i++)
   if (enu_variables_globale(i) == TEMPS_COURANT) // on regarde s'il s'agit d'un ddl patenté
    {depend_temps = true;
     break;
    };
 };

 
//// construction à partir des noms de variables, des tableaux tab_enu_etendu et
//// tab_enu_quelconque
//void Fonction_nD::Construction_enu_etendu_et_quelconque()
// {// on parcours les noms des variables
//  int taille = nom_variables.Taille();
//  // a priori on considère qu'il y a  équivalence
//  equivalence_nom_enu_etendu_et_enu_quelconque = true;
//  list <Ddl_enum_etendu> li_inter_enu; // une liste intermédiaire de travail
//  list <int> li_index_enu;
//  list <EnumTypeQuelconque> li_inter_tyQ; // idem
//  list <int> li_index_quelc;
//
//  // un conteneur de service: un réel par ddl
//  Ddl_enum_etendu ddl_de_service;
//  // par contre pour les grandeurs quelconques, on peut avoir plusieurs
//  // réels par grandeur quelconque
//
//
//  for (int i=1; i<= taille; i++)
//   {if (ddl_de_service.VerifExistence(nom_variables(i)))
//     {li_inter_enu.push_back(Ddl_enum_etendu(nom_variables(i)));
//      li_index_enu.push_back(i);
//     }
//    else if (Existe_typeQuelconque(nom_variables(i)))
//     {li_inter_tyQ.push_back(Id_nomTypeQuelconque(nom_variables(i)));
//      li_index_quelc.push_back(i);
//     }
//    else equivalence_nom_enu_etendu_et_enu_quelconque = false  ;
//   };
//  // maintenant on peut définir les tableaux
//  int tail_enu_ddl = li_inter_enu.size();
//  { tab_enu_etendu.Change_taille(tail_enu_ddl);
//    index_enu_etendu.Change_taille(tail_enu_ddl);
//    int i_enu=1; // un compteur pour le tableau
//    list <Ddl_enum_etendu>::iterator il,ilfin=li_inter_enu.end();
//    list <int>::iterator i_int=li_index_enu.begin();
//    for (il=li_inter_enu.begin();il!=ilfin;il++,i_enu++,i_int++)
//      {tab_enu_etendu(i_enu)=(*il);
//       index_enu_etendu(i_enu)=(*i_int);
//      };
//  };
//  int tail_enuquel = li_inter_tyQ.size();
//    { tab_enu_quelconque.Change_taille(tail_enuquel);
//    index_enu_quelconque.Change_taille(tail_enuquel);
//    int i_enu=1; // un compteur pour le tableau
//    list <EnumTypeQuelconque>::iterator il,ilfin=li_inter_tyQ.end();
//    list <int>::iterator i_int=li_index_quelc.begin();
//    for (il=li_inter_tyQ.begin();il!=ilfin;il++,i_enu++,i_int++)
//      {tab_enu_quelconque(i_enu)=(*il);
//       index_enu_quelconque(i_enu) = (*i_int);
//       #ifdef MISE_AU_POINT
//       EnumTypeQuelconque inter = (*il);
//       if (NombreElementFoncDim(Type_de_grandeur_associee(inter)) != 1)
//        { cout << "\n *** pb de dimensions d'argument non coherentes !! "
//               << " la grandeur quelconque "<< NomTypeQuelconque(inter)
//               << ", n'est pas un scalaire simple "
//               << "\n Fonction_nD::Construction_enu_etendu_et_quelconque(..."<<endl;
//          Sortie(1);
//        };
//       #endif
//      };
//  };
//  // on met à jour le tableau de transfert
//  // ici par défaut chaque type quelconque est associé à un conteneur scalaire
//  // si ce n'est pas le cas, on considère que l'utilisateur utilisera la méthode
//  // Preparation_Grandeur_quelconque( pour mettre les bonnes dimensions
//  x_x_i.Change_taille(tail_enu_ddl+tail_enuquel);
// };

// Contruction des index pour les grandeurs évoluées, ainsi que les conteneurs
void Fonction_nD::Construction_index_conteneurs_evoluees()
 {// on parcours les noms des variables
  int taille = nom_variables.Taille();
  t_inter_double.Change_taille(taille);
  // on dimensionne le tableau des types de variables
  type_des_variables.Change_taille(taille);
  // on nettoie les listes
  li_enu_etendu_scalaire.clear();
  // on part avec l'idée que toutes les grandeurs seront reconnues localement
  equivalence_nom_enu_etendu_et_enu_quelconque = true;
  
  // def de listes intermédiaires
  list <int> li_inter_posi_ddl_enum; // liste des positions
  // --- cas des tenseurs
  list <TenseurBB* > li_inter_tens_ddl_enum; // pour les tenseurs
 // list <Deuxentiers_enu > li_ind_tens; // pour les indices dans les tenseurs
  List_io <Ddl_enum_etendu> li_premier_famille_tenseur; // pour savoir si c'est déjà enregistré
  // --- cas des coordonnées
  list <Coordonnee > li_coor_ddl_enum;
 // list <int > li_num_dans_coor;
  List_io <Ddl_enum_etendu> li_premier_famille_Coord; // pour savoir si c'est déjà enregistré
  // --- init de la liste équivalente de grandeurs quelconques évoluées
  li_equi_Quel_evolue.clear(); // on remet à 0
  // on défini des conteneurs ad hoc
  int dim = ParaGlob::Dimension(); // la dimension globale
  //  ... cas des Coordonnees
  Coordonnee v_rep(dim); // un vecteur de travail
  Grandeur_coordonnee grand5(v_rep); // def d'une grandeur courante coordonnée
  //  ... cas des tenseurs
  TenseurBB* tens = NevezTenseurBB(dim);  // un tenseur typique
  //   maintenant on définit une grandeur typique de type tenseurBB
  Grandeur_TenseurBB gtBB(*tens);

  
  list < int > li_position; // liste de la position des variables dans les tableaux

  // on parcours les noms de variables
  list <Ddl_enum_etendu> li_inter_enu; // une liste intermédiaire de travail
  list <int> li_index_enu;
  list <EnumTypeQuelconque> li_inter_tyQ; // idem
  list <int> li_index_quelc;
  
  // un conteneur de service: un réel par ddl
  Ddl_enum_etendu ddl_de_service;
  list <double> list_inter_val_ddl_enum; // inter qui donnera ensuite: val_ddl_enum
  // par contre pour les grandeurs quelconques, on peut avoir plusieurs
  // réels par grandeur quelconque
  int indice_enu_ddl = 0; // init
  int indice_t_quelconque = 0; // init
  for (int i=1; i<= taille; i++) // on balaie les noms de variable
    {// on sépare tout d'abord entre ddl_enum_etendu et type quelconque
     if (ddl_de_service.VerifExistence(nom_variables(i)))
     {ddl_de_service = Ddl_enum_etendu(nom_variables(i));
      li_inter_enu.push_back(ddl_de_service);
      li_index_enu.push_back(i);
      // def de la position du ddl dans le tableau final des ddl (créé à la fin)
      indice_enu_ddl++;li_inter_posi_ddl_enum.push_back(indice_enu_ddl);
      // récup du type de grandeur auquel apartient l'énumération
      // l'idée est de passer en revue le type de grandeur
      EnumTypeGrandeur enu_type_grandeur = ddl_de_service.TypeDeGrandeur();

      switch (enu_type_grandeur)
       {case SCALAIRE : case SCALAIRE_ENTIER : case SCALAIRE_DOUBLE :
         {// dans le cas d'un scalaire on a directement une équivalence à Ddl_enum_etendu
          // quelque soit le scalaire, on le stocke en double
          list_inter_val_ddl_enum.push_back(0.); // on ajoute une valeur 0. arbitraire
          li_enu_etendu_scalaire.push_back(ddl_de_service);
          type_des_variables(i)=1;
          break;
         }
        case TENSEUR : case TENSEUR_NON_SYM : case TENSEURBB : case TENSEURHH :
        case TENSEURBH : case TENSEURHB : case TENSEUR_NON_SYM_BB :
        case TENSEUR_NON_SYM_HH :
         { // on considère que c'est toujours un tenseur en absolu et par défaut c'est un tenseur BB
           type_des_variables(i)=3;
           // maintenant il faut savoir si on a déjà enregistré un tenseur qui contiend la composante
           if (!(Ddl_enum_etendu::Existe_dans_la_liste(li_premier_famille_tenseur,Ddl_enum_etendu::PremierDdlEnumEtenduFamille(ddl_de_service))))
             // s'il n'existe pas on rajoute le premier de la famille
            { TenseurBB * pt_tens= NevezTenseurBB(dim);
              li_inter_tens_ddl_enum.push_back(pt_tens);
              li_premier_famille_tenseur.push_back
                (Ddl_enum_etendu::PremierDdlEnumEtenduFamille(ddl_de_service));
              // on s'occupe de la grandeur quelconque équivalente
              EnumTypeQuelconque enuQ = Ddl_enum_etendu::Equivalent_en_grandeur_quelconque(ddl_de_service);
              TypeQuelconque typQ6(enuQ,ddl_de_service.Enum(),gtBB);
              li_equi_Quel_evolue.push_back(typQ6);
            };
//           // maintenant il faut récupérer la position = l'indice, de l'enu dans le tenseur
//           Deuxentiers_enu deux = IJind(ddl_de_service.Enum(),dim);
//           li_ind_tens.push_back(deux);
           break;
         }
        case COORDONNEE : case COORDONNEEB : case COORDONNEEH :
         {// on considère que c'est toujours un type coordonnée en absolu et par défaut c'est un Coordonnee
           type_des_variables(i)=2;
           // maintenant il faut savoir si on a déjà enregistré un Coordonnee  qui contiend la composante
           if (!(Ddl_enum_etendu::Existe_dans_la_liste(li_premier_famille_Coord,Ddl_enum_etendu::PremierDdlEnumEtenduFamille(ddl_de_service))))
             // s'il n'existe pas on rajoute le premier de la famille
            { Coordonnee  pt_coor(dim);
              li_coor_ddl_enum.push_back(pt_coor);
              li_premier_famille_Coord.push_back(Ddl_enum_etendu::PremierDdlEnumEtenduFamille(ddl_de_service));
              // on s'occupe de la grandeur quelconque équivalente
              EnumTypeQuelconque enuQ = Ddl_enum_etendu::Equivalent_en_grandeur_quelconque(ddl_de_service);
              TypeQuelconque typQ6(enuQ,ddl_de_service.Enum(),grand5);
              li_equi_Quel_evolue.push_back(typQ6);
            };
//           // maintenant il faut récupérer la position = l'indice, de l'enu dans Coordonnee
//           int indice_coor  = Indice_coor(ddl_de_service.Enum(),dim);
//           li_num_dans_coor.push_back(indice_coor);
          break;
         }
        default : // pour l'instant les autres cas, par exemple Vecteur, ne sont pas pris en compte
         cout << "\nErreur : la grandeur " << nom_variables(i)
              << " n'est pas pris en compte pour les fonctions nD  !\n";
         cout << "\n Fonction_nD::Construction_index_conteneurs_evoluees(.. \n";
         Sortie(1);
       }; // fin du switch
     } // fin du cas où c'est un ddl_enum_etendu
    else if (Existe_typeQuelconque(nom_variables(i)))
     {li_inter_tyQ.push_back(Id_nomTypeQuelconque(nom_variables(i)));
      li_index_quelc.push_back(i);
      type_des_variables(i)=4;
     }
    else
      {// il y a des variables qui ne rentrent pas dans le cadre dd enu étendu et grandeur quelconque
       // on ne pourra pas utiliser l'appel via des grandeurs évoluées: on le sauvegarde
       // pour signaler des erreurs mais  cela peut changer ensuite
       // par exemple via la transformation de variables locales en variables globales qui sont
       // dynamiquement créés, du coup on laisse l'algo
       equivalence_nom_enu_etendu_et_enu_quelconque = false  ;
       type_des_variables(i)=0;
      };
    
   };
  // on poursuit même s'il n'y a pas équivalence parfaite
  // de manière a remplacer la méthode :  Construction_enu_etendu_et_quelconque()
  // cependant s'il y a une équivalence parfaite
  //  on ne pourra pas utiliser l'appel évolué
  // donc certains indexes ne seront pas utilisables
//  if (equivalence_nom_enu_etendu_et_enu_quelconque)
    {// maintenant on va construire les tableaux qui sont équivalent aux listes
     tailles_tab.Change_taille(4);
     tailles_tab(1)=list_inter_val_ddl_enum.size();
     tailles_tab(2)=li_coor_ddl_enum.size();
     tailles_tab(3)=li_inter_tens_ddl_enum.size();
     tailles_tab(4)=li_inter_tyQ.size();
     // .... pour les ddl étendue
     // le tableau global de ddl étendu
     tab_enu_etendu.Init_from_list(li_inter_enu);
     posi_ddl_enum.Init_from_list(li_inter_posi_ddl_enum);
     
     val_ddl_enum.Init_from_list(list_inter_val_ddl_enum);
     
     coor_ddl_enum.Init_from_list(li_coor_ddl_enum);
     premier_famille_Coord.Init_from_list(li_premier_famille_Coord);
//     num_dans_coor.Init_from_list(li_num_dans_coor);
     num_dans_coor.Change_taille(tab_enu_etendu.Taille());
     
     tens_ddl_enum.Init_from_list(li_inter_tens_ddl_enum);
     premier_famille_tenseur.Init_from_list(li_premier_famille_tenseur);
//     ind_tens.Init_from_list(li_ind_tens);
     ind_tens.Change_taille(tab_enu_etendu.Taille());
     
     index_enu_etendu.Init_from_list(li_index_enu);
  
     // .... pour les grandeurs quelconques
     // le tableau global de grandeurs quelconque
     tab_enu_quelconque.Init_from_list(li_inter_tyQ);
     index_enu_quelconque.Init_from_list(li_index_quelc);
  
     // il faut maintenant revoir le tableau posi_ddl_enum dans le cas
     // ou un tenseur et/ou un Coordonnee contient plusieurs Ddl_enum_etendu
     // on fait systématiquement le test
//     if (tab_enu_etendu.Taille() > (tailles_tab(1)+tailles_tab(2)+tailles_tab(3)))
      {// on utilise les premiers de famille dont l'indice est le même que les
       // tableau de tenseur et de Coordonnee
      
       int nb_enu = tab_enu_etendu.Taille();
       for (int i=1;i<=nb_enu;i++)
        {// récup du type de grandeur auquel apartient l'énumération
         // l'idée est de passer en revue le type de grandeur
         Ddl_enum_etendu & ddenumetendu = tab_enu_etendu(i); // pour simplifier
         EnumTypeGrandeur enu_type_grandeur = ddenumetendu.TypeDeGrandeur();
         //TypeGrandeur(ddenumetendu.Enum());
         switch (enu_type_grandeur)
          {case TENSEUR : case TENSEUR_NON_SYM : case TENSEURBB : case TENSEURHH :
           case TENSEURBH : case TENSEURHB : case TENSEUR_NON_SYM_BB :
           case TENSEUR_NON_SYM_HH :
            { // on récupère la position dans le tableau de tenseur
              int position = premier_famille_tenseur.Contient
              (Ddl_enum_etendu::PremierDdlEnumEtenduFamille(ddenumetendu));
              posi_ddl_enum(i)=position;
              // maintenant il faut récupérer la position = l'indice, de l'enu dans le tenseur
// erreur : 18 mars 2023              Deuxentiers_enu deux = IJind(ddl_de_service.Enum(),dim);
              Deuxentiers_enu deux = IJind(ddenumetendu.Enum(),dim);
              ind_tens(i) = deux;
              break;
            }
           case COORDONNEE : case COORDONNEEB : case COORDONNEEH :
            { // on récupère la position dans le tableau de Coordonnee
              int position = premier_famille_Coord.Contient
              (Ddl_enum_etendu::PremierDdlEnumEtenduFamille(ddenumetendu));
              posi_ddl_enum(i)=position;
              // maintenant il faut récupérer la position = l'indice, de l'enu dans Coordonnee
              int indice_coor  = Indice_coor(ddenumetendu.Enum(),dim);
              num_dans_coor(i) = indice_coor;
              break;
            }
           default : break;// sinon c'est des scalaires
          }; // fin du switch
        };
      }; // fin du if (tab_enu_etendu.Taille() > (tailles_tab(1)+tailles_tab(2)+tailles_tab(3)))
////------- debug
//cout << "\n\n debug Fonction_nD::Construction_index_conteneurs_evoluees() : FCT= " << nom_ref
//     << "\n les variables: "<< nom_variables
//     << "\n li_equi_Quel_evolue= " << li_equi_Quel_evolue
//     << " num_dans_coor= "<<num_dans_coor;
////------- fin debug

     // .... pour les grandeurs quelconques équivalentes aux grandeurs
     //       évoluées non scalaires

     // l'ordre d'apparition dans la liste est le même que celui dans les tableaux
     // donc on parcours deux fois la liste des grandeurs, une fois pour les coordonnées et
     // une fois pour les tenseurs
     int nb_etendu = tab_enu_etendu.Taille();

     int nb_coor = coor_ddl_enum.Taille();
     tab_equi_Coor.Change_taille(nb_coor);
     int nb_tenseur = tens_ddl_enum.Taille();
     tab_equi_tens.Change_taille(nb_tenseur);
     
     List_io <TypeQuelconque >::iterator iqc,iqc_fin=li_equi_Quel_evolue.end();
     
//     cout << "\n posi_ddl_enum= " << posi_ddl_enum << endl;
  
     for (int i=1;i<=nb_etendu;i++)
       if ((type_des_variables(index_enu_etendu(i)) == 2)
         || (type_des_variables(index_enu_etendu(i)) == 3))
           {EnumTypeQuelconque enuQ =
                      Ddl_enum_etendu::Equivalent_en_grandeur_quelconque(tab_enu_etendu(i));
            TypeQuelconque tq(enuQ);
            // on cherche dans la liste enregistrée
            List_io <TypeQuelconque >::iterator result1 =
               std::find(li_equi_Quel_evolue.begin(),li_equi_Quel_evolue.end(), tq);
            if (result1 == li_equi_Quel_evolue.end())
             {cout << "\n *** erreur d'adressage dans "
                  << "Fonction_nD::Construction_index_conteneurs_evoluees()";
              this->Affiche();
              Sortie(1);
             };

            if (type_des_variables(index_enu_etendu(i)) == 2) // cas de coordonnées
                 tab_equi_Coor(posi_ddl_enum(i))=result1;
            else if (type_des_variables(index_enu_etendu(i)) == 3) // cas des tenseurs
                 tab_equi_tens(posi_ddl_enum(i))=result1;
           };
  
     delete tens; // car on n'en a plus besoin

    // on met à jour le tableau de transfert
    // ici par défaut chaque type quelconque est associé à un conteneur scalaire
    // si ce n'est pas le cas, on considère que l'utilisateur utilisera la méthode
    // Preparation_Grandeur_quelconque( pour mettre les bonnes dimensions
    x_x_i.Change_taille(tab_enu_etendu.Taille()+tab_enu_quelconque.Taille());
   }; // fin du cas où il y a une équivalence parfaite
 };


// Passage des infos variables évoluées en tableau de réels
// I/O : di
Tableau <double > & Fonction_nD::Vers_tab_double(Tableau <double > & di
                                 ,const Tableau <double >* val_ddl_enum
                                 ,const Tableau <Coordonnee> * coor_ddl_enum
                                 ,const Tableau <TenseurBB* >* tens_ddl_enum
                                 ,const Tableau <const TypeQuelconque *  >* tqi
                                 ,const Tableau <int> * t_num_ordre)
 {
    #ifdef MISE_AU_POINT
    if (di.Taille() != (tab_enu_etendu.Taille() + tab_enu_quelconque.Taille()))
      { cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
             << "  tab_enu_etendu.Taille()= " << tab_enu_etendu.Taille()
             << "  tab_enu_quelconque.Taille()= "<< tab_enu_quelconque.Taille()
             << " ce n'est pas normal !! ,  on arrete le calcul   "
             << "\n Fonction_nD::Vers_tab_double(..."<<endl;
        Sortie(1);
      };
    if (tailles_tab(1) != 0) // cas où il existe des scalaires
      {if (val_ddl_enum == NULL)
        { cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
               << "  val_ddl_enum pointe sur NULL "
               << "  et il est prevu d'avoir des scalaires purs !"
               << " ce n'est pas normal !! ,  on arrete le calcul   "
               << "\n Fonction_nD::Vers_tab_double(..."<<endl;
          Sortie(1);
        }
       else
        {if (val_ddl_enum->Taille() != tailles_tab(1))
          { cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
                 << "  taille val_ddl_enum  = " << val_ddl_enum->Taille()
                 << "  est different du nombre prevu !" << tailles_tab(1)
                 << " ce n'est pas normal !! ,  on arrete le calcul   "
                 << "\n Fonction_nD::Vers_tab_double(..."<<endl;
            Sortie(1);
          };
        };
      };
    if (tailles_tab(2) != 0)
      {if (coor_ddl_enum == NULL)
        { cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
               << "  coor_ddl_enum pointe sur NULL "
               << "  et il est prevu d'avoir des coordonnees !"
               << " ce n'est pas normal !! ,  on arrete le calcul   "
               << "\n Fonction_nD::Vers_tab_double(..."<<endl;
          Sortie(1);
        };
      };
    if (tailles_tab(3) != 0)
      {if (tens_ddl_enum == NULL)
        { cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
               << "  tens_ddl_enum pointe sur NULL "
               << "  et il est prevu d'avoir des tenseurs !"
               << " ce n'est pas normal !! ,  on arrete le calcul   "
               << "\n Fonction_nD::Vers_tab_double(..."<<endl;
          Sortie(1);
        };
      };
    if (tailles_tab(4) != 0)
      {if (tqi == NULL)
        { cout << "\n *** pb dans le transfert des grandeurs quelconques vers scalaires "
               << "  tqi pointe sur NULL "
               << "  et il est prevu d'avoir des grandeurs quelconques !"
               << " ce n'est pas normal !! ,  on arrete le calcul   "
               << "\n Fonction_nD::Vers_tab_double(..."<<endl;
          Sortie(1);
        }
       else if (t_num_ordre != NULL)
        {if (t_num_ordre->Taille() != tqi->Taille())
          { cout << "\n *** pb dans le transfert des grandeurs quelconques vers scalaires "
                 << "  taille tqi  = " << tqi->Taille()
                 << "  est different du nombre de numero d'ordre prevu !" << t_num_ordre->Taille()
                 << " ce n'est pas normal !! ,  on arrete le calcul   "
                 << "\n Fonction_nD::Vers_tab_double(..."<<endl;
            Sortie(1);
          };
       };
     };
    #endif
    // on va boucler sur les arguments:
    // on utilise les index, pour un adressage indirect, pour le tableau de retour "et"
    // la grandeur, normalement, cela devrait être ok
    // 1) sur les enum
    int nb_enu = index_enu_etendu.Taille();
    for (int ienu=1;ienu <= nb_enu; ienu++)
      {int num_variable = index_enu_etendu(ienu); // le numéro de nom_variable
       switch (type_des_variables(num_variable))
        { case 1: // scalaire
            {di(num_variable) = val_ddl_enum->operator()(posi_ddl_enum(ienu));
             break;}
          case 2: // Coordonnee
            {int j = posi_ddl_enum(ienu);
             di(num_variable) = (*coor_ddl_enum)(j)(num_dans_coor(ienu));
             break;}
          case 3: // tenseur
            {int j = posi_ddl_enum(ienu);
             int k = ind_tens(ienu).i; int l = ind_tens(ienu).j;
             di(num_variable) = (*(*tens_ddl_enum)(j))(k,l);
             break;}
          default:
            break;
       };
      }; // fin de la boucle sur les enum
    // 2) sur les grandeurs quelconques
    int nb_quelc = index_enu_quelconque.Taille();
    for (int ieq = 1; ieq <= nb_quelc; ieq++)
     { int num_variable = index_enu_quelconque(ieq);
       int nb_ordre = 1; // init par défaut
       if (t_num_ordre != NULL)
         nb_ordre = (*t_num_ordre)(ieq);
       di(num_variable) = (*tqi)(ieq)->GrandeurNumOrdre(nb_ordre);
     }; // fin de la boucle sur les enu quelconques
     
   // retour
   return di;
 };

// idem, mais via les listes
// val_ddl_enum(k) correspond à li_evolue_scalaire de rang i
Tableau <double > & Fonction_nD::Vers_tab_double(Tableau <double > & di
                                 ,const Tableau <double >* val_ddl_enum
                                 ,List_io <Ddl_enum_etendu>* li_evolue_scalaire
                                 ,List_io <TypeQuelconque >* li_evoluee_non_scalaire
                                 ,const Tableau <const TypeQuelconque *  >* tqi
                                 ,const Tableau <int> * t_num_ordre)
 {
    #ifdef MISE_AU_POINT
    // on vérifie qu'il s'agit bien des mêmes listes
    if ((&li_enu_etendu_scalaire) !=  li_evolue_scalaire)
        { cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
               << "  la liste des enum etendu scalaires n'est pas celle fournie par la fonction"
               << " ce n'est pas normal !! ,  on arrete le calcul   "
               << "\n Fonction_nD::Vers_tab_double(..."<<endl;
          Sortie(1);
        };
    if ((&li_equi_Quel_evolue) !=  li_evoluee_non_scalaire)
        { cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
               << "  la liste des grandeurs evoluees non scalaire n'est pas celle fournie par la fonction"
               << " ce n'est pas normal !! ,  on arrete le calcul   "
               << "\n Fonction_nD::Vers_tab_double(..."<<endl;
          Sortie(1);
        };
  
    if (li_enu_etendu_scalaire.size() != 0)
     {if (val_ddl_enum==NULL)
        { cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
               << "  val_ddl_enum pointe sur NULL "
               << "  et il est prevu d'avoir "<< li_enu_etendu_scalaire.size() << " grandeurs scalaires !"
               << " ce n'est pas normal !! ,  on arrete le calcul   "
               << "\n Fonction_nD::Vers_tab_double(..."<<endl;
          Sortie(1);
        };
      if (val_ddl_enum->Taille() != li_enu_etendu_scalaire.size())
        { cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
               << "  val_ddl_enum est de taille " << val_ddl_enum->Taille()
               << "  alors qu'il est prevu d'avoir "<< li_enu_etendu_scalaire.size() << " grandeurs scalaires !"
               << " ce n'est pas normal !! ,  on arrete le calcul   "
               << "\n Fonction_nD::Vers_tab_double(..."<<endl;
          Sortie(1);
        };
     };

    if (tailles_tab(4) != 0)
      {if (tqi == NULL)
        { cout << "\n *** pb dans le transfert des grandeurs quelconques vers scalaires "
               << "  tqi pointe sur NULL "
               << "  et il est prevu d'avoir des grandeurs quelconques !"
               << " ce n'est pas normal !! ,  on arrete le calcul   "
               << "\n Fonction_nD::Vers_tab_double(..."<<endl;
          Sortie(1);
        }
       else if (t_num_ordre != NULL)
        {if (t_num_ordre->Taille() != tqi->Taille())
          { cout << "\n *** pb dans le transfert des grandeurs quelconques vers scalaires "
                 << "  taille tqi  = " << tqi->Taille()
                 << "  est different du nombre de numero d'ordre prevu !" << t_num_ordre->Taille()
                 << " ce n'est pas normal !! ,  on arrete le calcul   "
                 << "\n Fonction_nD::Vers_tab_double(..."<<endl;
            Sortie(1);
          };
       };
     };
    #endif
    
    // on va boucler sur les arguments:
    List_io <Ddl_enum_etendu>::iterator i_scal = li_enu_etendu_scalaire.begin();
    List_io <TypeQuelconque >::iterator i_evol = li_equi_Quel_evolue.begin();
    int indice_scal=1; // init : indice dans le tableau val_ddl_enum
  
////------- debug
//cout << "\n\n debug Fonction_nD::Vers_tab_double( : FCT= " << nom_ref
//     << "\n les variables: "<< nom_variables
//     << "\n li_equi_Quel_evolue= " << li_equi_Quel_evolue
//     << " num_dans_coor= "<<num_dans_coor;
////------- fin debug
    // 1) sur les enum
    int nb_enu = index_enu_etendu.Taille();
    // qui a la même taille que tab_enu_etendu, et dans le même ordre
    for (int ienu=1;ienu <= nb_enu; ienu++)
      {int num_variable = index_enu_etendu(ienu); // le numéro de nom_variable
       switch (type_des_variables(num_variable))
        { case 1: // scalaire
            {di(num_variable) = (*val_ddl_enum)(posi_ddl_enum(ienu));
             break;}
          case 2: // Coordonnee
            {int j = posi_ddl_enum(ienu);
             // pour simplifier l'écriture
             List_io<TypeQuelconque >::iterator& il = tab_equi_Coor(j);
             Grandeur_coordonnee& coo = *((Grandeur_coordonnee*) (*il).Grandeur_pointee());
             Coordonnee& coord = *(coo.ConteneurCoordonnee());
             di(num_variable) = coord(num_dans_coor(ienu));
////------- debug
//cout << "\n num_variable= "<<num_variable
//     << " di (num_variable)= "<<di(num_variable)
//     << " num_dans_coor("<<ienu<<")= "<<num_dans_coor(ienu)
//     << "\n coord= "<<coord ;
////------- fin debug
             i_evol++;
             break;}
          case 3: // tenseur
            {int j = posi_ddl_enum(ienu);
             int k = ind_tens(ienu).i; int l = ind_tens(ienu).j;
             // pour simplifier l'écriture
             List_io<TypeQuelconque >::iterator& il = tab_equi_tens(j);
             Grandeur_TenseurBB& ten = *((Grandeur_TenseurBB*) (*il).Grandeur_pointee());
             TenseurBB& tensBB = ten.RefConteneurTenseur();
             di(num_variable) = tensBB(k,l);
             i_evol++;
             break;}
          default:
            break;
       };
      }; // fin de la boucle sur les enum
  
    // 2) sur les grandeurs quelconques
    int nb_quelc = index_enu_quelconque.Taille();
    for (int ieq = 1; ieq <= nb_quelc; ieq++)
     { int num_variable = index_enu_quelconque(ieq);
       int nb_ordre = 1; // init par défaut
       if (t_num_ordre != NULL)
         nb_ordre = (*t_num_ordre)(ieq);
       di(num_variable) = (*tqi)(ieq)->GrandeurNumOrdre(nb_ordre);
     }; // fin de la boucle sur les enu quelconques
  
////------ debug
//cout << "\n  debug  Fonction_nD::Vers_tab_double( ";
//cout << di << endl;
//
////------ fin debug

   // retour
   return di;
 };

// appel de la fonction sous forme d'une méthode avec un nombre non limité
// de paramètres: en fait utilise Valeur
// c'est une méthode avec retour uniquement en scalaire, sinon -> erreur
// calcul  des valeurs de la fonction
double Fonction_nD::Val_avec_nbArgVariable(double x,...)
  {
    // un certain nombre de variables utilisée pour gérer
    // http://www.cplusplus.com/reference/cstdarg/va_copy/
    // cf. variadic function
   
    int count = 0;
    double val = x;
    va_list vl,vl_count;
    va_start(vl,x);
   
    // on va remplir le tableau xinter, pour faire un appel classique
    int nb_var = this->NbVariable();
    if (xinter == NULL)
      xinter = new Tableau <double >(nb_var);
    if (nb_var != 0)
     {(*xinter)(count+1)=val;
      /* count number of arguments: */
      va_copy(vl_count,vl);
      while (val != 0)
       {if (count < nb_var) // cas normal
         {val=va_arg(vl_count,double);
          ++count;
          (*xinter)(count+1)=val;
         }
        else // sinon il y a plus d'argument que prévu, on génère une erreur
         { cout << "\n *** erreur dans l'appel de la fonction " << nom_ref
                << " le nombre d'argument est superieur a "<< nb_var
                << " ce qui n'est pas prevu dans la definition de la fonction "
                << "\n Fonction_nD::Val_avec_nbArgVariable( ";
           if (ParaGlob::NiveauImpression() > 1)
             this->Affiche();
           cout << endl;
           Sortie(1);
         };
       };
      va_end(vl_count);
     };
    // maintenant on peut utiliser la méthode classique
    Tableau <double> & ret = this->Valeur_FnD_interne(xinter);
    return ret(1);
  
  };

// méthode utilisée par les classes dérivées, pour transférer les infos qui sont
// gérées au niveau de Fonction_nD
Fonction_nD& Fonction_nD::Transfert_info(const Fonction_nD& elt)
{ // on reprend toutes les données gérées par Fonction_nD
  typeFonction = elt.typeFonction;
  nom_ref = elt.nom_ref;
  nom_variables = elt.nom_variables;
  t_inter_double = elt.t_inter_double;
  enu_variables_globale = elt.enu_variables_globale;
  nom_variables_globales = elt.nom_variables_globales;
  tab_enu_etendu = elt.tab_enu_etendu;
  type_des_variables = elt.type_des_variables;
  val_ddl_enum = elt.val_ddl_enum;
  li_enu_etendu_scalaire = elt.li_enu_etendu_scalaire;
  coor_ddl_enum = elt.coor_ddl_enum;
  num_dans_coor = elt.num_dans_coor;
  tens_ddl_enum = elt.tens_ddl_enum;
  premier_famille_tenseur = elt.premier_famille_tenseur;
  ind_tens = elt.ind_tens;
  posi_ddl_enum = elt.posi_ddl_enum;
  tailles_tab = elt.tailles_tab;
  tab_enu_quelconque = elt.tab_enu_quelconque;
  equivalence_nom_enu_etendu_et_enu_quelconque = elt.equivalence_nom_enu_etendu_et_enu_quelconque;
  index_enu_etendu = elt.index_enu_etendu;
  index_enu_quelconque = elt.index_enu_quelconque;
  // les listes pour les appels via les listes
  li_enu_etendu_scalaire = elt.li_enu_etendu_scalaire;
  li_equi_Quel_evolue = elt.li_equi_Quel_evolue;
  tab_equi_Coor = elt.tab_equi_Coor;
  tab_equi_tens = elt.tab_equi_tens;
 
  x_x_i = elt.x_x_i;
  x_glob = elt.x_glob;
  depend_M = elt.depend_M;
  depend_Mt = elt.depend_Mt;
  depend_M0 = elt.depend_M0;
  depend_temps = elt.depend_temps;
};


// affichage des données internes, utilisée par les fonctions dérivées
// niveau donne le degré d'affichage
void Fonction_nD::Affiche_interne(int niveau) const
 { if (niveau > 0)
    { cout << "\n type_de_fonction: "<< Nom_Fonction_nD(typeFonction)
           << "  nom_ref= " << nom_ref
           << "\n les_variables_lues: " << nom_variables ;
      if (niveau > 1)
       { // les énumérés globaux éventuels
         int taille_enu_variables_globale= enu_variables_globale.Taille();
         if (taille_enu_variables_globale != 0)
          { cout << "\n enumeres_globaux:_taille " << enu_variables_globale.Taille();
            for (int i=1;i<= taille_enu_variables_globale;i++)
              cout << " " << Nom_GrandeurGlobale(enu_variables_globale(i));
          };
         // les noms de variables globales éventuelles
         int taille_nom_variables_globales= nom_variables_globales.Taille();
         if (taille_nom_variables_globales != 0)
          { cout << "\n noms_variables_globales:_taille " << nom_variables_globales.Taille();
            for (int i=1;i<= taille_nom_variables_globales;i++)
              cout << " " << nom_variables_globales(i);
          };
         // enu étendu équivalent aux variables non globales
         int taille_tab_enu_etendu= tab_enu_etendu.Taille();
         if (taille_tab_enu_etendu != 0)
          { cout << "\n enum_etendu_locaux:_taille " << tab_enu_etendu.Taille();
            for (int i=1;i<= taille_tab_enu_etendu;i++)
              {cout << " " << tab_enu_etendu(i).Nom_plein();
               int j = posi_ddl_enum(i);
               switch (type_des_variables(i))
                {case 1: cout << " type scalaire: valeur actuelle= "
                              << val_ddl_enum(j) ;
                        break;
                 case 2: cout << " type coordonnees: valeur actuelle= "
                              << coor_ddl_enum(j)(num_dans_coor(j));
                        break;
                 case 3: cout << " type tenseur: valeur actuelle= "
                              << (*tens_ddl_enum(j))(ind_tens(j).i,ind_tens(j).j) ;
                 break;
                 default: cout << "\n type non reconnue= " << type_des_variables(i)
                               << "\n Fonction_nD::Affiche_interne( ";
                          Sortie(1);
                };
              };
            // bilan des variables évoluées
            cout << "\n il y a: "
                 << tailles_tab(1) << " scalaire(s) "
                 << tailles_tab(2) << " coordonnee(s) "
                 << tailles_tab(3) << " composante(s) de tenseur "
                 << endl;
          };
         // grandeurs quelconques équivalentes aux variables non globales
         int taille_tab_enu_quelconque= tab_enu_quelconque.Taille();
         if (taille_tab_enu_quelconque != 0)
          { cout << "\n enum_quelconque:_taille " << tab_enu_quelconque.Taille()
                 << "\n liste: ";
            for (int i=1;i<= taille_tab_enu_quelconque;i++)
              cout << NomTypeQuelconque(tab_enu_quelconque(i)) << ", ";
          };
       };
      // autres infos
      cout << "\n il y a " << this->NbComposante() << " valeur(s) en retour de la fonction ";
      if (depend_temps || depend_M || depend_Mt ||depend_M0 )
        { cout << "\n ";
          if (depend_temps)
            cout << " la fonction depend du temps,  ";
          if (depend_M || depend_Mt ||depend_M0 )
             cout << " la fonction depend du point M : ";
          if (depend_M)
            cout << " courant, ";
          if (depend_Mt)
            cout << " a t, ";
          if (depend_M0)
            cout << " a 0, ";
        };
    };
 };


//------ méthodes appelée par les classes dérivées ----
//  relatives aux données gérées par Fonction_nD
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Fonction_nD::Lect_base_info(ifstream& ent,const int cas)
{
 if (cas == 1)
    { string toto; string nom;
      // lecture des arguments
      ent >> nom >> nom_variables;
      t_inter_double.Change_taille(nom_variables.Taille());
      // les énumérés des variables globales
      ent >> nom;
      int nb_enu=0;
      ent >> nom >> nb_enu;
      enu_variables_globale.Change_taille(nb_enu);
      for (int i=1;i<= nb_enu;i++)
       { ent >> nom;
         enu_variables_globale(i) = Id_nom_GrandeurGlobale(nom);
       };
     
      // les nom des variables globales indicées en string
      ent >> nom;
      int nb_nom=0;
      ent >> nom >> nb_nom;
      nom_variables_globales.Change_taille(nb_nom);
      for (int i=1;i<= nb_nom;i++)
       { ent >> nom;
         nom_variables_globales(i) = nom;
       };
     
      // enu étendu équivalent aux variables non globales
      ent >> nom >> tab_enu_etendu;

      // grandeurs quelconques équivalentes aux variables non globales
      int taille_tab_enu_quelconque; // init
      ent >> nom >> taille_tab_enu_quelconque >> toto;
      tab_enu_quelconque.Change_taille(taille_tab_enu_quelconque);
      for (int i=1;i<= taille_tab_enu_quelconque;i++)
       {ent >> nom;
        tab_enu_quelconque(i) = Id_nomTypeQuelconque(nom);
       };
     
      // bilan des variables évoluées (on lit pour passer les infos
      // dans le .BI, mais cela va être recalculé au moment de la fabrication
      // des index
      tailles_tab.Change_taille(4);
      ent >> nom
          >> tailles_tab(1) >> nom
          >> tailles_tab(2) >> nom
          >> tailles_tab(3) >> nom
          >> tailles_tab(4) >> nom;
      ent >> nom >> permet_affichage ;

      // Contruction des index pour les grandeurs évoluées, ainsi que les conteneurs
      Fonction_nD::Construction_index_conteneurs_evoluees();
    };
 };

// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Fonction_nD::Ecrit_base_info(ofstream& sort,const int cas)
{
 if (cas == 1)
    { // les variables
      sort << " \n arguments= " << nom_variables
           << " \n variables_globales_en_enumere= " ;
      int nb_enu = enu_variables_globale.Taille();
      sort << "taille " << nb_enu << "  ";
      for (int i=1;i<= nb_enu;i++)
        sort << Nom_GrandeurGlobale(enu_variables_globale(i)) << " ";
   
      sort  << " \n variables_globales_en_string= " ;
      int nb_str = nom_variables_globales.Taille();
      sort << "taille " << nb_str << "  ";
      for (int i=1;i<= nb_str;i++)
        sort << nom_variables_globales(i) << " ";

      // enu étendu équivalent aux variables non globales
      int taille_tab_enu_etendu= tab_enu_etendu.Taille();
      sort << "\n enum_etendu_locaux: " << tab_enu_etendu;

      // grandeurs quelconques équivalentes aux variables non globales
      int taille_tab_enu_quelconque= tab_enu_quelconque.Taille();
      sort << "\n enum_quelconque:_taille " << tab_enu_quelconque.Taille()
           << "\n liste: ";
      for (int i=1;i<= taille_tab_enu_quelconque;i++)
           sort << NomTypeQuelconque(tab_enu_quelconque(i)) << " ";

      // bilan des variables évoluées
      sort << "\n bilan_var_evolue_il_y_a: "
           << tailles_tab(1) << " scalaire(s) "
           << tailles_tab(2) << " coordonnee(s) "
           << tailles_tab(3) << " composante(s)_de_tenseur "
           << tailles_tab(4) << " grandeur_quelconque "
           ;
      sort << "\n permet_affichage_ "<<permet_affichage << " ";

    };
 };

// sortie du schemaXML: en fonction de enu
void Fonction_nD::SchemXML_Fonctions_nD(ofstream& sort,const Enum_IO_XML enu)
  {
 switch (enu)
 { case XML_TYPE_GLOBAUX :
  {
   break;
  }
  case XML_IO_POINT_INFO :
  {
   break;
  }
  case XML_IO_POINT_BI :
  {
   break;
  }
  case XML_IO_ELEMENT_FINI :
  {
   break;
  }
 };
  };

// lecture d'une ou plusieurs variables
// peut-être appelée plusieurs fois,
// stockage des infos dans Fonction_nD
void Fonction_nD::Lecture_variables(string& nom_lu,UtilLecture * entreePrinc)
 {
  // on lit tant que l'on ne rencontre pas une ligne contenant
  // une info ne correspondant pas à des variables    // ou un nouveau mot clé global auquel cas il y a pb !!
  MotCle motCle; // ref aux mots cle
  // on utilise des listes pour éviter les doublons
  list <Enum_GrandeurGlobale >  list_enu_variables_glob; // enum glob
  // on transvase le tableau dans la liste
  enu_variables_globale.Init_list(list_enu_variables_glob);
  // idem pour les noms globaux
  list < string> list_de_variables_nom_globales; //  string glob
  nom_variables_globales.Init_list(list_de_variables_nom_globales);
  // puis les variables qui ne sont pas globales
  list < string> list_de_variables; // liste
  nom_variables.Init_list(list_de_variables);
  
  bool lecture_effective = false; // init
  while ((   (strstr(entreePrinc->tablcar,"un_argument=")==0)
          && (strstr(entreePrinc->tablcar,"deb_list_var_")==0)
         )
        || (nom_lu == "un_argument=")
        || (nom_lu == "deb_list_var_")
       )
    {
     // si on a  un mot clé global dans la ligne courante c-a-d dans tablcar --> erreur
     if ( motCle.SimotCle(entreePrinc->tablcar))
      { cout << "\n erreur de lecture des parametre de definition d'une fonction nD : on n'a pas trouve de mot cle relatif a une variable"
             << " et par contre la ligne courante contient un mot cle global  "
             << " *** a priori il y a une erreur de mise en donnees ! " ;
        entreePrinc->MessageBuffer("** erreur des parametres d'une fonction nD **");
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);
      };
      
     // lecture d'un mot clé éventuellement
    if ((    (nom_lu != "un_argument=")
         && (nom_lu != "deb_list_var_")
        )
        || lecture_effective
       )
     *(entreePrinc->entree) >> nom_lu;
    // sinon cela veut dire que nom_lu a déjà été lu et repéré
    // relatif à une variable
    // ou que l'on vient de terminer une lecture de variabl
     
     if ((entreePrinc->entree)->rdstate() == 0)
       {} // lecture normale
     #ifdef ENLINUX
     else  if ((entreePrinc->entree)->fail())
               // on a atteind la fin de la ligne et on appelle un nouvel enregistrement
              {   // on lit sans tenir compte des < éventuelles
                  entreePrinc->NouvelleDonneeSansInf();
                  *(entreePrinc->entree) >>nom_lu;
              }
     #else
     else  if ((entreePrinc->entree)->eof())
              // la lecture est bonne mais on a atteind la fin de la ligne
              { if (nom_lu.find("fin_parametres_fonction_") == std::string::npos)
              //if(nom_lu != "fin_parametres_fonction_expression_litterale_")
                  // on lit sans tenir compte des < éventuelles
                  {entreePrinc->NouvelleDonneeSansInf();
                   *(entreePrinc->entree) >> nom_lu;
                  };
              }
     #endif
     else // cas d'une erreur de lecture
      { cout << "\n erreur de lecture inconnue  ";
        entreePrinc->MessageBuffer("** erreur2 des parametres d'une fonction nD **");
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);
      };

 
     // cas de la lecture d'une variable
     if(nom_lu == "un_argument=")
      {*(entreePrinc->entree) >> nom_lu;
       // on regarde s'il s'agit d'une variable globale correspondant à un énuméré global
       if (EstUneGrandeurGlobale(nom_lu))
        { list_enu_variables_glob.push_back(Id_nom_GrandeurGlobale (nom_lu));}
       // idem mais sous forme d'un string
       else if (ParaGlob::param->GrandeurGlobal(nom_lu) != NULL)
        { list_de_variables_nom_globales.push_back(nom_lu);}
       else // sinon ce n'est pas une grandeur globale
        {list_de_variables.push_back(nom_lu);};
       // on signale que la lecture a été effective
       lecture_effective = true;
      }
     else if(nom_lu == "deb_list_var_") // lecture d'une liste d'argument
      {// on va lire juqu'au mot clé fin_list_var_
       int nb_boucle = 0; // indicateur pour éviter une boucle infinie
       do
        {*(entreePrinc->entree) >> nom_lu;
         if (nom_lu == "fin_list_var_")
             break;
         // on regarde s'il s'agit d'une variable globale
         if (EstUneGrandeurGlobale(nom_lu))
          { list_enu_variables_glob.push_back(Id_nom_GrandeurGlobale (nom_lu));}
         // idem mais sous forme d'un string
         else if (ParaGlob::param->GrandeurGlobal(nom_lu) != NULL)
          { list_de_variables_nom_globales.push_back(nom_lu);}
         else // sinon ce n'est pas une grandeur globale
          {list_de_variables.push_back(nom_lu);};
         nb_boucle++;
        } while (nb_boucle < 200);
       if (nb_boucle > 199)
        { cout << "\n erreur de lecture au niveau d'une liste de variable  "
               << " deb_list_var_ nom1 nom2 ... fin_list_var_";
          entreePrinc->MessageBuffer("** erreur lecture parametre d'une d'une fonction nD ** **");
          throw (UtilLecture::ErrNouvelleDonnee(-1));
          Sortie(1);
        }
       else // sinon c'est ok
        // on signale que la lecture a été effective
        lecture_effective = true;
     }
     ; // sinon rien, ce n'est plus une variable, on va donc sortir
       // du while à la suite
   }; // fin du while
  // nom_lu contient la dernière information lue qui ne correspond pas à une variable
  
  //--- maintenant on va gérer les variables lues
  
  //  on supprime les doublons dans les variables globales
  list_enu_variables_glob.sort();
  list_enu_variables_glob.unique();
  list_de_variables_nom_globales.sort();
  list_de_variables_nom_globales.unique();
  
  // on remet à jour le tableau des énumérés globaux
  enu_variables_globale.Init_from_list(list_enu_variables_glob);
  // idem pour les noms de reférence globaux
  nom_variables_globales.Init_from_list(list_de_variables_nom_globales);
  // puis pour les variables qui ne sont pas globales
  nom_variables.Init_from_list(list_de_variables);
  
  // on met à jour les tableaux internes de passage de valeurs
  x_x_i.Change_taille(nom_variables.Taille());
  x_glob.Change_taille(enu_variables_globale.Taille()+nom_variables_globales.Taille());

};


// affichage des variables de la fonction, dépend du niveau d'impression
void Fonction_nD::Affichage_variables() const
 {
  if (permet_affichage > 5)
    {  cout << "\n ---- Fonction_nD " << nom_ref  ;
       cout << "  \n arguments_specifiques= " << nom_variables
            << "  \n variables_globales_en_enumere= " ;
       int nb_enu = enu_variables_globale.Taille();
       cout << "taille " << nb_enu << "  ";
       for (int i=1;i<= nb_enu;i++)
         cout << Nom_GrandeurGlobale(enu_variables_globale(i)) << " ";
      
       cout  << "  \n variables_globales_en_string= " ;
       int nb_str = nom_variables_globales.Taille();
       cout << "taille " << nb_str << "  ";
       for (int i=1;i<= nb_str;i++)
         cout << nom_variables_globales(i) << " ";
    };

  };


// récupération des valeurs des variables globales et stockage dans le tableau
// interne x_glob
void Fonction_nD::Recup_Grandeurs_globales()
 { // --- on parcours les variables globales:
   // 1) les énumérés
   int index_glob=1;
   int tail_enu = enu_variables_globale.Taille();
   if (tail_enu>0)
    {
     // en debug on vérifie que les grandeurs globales sont présentent
     #ifdef MISE_AU_POINT
     try
      { int taille = enu_variables_globale.Taille();
        for (int i=1;i<= taille;i++)
           {// on récupère le pointeur correspondant à la grandeur
            const void* pointe =  (ParaGlob::param->GrandeurGlobal(enu_variables_globale(i)));
            if (pointe == NULL)
              { cout << "\n *** pb dans l'appel de la fonction " << nom_ref << " !! "
                     << " la variable globale  "<< Nom_GrandeurGlobale(enu_variables_globale(i))
                     << ", n'est pas disponible, on ne peut pas continuer  "
                     << "\n Fonction_nD::Recup_Grandeurs_globales(..."<<endl;
                // on génère une interruption ce qui permettra de dépiler les appels
                this->Affiche();ErrCalculFct_nD toto;throw (toto);
                Sortie(1);
              };
           };
      }
     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 dans l'appel de la fonction "
             << nom_ref  ;
        cout << " verifier la presence des grandeurs globales voulues "
             << "\n Fonction_nD::Recup_Grandeurs_globales(..."<<endl;
        // on génère une interruption ce qui permettra de dépiler les appels
        this->Affiche();ErrCalculFct_nD toto;throw (toto);
        Sortie(1);
      };
     #endif
     for (int i=1;i<= tail_enu;i++,index_glob++)
      {// on récupère le pointeur correspondant à la grandeur
       const void* pointe =  (ParaGlob::param->GrandeurGlobal(enu_variables_globale(i)));
       TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
       switch(gr_quelc->Grandeur_pointee()->Type_structure_grandeurAssocie())
        { case  TYPE_SIMPLE:
            { switch(gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere())
               {case PARTICULIER_SCALAIRE_ENTIER:
                  {Grandeur_scalaire_entier& gr
                        = *((Grandeur_scalaire_entier*) gr_quelc->Grandeur_pointee()); // pour simplifier
                   x_glob(index_glob) = *(gr.ConteneurEntier());
                   break;
                  }
                case PARTICULIER_SCALAIRE_DOUBLE:
                  {Grandeur_scalaire_double& gr
                        = *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
                   x_glob(index_glob) = *(gr.ConteneurDouble());
                   break;
                  }
                case PARTICULIER_DDL_ETENDU:
                  {Grandeur_Ddl_etendu& gr
                        = *((Grandeur_Ddl_etendu*) gr_quelc->Grandeur_pointee()); // pour simplifier
                   x_glob(index_glob) = (gr.GrandeurNumOrdre(1));
                   break;
                  }
                case PARTICULIER_SCALAIRE_DOUBLE_NOMMER_INDICER:
                  {Grandeur_Double_Nommer_indicer& gr
                        = *((Grandeur_Double_Nommer_indicer*) gr_quelc->Grandeur_pointee()); // pour simplifier
                   x_glob(index_glob) = *(gr.ConteneurDouble());
                   break;
                  }
                default:
                  { cout << "\n *** pb dans dans l'appel de la fonction "<< nom_ref
                         << " la variable globale  "<< Nom_GrandeurGlobale(enu_variables_globale(i))
                         << ", n'est pas prise en compte actuellement , on ne peut pas continuer  "
                         << "\n Fonction_nD::Recup_Grandeurs_globales(..."
                         <<endl;
                    // on génère une interruption ce qui permettra de dépiler les appels
                    this->Affiche();ErrCalculFct_nD toto;throw (toto);
                    Sortie(1);
                  };
               }
            
             break;
            }
          default:
            { cout << "\n *** pb dans dans l'appel de la fonction "<< nom_ref
                   << " la variable globale  "<< Nom_GrandeurGlobale(enu_variables_globale(i))
                   << ", n'est pas prise en compte actuellement , on ne peut pas continuer  "
                   << "\n Fonction_nD::Recup_Grandeurs_globales(..."
                   <<endl;
              // on génère une interruption ce qui permettra de dépiler les appels
              this->Affiche();ErrCalculFct_nD toto;throw (toto);
              Sortie(1);
            };
        };
       if (permet_affichage > 5)
        {cout << "\n " << Nom_GrandeurGlobale(enu_variables_globale(i))
              << " " << x_glob(index_glob);
        };
      };
    };
   // 2) idem pour les globaux en nom c-a-d  typées sous forme de string
   int tail_nom = nom_variables_globales.Taille();
   if (tail_nom>0)
    {
     // en debug on vérifie que les grandeurs globales sont présentent
     #ifdef MISE_AU_POINT
     try
      { for (int i=1;i<= tail_nom;i++)
           {// on récupère le pointeur correspondant à la grandeur
            const void* pointe =  (ParaGlob::param->GrandeurGlobal(nom_variables_globales(i)));
            if (pointe == NULL)
              { cout << "\n *** pb dans Fonction_expression_litterale_nD " << nom_ref << " !! "
                     << " la variable globale  "<< nom_variables_globales(i)
                     << ", n'est pas disponible, on ne peut pas continuer  "
                     << "\n Fonction_nD::Recup_Grandeurs_globales(..."<<endl;
                // on génère une interruption ce qui permettra de dépiler les appels
                this->Affiche();ErrCalculFct_nD toto;throw (toto);
                Sortie(1);
              };
           };
      }
     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 dans l'appel de la fonction "
             << nom_ref  ;
        cout << " verifier la presence des grandeurs globales voulues "
             << "\n Fonction_nD::Recup_Grandeurs_globales(..."<<endl;
        // on génère une interruption ce qui permettra de dépiler les appels
        this->Affiche();ErrCalculFct_nD toto;throw (toto);
        Sortie(1);
      };
     #endif
     // on parcours les variables globales
     int taille = nom_variables_globales.Taille();
     for (int i=1;i<= taille;i++,index_glob++)
      {// on récupère le pointeur correspondant à la grandeur
       const void* pointe =  (ParaGlob::param->GrandeurGlobal(nom_variables_globales(i)));
       TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
       switch(gr_quelc->Grandeur_pointee()->Type_structure_grandeurAssocie())
        { case  TYPE_SIMPLE:
            { switch(gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere())
               {case PARTICULIER_SCALAIRE_ENTIER:
                  {Grandeur_scalaire_entier& gr
                        = *((Grandeur_scalaire_entier*) gr_quelc->Grandeur_pointee()); // pour simplifier
                   x_glob(index_glob) = *(gr.ConteneurEntier());
                   break;
                  }
                case PARTICULIER_SCALAIRE_DOUBLE:
                  {Grandeur_scalaire_double& gr
                        = *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
                   x_glob(index_glob) = *(gr.ConteneurDouble());
                   break;
                  }
                case PARTICULIER_DDL_ETENDU:
                  {Grandeur_Ddl_etendu& gr
                        = *((Grandeur_Ddl_etendu*) gr_quelc->Grandeur_pointee()); // pour simplifier
                   x_glob(index_glob) = (gr.GrandeurNumOrdre(1));
                   break;
                  }
                case PARTICULIER_SCALAIRE_DOUBLE_NOMMER_INDICER:
                  {Grandeur_Double_Nommer_indicer& gr
                        = *((Grandeur_Double_Nommer_indicer*) gr_quelc->Grandeur_pointee()); // pour simplifier
                   x_glob(index_glob) = *(gr.ConteneurDouble());
                   break;
                  }
                case PARTICULIER_VECTEUR_NOMMER:
                  {Grandeur_Vecteur_Nommer& gr
                        = *((Grandeur_Vecteur_Nommer*) gr_quelc->Grandeur_pointee()); // pour simplifier
                   x_glob(index_glob) = (gr.GrandeurNumOrdre(1));
                   #ifdef MISE_AU_POINT
                   // on vérifie qu'une seule grandeur est stockée
                   if (gr.NbMaxiNumeroOrdre() > 1)
                      { cout << "\n *** pb dans dans l'appel de la fonction "<< nom_ref
                             << " la variable globale  "<< nom_variables_globales(i)
                             << ", correspond a un vecteur a plusieur composantes, ce n'est pas pris en "
                             << " compte pour l'intant, on ne peut pas continuer  "
                             << "\n Fonction_nD::Recup_Grandeurs_globales(..."
                             <<endl;
                        // on génère une interruption ce qui permettra de dépiler les appels
                        this->Affiche();ErrCalculFct_nD toto;throw (toto);
                        Sortie(1);
                      };
                   #endif
                   break;
                  }
                default:
                  { cout << "\n *** pb dans dans l'appel de la fonction "<< nom_ref
                         << " la variable globale  "<< nom_variables_globales(i)
                         << ", n'est pas prise en compte actuellement , on ne peut pas continuer  "
                         << "\n Fonction_nD::Recup_Grandeurs_globales(..."
                         <<endl;
                    // on génère une interruption ce qui permettra de dépiler les appels
                    this->Affiche();ErrCalculFct_nD toto;throw (toto);
                    Sortie(1);
                  };
               }
            
             break;
            }
          case TABLEAU_T: // valable uniquement pour les vecteur nommer
           // dans ce cas on n'utilise pour l'instant que la première valeur
            { switch(gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere())
               { case PARTICULIER_VECTEUR_NOMMER:
                  {Grandeur_Vecteur_Nommer& gr
                        = *((Grandeur_Vecteur_Nommer*) gr_quelc->Grandeur_pointee()); // pour simplifier
                   x_glob(index_glob) = (gr.GrandeurNumOrdre(1));
                   #ifdef MISE_AU_POINT
                   // on vérifie qu'une seule grandeur est stockée
                   if (gr.NbMaxiNumeroOrdre() > 1)
                      { cout << "\n *** pb dans dans l'appel de la fonction "<< nom_ref
                             << " la variable globale  "<< nom_variables_globales(i)
                             << ", correspond a un vecteur a plusieur composantes, ce n'est pas pris en "
                             << " compte pour l'intant, on ne peut pas continuer  "
                             << "\n grandeur= "<<gr<< " NbMaxiNumeroOrdre()= "<< gr.NbMaxiNumeroOrdre()
                             << "\n Fonction_nD::Recup_Grandeurs_globales(..."
                             <<endl;
                        // on génère une interruption ce qui permettra de dépiler les appels
                        this->Affiche();ErrCalculFct_nD toto;throw (toto);
                        Sortie(1);
                      };
                   #endif
                   break;
                  }
                default:
                  { cout << "\n *** pb dans dans l'appel de la fonction "<< nom_ref
                         << " la variable globale  "<< nom_variables_globales(i)
                         << ", n'est pas prise en compte actuellement , on ne peut pas continuer  "
                         << "\n Fonction_nD::Recup_Grandeurs_globales(..."
                         <<endl;
                    // on génère une interruption ce qui permettra de dépiler les appels
                   this->Affiche();ErrCalculFct_nD toto;throw (toto);
                   Sortie(1);
                  };
               }
            
             break;
            }
          default:
            { cout << "\n *** pb dans dans l'appel de la fonction "<< nom_ref
                   << " la variable globale  "<< nom_variables_globales(i)
                   << ", n'est pas prise en compte actuellement , on ne peut pas continuer  "
                   << "\n Fonction_nD::Recup_Grandeurs_globales(..."
                   <<endl;
              // on génère une interruption ce qui permettra de dépiler les appels
              this->Affiche();ErrCalculFct_nD toto;throw (toto);
              Sortie(1);
            };
        };
       if (permet_affichage > 5)
        {cout << "\n " << nom_variables_globales(i)
              << " " << x_glob(index_glob);
        };
      };
    };
 
 };