329 lines
20 KiB
C++
329 lines
20 KiB
C++
|
|
// 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
|