
// 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/>.

/************************************************************************
 *     DATE:        23/01/97                                            *
 *                                                                $     *
 *     AUTEUR:      G RIO   (mailto:gerardrio56@free.fr)                *
 *                                                                $     *
 *     PROJET:      Herezh++                                            *
 *                                                                $     *
 ************************************************************************
 *     BUT:  definir le groupe de maillage                              *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/
#ifndef LESMAILLAGES_H
#define LESMAILLAGES_H

#include "Maillage.h"
#include "Tableau_T.h"
#include "UtilLecture.h"
#include "ParaGlob.h"
#include "LesReferences.h"
// #include "bool.h"
#include "DiversStockage.h"
#include "LesLoisDeComp.h"
#include "Front.h"
#include "Enum_dure.h"
#include "Nb_assemb.h"
#include "Basiques.h"
#include "Enum_dure.h"
#include "TypeQuelconque.h"
#include "Enum_IO_XML.h"

/** @defgroup Les_Maillages Les_Maillages
*
*     BUT:  definir le groupe de maillage                              *
*
* \author    Gérard Rio
* \version   1.0
* \date       23/01/97
* \brief       Définition du groupe de maillage
*
*/

/// @addtogroup Les_Maillages
///  @{
///

//------------------------------------------------------------------
//!      LesMaillages:  l'ensemble des maillages
//------------------------------------------------------------------
/// \author    Gérard Rio
/// \version   1.0
/// \date       23/01/97

class LesMaillages
{
  public :
    // VARIABLES PUBLIQUES :
    
    // CONSTRUCTEURS : le pointeur sur UtilLecture permet d'avoir acces a la lecture
    //  le second pointe sur les variables globales
    // le troisieme pointe sur l' instance des references
    LesMaillages (UtilLecture * , ParaGlob *,LesReferences* lesRef); 
    // constructeur par défaut
    LesMaillages();   
	   // Constructeur de copie, 
	   LesMaillages(const LesMaillages& lesmail);
    // DESTRUCTEUR :
    ~LesMaillages();    
    // METHODES PUBLIQUES :
    // lecture des maillages et des references s'y rapportant
    void LectureLesMaillages(); 
    // création et ajout d'un nouveau maillage en fonction d'un nom et d'une liste 
    // d'éléments
    // *** il n'y a pas de création de nouveaux noeuds et de nouveaux éléments,
    // ce sont les éléments et noeuds passés en paramètres qui sont ceux du maillage créé
    // >> ramène le numéro du nouveau maillage
    int Creation_nouveau_maillage
           (list <Noeud*>& li_noeud,list <Element*>& list_elem,const string& nom_maillage);
    // suppression d'un maillage existant
    // par défaut, tous les noeuds et éléments du maillage sont supprimés
    // si sans_conservation_noeuds_elements est false: les noeuds et les éléments ne sont pas supprimés
    // mais ils ne sont plus référencés dans ce maillage !
    void Suppression_maillage( const string& nom_maillage,const bool sans_conservation_noeuds_elements = true);
	   // ajout d'un tableau de noeud à un maillage
	   void Ajout_de_Noeuds(const list <Noeud *> & taN, int numMail)
	    {tabMaillage(numMail)->Ajout_de_Noeuds(taN);};
    // -- ajout de noeuds, éléments et éventuellement de ref à un maillage
    // ajout d'une liste d'éléments et de noeud à un maillage
    // si le numéro de maillage associé à l'élément ou noeud est nul, il est remplacé par celui du maillage
    // si le numéro de maillage est déjà existant et est différent ce celui de this, il y a
    // création d'un nouvel item  identique, avec le numéro this
    // ajout éventuel d'une liste de références associées , si celle-ci est non-nulle
    // il y a création de nouvelles ref correspondantes au numéro de maillage de this
    // et ces références sont rajoutées à lesRef
    // les noeuds qui sont associés aux éléments de taE, doivent faire partie : soit de taN, soit du maillage this
    void Ajout_elements_et_noeuds(const list <Noeud *> & taN, const list <Element *> & taE,list <const Reference*>* lref,LesReferences* lesRef, int numMail )
       {tabMaillage(numMail)->Ajout_elements_et_noeuds(taN,taE,lref,lesRef);};

    // affichage et definition interactive des commandes 
    void Info_commande_lesMaillages();
      
    // Affiche les donnees du maillage
	   void Affiche () const ;
    // Affiche les donnees du maillage dans le fichier de nom nom_fichier
	   // au format du fichier ".her"
	   void Affiche (char* nom_fichier)  const ;
	
	   // test si toutes les informations des maillages sont completes
	   // = true -> complet
	   // = false -> incomplet
	   bool Complet();
	
	   // introduction des lois de comportement dans les elements qui le necessite
    //    des sections pour les biellettes etc c-a-d , completer les elements
    // avec les donnees qui ont ete acquises apres la lecture du maillage
    // def des tableaux de ddl dans les noeuds
    // def des pointeurs d'assemblage dans les noeuds
    void Completer(DiversStockage* divers,LesLoisDeComp* lesLois
                  ,LesFonctions_nD*  lesFonctionsnD);
 
    // mise à jour des repères d'anisotropie
    void Mise_a_jour_repere_anisotropie(DiversStockage* divers,LesFonctions_nD*  lesFonctionsnD);

    // ramene le nombre de maillage
    inline int NbMaillage() const 
       { return nbMaillageTotal;};
       
    // ramene le nombre d'element du maillage i
    inline int Nombre_element(int i) const 
       { return tabMaillage(i)->Nombre_element();};
        
    // ramene le nombre de noeud du maillage i
    inline int Nombre_noeud(int i) const 
       { return tabMaillage(i)->Nombre_noeud();};
         
    // ramene l'element j du maillage i 
    inline Element& Element_LesMaille(int i, int j) const
       {return tabMaillage(i)->Element_mail(j);};
    // idem mais en version constant   
    inline const Element& Element_LesMaille_const(int i, int j) const
       {return tabMaillage(i)->Element_mail_const(j);};       
    
    // ramene le noeud j du maillage i 
    inline Noeud& Noeud_LesMaille(int i, int j) const 
       {return tabMaillage(i)->Noeud_mail(j);};

	   // Retourne le tableau des noeuds du maillage i
	   inline Tableau<Noeud *>& Tab_noeud (int i)
		     {	return tabMaillage(i)->Tab_noeud();	};
    
    // Retourne le nom du maillage i
    string NomMaillage(int i) const {return tabMaillage(i)->NomDuMaillage();};
    // retourne le numéro du maillage de nom donné
    // ou 0 si le nom ne correspond pas à un maillage
    int NumMaillage(const string& nom) const 
       {map < string, int , std::less <string> >::const_iterator itmap = mapNomMail.find(nom);
       if (itmap!=mapNomMail.end()) {return (*itmap).second;}
          else                      {return 0;}; 
       };
       
    // suppression éventuelle des noeuds, non référencés par les éléments et les références
    // dans tous les maillages
    void SuppressionNoeudNonReferencer(LesReferences& lesRef)
		    { for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->SuppressionNoeudNonReferencer(lesRef);};
    //  Affichage des noeuds, non référencés par les éléments
    void AffichageNoeudNonReferencer()
		    { for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->AffichageNoeudNonReferencer();};
 
    // renumérotation des noeuds de tous les  maillagesen même temps, + prise en compte
    // des conditions linéaires qui existent entre les noeuds
    // ramène false si rien n'a changé (à cause d'un pb ou parce que la renumérotation n'est pas meilleure), vrai sinon
    // si le pointeur d'assemblage est non nulle, cela veut dire que l'on veut également une mise à jour
    // globale des pointeurs d'assemblages (ce qui est différent de la méthode : MiseAJourPointeurAssemblage(
    //                                       qui agit maillage après maillage)
    // si le pointeur d'assemblage est non nulle et le drapeau: sans_changement_num_noeud = true
    // cela signifie que l'on désire uniquement une renumérotation de pointeur sans les noeuds
    // ramène dans tous les cas les nouvelles largeurs en ddl
    //  nouvelles_largeur_en_ddl.un = la largeur totale résultante
    //  nouvelles_largeur_en_ddl.deux = la demie largeur totale résultante
    //  nouvelles_largeur_en_ddl.trois = la demie largeur maximale pour la partie éléments finis
    //                                   uniquement (sans les CLL)
    //
    bool Renumerotation(LesReferences& lesRef,const Tableau <Tableau <Condilineaire> >& condCLL
                        ,TroisEntiers&  nouvelles_largeur_en_ddl,const Nb_assemb* nb_casAssemb = NULL
                        ,bool sans_changement_num_noeud = false);
 
    // renumérotation des noeuds maillages par maillage,
    // === sans prise en compte de conditions linéaires ===
    // en sortie les maillages sont mis à jour si la nouvelle numérotation conduit à une largeur de bande
    // plus faible que la largeur initiale: en noeuds
    // ramène: false si rien n'a changé (à cause d'un pb ou parce que la renumérotation n'est pas meilleure)
    //         vrai sinon
    bool Renumerotation(LesReferences& lesRef);

    // création éventuelle d'une référence sur les noeuds, non référencés par les éléments
    // dans tous les maillages
    void CreationRefNoeudNonReferencer(LesReferences& lesRef)
		    { for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->CreationRefNoeudNonReferencer(lesRef);};
 
    // ramène le numéro du noeud le plus proche du point donné pour t=0,
    // ceci pour le maillage i, par défaut i vaut 1
    inline int Noeud_le_plus_proche_0(const Coordonnee& M,int i = 1)
      { return  tabMaillage(i)->Noeud_le_plus_proche_0(M); };
    // idem à t  
    inline int Noeud_le_plus_proche_t(const Coordonnee& M,int i = 1)
      { return  tabMaillage(i)->Noeud_le_plus_proche_t(M); };
    // idem à tdt  
    inline int Noeud_le_plus_proche_tdt(const Coordonnee& M,int i = 1)
      { return  tabMaillage(i)->Noeud_le_plus_proche_tdt(M); };

    // ramène le numéro de l'élément qui contiend un point donné et le numéro du point
    // d'intégration le plus proche  pour les ddl de la liste (ddl spécifique à l'élément c'est-a-dire
    // hors des ddl des noeuds de l'éléments)
    // ceci pour le maillage i, (par défaut i vaut 1)
    // si pas de numéro d'élément ramène un numéro d'élément nulle
    // si les numéros de point d'intégration ne sont pas identique pour l'ensemble
    // des ddl, pb !!, le numéro du pt integ de retour est alors négatif
    // si pb ramène un numéro d'élément nulle
	   // enu_temps: dit si les coordonnées du point M sont à 0 ou t ou tdt
    inline Maillage::NBelemEtptInteg Element_le_plus_proche
        (Enum_dure enu_temps,const List_io <Ddl_enum_etendu>& list_enu,const Coordonnee& M,int i = 1)
             { return  tabMaillage(i)->Element_le_plus_proche(enu_temps,list_enu,M); };

    // ramène la liste des problèmes physiques gérés par les éléments de tous les maillages
    inline const list <Enum_ddl >& Ddl_representatifs_des_physiques()const
       {return ddl_representatifs_des_physiques;};

    // ramene la liste des degrés de liberté inconnus, associés aux pb
    // physiques gérés par les éléments qui existent dans tous les maillages
    // Si éléments mécaniques -> ddl Xi voir Vi et gamma_i
    // Si éléments thermiques -> ddl de température
    // Si éléments méca + éléments thermiques -> ddl Xi et température
    // etc. en fonction des éléments qui existent dans les maillages
    inline const list <EnumElemTypeProblem >& Types_de_problemes() const
       {return types_de_problemes;};
 

    // ramene le nombre total de ddl actifs du pb
    int NbTotalDdlActifs() const ;
    // idem mais pour un type de ddl donné, dans le cas de type
    // vectoriel on cumule les ddl de l'ensemble de la dimension
    int NbTotalDdlActifs(Enum_ddl enum_ddl) const;
    
    // ramene le nombre total de points d'intégration correspondant à un ddl donné
    int NbTotalPtInteg(Enum_ddl enum_ddl) const ;
    
    // ramene le nombre total de grandeurs génératrices, calculées aux points d'intégrations,
    //  correspondant à un ddl donné.
    int NbTotalGrandeursGeneratrices(Enum_ddl enu) const ;
		 
    //récupération d'une grandeur vectoriel de dimension, la dimension
    // de l'espace, défini au noeud et transféré dans un vecteur global
    // qui cumule de manière séquentielle toutes les grandeurs
    // en entrée : enum_ddl donne le type de la grandeur à récupérer
    // en fait de la première composante
    // duree : indique à quel temps doit s'effectuer le transfert, t=0 ou t ou tdt
    // enum_actif : le transfert s'effectue que si le ddl enum_actif est actif
    // ce qui permet la différentiation entre les différents ddl
    // vect : est le vecteur global de stockage qui normalement a été 
    // au préalable dimensionné avec NbTotalDdlActifs(Enum_ddl enum_ddl)
    // en retour : une référence sur vect
    Vecteur & Vect_loc_vers_glob(Enum_dure duree,Enum_ddl enum_actif
                                     ,Vecteur& vect,Enum_ddl enum_ddl);

    // fonction inverse de Vect_loc_vers_glob, il s'agit ici de passer
    // de la grandeur globale aux grandeurs locale
    void Vect_glob_vers_local(Enum_dure duree,Enum_ddl enum_actif
                                    ,const Vecteur& vect,Enum_ddl enum_ddl) ;
 
 
    //récupération d'une grandeur vectoriel de dimension, la dimension
    // de l'espace, défini au noeud et transféré dans un vecteur global
    // qui cumule de manière séquentielle toutes les grandeurs
    // en entrée : tab_enum_ddl donne le tableau des type de la grandeur à récupérer
    // en fait de la première composante
    // duree : indique à quel temps doit s'effectuer le transfert, t=0 ou t ou tdt
    // tab_enum_actif : pour chaque élément tab_enum_ddl(i), le transfert s'effectue que si
    // le ddl tab_enum_actif(i) est actif
    // ce qui permet la différentiation entre les différents ddl
    // vect : est le vecteur global de stockage qui normalement a été 
    // au préalable dimensionné avec somme des NbTotalDdlActifs(Enum_ddl enum_ddl), avec enum_ddl
    // qui balaie l'ensemble des éléments de tab_enum_ddl
    // Important: pour chaque famille de ddl, les ddl sont classés de manière croissante, ce qui signifie
    //  que c'est l'ordre des pointeurs d'assemblage si et seulement si, ces ddl ont été rangés dans les noeuds
    //  au préalable 
    // en retour : une référence sur vect
    Vecteur & Vect_loc_vers_glob(Enum_dure duree,const Tableau <Enum_ddl>& tab_enum_actif
                                     ,Vecteur& vect,const Tableau <Enum_ddl>& tab_enum_ddl);

    // fonction inverse de Vect_loc_vers_glob, il s'agit ici de passer
    // de la grandeur globale aux grandeurs locale
    void Vect_glob_vers_local(Enum_dure duree,const Tableau <Enum_ddl>& tab_enum_actif
                                    ,const Vecteur& vect,const Tableau <Enum_ddl>& tab_enum_ddl) ;

    //récupération d'une grandeur scalaire 
    // défini au noeud et transféré dans un vecteur global
    // qui cumule de manière séquentielle toutes les grandeurs
    // en entrée : enum_ddl donne le type de la grandeur à récupérer
    // duree : indique à quel temps doit s'effectuer le transfert, t=0 ou t ou tdt
    // enum_actif : le transfert s'effectue que si le ddl enum_actif est actif
    // ce qui permet la différentiation entre les différents ddl
    // vect : est le vecteur global de stockage qui normalement a été 
    // au préalable dimensionné avec NbTotalDdlActifs(Enum_ddl enum_ddl)
    // en retour : une référence sur vect
    Vecteur & Scalaire_loc_vers_glob(Enum_dure duree,Enum_ddl enum_actif
                                       ,Vecteur& vect,Enum_ddl enum_ddl);

    // fonction inverse de Scalaire_loc_vers_glob, il s'agit ici de passer
    // de la grandeur globale à la grandeur locale
    void Scalaire_glob_vers_local(Enum_dure duree,Enum_ddl enum_actif
                                    ,Vecteur& vect,Enum_ddl enum_ddl);

    // deux fonctions idem que pour les ddl : mais pour un Ddl_etendu
    Vecteur & Scalaire_loc_vers_glob(Enum_ddl enum_actif,Vecteur& vect,const Ddl_enum_etendu& enum_ddl_etend);
    void Scalaire_glob_vers_local(Enum_ddl enum_actif,Vecteur& vect,const Ddl_enum_etendu& enum_ddl_etend);

    // deux fonctions idem que pour les ddl_etendu : mais pour une grandeur quelconque
    Vecteur & Quelconque_loc_vers_glob(Enum_ddl enum_actif,Vecteur& vect,const TypeQuelconque& type_generique);
    void Quelconque_glob_vers_local(Enum_ddl enum_actif,Vecteur& vect,const TypeQuelconque& type_generique);

	   // retourne la liste des types de ddl principaux actuellement utilisé
	   // aux noeuds pour chaque maillage, la liste est exhaustive
	   // elle contiend tous les types au moins une fois utilisée
	   // cela ne signifie pas que le ddl en question soit présent
	   // pour tous les noeud du maillage considéré
	   // - le tableau de retour est indicé par le numéro de maillage correspondant
	   // - il y a une liste par maillage
	   Tableau <List_io <Ddl_enum_etendu> > Les_type_de_ddl_par_noeud(bool absolue);
		
	   // retourne la liste des types de ddl étendu actuellement utilisé
	   // aux noeuds pour chaque maillage, la liste est exhaustive
	   // elle contiend tous les types au moins une fois utilisée
	   // cela ne signifie pas que le ddl en question soit présent
	   // pour tous les noeud du maillage considéré
	   // - le tableau de retour est indicé par le numéro de maillage correspondant
	   // - il y a une liste par maillage
	   Tableau <List_io <Ddl_enum_etendu> > Les_type_de_ddl_etendu_par_noeud(bool absolue);
		
	   // retourne la liste des types quelconque actuellement utilisé
	   // aux noeuds pour chaque maillage, la liste est exhaustive
	   // elle contiend tous les types au moins une fois utilisée
	   // cela ne signifie pas que le ddl en question soit présent
	   // pour tous les noeud du maillage considéré
	   // - le tableau de retour est indicé par le numéro de maillage correspondant
	   // - il y a une liste par maillage
    // absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
	   Tableau <List_io <TypeQuelconque> > Les_type_de_TypeQuelconque_par_noeud(bool absolue);
 
    // initialisation par défaut de tous les conteneurs aux noeuds
    // de tous les maillages
    // contenant li_restreinte_TQ
    // ces conteneurs sont supposés déjà existés
    // typiquement si le conteneurs est un scalaire, on met 0
    void Init_par_defaut_conteneurs(List_io < TypeQuelconque >& li_restreinte_TQ);
    // idem pour une seule grandeur
    void Init_par_defaut_conteneurs(TypeQuelconque_enum_etendu enuTypeQuelconque);

    // intro de certains conteneurs internes en relation par exemple avec les demandes de visualisation
    // ou autre
    // exemple: si VECT_REAC_N qui est un type quelconque, a été choisit
    // il faut qu'il soit présent aux noeuds, alors qu'il est alimenter par les ddl pur ...
    // on introduit donc le type quelconque associé
    // NB: le conteneur passé en paramètre ne sert que pour localiser les grandeurs
    void Intro_Conteneurs_internes_noeud_relier_auto_autres_grandeur
                   ( const List_io < TypeQuelconque > & glob_noeud_evol_retenu);
 
    // idem mais ciblé en fonction d'un tableau indicé sur les maillages
    void Intro_Conteneurs_internes_noeud_relier_auto_autres_grandeur
                   ( const Tableau < List_io < TypeQuelconque > > & tab_noeud_evol_retenu);

	   // retourne la liste des types de ddl actuellement utilisé
	   // aux éléments pour chaque maillage, la liste est exhaustive
	   // elle contiend tous les types au moins une fois utilisée
	   // cela ne signifie pas que le ddl en question soit présent
	   // pour tous les éléments du maillage considéré
	   // - le tableau de retour est indicé par le numéro de maillage correspondant
	   // - il y a une liste par maillage
	   Tableau <List_io <Ddl_enum_etendu> > Les_type_de_ddl_par_element(bool absolue);
	   // idem pour les grandeurs évoluées interne actuellement utilisés
    // par les éléments, c'est-à-dire comme les ddl mais directement sous forme de vecteur, tenseurs ...
	   Tableau <List_io <TypeQuelconque> > Les_type_de_donnees_evolues_internes_par_element(bool absolue);
	   // idem pour les grandeurs particulières
	   Tableau <List_io <TypeQuelconque> > Les_type_de_donnees_particulieres_par_element(bool absolue);

    // retourne la liste des types de grandeur quelconque actuellement utilisé
    // aux faces élément pour chaque maillage, la liste est exhaustive
    // elle contiend tous les types au moins une fois utilisée
    // cela ne signifie pas que la grandeur en question soit présent
    // pour tous les éléments du maillage considéré
    // - le tableau de retour est indicé par le numéro de maillage correspondant
    // - il y a une liste par maillage
    Tableau <List_io <TypeQuelconque> > Les_type_de_donnees_evolues_internes_par_face_element(bool absolue);
    // idem pour les arêtes d'élément
    Tableau <List_io <TypeQuelconque> > Les_type_de_donnees_evolues_internes_par_arete_element(bool absolue);

    // Au niveau des noeuds: transfert des coordonnées de grandeurs vectorielles à des grandeurs évoluées
    // stockée sous forme de grandeurs TypeQuelconque
    //  exemple: les réactions qui sont naturellement stockée en composantes
    // le principe est que ce passage s'effectue si les conteneurs existent au niveau des noeuds
    void PassageInterneDansNoeud_composantes_vers_vectorielles();
	
	   // ..... transfert de grandeurs des points d'intégration aux noeuds .....
	   //    1- en entrée les type évoluées et les types particuliers que l'on veut transférer
	   //    2- en entrée: cas qui indique la méthode de transfert à utiliser
    //                  =1 : les valeurs aux noeuds sont obtenue par moyennage des valeurs des pts d'integ les plus près
    //                       des éléments qui entourent le noeud
	   // on décompose le processus en 4 étapes pour éviter d'initialiser plusieurs fois lorque l'on refait à chaque fois
	   // le même transfert
    // les méthodes: AjoutConteneurAuNoeud, InitUpdateAuNoeud, sont générales, peuvent être utilisés pour autres choses
 
 
    // A) première étape def des conteneurs et c'est tout, la méthode peut donc être utilisée
    //    pour autre chose. tabQ: permet d'avoir plusieurs listes de TypeQuelconque
    // en entrée: tabQ doit-être de dimension 2, donc pointe sur 2 listes, si un des pointeur
    //   est nulle on n'en tient pas compte
	   void AjoutConteneurAuNoeud(int num_maillage,const List_io < Ddl_enum_etendu >& lienu
	                                ,const Tableau <List_io < TypeQuelconque > * >& tabQ)
		        { tabMaillage(num_maillage)->AjoutConteneurAuNoeud(lienu,tabQ);};
    // fonctions utilitaires du même genre pour tous les maillages
    // ajout sur tous les maillages d'un ou plusieur ddl_enum_etendu comme conteneur
    // en entrée: tabQ doit-être de dimension 2, donc pointe sur 2 listes, si un des pointeur
    //   est nulle on n'en tient pas compte
	   void AjoutConteneurAuNoeud(const List_io < Ddl_enum_etendu >& lienu
                               ,const Tableau <List_io < TypeQuelconque > * >& tabQ)
		   { for (int imail=1;imail<=nbMaillageTotal;imail++)
         tabMaillage(imail)->AjoutConteneurAuNoeud(lienu,tabQ);};

     // B) initialisation des updates sur les noeuds
     //    lorsque l'on a des listes différentes pour chaque maillage on peut directement utiliser la routine de Maillage
	   void InitUpdateAuNoeud(const List_io < Ddl_enum_etendu >& lienu
	                                , const Tableau <List_io < TypeQuelconque > * >& tabQ,int cas)
		        { for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->InitUpdateAuNoeud(lienu,tabQ,cas);};
	   void InitUpdateAuNoeud(int numMail,const List_io < Ddl_enum_etendu >& lienu
	                                , const Tableau <List_io < TypeQuelconque > * >& tabQ,int cas)
		        { tabMaillage(numMail)->InitUpdateAuNoeud(lienu,tabQ,cas);};
    // C) exécution du transfert
		  // transfert de ddl des points d'intégrations (de tous) aux noeuds d'un éléments (on ajoute aux noeuds, on ne remplace pas)
		  // les ddl doivent déjà exister aux noeuds sinon erreur
		  // il doit s'agir du même type de répartition de pt d'integ pour toutes les grandeurs
	   void TransfertPtIntegAuNoeud(int numMail,Element& ele,const List_io < Ddl_enum_etendu >& lietendu
                                     ,const Tableau <Tableau <double> > & tab_val,int cas)
		   { tabMaillage(numMail)->TransfertPtIntegAuNoeud(ele,lietendu,tab_val,cas);};
	   // idem pour des grandeurs quelconques 
	   // les informations sont ici contenues dans les types quelconques
	   // liQ_travail: est une liste de travail qui sera utilisée dans le transfert                        
	   void TransfertPtIntegAuNoeud(int numMail,Element& ele,const Tableau <List_io < TypeQuelconque > >& tab_liQ
	                            ,List_io < TypeQuelconque > & liQ_travail,int cas)
		   { tabMaillage(numMail)->TransfertPtIntegAuNoeud(ele,tab_liQ,liQ_travail,cas);};
	    // D) dernière étape: (par exemple  calcul des moyennes en chaque noeuds)
	   void FinTransfertPtIntegAuNoeud(const List_io < Ddl_enum_etendu >& lienu
	                                , const Tableau <List_io < TypeQuelconque > * >& tabQ,int cas)
     { for (int i=1;i<=nbMaillageTotal;i++) tabMaillage(i)->FinTransfertPtIntegAuNoeud(lienu,tabQ,cas);};
	   void FinTransfertPtIntegAuNoeud(int numMail,const List_io < Ddl_enum_etendu >& lienu
	                                , const Tableau <List_io < TypeQuelconque > * >& tabQ,int cas)
     { tabMaillage(numMail)->FinTransfertPtIntegAuNoeud(lienu,tabQ,cas);};
 
	   // ..... cumul et moyenne de grandeurs venant des éléments vers les noeuds (exemple la pression appliquée) .....
	   // on décompose le processus en 4 étapes pour éviter d'initialiser plusieurs fois lorque l'on refait à chaque fois
	   // la même opération (typiquement à chaque incrément)
    // on peut utiliser:
    //  A)  AjoutConteneurAuNoeud : pour ajouter des conteneurs ad hoc aux noeuds
    //  B)  InitUpdateElementAuNoeud: avant le cumul, initialise les conteneurs
    //                                initialise uniquement les grandeurs qui sont gérées par l'élément
    //  C)  Accumul_aux_noeuds : balaie les éléments avec cumul aux noeuds, uniquement des grandeurs gérées par l'élement
    //  D)  MoyenneCompteurAuNoeud : effectue les moyennes aux noeuds
 
    // accumulation aux noeuds de grandeurs venant de tous les éléments vers ses noeuds (exemple la pression appliquée)
	   // autres que celles aux pti classiques, mais directements disponibles
    // le contenu du conteneur stockées dans liQ est utilisé en variable intermédiaire
    void Accumul_aux_noeuds(int numMail,const List_io < Ddl_enum_etendu >& lietendu
                            ,List_io < TypeQuelconque > & liQ,int cas)
		           { tabMaillage(numMail)->Accumul_aux_noeuds(lietendu,liQ,cas);};

    // fonctions utilitaires du même genre pour tous les maillages
 
    // ajout sur tous les maillages d'un conteneur particulier quelconque
    void AjoutConteneurAuNoeud(TypeQuelconque& tQ)
     { for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->AjoutConteneurAuNoeud(tQ);};

    // ajout sur tous les maillages d'un ou plusieur ddl_enum_etendu comme conteneur
	   void AjoutConteneurAuNoeud(const List_io < Ddl_enum_etendu >& lienu)
		   { for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->AjoutConteneurAuNoeud(lienu);};
    //  initialisation des updates de ddl_étendu uniquement sur les noeuds: on met à 0 les ddl_etendu correspondant, 
    //  les compteurs, comptant le nombre de fois où les noeuds sont modifiés, sont mis à 0
    void InitUpdateAuNoeud(const List_io < Ddl_enum_etendu >& lienu)
		    { for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->InitUpdateAuNoeud(lienu);};
	   // idem pour un seul ddl_etendu	 
    void InitUpdateAuNoeud(const Ddl_enum_etendu & enu)
		    { for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->InitUpdateAuNoeud(enu);};
	   // moyenne des valeurs aux noeuds (en fonction du nombre ou le noeud a été modifié)	 
	   void MoyenneCompteurAuNoeud(const Ddl_enum_etendu & enu)	 
		    { for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->MoyenneCompteurAuNoeud(enu);};

    // initialisation d'un ou de plusieurs nouveau cas d'assemblage
    // ramène le numéro du premier nouveau cas d'assemblage
    Nb_assemb InitNouveauCasAssemblage(int nb_cas);
    
    // ramène le nombre total de cas d'assemblage actuellement pris en compte dans les
    // maillages
    int Nb_total_en_cours_de_cas_Assemblage() const {return tab_nb_assemb;};


    // met a jour les pointeurs d'assemblage dans les noeuds pour un cas d'assemblage  
    // a effectuer si l'on a changer de nb de noeuds, de nb de ddl, de nb de maillage  
    // casAssemb : donne le cas d'assemblage qui est a considérer
    void MiseAJourPointeurAssemblage(const Nb_assemb& nb_casAssemb);

    // mise a zero de tous les ddl actifs autres que les deplacements
    // si indic = false; pas de creation des tableaux a t+dt
    // si indic = true; creation des tableaux a t+dt
    // cas = true; les coordonnées à t et éventuellement à t+dt sont initialisées
    //             aux valeurs de t=0 (cas par défaut),
    //             sinon on ne les modifies pas.
    void ZeroDdl(bool indic,bool cas = true);
	  
	   // force la mise à une valeur d'un ddl (ou de la liste de ddl fonction de la dimention) particulier, quelques soit son activité
	   // si fonction_de_la_dimension = true : c'est toute les ddl fct de la dimension qui sont mis à la valeur
	   void Force_Ddl_aux_noeuds_a_une_valeur(Enum_ddl enu, const double& val,Enum_dure temps, bool fonction_de_la_dimension)
	     { for (int imail=1;imail<=nbMaillageTotal;imail++) 
		        tabMaillage(imail)->Force_Ddl_aux_noeuds_a_une_valeur(enu,val,temps,fonction_de_la_dimension);}; 
	   // mise à zéro de dd_enum_etendu aux noeuds : force la mise à une valeur à 0
	   void Force_Ddl_etendu_aux_noeuds_a_zero(const Tableau<Ddl_enum_etendu>&  tab_enu)
	     { for (int imail=1;imail<=nbMaillageTotal;imail++) 
		        tabMaillage(imail)->Force_Ddl_etendu_aux_noeuds_a_zero(tab_enu);}; 
    
    // ramene la demi largeur de bande en ddl et la largeur de bande
    // casAssemb : donne le cas d'assemblage qui est a considérer
    void Largeur_Bande(int& demi, int& total,const Nb_assemb& nb_casAssemb);
    
	   // méthode permettant le calcul des matrices de connexion pour chaque
	   // élément ceci par rapport à la numérotation absolu des ddl
    // casAssemb : donne le cas d'assemblage qui est a considérer
	   void Table_connexion
	    (Tableau < Tableau <int> >& petites_matricespetites_matrices
	     ,const Nb_assemb& nb_casAssemb) const;

    // actualisation des ddl et des grandeurs actives de t+dt vers t      
    void TdtversT();
    // actualisation des ddl et des grandeurs actives de t vers tdt      
    void TversTdt();
    
    // actualisation des ddl  a t+dt, a partir du resultat de la resolution
    // casAssemb : donne le cas d'assemblage qui est a considérer
    void PlusDelta_tdt(Vecteur& sol,const Nb_assemb& nb_casAssemb);
    // actualisation des ddl actifs a t, a partir du resultat de la resolution
    // casAssemb : donne le cas d'assemblage qui est a considérer
    void PlusDelta_t(Vecteur& sol,const Nb_assemb& nb_casAssemb);
    // récupération du vecteur correspondant à l'incrément de ddl entre t et tdt
    // en paramètre le vecteur vide et en sortie le vecteur rempli
    // casAssemb : donne le cas d'assemblage qui est a considérer
    Vecteur& RecupDepde_tatdt(Vecteur& sol,const Nb_assemb& nb_casAssemb);
    // changement des ddl à tdt par ceux correspondant au vecteur passé en paramètre
    // casAssemb : donne le cas d'assemblage qui est a considérer
    void ChangeDdla_tdt(Vecteur& sol,const Nb_assemb& nb_casAssemb);
    
    // retrouver le ddl correspondant  a un pointeur de position
    // d'assemblage, le nb du noeud et du maillage
    // insol = le pointeur d'assemblage;
    // ddl = le ddl en sortie;  a t+dt  si elle il existe
    // sinon la valeur a t
    // casAssemb : donne le cas d'assemblage qui est a considérer
    Ddl  NoeudIndice(int inSol,int& nbNoeud, int& nbMaillage
                    ,const Nb_assemb& nb_casAssemb);
    // idem en ramenant en plus la valeur du ddl a 0
    // casAssemb : donne le cas d'assemblage qui est a considérer
    Ddl  NoeudIndice(int inSol,int& nbNoeud, int& nbMaillage, double& val0
                    ,const Nb_assemb& nb_casAssemb);
 
    // calcule des normales aux noeuds: dans le cas d'éléments 1D ou 2D uniquement
    // a priori le calcul s'effectue par une moyenne des normales des éléments qui
    // entourent le noeud.
    // init -> calcul des normales à t=0
    //         et ajout conteneur aux noeuds des normales à t = 0 et t
    void InitNormaleAuxNoeuds()
       { for (int imail=1;imail<=nbMaillageTotal;imail++)
           tabMaillage(imail)->InitNormaleAuxNoeuds();};
    // mise à jour -> mise à jour des normales à t
    void MiseAjourNormaleAuxNoeuds()
       { for (int imail=1;imail<=nbMaillageTotal;imail++)
           tabMaillage(imail)->MiseAjourNormaleAuxNoeuds();};
    // mise à jour -> mise à jour des normales à t
    // mais ici, on calcule les normales à tdt, et on transfert à t
    // cette méthode est utile si on veut utiliser des normales à t pour une valeur
    // particulière (transitoire) de la géométrie à tdt
    // cf: l'algo non dyna par exempel
    void MiseAjourNormaleAuxNoeuds_de_tdt_vers_T()
       { for (int imail=1;imail<=nbMaillageTotal;imail++)
           tabMaillage(imail)->MiseAjourNormaleAuxNoeuds_de_tdt_vers_T();};

    // ---------- particularité aux contacts ----------
    // creation des elements frontiere: cela n'a lieu qu'une seule fois
    // si les frontières existent déjà, --> aucune action, --> ramène 0
    // sinon il y a réellement création, et --> ramène 1
    int CreeElemFront();
    // ramene le nombre de maillage esclave
    inline int NbEsclave() { return domEsclave;};
    // ramene le tableau des list des elements frontiere
    inline Tableau <LaLIST <Front>*>& ListFrontiere() { return listFrontiere;}; 
    // ramene un tableau des noeuds des frontières des maillages esclaves
    Tableau < Tableau <Noeud*> *> Tab_noeud_frontiere_esclave();   
    // ramene le tableau des noeuds des frontières des maillages
    const Tableau <Tableau <Noeud*> *>& Tab_noeud_frontiere()  {return tt_noeud_front;}; 
    // calcul et ramene le tableau de tous les noeuds des maillages esclaves 
    // noeuds de la frontière et noeuds internes
    // s'ils existent, sinon le tableau est vide
    // le tableau n'est pas sauvegarde
    const Tableau<Noeud *> Esclave();
    // mise à jour des boites d'encombrements des éléments, qui contiennent des éléments frontières
    // et des éléments frontières eux-même
    void Mise_a_jour_boite_encombrement_elem_front(Enum_dure temps);
	   // crée et ramene pour tous les maillages, la liste des éléments qui contiennent chaque noeud
	   // mis à jour lorsque lors de la création des frontières
	   const Tableau < const Tableau <List_io < Element* > > *>&  Indice() ;					
    
    // inactive  tous les ddl et les données
    void Inactive_ddl_et_donnees();
    // inactive  les ddl mais pas les données
    void Inactive_ddl();

    // inactive les ddl primaires 
    void Inactive_ddl_primaire();  
    // active les ddl primaires 
    void Active_ddl_primaire();  
    // introduction des ddl de contraintes si cela veut dire quelques chose
    // pour l'élément
    void Plus_ddl_Sigma();
    // inactivation des ddls de contraintes si cela veut dire quelques chose
    // pour l'élément
    void Inactive_ddl_Sigma();
    // activation des ddls de contraintes si cela veut dire quelques chose
    // pour l'élément
    void Active_ddl_Sigma();
    // activation du premier  ddl de contraintes si cela veut dire quelques chose
    // pour l'élément
    void Active_premier_ddl_Sigma();
    // introduction des ddl d'erreur si cela veut dire quelques chose
    // pour l'élément
    void Plus_ddl_Erreur();
    // inactivation des ddls d'erreur si cela veut dire quelques chose
    // pour l'élément
    void Inactive_ddl_Erreur();
    // activation des ddls d'erreur si cela veut dire quelques chose
    // pour l'élément
    void Active_ddl_Erreur();

    // d'une manière plus générique une fonction pour activer une série de ddl
    // donnée par un identificateur, si c'est une grandeur vectoriel c'est l'ensemble
    // des ddl du vecteur qui sont inactivé. 
    void Active_un_type_ddl_particulier(Enum_ddl en);  
    void Active_un_type_ddl_particulier(Tableau<Enum_ddl>& tab_en);  // idem mais pour un tableau
    void Active_un_type_ddl_particulier(const list<Enum_ddl>& list_en);  // idem pour une liste
    // idem la fonction Active_ddl_noeud mais ici pour l'inactivation
    void Inactive_un_type_ddl_particulier(Enum_ddl en);  
    void Inactive_un_type_ddl_particulier(Tableau<Enum_ddl>& tab_en); // idem mais pour un tableau
    void Inactive_un_type_ddl_particulier(const list <Enum_ddl>& list_en);  // idem pour une liste
    // -- encore plus générique
    // changement de toutes les conditions données (service, variable, fixage ..)  
    // selon le tableau de ddl passé en paramètre
    // par contre les valeurs de ta ne sont pas utilisé donc les valeurs actuelles restent inchangé
    void ChangeToutesLesConditions(const Tableau<Ddl>& ta);
    // changement de statu des ddl d'une combinaison, en fonction du statut
    // de enuta dans chaque noeud, les ddl de la combinaison, prennent le même statut que celui
    // de enuta dans chaque noeud.
    // cas est la combinaison,
    void ChangeStatut(int cas,Enum_ddl enuta);
    // changement de statu des ddl d'une combinaison dans chaque noeud, en fonction
    // de enubold, les ddl de la combinaison, prennent le même statut que enubold
    // cas est la combinaison,
    void ChangeStatut(int cas,Enum_boolddl enubold);
 
    //change le statut de tous les ddl liés à la physique en cours
    //par exemple: met à libre ou bloque les ddl liés à la physique en cours
    void Libere_Ddl_representatifs_des_physiques(Enum_boolddl enubold);
 
    // Calcul de l'erreur  sur l'ensemble des éléments
    // type indique le type d'erreur retenue
    // type = 1 : cas d'un calcul aux moindres carrés
    // et retour un tableau de tableau de grandeurs sur les maillages en cours
    //      ret(i) : concerne le maillage i
    //      ret(i)(1) : somme des erreurs sur l'ensemble des éléments: est homogêne à
    //                  un |delta contrainte| * domaine
    //      ret(i)(2) : somme de la grandeur de ref du calcul d'erreur sur l'ensemble des
    //                  éléments: est homogêne à une |contrainte| * domaine
    //      ret(i)(3) : le maxi pour les tous les éléments de |delta contrainte| * domaine
    //      ret(i)(4) : le maxi pour les tous les éléments de |contrainte| * domaine
    Tableau <Tableau <double > >   ErreurSurChaqueElement(int type);
    
    // lecture de donnée en fonction d'un indicateur : type
    // type = 1 , on lit les tenseurs de contraintes
    void   LectureDonneesExternes(const int type ,const string& nomMaillage);
    
    // mise en place du travail à t  sur les maillages
    // indique que l'on va utiliser les ddl en 0, t
    // si les grandeurs en tdt existaient, elles sont supprimées
	   void Travail_t();
	   // idem pour un maillage donné de numéro num
	   void Travail_t(int num);
	 
	   // définition des coordonnées à t identiques à ceux à t=0,
	   void Insert_coord1();
 
    // mise en place du travail à t tdt sur les maillages
    // indique que l'on va utiliser les ddl en 0, t, tdt
    void Travail_tdt();
 
    // initialisation des coordonnées à t et tdt aux mêmes valeurs qu'à 0
    // utile quand on veut utiliser les métriques pour un pb non couplés
    void Init_Xi_t_et_tdt_de_0() { for (int imail=1;imail<=nbMaillageTotal;imail++)
                                     tabMaillage(imail)->Init_Xi_t_et_tdt_de_0();};
        
    // ramène le maximum de variation de coordonnée entre t et tdt de tous les noeuds du maillage
    double Max_var_dep_t_a_tdt() const;
	  
	   // ramène le minimum de la distance entre deux noeuds de l'ensemble des éléments pour tous les maillages
	   double Min_dist2Noeud_des_elements(Enum_dure temps) const ;
	  
	   // indique aux éléments un niveau de précision de calcul désiré pour les prochains calculs
	   // precision = 0 : aucune précision demandée, precision >=0 : précision maximale demandée
	   void Drapeau_preparation_calcul_precis(int precision);
	 
// --------- calcul dynamique ---------
    // ajout des ddl de vitesse pour tous les maillages
    // val_fixe indique si l'on veut des ddl libres ou pas 
    void Plus_Les_ddl_Vitesse(Enum_boolddl val_fixe);
    // ajout des ddl d'accélération pour tous les maillages
    // val_fixe indique si l'on veut des ddl libres ou pas 
    void Plus_Les_ddl_Acceleration(Enum_boolddl val_fixe);
    // calcul  de la longueur d'arrête d'élément minimal
    // divisé par la célérité dans le matériau
    double Longueur_arrete_mini_sur_c(Enum_dure temps);
    // initialisation éventuelle du bulk viscosity
    // choix peut-être égale à 0, 1 ou 2 
    void Init_bulk_viscosity(int choix,const DeuxDoubles &  coef);
    
	   //----- lecture écriture de restart -----
	   // 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 Lecture_base_info(ifstream& ent,const int cas);
     // cas donne le niveau de sauvegarde
     // = 1 : on sauvegarde tout
     // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
	   void Ecriture_base_info(ofstream& sort,const int cas);
     // sortie du schemaXML: en fonction de enu 
    void SchemaXML_LesMaillages(ofstream& sort,const Enum_IO_XML enu) const ;
	 
     
    // ------ informations utiles par exemples pour la visualisation 
    // retourne les dimensions minis et maxi suivant les axes du repère
    // absolu du maillage numéro nbmail (en faite le calcul est fondé
    // uniquement sur la position des noeuds du maillage
    // le premier vecteur contient les minimums
    // le deuxième vecteur contient les maximums     
    Tableau <Vecteur>  Taille_boite(int nbmail);
    // dans le cas ou aucun numéro de maillage n'est fournis
    // c'est l'encombrement de tous les maillages qui est fourni
    Tableau <Vecteur>  Taille_boite();
    
    
    // --------  utilitaires de manipulation de maillage
    // création de maillage quadratiques incomplets à partir de maillages linéaires. 
    // En fait il y création de maillages identiques aux maillages déjà existants, les éléments qui sont de types
    // linéaires  sont remplacés par des éléments quadratiques incomplets correspondants.
    // Il y a création de références correspondantes
    void CreeMaillagesQuadratiques_a_partir_des_lineaires(LesReferences* lesRef);
    // création de maillage quadratiques complets. En fait il y création de maillages identiques aux maillages
    // déjà existants, les éléments qui sont de types quadratiques incomplets sont remplacés par des éléments
    // quadratiques complets correspondants.
    // Il y a création de références correspondantes
    void CreeMaillagesQuadratiquesComplets_a_partir_des_incomplets(LesReferences* lesRef);
    // création de maillages par extrusion
    // Il y a création de références correspondantes
    void CreeMaillageExtrusion2D3D(LesReferences* lesRef);
    // définition interactive de listes de références
    void CreationInteractiveListesRef(LesReferences* lesRef);   
    // modification de l'orientation d'éléments
    void Modif_orientation_element(int cas_orientation,LesReferences* lesRef);   
    // collapse de noeuds très proche: appartenant à des éléments différents
    // rayon : donne la distance maxi entre les noeuds qui doivent être collapsé
    void Collapse_noeuds_proches(double rayon, LesReferences* lesRef);
    // Collapse des éléments supperposés, c-a-d identiques, dans le cas où il en existe
    void Collapse_element_supperpose(LesReferences* lesRef);
    // création d'un nouveau maillage issue de la fusion de maillages existants
    // nom_mails_a_fusionner : la liste des maillages à fusionner
    // new_mail              : le nom du nouveau maillage à construire
    // NB: si new_mail correspond à un maillage déjà existant, il y a fusion de ce maillage
    //     avec les autres, sans création d'un nouveau maillage
    void Fusion_maillages(List_io < string >& nom_mails_a_fusionner,const string& new_mail
                          ,LesReferences* lesRef);
    // création d'un nouveau maillage issue d'un maillages existants et d'une ref d'éléments
    // le nouveau maillage = les éléments de la ref
    void Cree_sous_maillage(int num_mail,LesReferences* lesRef, string nom_ref,const string& new_mail);
    // création d'éléments SFE en fonction d'éléments classiques
    // il y a création d'un nouveau maillage
    void CreationMaillageSFE();
     
    // Affiche les donnees des maillages dans des fichiers dont le nom est construit à partir du nom de 
    // chaque maillage au format  ".her" et ".lis"
    // le paramètre optionnel indique le numéro du maillage à afficher, s'il vaut -1, on affiche tous les maillages
    void Affiche_maillage_dans_her_lis(Enum_dure temps,LesReferences &lesRef,int imail=-1);
    
    // relocalisation des points milieux des arrêtes des éléments quadratiques
    void RelocPtMilieuMailleQuadra();
 
    // --- utilitaires pour calculs particuliers-------
    // calcul des diverses intégrations: volume et volume + temps,
    // alimentation des grandeurs globales associées
    void Integration();
    
    // calcul des diverses statistiques sur des ref de noeuds et avec éventuellement
    // cumul sur le temps
    // alimentation des grandeurs globales associées
    void CalStatistique();

  private :  
    // VARIABLES PROTEGEES :
    Tableau<Maillage *> tabMaillage ; // tableau de maillages
    // liste des noms de maillages associée à un numéro sous forme d'un arbre pour faciliter la recherche
    // cette liste est modifiée que par chaque maillage
    map < string, int , std::less <string> > mapNomMail;
    // const int nbEnreg; // nb de maillage initiaux
    int nbEnreg; // nb de maillage initiaux
    int nbMaillageTotal; // nb de maillage effectivement en cours
    int nbPortion ; // nbPortion = le nombre maxi de maillage enregistrable
    // avant une nouvelle allocation dynamique de nbEnreg places supplementaires
    UtilLecture * entreePrinc; // acces a la lecture du fichier principal
    ParaGlob * paraGlob ; // parametres globaux
    LesReferences* lesRef; // references
    int domEsclave; // nombre de domaine esclave, lorsqu'il est different de zero
     // il indique le nombre de maillage a partir de 1, qui sont esclave

    // ---- stockage des intégrales de volumes sur des références d'éléments ----
    // --- cas des intégrales volumiques: définition du conteneur, il peut également s'agir d'une intégration temporelle en +
    // d'où la grandeur courante et celle à t
    // 1) intégration de volume uniquement
    Tableau <TypeQuelconque>  integ_vol_typeQuel,  integ_vol_typeQuel_t;
    Tableau <const Reference*>   ref_integ_vol; // les références associées
    // si la référence est nulle, cela signifie que l'intégrale est figée: sa valeur ne change pas

    // 2) intégration de volume et en temps: donc on commule le delta
    Tableau <TypeQuelconque>  integ_vol_t_typeQuel,  integ_vol_t_typeQuel_t;
    Tableau <const Reference*>  ref_integ_vol_t; // les références associées
    // si la référence est nulle, cela signifie que l'intégrale est figée: sa valeur ne change pas

    // ---- stockage des statistiques sur des références de noeuds ----
    // --- cas des statistique: définition du conteneur, il peut également s'agir d'un cumul temporelle en +
    // d'où la grandeur courante et celle à t
    // 1) statistique de ref de noeuds uniquement
    Tableau <TypeQuelconque>  statistique_typeQuel,  statistique_typeQuel_t;
    Tableau <const Reference*>   ref_statistique; // les références associées
    // si la référence est nulle, cela signifie que la statistique
    // est figée: sa valeur ne change pas
    
    //pour_statistique_de_ddl a la même dimension que ref_statistique
    // 1) Dans le cas où ref_statistique(i) est une statistique de Ddl_enum_etendu
    // pour_statistique_de_ddl(i) == le Ddl_enum_etendu
    // 2) sinon, pour_statistique_de_ddl(i) == NU_DDL
    Tableau < Ddl_enum_etendu > pour_statistique_de_ddl;

    // 2)  statistique avec cumul en temps: donc on commule le delta
    Tableau <TypeQuelconque>   statistique_t_typeQuel,   statistique_t_typeQuel_t;
    Tableau <const Reference*>  ref_statistique_t; // les références associées
    // si la référence est nulle, cela signifie que la statistique est figée: sa valeur ne change pas
    
    //pour_statistique_t_de_ddl a la même dimension que ref_statistique_t
    // 1) Dans le cas où ref_statistique_t(i) est une statistique de Ddl_enum_etendu
    // pour_statistique_t_de_ddl(i) == le Ddl_enum_etendu
    // 2) sinon, pour_statistique_de_ddl(i) == NU_DDL
    Tableau < Ddl_enum_etendu > pour_statistique_t_de_ddl;

    // cumule les liste des types de degrés de liberté inconnus,
    // qui vont être calculés par la résolution des problèmes
    // physiques gérés par les éléments qui existent dans les maillages
    // Si éléments mécaniques -> ddl Xi voir Vi et gamma_i
    // Si éléments thermiques -> ddl de température
    // Si éléments méca + éléments thermiques -> ddl Xi et température
    // etc. en fonction des éléments qui existent dans les maillages
    // (généré à la lecture du maillage, ce qui permet d'optimiser la consultation par la suite)
    list <Enum_ddl >  ddl_representatifs_des_physiques;
    // idem au niveau des types de problèmes gérés par les éléments
    list <EnumElemTypeProblem > types_de_problemes;

    // stockage des pointeurd de listes d'element frontiere
    Tableau <LaLIST <Front>*> listFrontiere;
    // idem pour les noeuds des frontières
    Tableau <Tableau <Noeud*> *> tt_noeud_front;
	   // crée et ramene pour tous les maillages, la liste des éléments qui contiennent chaque noeud
	   // mis à jour lorsque lors de la création des frontières
	   Tableau < const Tableau <List_io < Element* > > *>  tous_indices;					
    // tableau d'indexage des ddl géré par les noeuds 
    // t_i_n (i)(j) -> donne les infos pour retrouver le ddl numéro j du cas de charge i 
    Tableau < Tableau <Posi_ddl_noeud> > t_i_n;
    // nombre actuellement de cas d'assemblage initialisé
    int tab_nb_assemb;
    
    // METHODES PROTEGEES :
    // on s'occupe de mettre à jour les types de pb et les ddl types associés
    void Mise_a_jour_type_pb_type_associe_ddl();

    // met a jour les pointeurs d'assemblage dans les noeuds pour un cas d'assemblage
    // a effectuer si l'on a changer de nb de noeuds, de nb de ddl, de nb de maillage
    // casAssemb : donne le cas d'assemblage qui est a considérer
    // ici, l'assemblage suit l'ordre du tableau de noeud passé en paramètre
    // le tableau de noeuds rassemble tous les noeuds des maillages mais avec une numérotation propre
    void MiseAJourPointeurAssemblage_interne(const Nb_assemb& nb_casAssemb,Tableau <Noeud* >& tab_N_final);
 
   // remise à jour des tableaux de pointeurs t_i_n uniquement, due à un changement de numéro de noeud
   // en fonction d'un changement de num de noeud (mais pas de changement de pointeur d'assemblage
   // pour chaque noeud, tab_N_final(i) correspond au noeud qui avait le numéro i ancien
   //   et qui a maintenant le numéro tab_N_final(i)->Num_noeud()
   void MiseAJourTableau_t_i_n(const Nb_assemb& nb_casAssemb,Tableau <Noeud* >& tab_N_final);


 };
 /// @}  // end of group

#endif  
