
// 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:  choix des grandeurs à visualiser.                          *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/
#ifndef CHOIX_GRANDEURS_MAPLE_T
#define CHOIX_GRANDEURS_MAPLE_T

#include "OrdreVisu.h"
#include "Ddl_enum_etendu.h"
#include "Bloc.h"
#include "BlocDdlLim.h"
#include "ChoixDesMaillages_vrml.h"
#include "TypeQuelconque.h"
#include "Basiques.h" 

class Animation_maple;

/// @addtogroup Les_sorties_au_format_maple
///  @{
///


class Choix_grandeurs_maple : public OrdreVisu
{
  public :
    // CONSTRUCTEURS :
     // par defaut
     Choix_grandeurs_maple () ; 
     
     // constructeur de copie 
     Choix_grandeurs_maple (const Choix_grandeurs_maple& algo);
               
    // DESTRUCTEUR :
     ~Choix_grandeurs_maple () ;  
    
    // METHODES PUBLIQUES :
    // initialisation : permet d'initialiser les différents paramètres de l'ordre
    // lors d'un premier passage des différents incréments
    // en virtuelle, a priori est défini si nécessaire dans les classes dérivées
    // incre : numéro d'incrément qui en cours
    void Initialisation(ParaGlob * ,LesMaillages *,LesReferences*
                      ,LesLoisDeComp* ,DiversStockage*,Charge*,LesCondLim*,LesContacts*
                      ,Resultats*,EnumTypeIncre type_incre,int incre
                      ,const map < string, const double * , std::less <string> >& listeVarGlob
                      ,const List_io < TypeQuelconque >& listeVecGlob
                      ,bool fil_calcul) ;
    // execution de l'ordre
    // tab_mail : donne les numéros de maillage concerné
    // incre : numéro d'incrément qui en cours
    // type_incre : indique si c'est le premier le dernier ou l'incrément courant a visualiser ou pas
    // animation : indique si l'on est en animation ou pas
    // unseul_incre : indique si oui ou non il y a un seul increment à visualiser
    void ExeOrdre(ParaGlob * ,const Tableau <int>& tab_mail ,LesMaillages *,bool unseul_incre,LesReferences*
                      ,LesLoisDeComp* ,DiversStockage*,Charge*,LesCondLim*,LesContacts*
                      ,Resultats*,UtilLecture & entreePrinc,OrdreVisu::EnumTypeIncre type_incre,int incre
                      ,bool animation,const map < string, const double * , std::less <string> >& listeVarGlob
                      ,const List_io < TypeQuelconque >& listeVecGlob);
    // choix de l'ordre, cet méthode peut entraîner la demande d'informations
    // supplémentaires si nécessaire. qui sont ensuite gérer par la classe elle même
    void ChoixOrdre();                   
            
    // initialisation de la liste des différentes grandeurs possibles à visualiser
    void Init_liste_grandeurs(LesMaillages * lesMail,LesCondLim* lesCondLim
                              ,LesContacts* lesContacts,bool fil_calcul);
    
    // écriture des informations d'entête, renseigne sur les infos du fichier, ceci
    // pour permettre l'exploitation par le programme en maple
    // en entrée : list_mail = la liste des maillages à visualiser 
    void Entete_fichier_maple(const list<int>& list_mail,ostream & sort);
    
    // demande de choix d'uniquement 2 grandeurs à visualiser: aux noeuds ou (exclusif) aux éléments
    // retourne un booléen indiquant si l'opération est un succes ou pas
    // num_mail : indique le maillage sur lequel on récupère l'info
    bool Choix_deux_grandeurs(int num_mail);
    // initialisation d'une liaison avec une instance de classe Animation_maple
    void Jonction_Animation_maple( Animation_maple *  choix) {animation_maple = choix;};                      
    // initialisation d'une liaison avec une instance de classe de choix des maillages
    void Jonction_ChoixDesMaillages(const ChoixDesMaillages_vrml* choix_m) {choix_mail = choix_m;};                      
    
    // lecture des paramètres de l'ordre dans un flux
    void Lecture_parametres_OrdreVisu(UtilLecture & entreePrinc);
    // écriture des paramètres de l'ordre dans un flux
    void Ecriture_parametres_OrdreVisu(UtilLecture & entreePrinc);
            
  private :
    // VARIABLES PROTEGEES :    
    Tableau <List_io < Ddl_enum_etendu > > tabnoeud_type_ddl; // ddl principaux aux noeuds possibles à visualiser
    Tableau <List_io < Ddl_enum_etendu > > tabnoeud_type_ddl_retenu; // ddl principaux aux noeuds  à visualiser
    Tableau <List_io < Ddl_enum_etendu > > tabnoeud_type_ddl_retenu_pourSM; // idem pour somme, moy etc. sur une ref
        // il s'agit ici des ddl principaux directement gérés par le noeuds
    int type_sortie_ddl_retenue; // indique un type de sortie parmi les types suivants
                                 // =0 sortie des grandeurs à t
                                 // =1 sortie des grandeurs à t-0
                                 // =2 sortie des grandeurs à 0 et à t
    bool absolue;       // par défaut on sort en absolue les tenseurs
                        // pour pouvoir correctement les visualiser, même pour les elem 2D
 
    // -> noeuds
    Tableau <List_io < Ddl_enum_etendu > > tabnoeud_type_ddlEtendu; // ddl étendu aux noeuds possibles à visualiser
    Tableau <List_io < Ddl_enum_etendu > > tabnoeud_type_ddlEtendu_retenu; // ddl étendu aux noeuds  à visualiser
    Tableau <List_io < Ddl_enum_etendu > > tabnoeud_type_ddlEtendu_retenu_pourSM; // idem pour somme, moy etc. sur une ref

    Tableau <List_io < TypeQuelconque > > tabnoeud_TypeQuelconque; // TypeQuelconque aux noeuds possibles à visualiser
    Tableau <List_io < TypeQuelconque > > tabnoeud_TypeQuelconque_retenu; // TypeQuelconque aux noeuds  à visualiser
    Tableau <List_io < TypeQuelconque > > tabnoeud_TypeQuelconque_retenu_pourSM; // idem pour somme, moy etc. sur une ref
   
    // -> éléments
    Tableau <List_io < Ddl_enum_etendu > > tabelement_type_ddl; // ddl aux elements possibles à visualiser
    Tableau <List_io < Ddl_enum_etendu > > tabelement_type_ddl_retenu; // ddl aux elements  à visualiser
    Tableau <List_io < Ddl_enum_etendu > > tabelement_type_ddl_retenu_pourSM; // idem pour somme, moy etc. sur une ref

    Tableau <List_io < TypeQuelconque > > tabelement_typeParti; // types particuliers aux elements possibles à visualiser
    Tableau <List_io < TypeQuelconque > > tabelement_typeParti_retenu; // ddl aux elements  à visualiser
    Tableau <List_io < TypeQuelconque > > tabelement_typeParti_retenu_pourSM; // idem pour somme, moy etc. sur une ref

    Tableau <List_io < TypeQuelconque > > tabelement_evoluee; // types evoluee aux elements possibles à visualiser    
    Tableau <List_io < TypeQuelconque > > tabelement_evoluee_retenu; // type evoluee aux elements  à visualiser
    Tableau <List_io < TypeQuelconque > > tabelement_evoluee_retenu_pourSM; // idem pour somme, moy etc. sur une ref
    
    // -> face d'éléments
    Tableau <List_io < TypeQuelconque > > tab_F_element_TypeQuelconque; // TypeQuelconque aux faces d'elements possibles à visualiser
    Tableau <List_io < TypeQuelconque > > tab_F_element_TypeQuelconque_retenu; // TypeQuelconque aux faces d'elements  à visualiser
    Tableau <List_io < TypeQuelconque > > tab_F_element_TypeQuelconque_retenu_pourSM; // idem pour somme, moy etc. sur une ref

    // -> arête d'éléments
    Tableau <List_io < TypeQuelconque > > tab_A_element_TypeQuelconque; // TypeQuelconque aux arêtes d'elements possibles à visualiser
    Tableau <List_io < TypeQuelconque > > tab_A_element_TypeQuelconque_retenu; // TypeQuelconque aux arête d'elements  à visualiser
    Tableau <List_io < TypeQuelconque > > tab_A_element_TypeQuelconque_retenu_pourSM; // idem pour somme, moy etc. sur une ref

    List_io <string >  list_grandeur_global; // les grandeurs globales que l'on peut visualiser
    List_io <string >  list_grand_global_retenu; // les grandeurs globales à visualiser
    
    List_io <TypeQuelconque >  listeVecGlobbal; // les vecteurs globaux que l'on peut visualiser
    List_io <TypeQuelconque >  listeVecGlobbal_retenu; // les vecteurs globaux à visualiser
    
    //  --- concerne les torseurs de réaction liées aux conditions limites ----
    // le string contient le nom de la référence qui conduit au torseur de réaction, l'entier est un indice utilisé par CondLim
    // pour optimiser 
    Tableau < List_io <String_et_entier > > tab_list_torseur_condLim; // les torseurs associées aux conditions limites, que l'on peut visualiser
    Tableau < List_io <String_et_entier > > tab_list_torseur_condLim_retenu; // les torseurs associées aux conditions limite, à visualiser
    
    LesMaillages * lesMail; // les maillages
    LesReferences * lesRef; // les références
 
    // --- pour les sorties concernant les sommes et moyennes etc. relativement à des références
    Tableau <List_io <string> > tab_nomDeRef_SM; //  pour somme, moy etc. sur une ref
    Tableau <List_io <BlocScal> > tab_nomDeRef_E_SM; // list de nom de références d'éléments et de point d'intégration associé
    Tableau <List_io <string> > tab_nomDeRef_ptinteg_SM; // list de nom de références de pt d'integ d'éléments

    Tableau <List_io <BlocScal> > tab_nomDeRef_F_E_SM; // list de nom de références de faces d'élément et de point d'intégration associé
    Tableau <List_io <string> > tab_nomDeRef_F_ptinteg_SM; // list de nom de références de pt d'integ de faces d'éléments

    Tableau <List_io <BlocScal> > tab_nomDeRef_A_E_SM; // list de nom de références d'arêtes d'élément et de point d'intégration associé
    Tableau <List_io <string> > tab_nomDeRef_A_ptinteg_SM; // list de nom de références de pt d'integ d'arêtes d'élément

    // --- pour les sorties individuelles: référencement des ref, noeuds, éléments, npti
    
    // -> les noeuds
    Tableau <List_io <string> > nomDeRef; // list de nom de références de noeuds    
    Tableau <List_io <int> > tab_num_noeud; // liste des noeuds à visualiser
    
    // -> les pti d'éléments
    Tableau <List_io <int> > tab_num_element; // liste des éléments à visualiser 
    Tableau <List_io <int> > tab_num_integ; // liste des numéros de point d'integration à visualiser associé à tab_num_element      
    Tableau <List_io <BlocScal> > nomDeRef_E; // list de nom de références d'éléments et de point d'intégration associé 
    Tableau <List_io <string> > nomDeRef_ptinteg; // list de nom de références de pt d'integ d'éléments
    
    // -> les pti de face d'éléments
    Tableau <List_io <int> > tab_num_F_element; // liste des éléments à visualiser
    Tableau <List_io <int> > tab_num_F; // liste des num de face ou arêtes d'éléments à visualiser
    Tableau <List_io <int> > tab_num_F_integ; // liste des numéros de point d'integration à visualiser associé à tab_num_F_element
    Tableau <List_io <BlocScal> > nomDeRef_F_E; // list de nom de références face  d'éléments associés
    Tableau <List_io <string> > nomDeRef_F_ptinteg; // list de nom de références de pt d'integ de face d'éléments

    // -> les pti d'arête d'éléments
    Tableau <List_io <int> > tab_num_A_element; // liste des éléments à visualiser
    Tableau <List_io <int> > tab_num_A; // liste des num d'arêtes d'éléments à visualiser
    Tableau <List_io <int> > tab_num_A_integ; // liste des numéros de point d'integration à visualiser associé à tab_num_A_element
    Tableau <List_io <BlocScal> > nomDeRef_A_E; // list de nom de références d'arête d'éléments  associé
    Tableau <List_io <string> > nomDeRef_A_ptinteg; // list de nom de références de pt d'integ d'arête d'éléments


    // info de stockage utiliser dans le cas d'une animation
    Ddl_enum_etendu x1; Ddl_enum_etendu x2;
    TypeQuelconque xx1; TypeQuelconque xx2; 
    int ddl_etpas_TQ_1, ddl_etpas_TQ_2; // indique si pour l'animation on utilise des ddl (1),
               //  ddl étendues de noeud (2), ddl étendues d'élément (3), ou un type quelconque (0)
    int nb_ordre_1,nb_ordre_2; // numéros d'ordre éventuelle des 2 types quelconques
    bool accroi_x1, accroi_x2; // indique si oui on non la visualisation concerne l'accroissement d'une grandeur entre t=0 et t
    bool type_xi; // indique si oui ou non x1 et x2 sont des grandeurs aux noeuds (sinon c'est aux éléments) 
    Animation_maple* animation_maple; // pour la liaison avec l'animation
    const ChoixDesMaillages_vrml* choix_mail; // contient lorqu'il est actif le choix des maillages
    
    // info pour le style de sortie
    int style_de_sortie; 
        
    int der_numero_mail; // variable de travail : dernier numéro de maillage à visualiser
    
    // METHODES PROTEGEES :
    // entrée du choix de ddl principaux aux noeuds
    void Entree_grandeur_principale_aux_noeuds(string& rep);
    // entrée du choix de ddl étendus secondaires aux noeuds
    void Entree_grandeur_etendue_secondaire_aux_noeuds(string& rep);
    // entrée du choix de cas de grandeurs particuliére aux noeuds
    void Entree_grandeur_TypeQuelconque_secondaire_aux_noeuds(string& rep);
    // entrée du choix d'une grandeur aux éléments
    void Entree_grandeur_aux_elements(string& rep);
    // entrée du choix d'une grandeur particulières (diff des ddl génériques) aux éléments
    void Entree_grandeur_particuliere_aux_elements(string& rep);
    // entrée du choix d'une grandeur tensorielle aux éléments
    void Entree_grandeur_tensorielle_aux_elements(string& rep);
    
    // entrée du choix d'une grandeur quelconque aux faces d'éléments
    void Entree_grandeur_quelconque_aux_faces_element(string& rep);
    // entrée du choix d'une grandeur quelconque aux arêtes d'éléments
    void Entree_grandeur_quelconque_aux_aretes_element(string& rep);
    
    // choix des éléments
    void Choix_element_a_retenir(int n_mail,List_io < Ddl_enum_etendu >& li_ddl);
    // choix des faces d'éléments
    void Choix_faces_element_a_retenir(int n_mail,List_io < EnumTypeQuelconque >& li_enu_quelc);
    // choix des arête d'éléments
    void Choix_aretes_element_a_retenir(int n_mail,List_io < EnumTypeQuelconque >& li_enu_quelc);
    // entrée du choix de grandeurs globals
    void Entree_grandeur_gobal(string& rep);
    // entrée du choix des torseurs de réaction
    void Entree_torseurs_reaction(string& rep);
    // entrée du choix pour les moyennes sommes etc. sur ref N
    void Entree_somme_moy_N(string& rep);
    // entrée du choix pour les moyennes sommes etc. sur ref E
    void Entree_somme_moy_E(string& rep);
    // entrée du choix pour les moyennes sommes etc. sur ref de face d'E
    void Entree_somme_moy_F_E(string& rep);
    // entrée du choix pour les moyennes sommes etc. sur ref d'arête d'E
    void Entree_somme_moy_A_E(string& rep);
    // choix des noeud
    void Choix_noeud_a_retenir(int n_mail,List_io < Ddl_enum_etendu >& li_ddl);
    // dans le cas d'une animation, il n'y a pas de sortie directe mais la création de listes qui sont transmises
    // à animation_maple
    void Construction_liste_pour_animation(int numMail ,LesMaillages * lesMail,Charge* charge);
    // entrée du choix de l'utilisation sur le style de sortie
    void Style_de_sortie(string& rep);
    // vérification des listes de pt d'integ et d'éléments relativement au grandeur à sortir
    void VerifListes();
	   // utilitaire de sortie d'entête pour les noeuds:
    void Sortie_entete_noeud_unitaire(list<int>::const_iterator imail,ostream & sort, int& num_col);
	   // utilitaire de sortie d'entête pour les éléments:
	   void Sortie_entete_element_unitaire(list<int>::const_iterator imail,ostream & sort, int& num_col, bool & temps_deja_affiche);
    // utilitaire de sortie d'entête pour les faces d'élément:
    void Sortie_entete_face_element_unitaire(list<int>::const_iterator imail,ostream & sort, int& num_col, bool & temps_deja_affiche);
    // utilitaire de sortie d'entête pour les arêtes d'élément:
    void Sortie_entete_arete_element_unitaire(list<int>::const_iterator imail,ostream & sort, int& num_col, bool & temps_deja_affiche);

    // sortie pour les moyennes sommes etc. sur ref N
    void Sortie_somme_moy_N(ostream &sort,Charge* charge,bool unseul_incre);
    // sortie pour les moyennes sommes etc. sur ref E
    void Sortie_somme_moy_E(ostream &sort,Charge* charge,bool unseul_incre);
    
    // sortie pour les moyennes sommes etc. sur ref de face E
    void Sortie_somme_moy_face_E(ostream &sort,Charge* charge,bool unseul_incre);
    // sortie pour les moyennes sommes etc. sur ref d'arête E
    void Sortie_somme_moy_arete_E(ostream &sort,Charge* charge,bool unseul_incre);

    // sortie de l'entete pour les moyennes sommes etc. sur ref N
    void Sortie_entete_somme_moy_N(ostream &sort,int & num_col);
    // sortie de l'entete pour les moyennes sommes etc. sur ref E
    void Sortie_entete_somme_moy_E(ostream &sort,int & num_col);
    
    // sortie de l'entete pour les moyennes sommes etc. sur ref de face E
    void Sortie_entete_somme_moy_face_E(ostream &sort,int & num_col);
    // sortie de l'entete pour les moyennes sommes etc. sur ref d'arête E
    void Sortie_entete_somme_moy_arete_E(ostream &sort,int & num_col);

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

#include "Animation_maple.h"
 
#endif  
