// 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) .
//
// 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 .
//
// For more information, please consult: .
/************************************************************************
* 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 >& 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 & 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 >& 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& 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 > tabnoeud_type_ddl; // ddl principaux aux noeuds possibles à visualiser
Tableau > tabnoeud_type_ddl_retenu; // ddl principaux aux noeuds à visualiser
Tableau > 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 > tabnoeud_type_ddlEtendu; // ddl étendu aux noeuds possibles à visualiser
Tableau > tabnoeud_type_ddlEtendu_retenu; // ddl étendu aux noeuds à visualiser
Tableau > tabnoeud_type_ddlEtendu_retenu_pourSM; // idem pour somme, moy etc. sur une ref
Tableau > tabnoeud_TypeQuelconque; // TypeQuelconque aux noeuds possibles à visualiser
Tableau > tabnoeud_TypeQuelconque_retenu; // TypeQuelconque aux noeuds à visualiser
Tableau > tabnoeud_TypeQuelconque_retenu_pourSM; // idem pour somme, moy etc. sur une ref
// -> éléments
Tableau > tabelement_type_ddl; // ddl aux elements possibles à visualiser
Tableau > tabelement_type_ddl_retenu; // ddl aux elements à visualiser
Tableau > tabelement_type_ddl_retenu_pourSM; // idem pour somme, moy etc. sur une ref
Tableau > tabelement_typeParti; // types particuliers aux elements possibles à visualiser
Tableau > tabelement_typeParti_retenu; // ddl aux elements à visualiser
Tableau > tabelement_typeParti_retenu_pourSM; // idem pour somme, moy etc. sur une ref
Tableau > tabelement_evoluee; // types evoluee aux elements possibles à visualiser
Tableau > tabelement_evoluee_retenu; // type evoluee aux elements à visualiser
Tableau > tabelement_evoluee_retenu_pourSM; // idem pour somme, moy etc. sur une ref
// -> face d'éléments
Tableau > tab_F_element_TypeQuelconque; // TypeQuelconque aux faces d'elements possibles à visualiser
Tableau > tab_F_element_TypeQuelconque_retenu; // TypeQuelconque aux faces d'elements à visualiser
Tableau > tab_F_element_TypeQuelconque_retenu_pourSM; // idem pour somme, moy etc. sur une ref
// -> arête d'éléments
Tableau > tab_A_element_TypeQuelconque; // TypeQuelconque aux arêtes d'elements possibles à visualiser
Tableau > tab_A_element_TypeQuelconque_retenu; // TypeQuelconque aux arête d'elements à visualiser
Tableau > tab_A_element_TypeQuelconque_retenu_pourSM; // idem pour somme, moy etc. sur une ref
List_io list_grandeur_global; // les grandeurs globales que l'on peut visualiser
List_io list_grand_global_retenu; // les grandeurs globales à visualiser
List_io listeVecGlobbal; // les vecteurs globaux que l'on peut visualiser
List_io 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 > tab_list_torseur_condLim; // les torseurs associées aux conditions limites, que l'on peut visualiser
Tableau < List_io > 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 > tab_nomDeRef_SM; // pour somme, moy etc. sur une ref
Tableau > tab_nomDeRef_E_SM; // list de nom de références d'éléments et de point d'intégration associé
Tableau > tab_nomDeRef_ptinteg_SM; // list de nom de références de pt d'integ d'éléments
Tableau > 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 > tab_nomDeRef_F_ptinteg_SM; // list de nom de références de pt d'integ de faces d'éléments
Tableau > 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 > 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 > nomDeRef; // list de nom de références de noeuds
Tableau > tab_num_noeud; // liste des noeuds à visualiser
// -> les pti d'éléments
Tableau > tab_num_element; // liste des éléments à visualiser
Tableau > tab_num_integ; // liste des numéros de point d'integration à visualiser associé à tab_num_element
Tableau > nomDeRef_E; // list de nom de références d'éléments et de point d'intégration associé
Tableau > nomDeRef_ptinteg; // list de nom de références de pt d'integ d'éléments
// -> les pti de face d'éléments
Tableau > tab_num_F_element; // liste des éléments à visualiser
Tableau > tab_num_F; // liste des num de face ou arêtes d'éléments à visualiser
Tableau > tab_num_F_integ; // liste des numéros de point d'integration à visualiser associé à tab_num_F_element
Tableau > nomDeRef_F_E; // list de nom de références face d'éléments associés
Tableau > 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 > tab_num_A_element; // liste des éléments à visualiser
Tableau > tab_num_A; // liste des num d'arêtes d'éléments à visualiser
Tableau > tab_num_A_integ; // liste des numéros de point d'integration à visualiser associé à tab_num_A_element
Tableau > nomDeRef_A_E; // list de nom de références d'arête d'éléments associé
Tableau > 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::const_iterator imail,ostream & sort, int& num_col);
// utilitaire de sortie d'entête pour les éléments:
void Sortie_entete_element_unitaire(list::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::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::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