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

/************************************************************************
 *     DATE:        23/01/97                                            *
 *                                                                $     *
 *     AUTEUR:      G RIO   (mailto:gerardrio56@free.fr)                *
 *                                                                $     *
 *     PROJET:      Herezh++                                            *
 *                                                                $     *
 ************************************************************************
 *     BUT:     Gestion des listes de references.                       *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/
#ifndef LESREFERENCES_H
#define LESREFERENCES_H

#include "Reference.h"
#include <list>
#include <map>
#include "UtilLecture.h"
#include "MotCle.h"

#ifdef UTILISATION_MPI
  #include <boost/mpi/environment.hpp>
  #include <boost/mpi/communicator.hpp>
  #include <boost/serialization/string.hpp>
  #include <boost/serialization/vector.hpp>
  #include <boost/mpi.hpp>
  namespace mpi = boost::mpi;
#endif

/// @addtogroup Les_classes_Reference
///  @{
///

///  Gestion des listes de references.
///
/// \author    Gérard Rio
/// \version   1.0
/// \date      23/01/97

//-------- une méthode permettant d'utiliser des tableaux de map de références -----
   // surcharge de l'operator d'ecriture
   ostream & operator << (ostream & sort, const map < string, Reference*, std::less <string> > & );

//----------- fin de la méthode permettant d'utiliser des tableaux de map de références -----
/// @}  // end of group

/// @addtogroup Les_classes_Reference
///  @{
///

///  Gestion des listes de references.
///
/// \author    Gérard Rio
/// \version   1.0
/// \date      23/01/97

class LesReferences
{
  public :
    // CONSTRUCTEURS :
    LesReferences ();  // par defaut
    // DESTRUCTEUR :
    ~LesReferences ();
    // METHODES PUBLIQUES :
    
    // def du numero de maillage courant, utilise avant la lecture
    void NbMaille(int nb);
    // def du type de reference a lire, utilise avant la lecture
    // type peut-être : noeud,element,surface,arete
    void Indic(string type);
    
    // lecture des references
    void Lecture(UtilLecture & entreePrinc);
    
    // ajout d'une référence déjà construite par ailleurs
    void Ajout_reference(Reference * refi); 
    
    // suppression d'une référence 
    void SupprimeReference(const string & st1,int num_mail);
    // suppression de tous les référence d'un maillage donné
    // si avec_diminution_num_maillage = true: 
    // tous les numéros de maillage, > num_mail,  associé aux maillages qui restent
    // sont diminués de un, pour tenir compte de la disparition du maillage et donc
    // d'une nouvelle numérotation des maillages
    // si avec_diminution_num_maillage = false, le conteneur des ref de maillage num_mail
    // est vidé, mais il continu à exister: on considère qu'il y a toujours un maillage num_mail potentiel
    void Supprime_tour_lesRef_un_maillage(int num_mail, bool avec_diminution_num_maillage);
    
    // affichage des informations contenu dans les references
    // par défaut affiche toutes les infos
    // si niveau = 1 : affiche que les noms des ref
    void Affiche(int niveau=0) const ;
 
    // affichage des informations contenu dans les references d'un certain type
    // défini par indic :
    // indic =  1 -> noeud, =2 -> element
    // =3 -> surface associée à un élément , =4 -> arete associée à un élément
    // =5 -> noeud associée à un élément
    // =6 -> point d'intégration associée à un élément
    // =7 -> de points d'intégrations relatifs à des surfaces d'éléments
    // =8 -> de points d'intégrations relatifs à des arete d'éléments
    // =0 -> rien_actuellement
    // par défaut affiche toutes les infos
    // si niveau = 1 : affiche que les noms des ref
    void Affiche(int indic, int niveau) const ;
		
	   // Affiche les donnees des références pour le maillage imail dans un fichier
	   // dont le nom est construit à partir du nom du maillage au format   ".lis"
	   void Affiche_dans_lis(const string& nom_maillage,int imail);
    
    // affichage et definition interactive des commandes 
    // nbMaxiNoeud: nombre maxi de noeud pour les exemples
    // nbMaxiElem : nombre maxi d'éléments pour les exemples
    // cas : =1 premier passage, il s'agit de références de noeuds uniquement
    // cas : =2 second passage, il s'agit de l'ensemble des possibilités de références
    void Info_commande_lesRef(int nbMaxiNoeud,int nbMaxiElem,UtilLecture * entreePrinc,int cas);
    
    //--- utilisation d'une boucle pour balayer l'ensemble des références existantes:
    // ***** très important: ce balaiyage ne fonctionne que si on ne modifie pas le stockage
    // ***** par exemple en supprimant une référence existante ou en ajoutant une nouvelle référence
    // ***** ou en lisant des références (donc ajout !!)
    // ***** par contre on peut changer le contenu des références existantes
    // initialise le questionnement de la récupération de référence et
    // retourne la première référence si elle existe sinon un pointeur nul
    const Reference* Init_et_Premiere();
    // retourne la référence suivante ou, s'il n'y en n'a plus, retourne
    // un pointeur nul
    const Reference* Reference_suivante();   
    //--- fin méthode pour faire une boucle pour balayer l'ensemble des références existantes:
    
    // test si la reference existe reellement
    // retourne false si n'existe pas , true sinon
    bool Existe(const string & st1,int num_mail) const ;
    bool Existe(const string & st1,const string* nom_mail) const; 
    // retourne la reference correspondant a une cle
    const Reference& Trouve(const string & st1,int num_mail) const ;
    const Reference& Trouve(const string & st1,const string* nom_mail) const ;
    // mise à jour de la map qui fait la liaison nom de maillage <=> numéro de maillage
    void MiseAJourMap( const map < string, int , std::less <string> >& listNomMail)
          { listeNomMail = & listNomMail;};  
            
    // mise à jour des références de noeud, dans le cas où les numéros de noeuds ont changés
//1) cas où l'on supprime éventuellement des noeuds de la référence,	qui ne sont plus référencé  
    // nv_tab est tel que : nv_tab(i) est le nouveau numéro qui avait auparavant le numéro "i"
    // non_referencer(i) : = true signifie qu'il ne faut plus tenir compte de ce noeud
    //                     = false indique qu'il continue d'être actif
    void Mise_a_jour_ref_noeud(const Tableau <int >& nv_tab,int num_mail,Tableau <bool>& non_referencer);
//2) cas où on considère tous les noeuds 
    // nv_tab est tel que : nv_tab(i) est le nouveau numéro qui avait auparavant le numéro "i"
    void Mise_a_jour_ref_noeud(const Tableau <int >& nv_tab,int num_mail);

    // mise à jour des références d'élément, dans le cas où les numéros d'élément ont changés
//1) cas où l'on supprime éventuellement des éléments de la référence,	qui ne sont plus référencé  
    // nv_tab est tel que : nv_tab(i) est le nouveau numéro qui avait auparavant le numéro "i"
    // non_referencer(i) : = true signifie qu'il ne faut plus tenir compte de cet élément
    //                     = false indique qu'il continue d'être actif
    void Mise_a_jour_ref_element(const Tableau <int >& nv_tab,int num_mail,Tableau <bool>& non_referencer);
 
    // mise à jour du numéro de maillage d'une référence
    void Mise_a_jour_num_maillage_ref(const string nom_ref, int old_num_maill, int new_num_maill)
       { Trouve_interne(nom_ref,old_num_maill).Change_Nbmaille(new_num_maill);};
    
	//----- lecture écriture dans base info -----
	// 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(istream& 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(ostream& sort,const int cas);
 
#ifdef UTILISATION_MPI
    // retour de la taille globale des sorties retardées
    // concernant les sorties sur .BI
    MPI_Offset Taille_buffer_sortie_BI();
    // récupération de l'offset global sur .BI pour la classe
    // et mise à jour des offsets de classes dérivées si besoin
    void Mise_a_jour_Offset_BI_ecriture(MPI_Offset offset,const int cas);
    // idem en lecture, mais là il s'agit uniquement de la mise à jour
    // de l'offset seul puis c'est la classe qui s'en débrouille
    void Mise_a_jour_Offset_BI_lecture(MPI_Offset offset,const int cas);

    // lecture MPI des infos bufferisées
    void Lecture_base_info_MPI_IO(MPI_File * ent_MPI,const int cas);
    // écriture MPI des infos bufferisées
    void Ecriture_base_info_MPI_IO(MPI_File * sort_MPI, const int cas);
#endif

  protected :
    // variable transitoires utilise pendant la lecture
    int nbMaille; // nb courant de maillage
    int indic ; // type courant de reference : = 1 -> noeud, =2 -> element
    // =3 -> surface associée à un élément , =4 -> arete associée à un élément
    // =5 -> noeud associée à un élément
    // =6 -> point d'intégration associée à un élément
    // =7 -> de points d'intégrations relatifs à des surfaces d'éléments
    // =8 -> de points d'intégrations relatifs à des arrete d'éléments
    // =0 -> rien_actuellement
    Reference * ref; // une variable de travail
      
    // VARIABLES PROTEGEES :
//    list <Reference*> listeDeRef; // liste des references
    
    // on utilise une map pour récupérer plus rapidemment une référence à partir d'un nom
    // t_mapDeRef (i) est la map relative au maillage i
    Tableau < map < string, Reference*, std::less <string> > > t_mapDeRef;
    
    // liste des noms de maillages associée à un numéro sous forme d'un arbre pour faciliter la recherche
    const map < string,  int , std::less <string> >* listeNomMail;
    // a utiliser avec Existe et Trouve, mais pas avant la lecture, seulement après
    
    static MotCle motCle; // liste des mots clés
    
    //list <Reference*>::const_iterator iref; 
    // deux variables intermédiaires pour les méthodes Init_et_Premiere et Reference_suivante
    map < string, Reference*, std::less <string> >::const_iterator iref; 
    int num_mail_presuivant;
    
 #ifdef UTILISATION_MPI
    // cas d'un calcul parallèle: // passage des infos entre process
    // pour les i/o
    MPI_Offset nb_buffer; // ici = 1 seul buffer
    Tableau <std::string > buffer_ioBI_MPI; // les buffers pour la sortie retardée
      // uniquement les buffers propres : ici taille 1 pour tous les proc
    std::vector<MPI_Offset>  tailles_buffer_ioBI_MPI; // tailles des buffers
      // size 1 pour tous les proc
    // offsets , offset_LesReferences[0] est l'offset de début (premier char)
    // [1] : position de la fin +1 (premier char après les ref)
    std::vector<MPI_Offset> offset_LesReferences;
    MPI_Offset taille_offset; // = 2 ici
 #endif
    
    // METHODES PROTEGEES :
    // lecture d'une  reference
    bool LectureReference(UtilLecture & entreePrinc);
    // retourne la reference correspondant a une cle, en non constant
    Reference& Trouve_interne(const string & st1,int num_mail) const ;
    Reference& Trouve_interne(const string & st1,const string* nom_mail) const ;
 

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

#endif  
