// 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: 07/01/2008 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: Visualisation du maillage initiale en Gmsh. *
* Uniquement l'ordre d'exécution est différent de la classe *
* vrml. *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef MAIL_INITIALE_GMSH_T
#define MAIL_INITIALE_GMSH_T
#include "OrdreVisu.h"
/// @addtogroup Les_sorties_gmsh
/// @{
///
class Mail_initiale_Gmsh : public OrdreVisu
{
public :
// CONSTRUCTEURS :
// par defaut
Mail_initiale_Gmsh () ;
// constructeur de copie
Mail_initiale_Gmsh (const Mail_initiale_Gmsh& algo);
// DESTRUCTEUR :
~Mail_initiale_Gmsh () ;
// 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();
// 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);
// récupération éventuelle de la liste des noms des différentes référence à sortir
// à l'écriture, chaque grandeurs s'écrit sur un fichier propre
// cette fonction sert donc à préparer l'ouverture de ces fichiers
// dans le cas où le tableau est vide cela signifie que les ref seront dans le fichier principal
const Tableau * NomsGrandeurSortie() const
{if (sortie_des_references==2) {return &tab_nom_tag_ref;} else {return NULL;}};
// ramène le tableau de listes de sous maillage
const Tableau < Tableau < List_io < Element* > > > &
Tableau_de_sous_maillage() const {return tabtab_sous_mesh;};
// ramène le tableau de le listes de types d'éléments différents
const Tableau < List_io >&
Tab_liste_type_element() const { return tabli_sig_elem;};
// ramène le tableau de listes de noms des sous maillages
const Tableau < List_io >&
Tab_listes_nom_sousMaillage() const { return tabli_sous_mesh;};
// ramène le décalages pour les numéros de noeuds du maillage "nmail"
int DecalNumNoeud(int nmail) const {return decal_noeud(nmail);};
// ramène le décalages pour les numéros d'éléments du maillage "nmail"
int DecalNumElement(int nmail) const {return decal_element(nmail);};
// ramène le tableau t_Egmsh
// t_Egmsh(im)(ie): donne pour le maillage im, et pour l'élément ie, le numéro gmsh de l'élément
const Tableau < Tableau < int > >& TabEgmsh() const {return t_Egmsh;};
// indique s'il y a quelque chose à regarder du coté des homothetie sur le maillage initiale
bool Considerer_homothetie() const {return considerer_homothetie;};
// ramène un tableau de bool qui indique si oui ou non on fait une pseudo-homothétie sur les coordonnées initiales de chaque maillage
const Tableau < bool >& T_homothetie() const{return t_homothetie ;};
// ramène l'origine et les facteurs multiplicatifs pour une pseudo-homothétie pour chaque maillage
const Tableau & T_orig()const {return t_orig;};
const Tableau & T_fact_mult() const {return t_fact_mult;};
// sortie maillage initiale (sans références ni tag) avec le nouveau format
void sortie_maillage_initial(const Tableau & tab_mail,LesMaillages * lesMail, ostream &sort);
// ramène le nombre total de noeuds
int Nb_total_noeud()const {return nb_total_noeud;};
// ramène le nombre total d'éléments
int Nb_total_element() const {return nb_total_element;};
private :
// VARIABLES PROTEGEES :
// tableau de liste de sous maillages
// chaque sous maillage représente un type d'élément fini particulier
// l'indice du tableau= le numéro de maillage
Tableau < Tableau < List_io < Element* > > > tabtab_sous_mesh;
// tableau de listes de type d'éléments différents
Tableau < List_io > tabli_sig_elem;
// tableau de listes des nom des sous_maillages créés
Tableau < List_io > tabli_sous_mesh;
// tableau des décalages pour les numéros de noeuds et d'éléments
Tableau decal_noeud;
Tableau decal_element;
int nb_total_noeud; // nombre total de noeuds
int nb_total_element; // nombre total d'éléments
int nb_total_ref; // nombre total de références
int sortie_des_references; // = 0, 1 ou 2: indique si oui (diff de 0) ou non
// on veut une sortie des références
// = 1: par défaut sortie des ref, dans un fichier unique
// = 2: sortie des refs dans des fichiers séparés
Tableau tab_nom_tag_ref; //le tableau des noms des tag correspondant aux ref
// tab_nom_tag_ref(i) = le nom du tag associé à la ref i, i étant le numéro d'apparition
// de la référence, quand on parcours toutes les références
// tableau construit dans la méthode: Initialisation(..
Tableau lesRefInitiales; // le tableau des ref initiales, construit avec Initialisation(..
Tableau tab_num_tag; // le tableau des numéros des tag correspondant aux ref
// tab_num_tag(i) = le numéro du tag associé à la ref i, i étant le numéro d'apparition
// de la référence, quand on parcours toutes les références
// tableau construit dans la méthode: SortieTagPhysicalNames
// concernant les éléments points qu'il faut rajouter pour voir sous gmsh les références de noeud !!
// un tableau d'adressage indirecte qui permet d'utiliser ces noeuds éléments
Tableau > t_jonction_N_Nelem;
// t_jonction_N_Nelem(i)(j) donne le numéro de noeud_élément correspondant à l'ancien numéro j pour le maillage i
// n'est rempli que pour les noeuds ayant conduit à la création d'un noeud_élément
// concernant les ref de pti: on stocke le nombre de noeud additionnel et de noeud élément additionnel:
int nombre_noeud_ref_pti; // c'est le même nombre: à chaque pti on ajoute un noeud et un noeud élément
int nombre_ref_pti; // nombre de référence de point d'intégration
// un tableau d'adressage indirecte qui permet d'utiliser ces noeuds éléments pour les pti
Tableau > t_jonction_N_NelemPti;
// t_jonction_N_NelemPti(i)(j) donne le numéro de noeud_élément correspondant
// au numéro j dans la ref, pour la référence de pti i
// n'est rempli que pour les noeuds ayant conduit à la création d'un noeud_élément
Tableau tab_dim_de_ref; // tab_dim_de_ref(i) donne la dimension des éléments
// de la ref de nom tab_nom_tag_ref(i)
// 1 pour ligne 2 pour surface, 3 pour volume, 0 pour autre
// un tableau de liaison entre les éléments herezh des maillages et les numéros associés de gmsh
// t_Egmsh(im)(ie): donne pour le maillage im, et pour l'élément ie, le numéro gmsh de l'élément
Tableau < Tableau < int > > t_Egmsh;
bool considerer_homothetie; // indique s'il y a quelque chose à regarder du coté des homotheties
// (on pourrait faire avec t_homothetie mais c'est plus facile avec un paramètre globale)
Tableau < bool > t_homothetie ; // oui ou non on fait une pseudo-homothétie sur les coordonnées
// initiales de chaque maillage
// on considère un rapport d'homothétie qui peut-être différent sur les 3 axes d'ou le nom de pseudo
Tableau t_orig,t_fact_mult; // origine et facteurs multiplicatifs pour
// une pseudo-homothétie pour chaque maillage
// METHODES PROTEGEES :
// sortie de la définition des tag de PhysicalNames (sert pour les références)
void SortieTagPhysicalNames(const Tableau & tab_mail,LesMaillages * lesMail,ostream &sort);
// sortie uniquement des noeuds avec éventuellement, def de noeud aux points d'intégration
void SortieDesNoeuds(const Tableau & tab_mail,LesMaillages * lesMail, ostream &sort);
// sortie uniquement des éléments
void SortieDesElements(const Tableau & tab_mail,LesMaillages * lesMail,ostream &sort);
// sortie des références
void SortieReferences(const Tableau & tab_mail,LesMaillages * lesMail,UtilLecture & entreePrinc);
// sortie éventuelle d'un seul élément au format gmsh
// et modification éventuelle du tableau t_Egmsh
// num_elem : numero initial de l'élément
// decal_ele : décalage de numéro pour tenir compte de la présence de plusieurs maillages
// (ou sous maillages)
// decal_noe : décalage de numéro de noeud, pour tenir compte de la présence de plusieurs maillages
// tab_noeud : le tableau des noeuds de la connection
// id_geom et id_interpol : permettent de repérer un type d'élément fini associé
// (donc pas seulement géométrique)
// : il s'agit ici de la géométrie et interpolation "élément fini"
// sort : flux de sortie
// modifier_t_Egmsh : indique si pour l'élément considéré, on abonde le tableau t_Egmsh
// im : num du maillage ou sous maillage
// elem_a_sortir : indique si pour l'élémen considéré, on le sort dans le fichier gmsh
void SortieDunElements(bool elem_a_sortir, const int& num_elem
, ostream &sort
, const int& decal_ele, Tableau& tab_noeud
, const int& decal_noe, Enum_geom id_geom, Enum_interpol id_interpol
, bool modifier_t_Egmsh , int im);
// constitution des sous maillages, utilisé par les isovaleurs par exemple
// on suit la même logique que dans gid, un sous maillage par type d'élément
// ce n'est pas nécessaire, c'est pas simplicité, à modifier si nécessaire par la suite
void CreaSousMaillages(const Tableau & tab_mail,LesMaillages * lesMail);
// sortie sur le flot passé en paramètre, de la partie noeud du maillage sans entête ni fin
void Sortie_noeuds_initiaux(const Tableau & tab_mail,LesMaillages * lesMail, ostream &sort);
// sortie sur le flot passé en paramètre, de la partie élément du maillage sans entête ni fin
void Sortie_element_initiaux(const Tableau & tab_mail,LesMaillages * lesMail, ostream &sort);
};
/// @} // end of group
#endif