
// 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 de la  sortie des differents resultats.          *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/
#ifndef RESULTATS_H
#define RESULTATS_H

#include "UtilLecture.h"
// #include "bool.h"
#include "MotCle.h"
#include "string.h"
#include "Tableau_T.h"
#include "LesMaillages.h"
#include "LesReferences.h"
#include "LesCondLim.h"
#include <list>
#include "LesContacts.h"
#include "LesValVecPropres.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


/** @defgroup Les_sorties_generiques
*
*     BUT:   groupe concernant le postraitement de manière générique (classe virtuelle et sorties avec un format spécifique d'Herezh )
*
*
* \author    Gérard Rio
* \version   1.0
* \date       23/01/97
* \brief       groupe concernant le postraitement de manière générique
*
*/

/// @addtogroup Les_sorties_generiques
///  @{
///


class Resultats
{
  public :
    // CONSTRUCTEURS :
    // entreePrinc gere les entrees sorties
    Resultats(UtilLecture* entreePrinc);
    // DESTRUCTEUR :
    ~Resultats();
    
    // METHODES PUBLIQUES :
    // lecture des parametres de gestions de la sortie des resultats
    void Lecture(LesReferences* lesRef);
    // affichage des parametres de gestions de la sortie des resultats
    void Affiche() const ;
    // retourne la variable copie
    bool Copie() { return copie;};
	 
	 // def interactive des parametres de gestion de la sortie des resultats
    void Info_commande_Resultats();

    // sortie des resultats suivant les infos stockee durant la lecture du fichier d'entree
    void SortieInfo(ParaGlob * paraGlob,LesMaillages* lesMail,LesReferences* lesRef,
                        LesCondLim * lesCondLim, LesContacts* lescontacts);
    // ramène le container relatif aux valeurs et vecteur propres
    inline LesValVecPropres & VeaPropre() { return lesValVecPropres;}; 
	 
	 //----- 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 Lect_result_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 Ecri_result_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

  private :  
    // VARIABLES PROTEGEES :
    UtilLecture* entreePrinc; // gestion des entrees/sorties
    
    list < BlocDdlLim < BlocGen> > tabRegion; // tableau des regions ou l'on veut sortir
          // des resultats des variables duales aux pt d'integ
    
    //  parametres de gestion
    bool copie; // copie de la lecture des donnees ? 
	   bool pas_de_sortie; // indique éventuellement que l'on ne veut pas de sortie
    
    // la sauvegarde de valeurs propres et vecteurs propres éventuelles
    LesValVecPropres lesValVecPropres; 
           
 #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_Resultats[0] est l'offset de début (premier char)
    // [1] : position de la fin
    std::vector<MPI_Offset> offset_Resultats;
    MPI_Offset taille_offset; // = 2 ici
 #endif
           

    // METHODES PROTEGEES :
    // lecture concernant les sorties aux points d'integration
    void ReadPtInteg(LesReferences* lesRef,Tableau<string>& TsousMot);
    // Lectures concernant les sorties aux noeuds
    void ReadNoeuds(LesReferences* lesRef);
    // lectures concernant les reactions
    void ReadReac(LesReferences* lesRef);
    // lectures concernant les deformees
    void ReadDeformee(LesReferences* );

    // sortie des grandeurs duales aux points d'integration
    void PointsDintegration(LesMaillages* lesMail,LesReferences* lesRef);
    // sortie des ddls et grandeurs aux noeuds 
    void SortieNoeuds(LesMaillages* lesMail,LesReferences* lesRef);
    // sortie des reactions
    void SortieReactions(LesMaillages* lesMail,LesReferences* lesRef,LesCondLim * lesCondLim);
    // sortie du contact
    void SortieContacts(LesContacts* lescontacts);
    // sortie pour le flambement
    void SortieFlamb();
    // sortie des deformees
    void SortieDeformee(LesMaillages* lesMail,LesReferences* lesRef,ParaGlob * paraGlob);
    // dans le cas ou l'on  a une remontée aux contraintes, sortie d'isovaleurs
    // de contraintes.
    void SortieNoeudContaintes
              (LesMaillages* lesMail,LesReferences* lesRef,ParaGlob * paraGlob);
    // dans le cas ou l'on  a une remontée aux erreurs, sortie d'isovaleurs
    // d'erreur aux noeuds.
    void SortieNoeudErreur
              (LesMaillages* lesMail,LesReferences* lesRef,ParaGlob * paraGlob);
    // dans le cas ou l'on  a une remontée aux erreurs, sortie des valeurs d'erreurs
    // aux éléments.
    void SortieElemErreur
              (LesMaillages* lesMail,LesReferences* lesRef,ParaGlob * paraGlob);
    // sortie des contraintes aux éléments en texte peu lisible mais condensé
    void SortieElemenContrainte
              (LesMaillages* lesMail,ParaGlob * paraGlob);
    // sortie des frontières
    void SortieFrontieres (LesMaillages* lesMail);

    
    // sortie de la deformee du maillage pour l'article
    void DeformeeArticle(LesMaillages* lesMail);                
  
    // pour un cube, creation de noeuds intermediaires et de faces pour la visualisation
    void ZoomElem
      (Tableau <Noeud*>& TabNo, int n, Tableau <Coordonnee>& TabC, Tableau < Tableau <int> > & Tabnn);
    // dessin d'un cube initial
    void InitialC
      (Tableau <Noeud*>& TabNo, int n, Tableau <Coordonnee>& TabC, Tableau < Tableau <int> > & Tabnn);
        
   };
 /// @}  // end of group

#endif  
