Herezh_dev/herezh_pp/Resultats/Gid/Visualisation_Gid.cc

408 lines
18 KiB
C++
Raw Normal View History

// 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-2021 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/>.
#include "Visualisation_Gid.h"
#include <stdlib.h>
#include <iomanip>
// les ordres possibles
#include "Mail_initiale_Gid.h"
#include "Deformees_Gid.h"
#include "Fin_Gid.h"
#include "Visuali_Gid.h"
#include "Increment_vrml.h"
#include "ChoixDesMaillages_vrml.h"
#include "Isovaleurs_Gid.h"
#include "Banniere.h"
// CONSTRUCTEURS :
Visualisation_Gid::Visualisation_Gid () // par defaut
{ cout << "\n ce constructeur ne doit pas etre utilise !! \n" ;
cout << " Visualisation_Gid::Visualisation_Gid () // par defaut " << endl;
};
// le bon constructeur
Visualisation_Gid::Visualisation_Gid (UtilLecture* ent) :
lesValVecPropres(),ordre_possible(),entreePrinc(ent)
,fin_o(NULL),visuali(NULL),choix_inc(NULL)
,list_incre(),list_balaie(NULL)
,animation(false)
,activ_sort_Gid(false)
{ // définition des ordres possibles
list <OrdreVisu>::iterator it;
OrdreVisu* ptordre;
// maillage initial
ptordre = new Mail_initiale_Gid(); ordre_possible.push_back(ptordre);
mailInit = ptordre; // récup de l'ordre
// Choix de la visualisation des isovaleurs
//NB: il faut que l'isovaleur soit avant la déformée !! pour que la déformée puisse
// utiliser les couleurs définis dans isovaleurs
ptordre = new Isovaleurs_Gid(); ordre_possible.push_back(ptordre);
choix_isovaleur = ptordre; // récup de l'ordre
// déformée
ptordre = new Deformees_Gid(); ordre_possible.push_back(ptordre);
ptdeformee = ptordre; // récup de l'ordre
// Choix du ou des incréments à visualiser.
ptordre = new Increment_vrml(); ordre_possible.push_back(ptordre);
choix_inc = ptordre; // récup de l'ordre
// Choix du ou des maillages à visualiser.
ptordre = new ChoixDesMaillages_vrml(); ordre_possible.push_back(ptordre);
choix_mail = ptordre; // récup de l'ordre
// transmission de la position à la déformée
((Deformees_Gid*) ptdeformee)->Jonction_isovaleur((Isovaleurs_Gid*)choix_isovaleur);
((Deformees_Gid*) ptdeformee)->Jonction_ChoixDesMaillages((ChoixDesMaillages_vrml*)choix_mail);
// transmission du maillage initiale aux isovaleurs et à la déformée
((Isovaleurs_Gid*) choix_isovaleur)->Jonction_MaillageInitiale((Mail_initiale_Gid*)mailInit);
((Deformees_Gid*) ptdeformee)->Jonction_MaillageInitiale((Mail_initiale_Gid*)mailInit);
// ordre de visualisation
ptordre = new Visuali_Gid(); ordre_possible.push_back(ptordre);
visuali = ptordre; // récup de l'ordre
// fin de la visualisation
ptordre = new Fin_Gid(); ordre_possible.push_back(ptordre);
fin_o = ptordre; // récup de l'ordre fin
/* string ordre,comment;
comment = "évolution force/déplacement : "; ordre = "evolFD";
commentaires_ordres.push_back(comment); ordre_possible.push_back(ordre);*/
};
// DESTRUCTEUR :
Visualisation_Gid::~Visualisation_Gid ()
{ // destruction de la liste d'ordre
list <OrdreVisu*>::iterator il,ifin;
ifin = ordre_possible.end();
for (il=ordre_possible.begin();il!=ifin;il++)
delete (*il);
};
// METHODES PUBLIQUES :
// affichage des différentes possibilités (ordres possibles)
// ramène un numéro qui renseigne le programme appelant
// =-1 : signifie que l'on veut stopper la visualisation
// = 0 : signifie que l'on demande la visualisation effective
int Visualisation_Gid::OrdresPossible()
{ // si l'on passe ici cela signifie que la visualisation Gid est active
activ_sort_Gid= true;
string reponse; // réponse utilisateur
// on commence par inactiver les ordres de visualisation et de fin
fin_o->Inactive_ordre(); visuali->Inactive_ordre();
// on boucle
while ( !(fin_o->Actif()) && !(visuali->Actif()))
{
while ((reponse.length () == 0) || (Existe(reponse)==NULL))
{ // affichage des options possibles
Affiche_options();
// lecture de la commande voulu
reponse = lect_chaine();
OrdreVisu* ord = Existe(reponse);
if (ord == NULL)
{ // dans le cas d'un ordre non connu
cout << "\n ordre non connu !!, verifiez votre demande \n";
}
else
// demande d'activation de l'ordre
ord->ChoixOrdre();
}
// on vide la réponse pour une autre boucle éventuelle
reponse ="";
}
// récupération de la liste des incréments à visualiser
list_balaie = &((Increment_vrml*)choix_inc)->List_choisit();
// def du retour
if (fin_o->Actif())
return -1;
else
return 0;
};
// information de l'instance de la liste d'incrément disponible pour la visualisation
void Visualisation_Gid::List_increment_disponible(list <int> & list_incr)
{ list_incre = list_incr; // stockage interne
// puis passage à l'instance d'ordre qui gère les incréments
((Increment_vrml*)choix_inc)->Init_list_inc(list_incre);
} ;
// indique le choix de la liste d'incrément à utiliser pour l'initialisation
// des fonctions d'initialisation
const list<int> & Visualisation_Gid::List_balaie_init()
{ // choix entre tous les incréments : option par défaut
// ou une liste plus restreinte d'incrément, utile lorsqu'il y a vraiment
// beaucoup d'incrément
bool choix_valide = false;
string rep;
while (!choix_valide)
{
cout << "\n === choix des increments utilises pour l'initialisation de la visualisation ===="
<< "\n option par defaut : tous les increments (rep 1)"
<< "\n choix d'un nombre plus petit d'increment (rep 2)";
cout << "\n reponse ? "; rep = lect_return_defaut(true,"1");cout << "\n";
if ((rep == "1") || (rep == "2"))
// cas d'un choix valide
choix_valide = true;
else
cout << "\n la reponse : " << rep << " n'est pas utilisable, recommencez !";
}
// exécution
if (rep == "1")
// cas de tous les incréments
return list_incre;
else if (rep == "2")
// cas d'un choix d'incrément, appel du choix d'incrément
{ ((Increment_vrml*)choix_inc)->ChoixOrdre();
return (((Increment_vrml*)choix_inc)->List_choisit());
}
// pour éviter un warning, car normalement on ne passe jamais ici
return list_incre;
};
// impose une liste d'incrément à utiliser
void Visualisation_Gid::List_balaie_init(const list<int> & )
//void Visualisation_Gid::List_balaie_init(const list<int> & list_init)
{ ((Increment_vrml*)choix_inc)->Impos_list(list_incre);
// récupération de la liste des incréments à visualiser
list_balaie = &((Increment_vrml*)choix_inc)->List_choisit();
};
// information de l'instance du nombre de maillages disponibles pour la visualisation
// par défaut tous les maillages seront visualisés, ceci est descidé aussi ici
void Visualisation_Gid::List_maillage_disponible(int nombre_maillage_dispo)
{ nb_maillage_dispo = nombre_maillage_dispo;
// on défini la liste de tous les maillages par défaut
((ChoixDesMaillages_vrml*)choix_mail)->Init_nb_maill(nb_maillage_dispo);
};
// initialisation des ordres disponibles
// par exemple pour les isovaleurs on définit la liste des isovaleurs disponibles et les extrémas
void Visualisation_Gid::Initialisation(ParaGlob * paraGlob,LesMaillages * lesMaillages
,LesReferences* lesReferences
,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage
,Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts
,Resultats* resultats,OrdreVisu::EnumTypeIncre type_incre,int incre
,const map < string, const double * , std::less <string> >& listeVarGlob
,const List_io < TypeQuelconque >& listeVecGlob
,bool fil_calcul)
{
// on passe en revue l'ensemble des ordres possibles
list <OrdreVisu*>::iterator s_or,s_or_fin;
s_or_fin = ordre_possible.end();
for (s_or = ordre_possible.begin();s_or != s_or_fin; s_or++)
(*s_or)->Initialisation(paraGlob,lesMaillages,lesReferences
,lesLoisDeComp ,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,incre
,listeVarGlob,listeVecGlob
,fil_calcul);
};
// méthode principale pour activer la visualisation
void Visualisation_Gid::Visu(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesReferences* lesReferences
,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage
,Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts
,Resultats* resultats,OrdreVisu::EnumTypeIncre type_incre,int incre
,const map < string, const double * , std::less <string> >& listeVarGlob
,const List_io < TypeQuelconque >& listeVecGlob)
{ // récup de la liste de maillage
const list <int>& li_mail = ((ChoixDesMaillages_vrml*)choix_mail)->List_choisit();
list <int>::const_iterator ik,ikfin;
ikfin = li_mail.end();
// on définit un tableau des maillages à sortir, plus pratique pour les itérations
// dans les routines internes (et plus rapide)
Tableau <int> tab_mail(li_mail.size()); int iidd = 1;
for (ik= li_mail.begin();ik!=ikfin;ik++,iidd++) tab_mail(iidd)=*ik;
// initialisation de l'animation : ce paramètre n'est pas utilisé pour la sortie GID
// on le met par défaut à false
animation = false;
// ici on passe en revue l'ensemble des ordres possibles
list <OrdreVisu*>::iterator s_or,s_or_fin;
s_or_fin = ordre_possible.end();
// s'il n'y a qu'un seul incrément à visualisé on le signale
bool unseul_incre = true; if (list_balaie->size() > 1) unseul_incre = false;
for (s_or = ordre_possible.begin();s_or != s_or_fin; s_or++)
{ (*s_or)->ExeOrdre(paraGlob,tab_mail,lesMaillages,unseul_incre,lesReferences
,lesLoisDeComp ,diversStockage
,charge,lesCondLim,lesContacts,resultats,*entreePrinc
,type_incre,incre,animation,listeVarGlob,listeVecGlob);
};
//on vide le buffer
entreePrinc->Sort_initial_Gid() << endl;
entreePrinc->Sort_initial_Gid() << flush;
// s'il y a un fichier résultat idem
if (entreePrinc->Existe_resultat_Gid())
{ entreePrinc->Sort_resultat_Gid() << endl << flush;};
};
// == définition des paramètres de visualisation
// titre, navigation, éclairage
// et initialisation des paramètres de la classe
void Visualisation_Gid::Contexte_debut_visualisation()
{// ==== tout d'abord le maillage initial
ostream &sort = entreePrinc->Sort_initial_Gid();
// écriture de l'entête
sort << "\n # --------------------------------------------------------"
<< "\n # format fichier Gid (maillage initial) "
<< "\n # --------------------------------------------------------"
<< "\n # ";
// le titre
sort << "\n # "
<< "\n # Visualisation elements finis : Herezh++ V" << ParaGlob::NbVersion()
<< "\n #"
// << "info [ \"Copyright (c) 1997-2003, Gérard Rio (gerard.rio@univ-ubs.fr) http://www-lg2m.univ-ubs.fr\" ]\n"
<< "\n # ";
sort << Banniere::CopiPirate() << " \n";
// ==== puis pour les résultats
ostream &sart = entreePrinc->Sort_resultat_Gid();
// écriture de l'entête
sart << "GiD Post Results File 1.0 \n";
sart << "\n # -------------------------------------------------"
<< "\n # format fichier Gid (resultats) "
<< "\n # -------------------------------------------------"
<< "\n # ";
// le titre
sart << "\n # "
<< "\n # Visualisation elements finis : Herezh++ V" << ParaGlob::NbVersion()
<< "\n #"
// << "info [ \"Copyright (c) 1997-2003, Gérard Rio (gerard.rio@univ-ubs.fr) http://www-lg2m.univ-ubs.fr\" ]\n"
<< "\n # ";
sart << Banniere::CopiPirate() << " \n";
// === puis initialisation
animation = false;
};
// (points de vue) et enchainement si nécessaire
void Visualisation_Gid::Contexte_fin_visualisation()
{// définition des points de vue avec l'angle adoc
};
// lecture des paramètres de l'ordre dans un flux
void Visualisation_Gid::Lecture_parametres_OrdreVisu(UtilLecture & entreePrinc)
{ // si dans le flot il existe l'identificateur adoc on lit sinon on passe
if (strstr(entreePrinc.tablcarCVisu,"debut_visualisation_Gid")!=NULL)
{// essaie de lecture
try
{ string nom;
(*entreePrinc.entCVisu) >> nom ;
if (nom != "debut_visualisation_Gid")
{ cout << "\n Erreur en lecture de la visualisation Gid a partir d'un fichier .CVisu,"
<< " le premier enregistrement doit etre le mot clef: debut_visualisation_Gid "
<< " la visualisation Gid n'est pas validee !! ";
}
else
{ // on valide la visualisation
activ_sort_Gid=true;
entreePrinc.NouvelleDonneeCVisu();
// on passe en revue tous les ordres disponibles
list <OrdreVisu*>::iterator s_or,s_or_fin;
while (strstr(entreePrinc.tablcarCVisu,"fin_visualisation_Gid")==NULL)
{ s_or_fin = ordre_possible.end();
for (s_or = ordre_possible.begin();s_or != s_or_fin; s_or++)
(*s_or)->Lecture_parametres_OrdreVisu(entreePrinc);
}
}
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch (...)// erreur de lecture
{ cout << "\n Erreur en lecture de la visualisation Gid a partir d'un fichier .CVisu,"
<< " la visualisation Gid n'est pas validee !! ";
activ_sort_Gid=false;
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n Visualisation::Lecture_parametres_OrdreVisu(..";
}
// on passe à un nouvel enregistrement
entreePrinc.NouvelleDonneeCVisu();
}
};
// écriture des paramètres de l'ordre dans un flux
void Visualisation_Gid::Ecriture_parametres_OrdreVisu(UtilLecture & entreePrinc)
{ // récup du flot
ostream & sort = (*(entreePrinc.Sort_CommandeVisu()));
// on s'occupe des ordres spécifiques à la visualisation Gid
// il n'y a écriture que si la visualisation Gid est active
if(activ_sort_Gid)
{// tout d'abord l'activation du type Gid
// on commente le fonctionnement
sort << "\n # =================================================================================";
sort << "\n # || ***** demande d'une visualisation Gid: ***** || "
<< "\n # ================================================================================="
<< "\n # un mot cle de debut (debut_visualisation_Gid)"
<< "\n # un mot cle de fin ( fin_visualisation_Gid) apres tous les ordres particuliers"
<< "\n # la seule presence du premier mots cle suffit a activer la visualisation Gid"
<< "\n # la presence du second permet une meilleur lisibilite du fichier, mais n'est pas indispensable" ;
// on sort les mots clés d'activation du type Gid
sort << "\n debut_visualisation_Gid \n" ;
// on passe en revue tous les ordres disponibles
list <OrdreVisu*>::iterator s_or,s_or_fin;
s_or_fin = ordre_possible.end();
for (s_or = ordre_possible.begin();s_or != s_or_fin; s_or++)
(*s_or)->Ecriture_parametres_OrdreVisu(entreePrinc);
// fin de l'activation Gid
sort << "\n fin_visualisation_Gid"
<< "\n # ================================================================================="
<< "\n # || fin de la visualisation Gid || "
<< "\n # ================================================================================= \n \n";
}
};
//============================== méthodes privées =====================
// test si la réponse fait partie des ordres possibles
// si l'on trouve un ordre ok on ramène un pointeur sur l'ordre
// sinon on ramène un pointeur null
OrdreVisu* Visualisation_Gid::Existe(string& reponse)
{ // on passe en revue la liste d'ordre
list <OrdreVisu*>::iterator s_or,s_or_fin;
s_or_fin = ordre_possible.end();
for (s_or = ordre_possible.begin();s_or != s_or_fin; s_or++)
if ((*s_or)->OrdreVrai(reponse))
return (*s_or); // cas d'un ordre correcte
return NULL; // pas d'ordre correcte trouvé
};
// affichage des options possibles
void Visualisation_Gid::Affiche_options()
{ // écriture d'une ligne de transition
cout << setw(60) << setfill('-') << "\n " << setfill(' ');
list <OrdreVisu*>::iterator s_or,s_or_fin;
s_or_fin = ordre_possible.end();
for (s_or = ordre_possible.begin();s_or != s_or_fin; s_or++)
(*s_or)->Affiche_ordre();
cout << "\n reponse ? ";
};