// FICHIER : Element.cc
// CLASSE : Element  


// 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 <iostream>
using namespace std;  //introduces namespace std


#include "Element.h"
#include "ConstMath.h"
#include "Util.h"
#include "TypeQuelconqueParticulier.h"

//----------------------------------------------------------------
// def des donnees commune a tous les elements ( membre static)
//----------------------------------------------------------------
list <Element::NouvelleTypeElement> Element::listTypeElement;
// constantes générales qui permettent d'éviter d'utiliser des chiffres dans les classes
// dérivées ceci pour plus de lisibilité et de sureté
const double Element::epaisseur_defaut       = -1. + sqrt(2.)/1000.;      // épaisseur par défaut
const double Element::largeur_defaut         = -1. + sqrt(2.)/1001.;     // largeur par défaut
const double Element::section_defaut         = -1. + sqrt(2.)/1002.;     // section par défaut
const double Element::masse_volumique_defaut = -1. + sqrt(2.)/1003.;     // masse_volumique par défaut
// variable de travail pour la fonction Choix_element
bool Element::premier_passage_Choix_element=true; 

//--------------------------------------------------------------------------------------
//                       def des class internes et fonctions pour les classes internes
//--------------------------------------------------------------------------------------

// constructeur par défaut
Element::NouvelleTypeElement::NouvelleTypeElement() : 
        id_geom(RIEN_GEOM),id_interpol(RIEN_INTERPOL)
		,id_typeProblem(MECA_SOLIDE_DEFORMABLE),infos_annexes(""),el(NULL)
		    {};
// constructeur normal
Element::NouvelleTypeElement::NouvelleTypeElement(const Enum_geom id_g,const Enum_interpol id_in
		                         , const EnumElemTypeProblem id_type
		                         ,ConstrucElement * eli ,string   discri  ) :
        id_geom(id_g),id_interpol(id_in)
		,id_typeProblem(id_type),infos_annexes(discri),el(eli) 
		    {};
		                         
// constructeur de copie
Element::NouvelleTypeElement::NouvelleTypeElement(const NouvelleTypeElement& nvel) :
        id_geom(nvel.id_geom),id_interpol(nvel.id_interpol)
		,id_typeProblem(nvel.id_typeProblem),infos_annexes(nvel.infos_annexes),el(nvel.el) 
		    {};
// opérateur d'assigment
Element::NouvelleTypeElement& Element::NouvelleTypeElement::operator= (const Element::NouvelleTypeElement& nvel)
 { id_geom=nvel.id_geom;id_interpol=nvel.id_interpol;
   id_typeProblem=nvel.id_typeProblem;infos_annexes=nvel.infos_annexes;el=nvel.el;
   	return (*this);	
  };
// opérateur tests
bool Element::NouvelleTypeElement::operator == (const Element::NouvelleTypeElement& nvel)
 { if (  (id_geom==nvel.id_geom)&&(id_interpol==nvel.id_interpol)
       &&(id_typeProblem==nvel.id_typeProblem)&&(infos_annexes==nvel.infos_annexes)
       &&(el==nvel.el))
        return true;
    else return false;    
  };
bool Element::NouvelleTypeElement::operator != (const Element::NouvelleTypeElement& elt)
 { if (*this == elt) return true; else return false;
  };
// retourne vraie si *this est le meme type d'élément que elt  
bool Element::NouvelleTypeElement::MemeTypeElement(const Element::NouvelleTypeElement& nvel)
 { if (  (id_geom==nvel.id_geom)&&(id_interpol==nvel.id_interpol)
       &&(id_typeProblem==nvel.id_typeProblem)&&(infos_annexes==nvel.infos_annexes))
        return true;
    else return false;    
  };
  
// surcharge de l'operateur d'ecriture pour les éléments de la classe signature
ostream & operator << ( ostream & sort,const  Element::Signature & signature)
  { // sortie
    sort << "element_finis_de_signature: " << NomElemTypeProblem(signature.id_problem) 
         << " " << Nom_geom(signature.id_geom)
         << " " << Nom_interpol(signature.id_interpol)
         << " " << signature.infos_annexes;
    return sort;      
  };
// surcharge de l'affectation
Element::Signature& Element::Signature::operator = ( const Element::Signature& a) 	         
    { id_interpol = a.id_interpol;
      id_geom = a.id_geom; id_problem = a.id_problem;
      infos_annexes = a.infos_annexes;
      return *this;
     };
// surcharge de l'égalité
bool Element::Signature::operator == (const Element::Signature& a) 
  {  if ( (id_interpol==a.id_interpol)
       && (id_geom == a.id_geom) && (id_problem == a.id_problem)
       && (infos_annexes == a.infos_annexes))
         return true;
     else return false;    
   };
// surcharge de non égalité
bool Element::Signature::operator != (const Element::Signature& a) 
    { return !(*this == a);}; 

//--------------------------------------------------------------
//--                      les constructeurs                   --
//--------------------------------------------------------------

Element::Element (int num_maill,int num_id) :

// Constructeur utile quand le numero de maillage et d'identification de l'element est connu
 tab_noeud(),residu(NULL),raideur(NULL),res_extA(NULL),raid_extA(NULL)
 ,res_extS(NULL),raid_extS(NULL),mat_masse(NULL)
 ,volume(0.),num_maillage(0),volumePlan(ParaGlob::Dimension())
 ,integ_vol_typeQuel(NULL),integ_vol_typeQuel_t(NULL),index_Integ_vol_typeQuel(NULL)
 ,integ_vol_t_typeQuel(NULL),integ_vol_t_typeQuel_t(NULL),index_Integ_vol_t_typeQuel(NULL)
 ,enu_integ_vol_TQ(NULL),enu_integ_vol_t_TQ(NULL)
 ,tabb(),ind_front_lin(0),ind_front_surf(0),posi_tab_front_lin(0)
 ,ind_front_point(0),posi_tab_front_point(0)
 ,boite_encombre(),prepa_niveau_precision(0)
 ,sens_numerotation(1)
{   num_maillage=num_maill; num_elt=num_id;
    id_interpol=RIEN_INTERPOL;
    id_geom=RIEN_GEOM;
    id_problem = RIEN_PROBLEM;
    infos_annexes = "";
};

Element::Element (int num_maill,int num_id,const Tableau<Noeud *>& tab):
// Constructeur utile quand le numero de maillage et de l'élément, et le tableau des noeuds 
// de l'element sont connu
tab_noeud(tab),residu(NULL),raideur(NULL),res_extA(NULL),raid_extA(NULL)
 ,res_extS(NULL),raid_extS(NULL),mat_masse(NULL)
 ,volume(0.),volumePlan(ParaGlob::Dimension())
 ,integ_vol_typeQuel(NULL),integ_vol_typeQuel_t(NULL),index_Integ_vol_typeQuel(NULL)
 ,integ_vol_t_typeQuel(NULL),integ_vol_t_typeQuel_t(NULL),index_Integ_vol_t_typeQuel(NULL)
 ,enu_integ_vol_TQ(NULL),enu_integ_vol_t_TQ(NULL)
 ,tabb(),ind_front_lin(0),ind_front_surf(0),posi_tab_front_lin(0)
 ,ind_front_point(0),posi_tab_front_point(0)
 ,boite_encombre(),prepa_niveau_precision(0)
 ,sens_numerotation(1)
{   num_maillage=num_maill; num_elt=num_id;
    id_interpol=RIEN_INTERPOL;
    id_geom=RIEN_GEOM;
    id_problem = RIEN_PROBLEM;
    infos_annexes = "";
};
	

// Constructeur utile quand le numero du maillage et d'identification est connu,
// ainsi que la geometrie le type d'interpolation le problème traité de l'element
// et éventuellement un string d'information annexe
Element::Element (int num_maill,int num_id,Enum_interpol id_interp_elt,Enum_geom id_geom_elt,
                  EnumElemTypeProblem id_prob,string info):
  num_maillage(num_maill),num_elt(num_id),id_interpol(id_interp_elt),id_geom(id_geom_elt)
  ,id_problem(id_prob),infos_annexes(info),tab_noeud()
  ,residu(NULL),raideur(NULL),res_extA(NULL),raid_extA(NULL)
  ,res_extS(NULL),raid_extS(NULL),mat_masse(NULL)
  ,volume(0.),volumePlan(ParaGlob::Dimension())
  ,integ_vol_typeQuel(NULL),integ_vol_typeQuel_t(NULL),index_Integ_vol_typeQuel(NULL)
  ,integ_vol_t_typeQuel(NULL),integ_vol_t_typeQuel_t(NULL),index_Integ_vol_t_typeQuel(NULL)
  ,enu_integ_vol_TQ(NULL),enu_integ_vol_t_TQ(NULL)
  ,tabb(),ind_front_lin(0),ind_front_surf(0),posi_tab_front_lin(0)
  ,ind_front_point(0),posi_tab_front_point(0)
  ,boite_encombre(),prepa_niveau_precision(0)
  ,sens_numerotation(1)
{ };

// Constructeur fonction d'un numéro de maillage, d'un numero et de deux noms (geometrie, interpolation)
//et le type de problème traité par  l'element  
Element::Element (int num_maill,int num_id,const string& nom_interpol,const string& nom_geom,
            const string& nom_prob,string info):
  num_maillage(num_maill),num_elt(num_id),infos_annexes(info),tab_noeud()
  ,residu(NULL),raideur(NULL),res_extA(NULL),raid_extA(NULL)
  ,res_extS(NULL),raid_extS(NULL),mat_masse(NULL)
  ,volume(0.),volumePlan(ParaGlob::Dimension())
  ,integ_vol_typeQuel(NULL),integ_vol_typeQuel_t(NULL),index_Integ_vol_typeQuel(NULL)
  ,integ_vol_t_typeQuel(NULL),integ_vol_t_typeQuel_t(NULL),index_Integ_vol_t_typeQuel(NULL)
  ,enu_integ_vol_TQ(NULL),enu_integ_vol_t_TQ(NULL)
  ,tabb(),ind_front_lin(0),ind_front_surf(0),posi_tab_front_lin(0)
  ,ind_front_point(0),posi_tab_front_point(0)
  ,boite_encombre(),prepa_niveau_precision(0)
  ,sens_numerotation(1)
{
	id_interpol=Id_nom_interpol(nom_interpol);
	id_geom=Id_nom_geom(nom_geom);
	id_problem=Id_nom_ElemTypeProblem(nom_prob);
};

// Constructeur fonction d'un numéro de maillage, d'un numero, du tableau de connexite des noeuds et de
// trois identificateurs et un nom (geometrie, interpolation, type de probleme,
//                                  particularité éventuelle),
// et du type de problème traité par  l'element 
Element::Element (int num_maill,int num_id,const Tableau<Noeud *>& tab,Enum_interpol id_interp_elt,
				   Enum_geom id_geom_elt,EnumElemTypeProblem id_prob,string info):
  num_maillage(num_maill),num_elt(num_id),id_interpol(id_interp_elt),id_geom(id_geom_elt)
  ,id_problem(id_prob),infos_annexes(info),tab_noeud(tab)
  ,residu(NULL),raideur(NULL),res_extA(NULL),raid_extA(NULL)
  ,res_extS(NULL),raid_extS(NULL),mat_masse(NULL)
  ,volume(0.),volumePlan(ParaGlob::Dimension())
  ,integ_vol_typeQuel(NULL),integ_vol_typeQuel_t(NULL),index_Integ_vol_typeQuel(NULL)
  ,integ_vol_t_typeQuel(NULL),integ_vol_t_typeQuel_t(NULL),index_Integ_vol_t_typeQuel(NULL)
  ,enu_integ_vol_TQ(NULL),enu_integ_vol_t_TQ(NULL)
  ,tabb(),ind_front_lin(0),ind_front_surf(0),posi_tab_front_lin(0)
  ,ind_front_point(0),posi_tab_front_point(0)
  ,boite_encombre(),prepa_niveau_precision(0)
  ,sens_numerotation(1)
{
}; 

// Constructeur fonction d'un numéro de maillage, d'un numero, du tableau de connexite des noeuds, de
// quatre noms (geometrie, interpolation, type de probleme, particularité éventuelle), 															
// et du type de problème traité par  l'element 
Element::Element (int num_maill,int num_id,const Tableau<Noeud *>& tab,const string& nom_interpol,
				  const string& nom_geom,const string& nom_prob,string info):
  num_maillage(num_maill),num_elt(num_id),infos_annexes(info),tab_noeud(tab)
  ,residu(NULL),raideur(NULL),res_extA(NULL),raid_extA(NULL)
  ,res_extS(NULL),raid_extS(NULL),mat_masse(NULL)
  ,volume(0.),volumePlan(ParaGlob::Dimension())
  ,integ_vol_typeQuel(NULL),integ_vol_typeQuel_t(NULL),index_Integ_vol_typeQuel(NULL)
  ,integ_vol_t_typeQuel(NULL),integ_vol_t_typeQuel_t(NULL),index_Integ_vol_t_typeQuel(NULL)
  ,enu_integ_vol_TQ(NULL),enu_integ_vol_t_TQ(NULL)
  ,tabb(),ind_front_lin(0),ind_front_surf(0),posi_tab_front_lin(0)
  ,ind_front_point(0),posi_tab_front_point(0)
  ,boite_encombre(),prepa_niveau_precision(0)
  ,sens_numerotation(1)
{
	id_interpol=Id_nom_interpol(nom_interpol);
	id_geom=Id_nom_geom(nom_geom);
	id_problem=Id_nom_ElemTypeProblem(nom_prob);
};

// Constructeur de copie
Element::Element (const Element& elt):
    num_maillage(elt.num_maillage),num_elt(elt.num_elt),id_interpol(elt.id_interpol)
    ,id_geom(elt.id_geom),id_problem(elt.id_problem),infos_annexes(elt.infos_annexes)
    ,tab_noeud(elt.tab_noeud)
    ,residu(NULL),raideur(NULL),res_extA(NULL),raid_extA(NULL)
    ,res_extS(NULL),raid_extS(NULL),mat_masse(NULL)
	   ,volume(elt.volume),volumePlan(elt.volumePlan)
    ,integ_vol_typeQuel(NULL),integ_vol_typeQuel_t(NULL),index_Integ_vol_typeQuel(NULL)
    ,integ_vol_t_typeQuel(NULL),integ_vol_t_typeQuel_t(NULL),index_Integ_vol_t_typeQuel(NULL)
    ,enu_integ_vol_TQ(NULL),enu_integ_vol_t_TQ(NULL)
    ,tabb(),ind_front_lin(0),ind_front_surf(0),posi_tab_front_lin(0)
    ,ind_front_point(0),posi_tab_front_point(0)
    ,boite_encombre(elt.boite_encombre),prepa_niveau_precision(elt.prepa_niveau_precision)
    ,sens_numerotation(elt.sens_numerotation)
// on ne recopie pas les adresses pointees car celles-ci peuvent changer, donc il vaut mieux
// les reconstruire si besoin est 
{if (elt.integ_vol_typeQuel != NULL)
   {integ_vol_typeQuel = new Tableau <TypeQuelconque>(*(elt.integ_vol_typeQuel));};
 if (elt.integ_vol_typeQuel_t != NULL)
    {integ_vol_typeQuel_t = new Tableau <TypeQuelconque>(*(elt.integ_vol_typeQuel_t));};
 if (elt.index_Integ_vol_typeQuel != NULL)
    {index_Integ_vol_typeQuel = new Tableau <int> (*(elt.index_Integ_vol_typeQuel));}
 if (elt.integ_vol_t_typeQuel != NULL)
    {integ_vol_t_typeQuel = new Tableau <TypeQuelconque>(*(elt.integ_vol_t_typeQuel));};
 if (elt.integ_vol_t_typeQuel_t != NULL)
    {integ_vol_t_typeQuel_t = new Tableau <TypeQuelconque>(*(elt.integ_vol_t_typeQuel_t));};
 if (elt.index_Integ_vol_t_typeQuel != NULL)
    {index_Integ_vol_t_typeQuel = new Tableau <int> (*(elt.index_Integ_vol_t_typeQuel));}
 if (elt.enu_integ_vol_TQ != NULL)
    {enu_integ_vol_TQ = new Tableau <TypeQuelconque_enum_etendu>(*(elt.enu_integ_vol_TQ));};
 if (elt.enu_integ_vol_t_TQ != NULL)
    {enu_integ_vol_t_TQ = new Tableau <TypeQuelconque_enum_etendu> (*(elt.enu_integ_vol_t_TQ));}
};

Element::~Element()
// Destructeur
{ int dimtaille= tabb.Taille();
////---- debug
//if ((num_elt==1) && (num_maillage==1))
// cout << "\n debug Element::~Element () "<<endl;
////--- fin debug

  for (int i=1;i<= dimtaille;i++)
    if (tabb(i) != NULL) delete tabb(i);

  // cas des intégrales de volumes
  if (integ_vol_typeQuel != NULL)
     {delete integ_vol_typeQuel;};
  if (integ_vol_typeQuel_t != NULL)
     {delete integ_vol_typeQuel_t;};
  if (integ_vol_t_typeQuel != NULL)
     {delete integ_vol_t_typeQuel;};
  if (integ_vol_t_typeQuel_t != NULL)
     {delete integ_vol_t_typeQuel_t;};
  if (index_Integ_vol_typeQuel != NULL)
     delete index_Integ_vol_typeQuel;
  if (index_Integ_vol_t_typeQuel != NULL)
     delete index_Integ_vol_t_typeQuel;
  if (enu_integ_vol_TQ != NULL)
     delete enu_integ_vol_TQ;
  if (enu_integ_vol_t_TQ != NULL)
     delete enu_integ_vol_t_TQ;
};

/*// lecture de l'entete de l'element, permet son identification parmi
// tous les elements derivants
void Element::LectureEnTete(UtilLecture * entreePrinc)
{ *(entreePrinc->entree) >> num_elt >> id_geom >> id_interpol; };*/

// test si l'element est complet
int Element::TestComplet()
    { int ret =1;
      if (tab_noeud.Taille() == 0) 
       { cout << " \n *** Warning le tableau de noeud est vide dans l element "
                  << num_elt << '\n';
//         ret = 0;
       }
      if (num_elt == -3)
       { cout << " \n  l'element  n a pas de numero d'identification \n ";
         ret = 0;
       };
      if (id_geom == RIEN_GEOM)
       { cout << " \n la geometrie de l'element  n est pas defini\n ";
         ret = 0;
       };
      if (id_interpol == RIEN_INTERPOL)
       { cout << " \n l interpolation sur l'element  n est pas defini\n ";
         ret = 0;
       };
      if (id_problem == RIEN_PROBLEM)
       { cout << " \n le type de probleme de l'element  n est pas defini\n ";
         ret = 0;
       };     
       return ret; 
    }; 
// Libere la place occupee par le residu et eventuellement la raideur
void Element::Libere ()
  { // if (residu != NULL) delete residu;  // tous les résidus, raideurs et tableaux de
    // if (raideur != NULL) delete raideur;// pointent sur des données static
  };

  // mise à jour éventuel de repère d'anisotropie
void Element::Mise_a_jour_repere_anisotropie(BlocGen & bloc,LesFonctions_nD*  lesFonctionsnD)
 { cout << "\n Erreur , methode actuellement non defini pour l'element \n";
   cout << "\n Element::Mise_a_jour_repere_anisotropie(.. \n";
   Sortie(1);
 };

// test si this et l'élément passé en paramètre sont identiques uniquement concernant la signature, la géométrie
// et le maillage
// par contre il peut y avoir des différences au niveau de la loi, de la matière etc.
// ramène true s'il y a identité, false sinon
bool Element::Meme_signature_et_geometrie(const Element& elem)const
{ // on continue que si les deux éléments ont la même signature
  if ((this->Signature_element() == elem.Signature_element())
     && (num_maillage == elem.Num_maillage()))
   { int ta = tab_noeud.Taille(); // nb de noeud de this
     const Tableau<Noeud *>& tab_noeu_ext = elem.Tab_noeud_const(); // pour simplifier
     switch (ta)
       	{ case 1 : // cas d'un élément point, on simplifie
       		if (tab_noeud(1) == tab_noeu_ext(1)) {return true;} else {return false;}
       	    break;
       	  case 2 : // cas d'un élément à 2 noeuds uniquement
       	   {if (tab_noeud(1) == tab_noeu_ext(1))
       	      {if (tab_noeud(2) == tab_noeu_ext(2)) {return true;} else {return false;}}
       	    else if (tab_noeud(1) == tab_noeu_ext(2))
       	      {if (tab_noeud(2) == tab_noeu_ext(1)) {return true;} else {return false;}}
       	    else {return false;}; 
       	    break;
       	  	}
       	  default : // les autres cas	
           {// récup de l'élément géométrique
            const ElemGeomC0 & elemgeom = this->ElementGeometrique();
            const Tableau <int> & ind = elemgeom.Ind(); // récup du tableau des tranches
            int nb_tranche = ind.Taille(); // le nombre d'intervalle de numéros de noeuds constituant la numérotation
                     // vérification que la taille de toutes les tranches est au moins supérieure à 1
            #ifdef MISE_AU_POINT
             if (nb_tranche == 0)
                 {cout << "\n *** erreur, pas de tranche de nb de noeud definie "
                       << "\n Element::Meme_signature_et_geometrie(... " << endl;
                  Sortie(1);
                 };
             for (int i1=1;i1<=nb_tranche;i1++)
               if (ind(i1) < 1)
                 {cout << "\n *** erreur, une tranche de nb de noeud est nulle "
                       << " tableau ind: " << ind
                       << "\n Element::Meme_signature_et_geometrie(... " << endl;
                  Sortie(1);
                 };
            #endif
            // on balaie chaque intervalle
            int deb_intervalle = 0; int fin_intervalle = 0; // init
            for (int iter =1;iter<= nb_tranche;iter++)
             { int tranche = ind(iter);
               deb_intervalle = fin_intervalle+1; // mise à jour des bornes de l'intervalle de scrutation
               fin_intervalle += tranche;   //      "           "
               // on commence par chercher un premier noeud identique dans l'intervalle
               bool res = false; 
               int nd; // indice du cote this
               Noeud * ptNoeud_a = tab_noeu_ext(deb_intervalle);
               for (nd=deb_intervalle; nd<= fin_intervalle; nd++)
                {if  (tab_noeud(nd) == ptNoeud_a)
                  { res = true; break; };
                };
               if (!res)          // on arrête de suite si 
                  {return false;}; // on n'a pas trouvé de premier noeud !!
               // s'il n'y a qu'un seule noeud dans la tranche, on a finit cette tranche sinon on continue
               if (tranche > 1)
                { // on regarde dans quel sens il faut tourner
                  int ndplus = nd + 1; if (ndplus > fin_intervalle) ndplus -= tranche;
                  int ndmoins = nd - 1; if (ndmoins < deb_intervalle) ndmoins += tranche;
                  if  (tab_noeud(ndplus) == tab_noeu_ext(deb_intervalle+1))
                    {// on est dans le bon sens en augmentant, et c'est ok pour le 2ième noeud,
                     // continue que s'il y a plus de 2 noeuds dans la tranche
                     if (tranche > 2)
                      { for (int i=1;i<= (tranche-2);i++)
                         { ndplus++;
                           if (ndplus > fin_intervalle) ndplus -= tranche;
                           if (tab_noeud(ndplus) != tab_noeu_ext(deb_intervalle+i+1))
                             return false;
                         };
                      };
                     // sinon ok, on vient de balayer tous les noeuds, on continue
                    }
                  // le sens 1 ne marche pas , on regarde l'autre sens
                  else if (tab_noeud(ndmoins) == tab_noeu_ext(deb_intervalle+1))
                    {// le bon sens est finalement en diminuant
                     // continue que s'il y a plus de 2 noeuds dans la tranche
                     if (tranche > 2)
                       { for (int i=1;i<= (tranche-2);i++)
                          { ndmoins--;
                            if (ndmoins < deb_intervalle) ndmoins += tranche;
                            if (tab_noeud(ndmoins) != tab_noeu_ext(deb_intervalle+i+1))
                            return false;
                          };
                       };
                     // sinon ok, on vient de balayer tous les noeuds, on continue
                    }
                  else  // sinon ne marche pas dans les deux sens
                    { return false;};
                };
             }; // fin de la boucle sur les tranches
            
           }; // fin du cas courant (default du switch)
       	}; // fin du switch sur le nombre de noeuds
   }
  else // le type est different et ou le numéro de maillage est différent                     
   {return false;};
  // si on arrive ici, cela veut dire que toutes les égalités sont bonnes pour un cas autre que 
  // point ou élément à 2 noeuds
  return true;	     
};


//------- calcul d'erreur, remontée des contraintes -------------------
// calcul du résidu et de la matrice de raideur pour le calcul d'erreur
	         // pour l'instant uniquement virtuel, par la suite devra être virtuelle pure
	      //1) remontée aux contraintes
Element::Er_ResRaid Element::ContrainteAuNoeud_ResRaid()
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : ContrainteAuNoeud_ResRaid() \n";
    Sortie(1);
    return Element::Er_ResRaid();
  };
          // 2) remontée aux erreurs aux noeuds
Element::Er_ResRaid Element::ErreurAuNoeud_ResRaid()
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : ErreurAuNoeud_ResRaid() \n";
    Sortie(1);
    return Element::Er_ResRaid();
  };
    
// suppression d'un élément frontière
void Element::SupprimeFront(ElFrontiere* elemFront)
 { // on commence par mettre à jour les répercussions de la
   // suppression sur les classes dérivées
   Prise_en_compte_des_consequences_suppression_une_frontiere(elemFront);
   // puis suppression dans les tableaux gérés par Element
   int taille = tabb.Taille();
   for (int i=1; i<=taille; i++)
     if (tabb(i) == elemFront)
       { delete tabb(i);
         tabb(i) = NULL;
         // puis gestion des indicateurs
         if ((ind_front_point != 0) && (i>posi_tab_front_point))
         // cas d'une frontière point
           ind_front_point = 2; 
         else if ((ind_front_lin != 0) && (i> posi_tab_front_lin))
           // cas d'une frontière linéique
           ind_front_lin = 2;
         else if (ind_front_surf != 0)
           // cas d'une frontière surfacique
           ind_front_surf = 2;
         else
          { cout << "\n erreur l'élément frontière n'est pas correcte "
                 << "\n Element::SupprimeFront(ElFrontiere* elemFront)";
            Sortie(1);     
          }
         break;
       };
  };

// suppression de tous les  éléments frontières
void Element::SupprimeFront()
 { // on commence par mettre à jour les répercussions de la
   // suppression sur les classes dérivées
   Prise_en_compte_des_consequences_suppression_tous_frontieres();
   // puis suppression dans les tableaux gérés par Element
   int taille = tabb.Taille();
   for (int i=1; i<=taille; i++)
    { delete tabb(i);
      tabb(i) = NULL;
    };
   ind_front_surf = 0;
   ind_front_lin = 0;  
   ind_front_point = 0;  
  };

// mise à jour de la boite d'encombrement de l'élément, suivant les axes I_a globales
// en retour coordonnées du point mini dans retour.Premier() et du point maxi dans .Second()
const DeuxCoordonnees& Element::Boite_encombre_element(Enum_dure temps)
  { int tab_taille= tab_noeud.Taille();
    Coordonnee& encomb_min_e=boite_encombre.Premier();
    Coordonnee& encomb_max_e=boite_encombre.Second();
    switch (temps)
    { case TEMPS_0:
      {encomb_min_e=tab_noeud(1)->Coord0();encomb_max_e=encomb_min_e; // init
       for (int i=2;i<=tab_taille;i++) // balayage des autres noeuds
          { Coordonnee co=tab_noeud(i)->Coord0();
            encomb_min_e.Modif_en_min(co); encomb_max_e.Modif_en_max(co);
           };
        break;		
    	}
      case TEMPS_t:
      {encomb_min_e=tab_noeud(1)->Coord1();encomb_max_e=encomb_min_e; // init
       for (int i=2;i<=tab_taille;i++) // balayage des autres noeuds
          { Coordonnee co=tab_noeud(i)->Coord1();
            encomb_min_e.Modif_en_min(co); encomb_max_e.Modif_en_max(co);
           };
        break;		
    	}
      case TEMPS_tdt:
      {encomb_min_e=tab_noeud(1)->Coord2();encomb_max_e=encomb_min_e; // init
       for (int i=2;i<=tab_taille;i++) // balayage des autres noeuds
          { Coordonnee co=tab_noeud(i)->Coord2();
            encomb_min_e.Modif_en_min(co); encomb_max_e.Modif_en_max(co);
           };
        break;		
    	}
    }; // fin du switch
    // maintenant on tiend compte d'un facteur majorant pour incertitude
    Coordonnee delta=(encomb_max_e- encomb_min_e) 
                        * (ParaGlob::param->ParaAlgoControleActifs().Extra_boite_prelocalisation()-1.);
    // ajout d'un extra dans toutes les directions
    delta.Ajout_meme_valeur(ParaGlob::param->ParaAlgoControleActifs().Ajout_extra_boite_prelocalisation());
    // mise à jour
    encomb_min_e -= delta; encomb_max_e += delta;
    // retour
    return boite_encombre; 
   };
  
// test si le point passé en argument appartient à la boite d'encombrement de l'élément
// tous les points sont supposées avoir la même dimension
// si depass est différent de 0, les maxi et mini de la boite sont augmentés de "depass"
bool Element::In_boite_emcombrement_elem(const Coordonnee& M,double depass) const
{ // on va essayer de faire efficace, pour cela on test le minimum
  const Coordonnee& co_min = boite_encombre.Premier();  // par commodité
  const Coordonnee& co_max = boite_encombre.Second();   // par commodité
  #ifdef MISE_AU_POINT
  if ((M.Dimension() != ParaGlob::Dimension())|| (M.Dimension()	!= co_min.Dimension()))
  	{ cout << "\n *** pb de dimensions non coherente !! "
  	       << "\n Element::In_boite_emcombrement_elem(...";
  	  Sortie(1);     
  	};
  #endif
//debug 
//cout << "\n M= " << M << " co_min= " << co_min << " co_max= " << co_max << endl;
//fin debug  
  if (depass == 0.)
   {switch (ParaGlob::Dimension())
     { case 3: if ((M(3)<co_min(3)) || (M(3) > co_max(3))) return false;
       case 2: if ((M(2)<co_min(2)) || (M(2) > co_max(2))) return false;
   	   case 1: if ((M(1)<co_min(1)) || (M(1) > co_max(1))) return false;
     };
   }
   else // cas ou il faut rajouter depass
   {depass = Dabs(depass);
    switch (ParaGlob::Dimension())
     { case 3: if ((M(3)<(co_min(3)-depass)) || (M(3) > (co_max(3)+depass))) return false;
       case 2: if ((M(2)<(co_min(2)-depass)) || (M(2) > (co_max(2)+depass))) return false;
   	   case 1: if ((M(1)<(co_min(1)-depass)) || (M(1) > (co_max(1)+depass))) return false;
     };
   };
   
  // si on arrive ici c'est que le point est interne
  return true; 
}; 
  
void 
Element::Affiche (int n) const 
// Affiche les donnees liees a un element
{  // n indique un niveau d'impression
   if((n < 1) || (n > 4))
      { cout << "\n il faut un chiffre entre 1 et 4 ! \n";
        cout << " Element::Affiche (int n), n = " << n << '\n';
        return; }
 
    switch (n)
      { case 4 : // + la raideur et la matrice de masse si elle existe
	        { if ( raideur == NULL )
            {cout << "\n ** pas encore de raideur \n";}
	          else
	           {cout << "\t raideur : \n"; 
             cout << "nombre de ligne  : " << (*raideur).Nb_ligne() << " .\n";
             cout << "nombre de colonne  : " << (*raideur).Nb_colonne() << " .\n";
	            cout << "Composante(s) :\n ";
	            for (int i=1;i<= (*raideur).Nb_ligne();i++)
	            { cout << "\t[  ";
	              for (int j=1; j<= (*raideur).Nb_colonne(); j++)
		                cout << (*raideur)(i,j) << "  ";
               cout << "]\n\n";
             };
            };
	         if ( mat_masse == NULL )
            {cout << "\n ** pas de matrice masse \n";}
	         else
	         {cout << "\t matrice_masse : \n"; 
           cout << "nombre de ligne  : " << (*mat_masse).Nb_ligne() << " .\n";
           cout << "nombre de colonne  : " << (*mat_masse).Nb_colonne() << " .\n";
	          cout << "Composante(s) :\n ";
	          for (int i=1;i<= (*mat_masse).Nb_ligne();i++)
	            { cout << "\t[  ";
	              for (int j=1; j<= (*mat_masse).Nb_colonne(); j++)
		              cout << (*mat_masse)(i,j) << "  ";
		             cout << "]\n\n";
		           };
          };
         }	  
	       case 3 : // + le residu
	        {if ( residu == NULL )
            {cout << "\n ** pas encore de residu \n";}
	         else
	         {cout << "\t residu : \n"; 
           cout << "Taille du residu : " << (*residu).Taille() << " .\n";
	          cout << "Composante(s) :\n\t[  ";
	          for (int i=1;i<= (*residu).Taille();i++)
		            cout << (*residu)(i) << "  ";
	          cout << "]\n\n";
          };
         }
	       case 2 : // + tableau de noeuds  
         {cout << "\tNoeuds de l'element : \n";
	         cout << "Taille du tableau : " << tab_noeud.Taille() << " .\n";
	         cout << "Composante(s) :\n\t[  ";
	         for (int i=1;i<=tab_noeud.Taille();i++)
		          cout << Num_noeud(i) << "  ";
	         cout << "]\n\n";
         }
	       case 1 : // donnees d'en-tete
         {cout << "\tNumero d'identification de l'element : ";
          if (num_elt > 1000000)
           { cout << " interne Hourglass \n"; }
          else { cout << num_elt << "\n"; };
	         cout << "\tType de geometrie : " << Nom_geom(id_geom) << "\n";
	         cout << "\tType d'interpolation : " << Nom_interpol(id_interpol) << "\n";
          cout << "\tType de problem : " << NomElemTypeProblem(id_problem) << "\n";
          if (infos_annexes != "")
 	           cout << "particularité: " << infos_annexes;
         }  	  
	     };
};

Element&
Element::operator= (Element& elt)
// Surcharge de l'operateur = : realise l'egalite de deux elements
{num_elt=elt.num_elt;
	tab_noeud=elt.tab_noeud;
	id_interpol=elt.id_interpol;
	id_geom=elt.id_geom;
	id_problem=elt.id_problem;
	infos_annexes=elt.infos_annexes;
	//*residu = *elt.residu; // tous les résidus, raideurs et tableaux de
    //*raideur = *elt.raideur;// pointent sur des données static
 volume = elt.volume;
 volumePlan = elt.volumePlan;
 // ---- cas des intégrales ----
 if (elt.integ_vol_typeQuel != NULL)
  {if (integ_vol_typeQuel == NULL)
    {integ_vol_typeQuel = new Tableau <TypeQuelconque>(*(elt.integ_vol_typeQuel));}
   else {(*integ_vol_typeQuel) = (*elt.integ_vol_typeQuel);};
  }
 else {if (integ_vol_typeQuel != NULL) delete integ_vol_typeQuel;};
 
 if (elt.integ_vol_typeQuel_t != NULL)
  {if (integ_vol_typeQuel_t == NULL)
    {integ_vol_typeQuel_t = new Tableau <TypeQuelconque>(*(elt.integ_vol_typeQuel_t));}
   else {(*integ_vol_typeQuel_t) = (*elt.integ_vol_typeQuel_t);};
  }
 else {if (integ_vol_typeQuel_t != NULL) delete integ_vol_typeQuel_t;};
 
 if (elt.integ_vol_t_typeQuel != NULL)
  {if (integ_vol_t_typeQuel == NULL)
    {integ_vol_t_typeQuel = new Tableau <TypeQuelconque>(*(elt.integ_vol_t_typeQuel));}
   else {(*integ_vol_t_typeQuel) = (*elt.integ_vol_t_typeQuel);};
  }
 else {if (integ_vol_t_typeQuel != NULL) delete integ_vol_t_typeQuel;};

 if (elt.integ_vol_t_typeQuel_t != NULL)
  {if (integ_vol_t_typeQuel_t == NULL)
    {integ_vol_t_typeQuel_t = new Tableau <TypeQuelconque>(*(elt.integ_vol_t_typeQuel_t));}
   else {(*integ_vol_t_typeQuel_t) = (*elt.integ_vol_t_typeQuel_t);};
  }
 else {if (integ_vol_t_typeQuel_t != NULL) delete integ_vol_t_typeQuel_t;};

 if (elt.index_Integ_vol_typeQuel != NULL)
  {if (index_Integ_vol_typeQuel == NULL)
    {index_Integ_vol_typeQuel = new Tableau <int>(*(elt.index_Integ_vol_typeQuel));}
   else {(*index_Integ_vol_typeQuel) = (*elt.index_Integ_vol_typeQuel);};
  }
 else {if (index_Integ_vol_typeQuel != NULL) delete index_Integ_vol_typeQuel;};

 if (elt.index_Integ_vol_t_typeQuel != NULL)
  {if (index_Integ_vol_t_typeQuel == NULL)
    {index_Integ_vol_t_typeQuel = new Tableau <int>(*(elt.index_Integ_vol_t_typeQuel));}
   else {(*index_Integ_vol_t_typeQuel) = (*elt.index_Integ_vol_t_typeQuel);};
  }
 else {if (index_Integ_vol_t_typeQuel != NULL) delete index_Integ_vol_t_typeQuel;};

 if (elt.enu_integ_vol_TQ != NULL)
  {if (enu_integ_vol_TQ == NULL)
    {enu_integ_vol_TQ = new Tableau <TypeQuelconque_enum_etendu>(*(elt.enu_integ_vol_TQ));}
   else {(*enu_integ_vol_TQ) = (*elt.enu_integ_vol_TQ);};
  }
 else {if (enu_integ_vol_TQ != NULL) delete enu_integ_vol_TQ;};

 if (elt.enu_integ_vol_t_TQ != NULL)
  {if (enu_integ_vol_t_TQ == NULL)
    {enu_integ_vol_t_TQ = new Tableau <TypeQuelconque_enum_etendu>(*(elt.enu_integ_vol_t_TQ));}
   else {(*enu_integ_vol_t_TQ) = (*elt.enu_integ_vol_t_TQ);};
  }
 else {if (enu_integ_vol_t_TQ != NULL) delete enu_integ_vol_t_TQ;};

//--------- fin intégrale

// tabb = elt.tabb; // non ça c'est une erreur car on fait une recopie de frontière et
// pas de création 
 int dim_tabb_new = elt.tabb.Taille();
 // on commence par supprimer le tableau actuel, car les nouvelles frontières peuvent
 // être complètement différentes des anciennes
 Element::SupprimeFront();
 // maintenant on affecte
 tabb.Change_taille(dim_tabb_new);
 for (int i=1;i<=dim_tabb_new;i++)
  if (elt.tabb(i) != NULL)
    tabb(i) = elt.tabb(i)->NevezElemFront();
 // maintenant les indicateurs
 ind_front_lin = elt.ind_front_lin;
 ind_front_surf = elt.ind_front_surf;
 ind_front_point = elt.ind_front_point;
 posi_tab_front_lin = elt.posi_tab_front_lin;
 posi_tab_front_point = elt.posi_tab_front_point;
 boite_encombre = elt.boite_encombre;
 prepa_niveau_precision = elt.prepa_niveau_precision;
 sens_numerotation = elt.sens_numerotation;
 
	return (*this);	
};
		
// calcul d'une longueur géométrique mini représentative de l'élément
// cas = 1: correspond à la distance mini entre deux noeuds coins de l'élément
// cas = 2: dans le cas 1D -> distance mini entre noeuds extrèmes
//          en 2D: quadrangle: racine carré de la surface; triangle: racine carré de 2*surface
//          en 3D: hexa: racine cubique de vol; penta: racine cub de 2*vol, tétra: racine cub 6*vol
// cas = 3: 1D idem cas 2, 2D: distance mini noeud arrête opposée, 3D: distance mini noeud face opposé
double Element::LongueurGeometrique(int cas) const 
 { double longueur=0.; // valeur de retour
   switch (cas)
    { case 1:
       { int nbne = tab_noeud.Taille(); // récup du nombre de noeud
//cout << "\n nbne=" << nbne;		 
         // tout d'abord l'objectif est de déterminer la distance minimum entre les différents noeuds
         // initialisation de la distance entre les deux noeuds
         double dist = ConstMath::tresgrand;
         if (tab_noeud(1)->ExisteCoord1())
          {// cas où les coordonnées à t sont définit
            for (int i=1;i<= nbne;i++)
              // on itère sur les noeuds restants
              for (int j=i+1;j<= nbne;j++)
               { double dist_new = (tab_noeud(i)->Coord1() - tab_noeud(j)->Coord1()).Norme();
//cout << " dist_new= " << dist_new;					
                 if (dist_new < dist) dist = dist_new;
                }
           } 
         else 
           {// cas où seules les coordonnées à 0 sont définit
            for (int i=1;i<= nbne;i++)
              // on itère sur les noeuds restants
              for (int j=i+1;j<= nbne;j++)
               { double dist_new = (tab_noeud(i)->Coord0() - tab_noeud(j)->Coord0()).Norme();
                 if (dist_new < dist) dist = dist_new;
                }
           } 
         // traitement d'une erreur éventuelle
         if (dist <= ConstMath::petit)
          { cout << "\n **** ERREUR une longueur d'arrête de l'element est nulle"
                 << "\n Element::LongueurGeometrique(int cas)"
                 << "\n element: "; this->Affiche(1);
            #ifdef MISE_AU_POINT
            cout << "\n *** version mise au point: on continue neanmoins avec une longueur "
                 << " arbitrairement tres petite (" <<ConstMath::petit <<")  ";
            #else
            Sortie(1);
            #endif
           }
         longueur=dist; //enregistrement     
         break;
        }
      default :
	   cout << "\nErreur : cas:" << cas <<" non encore traite  !\n"
			<< "Element::LongueurGeometrique(int cas) ) \n";
	   Sortie(1);
	 }  
//cout << " longueur= "<<  longueur << endl;
   return longueur;   
  };

// calcul le volume entre l'élément (=surface2D) et les plans de ref: yz, xz, xy, dans cet ordre
// valable uniquement pour les éléments 2D dans un espace 3D, ramène une dim nulle sinon
// le calcul est approché, il est effectué à partir d'une triangulation de la surface de l'élément
const Coordonnee & Element::VolumePlan()
{ // petite vérif au début
  if (!((ParaGlob::Dimension()==3)&&(Type_geom_generique(id_geom)==SURFACE)))
    {
     #ifdef MISE_AU_POINT
      if (ParaGlob::NiveauImpression() > 4)
       {cout << "\n **** attention "
             << " ( elem "<<num_elt<<" du maillage "<< num_maillage <<") ";
        if (ParaGlob::Dimension()!=3) cout << " dim " << ParaGlob::Dimension();
        if (Type_geom_generique(id_geom)!=SURFACE)
         cout << " geometrie " << Nom_type_geom(Type_geom_generique(id_geom));
        cout << " pas de calcul definit de volume entre surface et plans de ref ";
       
//       cout << "\n **** attention, soit la geometrie n'est pas une surface, soit la dimension n'est pas 3 !!!! "
//             << "\n ( elem "<<num_elt<<" du maillage "<< num_maillage <<") "
//             << "\n **** le calcul du volume entre la surface et les plans de reference n'est pas definit dans ce cas " ;
        if (ParaGlob::NiveauImpression() > 8)
             cout << " Coordonnee & Element::VolumePlan() ";
//        cout << endl;
       };
     #endif
     volumePlan.Change_dim(0);
	    return volumePlan;
	   };
  // --- maintenant on est dans le cas d'un élément 2D et le calcul est en 3D
  // on récupère l'élément géométrique
  ElemGeomC0& elgeo = this->ElementGeometrique(); 
  // on récupère la triangulation
  const Tableau<Tableau<Tableau<int> > >& triaLinGlob = elgeo.Trian_lin();
  // comme on a un élément surface, il n'y a qu'une face pour l'élément, on simplifie
  const Tableau<Tableau<int> > & triaLin = triaLinGlob(1); 
  // on boucle sur les triangles
  int nbtriang = triaLin.Taille();
  volumePlan.Zero();
  for (int i=1;i<=nbtriang;i++)
   { const Tableau<int> & tabNG = triaLin(i); // pour simplifier
     const Coordonnee& A = tab_noeud(tabNG(1))->Coord2();
     const Coordonnee& B = tab_noeud(tabNG(2))->Coord2();
     const Coordonnee& C = tab_noeud(tabNG(3))->Coord2();	
     Coordonnee AB(B-A); Coordonnee AC(C-A);
     Coordonnee G=1./3.*(A+B+C); // coordonnées du centre de gravité
     Coordonnee so=0.5*Util::ProdVec_coor(AB,AC);
     so(1) *=G(1);so(2) *=G(2);so(3) *=G(3); 
     volumePlan += so;
   };
  // retour
  return volumePlan;
};

// vérification de l'existence d'un point d'intégration correspondant à un ddl
bool Element::Existe_pt_integ (int nbptinteg, Enum_ddl enu) const
   { // récup de l'élement géométrique de l'élément
     const ElemGeomC0& elemgeo = this->ElementGeometrie(enu);
     // vérif du numéro de pt d'integ
     if ((nbptinteg <= 0) || (nbptinteg > elemgeo.Nbi())) 
        return false;
     else 
        return true;
    };
    
// avec la méthode Frontiere() on obtient un tableau de frontières tabb(i) , qui peut contenir des points, lignes ou surfaces
// la méthode qun peu redondante, mais pratique, qui ramène le numéro local "n" de frontière dans  le type en fonction du numéro global "i"
// d'une manière générale supposons que tabb contient des lignes, points et surfaces, alors:  
//     si tabb(i) est une surface, Num_de_frontiere_dans_le_type(i) donnera le numéro de la surface 
//     si tabb(i) est une ligne, Num_de_frontiere_dans_le_type(i) donnera le numéro de la ligne 
//     si tabb(i) est un point, Num_de_frontiere_dans_le_type(i) donnera le numéro du point
int Element::Num_de_frontiere_dans_le_type(int i) const
 { // on supprime les cas hors du tableau tabb
   if (i<1) return 0; 
   int tailletab = tabb.Taille();
	if (i>tailletab) return 0;
	// cas normal
	if (i <= posi_tab_front_lin) 
	   // cela veut dire que i est une surface car les premières frontières sont les surfaces, de plus i est directement le numéro de surface
	   { return i;}
	else if (i <= posi_tab_front_point) 	
	   // cela veut dire que i est une ligne car les  frontières après les surfaces sont les lignes
		{ return (i-posi_tab_front_lin); }
	else 	
	   // cela veut dire que i est un point car les  frontières après les lignes sont des points
		{ return (i-posi_tab_front_point);};
  };

// ramene le numero de la frontière passée en argument si elle existe actuellement au niveau de l'élément
// sinon ramène 0
// ramene également type_front: qui indique le type de frontière: POINT_G, LIGNE ou SURFACE
// c'est une méthode très longue, a utiliser avec précaution
int Element::Num_frontiere(const ElFrontiere& fronti, Enum_type_geom& type_front)
 { int num=0; type_front = RIEN_TYPE_GEOM; // initialisation du retour
   // on commence par balayer toutes les frontières pour trouver le numéro global
   int tail_tab=tabb.Taille(); 
   for (int i=1;i<=tail_tab;i++)
     if (fronti == (*tabb(i))) {num = i; break;}
   // si num est diff de 0 c'est ok, on recherche le type de frontière
   if (num != 0)
     { // les frontières sont rangées selon: surface, ligne, point
	    // s'il n'y a pas de point: ind_front_point = 0, dans ce cas posi_tab_front_point = 0 par défaut et ne veut rien dire
		 // idem pour les lignes et les surfaces
		 // suivant le type de frontière on retire la position initiale de ce type dans le tableau
	    if ((num > posi_tab_front_point)&&(ind_front_point!=0)) {type_front = POINT_G;num -= posi_tab_front_point;}
       else if ((num > posi_tab_front_lin)&&(ind_front_lin!=0)) {type_front = LIGNE;num -= posi_tab_front_lin;}
		 // si ce n'est ni un point ni une ligne, vue que ça doit-être quelque chose ça ne peut être qu'une surface
       else {type_front = SURFACE;}; // et num a directement la bonne valeur que ce sont d'abord les faces qui sont stockées
      }
   // retour des infos   
   return num;   
  };

// ========== calcul des seconds membres suivant les chargements =======
	   // cas d'un chargement surfacique, sur les frontières des éléments
	   // force indique la force surfacique appliquée
	   // numface indique le numéro de la face chargée
	   // retourne  le second membre résultant 
// ici la définition est celle par défaut qui concerne tous les éléments
// qui ne possède pas de surface externe, type biellette etc
// -> version explicite à t	   
Vecteur Element::SM_charge_surfacique_E_t(const Coordonnee& ,Fonction_nD* ,int ,const ParaAlgoControle & )
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SM_charge_surfacique_E_t(const "
         << "Coordonnee& force,int numFace)  \n";
    Sortie(1);
    return Vecteur();
    };
// -> version explicite à tdt	   
Vecteur Element::SM_charge_surfacique_E_tdt(const Coordonnee& ,Fonction_nD* ,int ,const ParaAlgoControle &  )
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SM_charge_surfacique_E_tdt(const "
         << "Coordonnee& force,int numFace)  \n";
    Sortie(1);
    return Vecteur();
    };
	   // cas d'un chargement surfacique, sur les frontières des éléments
	   // force indique la force surfacique appliquée
	   // numface indique le numéro de la face chargée
	   // NB: il y a une définition par défaut pour les éléments qui n'ont pas de 
	   // surface externe -> message d'erreur  d'où le virtuel et non virtuel pur
// ici la définition est celle par défaut qui concerne tous les éléments
// -> implicit
// pa : permet de déterminer si oui ou non on  calcul la contribution à la raideur 
Element::ResRaid Element::SMR_charge_surfacique_I(const Coordonnee& ,Fonction_nD* ,int ,const ParaAlgoControle & )
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SMR_charge_surfacique_I( "
         << "Coordonnee& force,int numFace)  \n";
    Sortie(1);
    return ResRaid();
    };

	   // cas d'un chargement de type pression, sur les frontières des éléments
	   // pression indique la pression appliquée
	   // numface indique le numéro de la face chargée
	   // retourne  le second membre résultant
	   // NB: il y a une définition par défaut pour les éléments qui n'ont pas de 
	   // surface externe -> message d'erreur  d'où le virtuel et non virtuel pur
// -> cas d'un calcul explicite à t	   
Vecteur Element::SM_charge_pression_E_t(double ,Fonction_nD* ,int ,const ParaAlgoControle &)
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SM_charge_pression_E_t( "
         << "double pression,int numFace)  \n";
    Sortie(1);
    return Vecteur();
    };
// -> cas d'un calcul explicite à tdt	   
Vecteur Element::SM_charge_pression_E_tdt(double ,Fonction_nD* ,int ,const ParaAlgoControle & )
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SM_charge_pression_E_tdt( "
         << "double pression,int numFace)  \n";
    Sortie(1);
    return Vecteur();
    };
    
// -> implicite, 
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur 
// retourne le second membre et la matrice de raideur correspondant
Element::ResRaid Element::SMR_charge_pression_I(double ,Fonction_nD* ,int ,const ParaAlgoControle & ) 
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SMR_charge_pression_I( "
         << "double pression,int numFace)  \n";
    Sortie(1);
    return ResRaid();
    };


	   // cas d'un chargement de type pression unidirectionnelle, sur les frontières des éléments
	   // presUniDir indique le vecteur  appliquée
	   // numface indique le numéro de la face chargée
	   // retourne  le second membre résultant
	   // NB: il y a une définition par défaut pour les éléments qui n'ont pas de 
	   // surface externe -> message d'erreur  d'où le virtuel et non virtuel pur
// -> cas d'un calcul explicite à t	   
Vecteur Element::SM_charge_presUniDir_E_t(const Coordonnee& ,Fonction_nD* ,int ,const ParaAlgoControle &  )
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SM_charge_presUniDir_E_t( "
         << "const Coordonnee& presUniDir,int numFace)  \n";
    Sortie(1);
    return Vecteur();
    };
// -> cas d'un calcul explicite à tdt	   
Vecteur Element::SM_charge_presUniDir_E_tdt(const Coordonnee& ,Fonction_nD* ,int ,const ParaAlgoControle & )
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SM_charge_presUniDir_E_tdt( "
         << "const Coordonnee& presUniDir,int numFace)  \n";
    Sortie(1);
    return Vecteur();
    };
	   // -> implicite, 
       // pa: permet de déterminer si oui ou non on calcul la contribution à la raideur 
	   // retourne le second membre et la matrice de raideur correspondant
Element::ResRaid Element::SMR_charge_presUniDir_I(const Coordonnee& ,Fonction_nD* ,int ,const ParaAlgoControle & )
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SMR_charge_presUniDir_I( "
         << "const Coordonnee& presUniDir,int numFace)  \n";
    Sortie(1);
    return ResRaid();
    };

	   // cas d'un chargement lineique, sur les aretes frontières des éléments
	   // force indique la force lineique appliquée
	   // numarete indique le numéro de l'arete chargée
	   // retourne  le second membre résultant
// ici la définition est celle par défaut qui concerne tous les éléments
// qui ne possède pas d'arete externe, type point !	   
// -> explicite à t
Vecteur Element::SM_charge_lineique_E_t(const Coordonnee& ,Fonction_nD* ,int ,const ParaAlgoControle & )
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SM_charge_lineique_E_t(const "
         << "Coordonnee& force,int numFace)  \n";
    Sortie(1);
    return Vecteur();
    };
// -> explicite à tdt
Vecteur Element::SM_charge_lineique_E_tdt(const Coordonnee& ,Fonction_nD* ,int ,const ParaAlgoControle & )
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SM_charge_lineique_E_tdt(const "
         << "Coordonnee& force,int numFace)  \n";
    Sortie(1);
    return Vecteur();
    };
    
// -> implicite, 
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur 
// retourne le second membre et la matrice de raideur correspondant
Element::ResRaid Element::SMR_charge_lineique_I(const Coordonnee& ,Fonction_nD* ,int ,const ParaAlgoControle & )
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SMR_charge_lineique__I(bool "
         << "Coordonnee& force,int numFace)  \n";
    Sortie(1);
    return ResRaid();
    };

	   // cas d'un chargement lineique suiveuse, sur les aretes frontières des éléments 2D (uniquement)
	   // force indique la force lineique appliquée
	   // numarete indique le numéro de l'arete chargée
	   // retourne  le second membre résultant
// ici la définition est celle par défaut qui concerne tous les éléments
// qui ne possède pas d'arete externe, type point ! ou 3D pour lesquels la fonction n'est pas implantée	   
// -> explicite à t
Vecteur Element::SM_charge_lineique_Suiv_E_t(const Coordonnee& ,Fonction_nD* ,int ,const ParaAlgoControle & )
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SM_charge_lineique_Suiv_E_t(const "
         << "Coordonnee& force,int numFace)  \n";
    Sortie(1);
    return Vecteur();
    };
// -> explicite à tdt
Vecteur Element::SM_charge_lineique_Suiv_E_tdt(const Coordonnee& ,Fonction_nD* ,int ,const ParaAlgoControle & )
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SM_charge_lineique_Suiv_E_tdt(const "
         << "Coordonnee& force,int numFace)  \n";
    Sortie(1);
    return Vecteur();
    };
    
// -> implicite, 
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur 
// retourne le second membre et la matrice de raideur correspondant
Element::ResRaid Element::SMR_charge_lineique_Suiv_I(const Coordonnee& ,Fonction_nD* ,int ,const ParaAlgoControle &)
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SMR_charge_lineique_Suiv_I(bool "
         << "Coordonnee& force,int numFace)  \n";
    Sortie(1);
    return ResRaid();
    };

       // cas d'un chargement volumique, 
	   // force indique la force volumique appliquée
	   // retourne  le second membre résultant
// -> explicite à t
Vecteur Element::SM_charge_volumique_E_t(const Coordonnee& ,Fonction_nD* ,const ParaAlgoControle & ,bool )
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SM_charge_volumique_E_t(const "
         << "Coordonnee& force)  \n";
    Sortie(1);
    return Vecteur();
    };
// -> explicite à tdt
Vecteur Element::SM_charge_volumique_E_tdt(const Coordonnee& ,Fonction_nD* ,const ParaAlgoControle & ,bool )
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SM_charge_volumique_E_tdt(const "
         << "Coordonnee& force)  \n";
    Sortie(1);
    return Vecteur();
    };
    
// -> implicite, 
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur 
// retourne le second membre et la matrice de raideur correspondant
Element::ResRaid Element::SMR_charge_volumique_I(const Coordonnee& ,Fonction_nD* ,const ParaAlgoControle & ,bool )
  { cout << "\n Erreur , fonction non défini pour l'élément \n";
    cout << "\n méthode : SMR_charge_volumique_I(bool "
         << "Coordonnee& force)  \n";
    Sortie(1);
    return ResRaid();
    };



// cas d'un chargement surfacique hydrostatique, 
// poidvol: indique le poids volumique du liquide
// M_liquide : un point de la surface libre
// dir_normal_liquide : direction normale à la surface libre
// sans_limitation : indique s'il y a une limitation du calcul pour les seuls positions négatives
// retourne  le second membre résultant
// -> explicite à t	   
Vecteur Element::SM_charge_hydrostatique_E_t(const Coordonnee& ,const double& ,int
                                       ,const Coordonnee& ,const ParaAlgoControle & , bool)
  { cout << "\n Erreur , fonction non defini pour l'element \n";
    cout << "\n methode : SM_charge_hydrostatique_E_t(... \n";
    Sortie(1);
    return Vecteur();
    };
// -> explicite à tdt	   
Vecteur Element::SM_charge_hydrostatique_E_tdt(const Coordonnee& ,const double& ,int
                                      ,const Coordonnee& ,const ParaAlgoControle & ,bool )
  { cout << "\n Erreur , fonction non defini pour l'element \n";
    cout << "\n methode : SM_charge_hydrostatique_E_tdt(... \n";
    Sortie(1);
    return Vecteur();
    };
// -> implicite, 
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur 
// retourne le second membre et la matrice de raideur correspondant
Element::ResRaid Element::SMR_charge_hydrostatique_I(const Coordonnee&  ,const double& ,int
                                    ,const Coordonnee& ,const ParaAlgoControle & ,bool)
  { cout << "\n Erreur , fonction non defini pour l'element \n";
    cout << "\n methode : SMR_charge_hydrostatique_I(... \n";
    Sortie(1);
    return ResRaid();
    };
	 

	   // cas d'un chargement surfacique hydro-dynamique, 
       // Il y a trois forces: une suivant la direction de la vitesse: de type traînée aerodynamique
       // Fn = poids_volu * fn(V) * S * (normale*u) * u, u étant le vecteur directeur de V (donc unitaire)
       // une suivant la direction normale à la vitesse de type portance
       // Ft = poids_volu * ft(V) * S * (normale*u) * w, w unitaire, normal à V, et dans le plan n et V
       // une suivant la vitesse tangente de type frottement visqueux
       // T = to(Vt) * S * ut, Vt étant la vitesse tangentielle et ut étant le vecteur directeur de Vt
       // coef_mul: est un coefficient multiplicateur global (de tout)
	   // retourne  le second membre résultant
// -> explicite à t	   
Vecteur Element::SM_charge_hydrodynamique_E_t( Courbe1D* ,const double& 
	                                         , Courbe1D* ,int ,const double& 
	                                         , Courbe1D* ,const ParaAlgoControle & )
  { cout << "\n Erreur , fonction non defini pour l'element \n";
    cout << "\n methode : SM_charge_hydrodynamique_E_t(... \n";
    Sortie(1);
    return Vecteur();
    };
// -> explicite à tdt	   
Vecteur Element::SM_charge_hydrodynamique_E_tdt( Courbe1D* ,const double& 
	                                         , Courbe1D* ,int ,const double& 
	                                         , Courbe1D*  ,const ParaAlgoControle & )
  { cout << "\n Erreur , fonction non defini pour l'element \n";
    cout << "\n methode : SM_charge_hydrodynamique_E_tdt(... \n";
    Sortie(1);
    return Vecteur();
    };
// -> implicite, 
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur 
// retourne le second membre et la matrice de raideur correspondant
Element::ResRaid Element::SMR_charge_hydrodynamique_I( Courbe1D* ,const double& 
	                                         ,  Courbe1D* ,int ,const double& 
	                                         ,  Courbe1D*  ,const ParaAlgoControle & ) 
  { cout << "\n Erreur , fonction non defini pour l'element \n";
    cout << "\n methode : SMR_charge_hydrodynamique_I(... \n";
    Sortie(1);
    return ResRaid();
    };
	 

// ======== choix d'un element =====================================
	    // choix d'un element derive etaffectation d'un pointeur d'element 
	    // en fonction de id_geom et id_interpol
        // le numero d'element : num_elt, est affecte a l'element pointe par ptr
        // fonctionnement : le choix est effectue grace a la liste static "listTypeElement"
        // qui est rempli au moment du chargement du programme, par toutes
        // classes derivees
Element* Element::Choix_element(int num_mail,int num_elt,Enum_geom id_geom,
                         Enum_interpol id_interpol,EnumElemTypeProblem  id_typeProb
                         ,const string& infos_annexes)
  {  // déclaration d'une variable static qui permet de gagner du temps de recherche
     static list <Element::NouvelleTypeElement>::iterator dernier_itt;       
     list <Element::NouvelleTypeElement>::iterator itt=dernier_itt;
     Element * ptr = NULL;
     if (!premier_passage_Choix_element)
       // on teste de dernier choix d'élément
       {if (((*itt).id_interpol == id_interpol) && ((*itt).id_geom == id_geom)
            && ((*itt).id_typeProblem == id_typeProb)&&((*itt).infos_annexes == infos_annexes))
          {// on a trouve le bon element
           ptr = ((*itt).el)->NouvelElement(num_mail,num_elt);
           // on sauvegarde le pointeur pour la prochaine fois pour gagner du temps de recherche
           dernier_itt=itt;
           return ptr;
           }
       }  
     // si l'on n'a pas trouvé on balaie la liste des elements enregistre
     for (itt=Element::listTypeElement.begin() ; itt != Element::listTypeElement.end(); itt++)
        if (((*itt).id_interpol == id_interpol) && ((*itt).id_geom == id_geom)
            && ((*itt).id_typeProblem == id_typeProb) 
            &&((*itt).infos_annexes == infos_annexes))
         {/*cout << "\n(*itt).infos_annexes.size() " << (*itt).infos_annexes.size();
          cout << "\n infos_annexes.size() " << infos_annexes.size();
          cout << "\n (*itt).infos_annexes " << (*itt).infos_annexes;
         if ((((*itt).infos_annexes.size()==0)&&(infos_annexes.size()==0))
               || ((*itt).infos_annexes == infos_annexes)) */
             {// on a trouve le bon element
              ptr = ((*itt).el)->NouvelElement(num_mail,num_elt);
              // on sauvegarde le pointeur pour la prochaine fois pour gagner du temps de recherche
              dernier_itt=itt;
              return ptr;
              }
           }
     // cas ou l'on n'a pas trouve d'element
     ptr = NULL;
     itt = Element::listTypeElement.begin(); // pour éviter une erreur au prochain passage
     return ptr;     
  };
                         	
// idem en fonction de la signature
Element* Element::Choix_element(int num_mail,int num_elt,Signature signa)
   { return  Choix_element(num_mail,num_elt,signa.id_geom,signa.id_interpol,signa.id_problem
                          ,signa.infos_annexes);
    };
    
// renseignement d'un élément complet à partir d'un élément incomplet de même type
// retourne les nouveaux noeuds construit à partir de l'interpolation incomplète.
// dans le cas l'élément n'est pas concerné, retourne une liste vide
// ramène également une liste de même dimension contenant les bornes en numéros de noeuds
// entre lesquelles il faut définir les nouveaux numéros de noeuds si l'on veut conserver
// une largeur de bande optimisée du même type
// nbnt+1: est le premier numéro de noeud utilisable pour les nouveaux noeuds
list <Noeud *> Element::Construct_from_imcomplet(const Element & ,list <DeuxEntiers> & ,int  )
   { list <Noeud *> li;
     if (this->id_interpol != QUADRACOMPL)
       // l'élément n'est pas concerné
       return li;
     else
      { cout << "\n fonction non implante actuellement pour l'element ";
        Affiche();
        Sortie(1);
       }
     return li; // pour faire taire le compilo
    };
        
// renseignement d'un élément quadratique incomplet à partir d'un élément linéaire de même type
// retourne les nouveaux noeuds construit à partir de l'interpolation linéqire.
// dans le cas où l'élément n'est pas concerné, retourne une liste vide
// ramène également une liste de même dimension contenant les bornes en numéros de noeuds
// entre lesquelles il faut définir les nouveaux numéros de noeuds si l'on veut conserver
// une largeur de bande optimisée du même type
// nbnt+1: est le premier numéro de noeud utilisable pour les nouveaux noeuds
list <Noeud *> Element::Construct_from_lineaire(const Element & ,list <DeuxEntiers> & , int )
   { list <Noeud *> li;
     if (this->id_interpol != LINEAIRE)
       // l'élément n'est pas concerné
       return li;
     else
      { cout << "\n fonction non implante actuellement pour l'element ";
        Affiche();
        Sortie(1);
       }
     return li; // pour faire taire le compilo
    };

// réaffectation d'un pointeur de noeud
// ramène faux si l'opération n'est pas possible
bool Element::Reaffectation_pointeur_noeud(Noeud * ancien, Noeud * nouveau)
 { // on balaie les noeuds de l'éléments
   int nbn = tab_noeud.Taille();
   for (int i=1;i<=nbn;i++)
    { if (tab_noeud(i)==ancien)
        { tab_noeud(i) = nouveau;
          return true;
         }
     }
   // cas ou l'on n'a pas trouvé le noeud
   return false; 
  };
                         
// ======== sortie fichier de commande ====================================
// ramène un tableau de pointeur  d'élément qui sont concerné
// par la sortie des commandes 
Tableau <Element*> Element::Info_commande_Element(UtilLecture * )
  {  // tout d'abord on balaie la liste des elements enregistre pour savoir le nombre
     // d'element concerné
     string ordd = "concerne"; int nbel=0; int nbmail=0;
     list <Element::NouvelleTypeElement>::iterator itt;
     for (itt=Element::listTypeElement.begin() ; itt != Element::listTypeElement.end(); itt++)
       {bool ret = ((*itt).el)->Element_possible();
        if (ret) 
          nbel++;
        }
     // maintenant on peut dimensionner le tableau de manière a_doc
     Tableau <Element*> retour(nbel); 
     // on cree le tableau d'element
     nbel=1;
     for (itt=Element::listTypeElement.begin() ; itt != Element::listTypeElement.end(); itt++)
       {bool ret = ((*itt).el)->Element_possible();
        if (ret) 
          { retour(nbel) = ((*itt).el)->NouvelElement(nbmail,nbel);
            nbel++;
           } 
        }
     return retour;  
  };                       	
        
//=====================================================================================
// METHODES  PROTEGEES utilisables par les classes derivees :
//=====================================================================================
        
// affichage d'info en fonction de ordre
// ordre = "commande" : affichage d'un exemple d'entree pour l'élément
void Element::Info_com_El
        (int nbnoeu,UtilLecture * entreePrinc,string& ordre,Tableau<Noeud  *> * tabMaillageNoeud)                          
  { if (ordre == "commande")
     { // def des noeuds de l'élément
       tab_noeud.Change_taille(nbnoeu);
       for (int i=1;i<=nbnoeu;i++)
         tab_noeud(i) = (*tabMaillageNoeud)(i); 
       // construction du tableau de ddl des noeuds de biellette
       ConstTabDdl(); 
       // affichage de l'élément
       ofstream & sort = *(entreePrinc->Commande_pointInfo());
       sort << "\n " << setw (6) << this->Num_elt() 
            << "   " <<  this->Geometrie()
            << "   " <<  this->Interpolation() << "  ";
       // sortie de la connection
       int compteur_ligne=6;
       for (int n1=1;n1<= nbnoeu;n1++,compteur_ligne++)
         { if (compteur_ligne > 10) 
             { compteur_ligne = 0; sort << "\n";}
               sort << setw (6) << n1 <<" ";
           }
      } 
  };
        	 
                         				
	// ---------------- lecture écriture dans base info  ----------------
	//  pour les données spécifiques à element
	
	   // 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 Element::Lect_bas_inf_element
   (ifstream& ent,const Tableau<Noeud  *> * tabMaillageNoeud,const int cas) 
 {switch (cas)
  { case 1 : // ------- on récupère tout -------------------------
     { // le tableau de connection des noeuds
       int tab_noeudTaille; string toto;
       ent >> toto >> tab_noeudTaille >> toto;
       if (tab_noeud.Taille() != tab_noeudTaille)
	       { cout << "\nErreur : valeur incorrecte du nombre de noeud !\n";
	         cout << "Element::Lect_bas_inf_element(...)";
     	    Sortie(1);
     	  };
       int nb;	  
       for (int i=1;i<= tab_noeudTaille; i++)
         { ent >> nb;
           tab_noeud(i) = (*tabMaillageNoeud)(nb);
         };
	      break;
	    }
    case  2 : // ----------- lecture uniquement de se qui varie --------------------
     { // ici on lit et on vérifie que la connexion est correcte mais on ne change rien
       int tab_noeudTaille; string toto;
//     sort << "connexion " << tab_noeudTaille << " noeuds:  ";
       ent >> toto >> tab_noeudTaille >> toto;
       bool erreur_connexion=false;
       if (tab_noeud.Taille() != tab_noeudTaille)
        erreur_connexion = true;
       Tableau <int> inter(tab_noeudTaille);	
       for (int i=1;i<= tab_noeudTaille; i++)
         { ent >> inter(i);
           if (inter(i) != tab_noeud(i)->Num_noeud())
             {erreur_connexion = true;}
          };
      
       if (erreur_connexion)
	       { cout << "\nErreur : valeur incorrecte du nombre de noeud lu !"
               << " element nb: "<< num_elt << " maillage " << num_maillage;
          cout  << " \n la connexion en cours :";
          cout << "connexion " << tab_noeud.Taille() << " noeuds:  ";
          for (int i=1;i<= tab_noeud.Taille(); i++)
            cout << tab_noeud(i)->Num_noeud() << " ";
          cout << "\n connexion lue:                   " << tab_noeudTaille << " noeuds:  ";
          for (int i=1;i<= tab_noeudTaille; i++)
            cout << inter(i) << " ";
          cout  << "\n";
          if (ParaGlob::NiveauImpression() > 5)
	            cout << "Element::Lect_bas_inf_element(...)";
          Sortie(1);
     	  };
       // lecture du volume
       ent >> toto >> volume;
      
       // --- cas des intégrales volumiques:
       // 1) les intégrales de volume
       string mot;
       ent >> mot;
       if (mot != "int_vol" )
         { cout << "\n *** erreur en lecture du .info, le mot cle lu est "<<mot
                << " on attendait int_vol , la suite va etre erronee, on stop la lecture "
                << endl;
           Sortie(1);
         };
       int indic_test=0; ent >> indic_test; // on ne continue que si indic est diff de 0
       if (indic_test)
        { int taille=indic_test;
          for (int i=1; i<= taille;i++)
            {// lecture avec création éventuelle si le type n'existe pas
             TypeQuelconque_enum_etendu tqnevez =
                 TypeQuelconque_enum_etendu::Lecture_avec_creation_eventuelle(ent);
             // on parcours la liste actuelle pour trouver la bonne grandeur éventuelle
             int indic = 0 ; // init
             if (enu_integ_vol_TQ != NULL)
               indic = enu_integ_vol_TQ->Contient(tqnevez);
             // maintenant, éventuellement indic = le numéro du conteneur existant
             if (indic)
              { (*integ_vol_typeQuel_t)(indic).Grandeur_pointee()->Lecture_grandeur(ent);
              }
             else // cas ou la grandeur n'existe pas
              { // c'est un peu plus délicat car on ne sait pas ce que l'on doit lire
                 // on lit l'entête du type quelconque
                //  -> on crée un grandeur quelconque sans grandeur associé ceci pour lire les entêtes
                TypeQuelconque pour_lire(RIEN_TYPEQUELCONQUE);
                // lecture de l'entête et récup d'enu
                EnuTypeQuelParticulier enu = pour_lire.Lecture_un(ent);
                // création d'une grandeur associée et lecture des information sur le flot
                TypeQuelconque::Grandeur* grandeur =NevezGrandeurParticuliereEnLecture(enu,ent);
                // création du type quelconque
                TypeQuelconque typQ(pour_lire.EnuTypeQuelconque(),pour_lire.Enum(),*grandeur);
                delete grandeur; // car il ne sert plus à rien
                // maintenant on va mettre à jour le stockage interne
                // ici on rajoute à la fin des tableaux, donc cela ne change pas ce qui a été lue
                // à l'initialisation du .info
                taille = integ_vol_typeQuel->Taille()+1;
                integ_vol_typeQuel->Change_taille(taille);
                integ_vol_typeQuel_t->Change_taille(taille);
                (*integ_vol_typeQuel)(taille) = typQ;
                (*integ_vol_typeQuel_t)(taille) = typQ;
                index_Integ_vol_typeQuel->Change_taille(taille);
                // par défaut on met l'index à -1, ce qui veut dire que la grandeur est
                // pour l'instant figé, tant que le calcul n'a pas démarré et que
                // l'utilisateur a indiqué qu'il désirait continuer l'intégration
                (*index_Integ_vol_typeQuel)(taille) = -1;
                enu_integ_vol_TQ->Change_taille(taille);
                (*enu_integ_vol_TQ)(taille)=tqnevez;
              };

            };
        };

       // 2) les intégrales de volume et en temps
       ent >> mot;
       if (mot != "int_vol_t" )
         { cout << "\n *** erreur en lecture du .info, le mot cle lu est "<<mot
                << " on attendait int_vol_t , la suite va etre erronee, on stop la lecture "
                << endl;
           Sortie(1);
         };
       int indic_test_t=0; ent >> indic_test_t; // on ne continue que si indic est diff de 0
       if (indic_test_t)
        { int taille=indic_test_t;
          for (int i=1; i<= taille;i++)
            {// lecture avec création éventuelle si le type n'existe pas
             TypeQuelconque_enum_etendu tqnevez =
                 TypeQuelconque_enum_etendu::Lecture_avec_creation_eventuelle(ent);
             // on parcours la liste actuelle pour trouver la bonne grandeur éventuelle
             int indic = 0 ; // init
             if (enu_integ_vol_t_TQ != NULL)
               indic = enu_integ_vol_t_TQ->Contient(tqnevez);
             // maintenant, éventuellement indic = le numéro du conteneur existant
             if (indic)
              // cas simple où la grandeur exise déjà
              { (*integ_vol_t_typeQuel_t)(indic).Grandeur_pointee()->Lecture_grandeur(ent);
              }
             else // cas ou la grandeur n'existe pas
              { // c'est un peu plus délicat car on ne sait pas ce que l'on doit lire
                // on lit l'entête du type quelconque
                //  -> on crée un grandeur quelconque sans grandeur associé ceci pour lire les entêtes
                TypeQuelconque pour_lire(RIEN_TYPEQUELCONQUE);
                // lecture de l'entête et récup d'enu
                EnuTypeQuelParticulier enu = pour_lire.Lecture_un(ent);
                // création d'une grandeur associée et lecture des information sur le flot
                TypeQuelconque::Grandeur* grandeur =NevezGrandeurParticuliereEnLecture(enu,ent);
                // création du type quelconque
                TypeQuelconque typQ(pour_lire.EnuTypeQuelconque(),pour_lire.Enum(),*grandeur);
                delete grandeur; // car il ne sert plus à rien
                // maintenant on va mettre à jour le stockage interne
                // ici on rajoute à la fin des tableaux, donc cela ne change pas ce qui a été lue
                // à l'initialisation du .info
                taille = integ_vol_t_typeQuel->Taille()+1;
                integ_vol_t_typeQuel->Change_taille(taille);
                integ_vol_t_typeQuel_t->Change_taille(taille);
                (*integ_vol_t_typeQuel)(taille) = typQ;
                (*integ_vol_t_typeQuel_t)(taille) = typQ;
                index_Integ_vol_t_typeQuel->Change_taille(taille);
                // par défaut on met l'index à -1, ce qui veut dire que la grandeur est
                // pour l'instant figé, tant que le calcul n'a pas démarré et que
                // l'utilisateur a indiqué qu'il désirait continuer l'intégration
                (*index_Integ_vol_t_typeQuel)(taille) = -1;
                enu_integ_vol_t_TQ->Change_taille(taille);
                (*enu_integ_vol_t_TQ)(taille)=tqnevez;
              };
            };
        };
     
     break;
    }
    default :
	    { cout << "\nErreur : valeur incorrecte du type de lecture !\n";
	      cout << "Element::Lect_bas_inf_element(   "
			         << " cas= " << cas << endl;
	      Sortie(1);
	    }
  };
 }; 
       // cas donne le niveau de sauvegarde
       // = 1 : on sauvegarde tout
       // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Element::Ecri_bas_inf_element(ofstream& sort,const int cas) 
 { // en fait ici on sauvegarde la même chose dans tous les cas, par contre la sortie
   // totale est documentée.
   switch (cas)
    { case 1 : // ------- on sauvegarde tout -------------------------
     { // le tableau de connection des noeuds
       int tab_noeudTaille = tab_noeud.Taille();
       sort << "connexion " << tab_noeudTaille << " noeuds:  ";
       for (int i=1;i<= tab_noeudTaille; i++)
         sort << tab_noeud(i)->Num_noeud() << " ";
       sort << "\n";  
	      break;
	    }
    case  2 : // ----------- sauvegarde uniquement de se qui varie --------------------
     { // on sauvegarde néanmoins la connexion, car cela permettra de détecter une variation
       // éventuelle de la numérotation, ce qui conduit à des erreurs de restart, très difficile
       // à localiser !!
       // donc le tableau de connection des noeuds
       int tab_noeudTaille = tab_noeud.Taille();
       sort << "connexion " << tab_noeudTaille << " noeuds:  ";
       for (int i=1;i<= tab_noeudTaille; i++)
         sort << tab_noeud(i)->Num_noeud() << " ";
       sort << "\n vol= " << volume << " ";
       // --- cas des grandeurs intégrés éventuelles
       // 1) les intégrales de volume
       sort << "\n int_vol ";
       if (integ_vol_typeQuel == NULL)
         {sort << 0 << " "; }
       else // sinon on sort les informations 
         { int taille = integ_vol_typeQuel->Taille();
           sort << taille ;
           for (int i=1; i<= taille;i++)
            { sort << " \n " << (*enu_integ_vol_TQ)(i) << " "; // l'identificateur
              // puis la grandeur à t
              (*integ_vol_typeQuel_t)(i).Const_Grandeur_pointee()->Ecriture_grandeur(sort);
            };
         };
       // 2) les intégrales de volume et en temps
       sort << "\n int_vol_t ";
       if (integ_vol_t_typeQuel == NULL)
         {sort << 0 << " "; }
       else // sinon on sort les informations
         { int taille = integ_vol_t_typeQuel->Taille();
           sort << taille ;
           for (int i=1; i<= taille;i++)
            { sort << " \n " << (*enu_integ_vol_t_TQ)(i) << " "; // l'identificateur
              // puis la grandeur à t
              (*integ_vol_t_typeQuel_t)(i).Const_Grandeur_pointee()->Ecriture_grandeur(sort);
            };
         };
       sort << "\n";
       break;
	     }
    default :
	     { cout << "\nErreur : valeur incorrecte du type d'écriture !\n";
	       cout << "ElemMeca::Ecriture_bas_inf(ofstream& sort,const int cas)"
			          << " cas= " << cas << endl;
	       Sortie(1);
      }
    };
 };