rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Algo/AlgoRef/Algori2.cc

2186 lines
125 KiB
C++
Raw Normal View History

ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// 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.
//
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// 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 "Algori.h"
#include "string"
#include "MathUtil.h"
#include <iostream> // pour utiliser la classe istrstream
#include <strstream> // nouveau dans CW5.3
#include "ReferenceNE.h"
#include "ReferenceAF.h"
#include "AlgoriCombine.h" // pour la sortie base_info
// cas eventuel d'un démarrage à partir de base_info
// si inc_voulu est négatif cela signifie que l'on est déjà positionné sur un
// incrément voulu et qu'il faut simplement faire la lecture des infos
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages,
LesReferences* lesReferences,LesCourbes1D* lesCourbes1D,
LesFonctions_nD* lesFonctionsnD,LesLoisDeComp* lesLoisDeComp,
DiversStockage* diversStockage,Charge* charge,
LesCondLim* lesCondlim,LesContacts* lesContacts,Resultats* resultats,
int inc_voulu)
{ //il y a deux types d'entrée de donnée soit via un fichier info
// soir via via base info
int lec_ent_info = entreePrinc->Lec_ent_info();
// récup du flot d'entrée
ifstream * entrons = entreePrinc->Ent_BI();
// si l'incrément est positif on se positionne à l'incrément voulu
if (inc_voulu >= 0)
// lecture différenciée en fonction du cas -> positionnement à l'incrément donné
switch (lec_ent_info)
{ case 0 : // ---- cas d'un restart, on récupère à un incrément donné -----------
{bool inc_trouve = entreePrinc->Positionnement_base_info(inc_voulu);
if (!inc_trouve)
{ cout << "\nErreur : On ne trouve pas l'increment de restart demande !\n";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
cout << "Algori::Lecture_base_info(....)"
<< " increment = " << inc_voulu << endl;
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// dans le cas où un comptage du calcul est en cours on l'arrête
if (tempsInitialisation.Comptage_en_cours()) tempsInitialisation.Arret_du_comptage();
if (tempsMiseAjourAlgo.Comptage_en_cours()) tempsMiseAjourAlgo.Arret_du_comptage();
Sortie(1);
};
break;
}
case 1 : // ------- on récupère tout -------------------------
// dans le cas d'une première lecture on passe les informations sur les incréments
{string toto; int titi; double xxx;
(*entrons) >> toto
>> titi >> toto >> xxx >> toto >> xxx >> toto >> xxx;
(*entrons) >> toto ; // la ligne des tirets
break;
}
case 2 : case 3 : // ----------- on récupère à un incrément donné --------------------
{string toto; int titi; int inc; bool inc_trouve = false;double xxx;
// lecture tant que l'on n'a pas atteint la fin du fichier
do
{ (*entrons) >> toto;
if (toto == "INCREMENT_DE_CHARGE_:")
// on a trouvé un incrément
{ (*entrons) >> inc;
if (inc == inc_voulu)
// ok on a l'incrément voulu
// fin de la préparation de la lecture pour l'incrément
{(*entrons) >> titi >> toto >> xxx >> toto >> xxx >> toto >> xxx;
(*entrons) >> toto ; // la ligne des tirets
inc_trouve = true;
};
};
// test pour vérifier l'intégrité du flot
if (entrons->rdstate() != 0)
// si l'on est arrivé à la fin du fichier il n'y a rien à faire
// sinon on remet à flot le flot (cas par exemple d'entier au lieu de caractère)!
if (!(entrons->eof()))
entrons->clear();
}
while ((!(entrons->eof()))&& (!inc_trouve));
// dans le cas où on n'a pas trouvé le bon incrément message d'erreur
if (!inc_trouve)
{ cout << "\nErreur : On ne trouve pas l'increment demande !\n";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
cout << "Algori::Lecture_base_info(....)"
<< " incrément = " << inc_voulu << endl;
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// dans le cas où un comptage du calcul est en cours on l'arrête
if (tempsInitialisation.Comptage_en_cours()) tempsInitialisation.Arret_du_comptage();
if (tempsMiseAjourAlgo.Comptage_en_cours()) tempsMiseAjourAlgo.Arret_du_comptage();
Sortie(1);
};
break;
}
default :
{ cout << "\nErreur : valeur incorrecte du type de restart !\n";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
cout << "Algori::Lecture_base_info(....)"
<< " cas= " << cas << endl;
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// dans le cas où un comptage du calcul est en cours on l'arrête
if (tempsInitialisation.Comptage_en_cours()) tempsInitialisation.Arret_du_comptage();
if (tempsMiseAjourAlgo.Comptage_en_cours()) tempsMiseAjourAlgo.Arret_du_comptage();
Sortie(1);
}
};
// fin du positionnement à l'incrément donné
// lecture particulière à l'algorithme
Lecture_base_info(*entrons,cas);
mise à jour 7.010
2023-05-03 17:23:49 +02:00
#ifdef UTILISATION_MPI
// si calcul on sauvegarde la distribution
distribution_CPU_algo.Lecture_base_info(*entrons,cas);
#endif
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
lesMaillages->Lecture_base_info(*entrons,cas); // lecture des maillages et des references
lesReferences->Lecture_base_info(*entrons,cas); // lecture des références
lesCourbes1D->Lecture_base_info(*entrons,cas); // lecture des courbes1D
lesFonctionsnD->Lecture_base_info(*entrons,cas); // lecture des fonctions nD
lesLoisDeComp->Lecture_base_info(*entrons,cas,*lesReferences,*lesCourbes1D,*lesFonctionsnD); // lecture des lois
diversStockage->Lecture_base_info(*entrons,cas); // premiere lecture des stockages divers
charge->Lecture_base_info(*entrons,cas,*lesReferences,*lesCourbes1D,*lesFonctionsnD); // lecture des actions exterieurs de chargement
lesCondlim->Lecture_base_info(*entrons,cas,*lesReferences,*lesCourbes1D,*lesFonctionsnD); // lecture des ddl bloques
lesContacts->Lec_base_info_LesContacts(*entrons,*lesMaillages
, &LesMaillages::Noeud_LesMaille, &LesMaillages::Element_LesMaille); // lecture des contacts éventuelles
resultats->Lect_result_base_info(*entrons,cas); // lecture des parametres de gestion de la sortie des resultats
// --- on récupère la position du pointeur dans le fichier
// l'opération n'est pas si simple car on a deux cas:
// 1) soit on est arrivée à la fin du fichier c-a-d eofbit = 1<<1, // -> 2
// dans ce cas il ne faut pas utiliser tellg() car cela va générer un failbit = 1<<2, // -> 4
// au contraire on va à la fin et ensuite on demande la position
// comme on ne peut plus changer les bit
if (entrons->eof())
{ // ici on fait une manip bizarre mais qui marche
entreePrinc->Fermeture_base_info(); // on ferme
entreePrinc->Ouverture_base_info("lecture"); // puis on ouvre
// récup du flot d'entrée
entrons = entreePrinc->Ent_BI();
entrons->seekg (0, entrons->end); // on se met à la fin
debut_increment = entrons->tellg(); // on récupère la position
}
else // sinon cela veut que l'on n'est pas à la fin, on peut donc récupérer la position
debut_increment = entrons->tellg();
// mémorisation du temps de la sauvegarde
temps_derniere_sauvegarde=pa.Variables_de_temps().TempsCourant();
list_incre_temps_sauvegarder.push_front(Entier_et_Double(inc_voulu,temps_derniere_sauvegarde));
{// cas de la lecture de données déjà calculées
// a priori on effectue la lecture des maillages
// il faut penser au contact !!!!!!!
};
};
// sauvegarde sur base info
// sauvegarde sur base info
// cas donne le niveau de sauvegarde
// = 0 : initialisation de la sauvegarde -> c'est-à-dire de la sortie base info
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
// incre : numero d'incrément auquel on sauvegarde
// éventuellement est définit de manière spécifique pour chaque algorithme
// dans les classes filles
// type_incre :signal permet de localiser le dernier incrément
void Algori::Ecriture_base_info
(int cas,LesMaillages *lesMaillages,
LesReferences* lesReferences,LesCourbes1D* lesCourbes1D,
LesFonctions_nD* lesFonctionsnD,LesLoisDeComp* lesLoisDeComp,
DiversStockage* diversStockage,Charge* charge,
LesCondLim* lesCondlim,LesContacts* lesContacts,Resultats* resultats
,OrdreVisu::EnumTypeIncre type_incre, int incre)
{
tempsSauvegarde.Mise_en_route_du_comptage(); // temps cpu
// récup des flots pour base info
ofstream * sortons = entreePrinc->Sort_BI();
bool sortie_effectuee = false;
switch (cas)
{ case 1 : // ------- on sauvegarde tout -------------------------
{ entreePrinc->Enregistrement_position_increment_base_info(0.);
// écriture du numéro d'incrément = 0 pour signifier que c'est le début des infos
(*sortons) << "\n=========================================================================="
<< "===================="
<< "\n INCREMENT_DE_CHARGE_: " << 0 << " intensite " << 0.
<< " t= " << setprecision(ParaGlob::NbdigdoCA()) << pa.Variables_de_temps().TempsCourant()
<< " dt= " << setprecision(ParaGlob::NbdigdoCA())<< ParaGlob::Variables_de_temps().IncreTempsCourant()
<< "\n========================================================================================="
<< "====================";
// mémorisation du temps de la sauvegarde
temps_derniere_sauvegarde=pa.Variables_de_temps().TempsCourant();
list_incre_temps_sauvegarder.push_front(Entier_et_Double(0,temps_derniere_sauvegarde));
sortie_effectuee = true;
break;
}
case 2 : // ----------- sauvegarde uniquement de se qui varie --------------------
{ // la sauvegarde est effectuée uniquement pour les incréments demandés
// --dans le cas où le temps courant == le dernier temps déjà sauvegardé, ce n'est pas la peine de faire une seconde sauvegarde
// sauf si c'est une demande explicite via les paramètres de contrôle
if ((pa.Variables_de_temps().TempsCourant() == temps_derniere_sauvegarde)
&& (!pa.EtatSortieEtatActuelDansBI()))return;
if ((pa.SauvegardeAutorisee(incre,temps_derniere_sauvegarde,(type_incre==OrdreVisu::DERNIER_INCRE))) // cas courant
|| (pa.EtatSortieEtatActuelDansBI())) // cas où la demande est explicite -> ce n'est pas le cas courant
{
double temps = pa.Variables_de_temps().TempsCourant();
entreePrinc->Enregistrement_position_increment_base_info(incre);
// écriture du numéro d'incrément dans le cas d'une sauvegarde partielle
// écriture du numéro d'incrément
(*sortons) << "\n========================================================================================="
<< "===================="
<< "\n INCREMENT_DE_CHARGE_: " << incre << " intensite "
<< setprecision(ParaGlob::NbdigdoCA()) << charge->IntensiteCharge()
<< " t= " << setprecision(ParaGlob::NbdigdoCA()) << pa.Variables_de_temps().TempsCourant()
<< " dt= " << setprecision(ParaGlob::NbdigdoCA())<< ParaGlob::Variables_de_temps().IncreTempsCourant()
<< "\n========================================================================================="
<< "====================";
// mémorisation du temps de la sauvegarde
temps_derniere_sauvegarde=temps;
list_incre_temps_sauvegarder.push_front(Entier_et_Double(incre,temps_derniere_sauvegarde));
sortie_effectuee = true;
}
break;
}
default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
cout << "Algori::Ecriture_base_info(....)"
<< " cas= " << cas << endl;
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// dans le cas où un comptage du calcul est en cours on l'arrête
if (tempsSauvegarde.Comptage_en_cours()) tempsSauvegarde.Arret_du_comptage();
if (tempsSortieFilCalcul.Comptage_en_cours()) tempsSortieFilCalcul.Arret_du_comptage();
Sortie(1);
};
};
// écriture sur le flot de sortie en fonction du "cas"
// if ((incre % pa.Sauvegarde()) == 0)
if (sortie_effectuee)
{
// ******* reste lescontacts
Ecriture_base_info(*sortons,cas);
mise à jour 7.010
2023-05-03 17:23:49 +02:00
#ifdef UTILISATION_MPI
// si calcul on sauvegarde la distribution
distribution_CPU_algo.Ecriture_base_info(*sortons,cas);
#endif
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
lesMaillages->Ecriture_base_info(*sortons,cas); // Ecriture des maillages et des references
lesReferences->Ecriture_base_info(*sortons,cas); // Ecriture des references
lesCourbes1D->Ecriture_base_info(*sortons,cas); // Ecriture des courbes1D
lesFonctionsnD->Ecriture_base_info(*sortons,cas); // Ecriture des fonctions nD
lesLoisDeComp->Ecriture_base_info(*sortons,cas); // Ecriture des lois
diversStockage->Ecriture_base_info(*sortons,cas); // Ecriture des stockages divers
charge->Ecriture_base_info(*sortons,cas); // Ecriture des actions exterieurs de chargement
lesCondlim->Ecriture_base_info(*sortons,cas); // Ecriture des ddl bloques
lesContacts->Ecri_base_info_LesContacts(*sortons); // Ecriture des contacts éventuelles
resultats->Ecri_result_base_info(*sortons,cas); // Ecriture des parametres de gestion de la sortie des resultats
(*sortons) << "\n\n" << endl; // pour passer une ligne et avoir une séparation plus claireflush;
// cout << "\n écriture terminée !!";
};
tempsSauvegarde.Arret_du_comptage(); // temps cpu
};
// visualisation intéractive via le standard vrml
// la fonction est virtuelle ce qui lui permet d'être éventuellement facilement surchargée
// dans les algorithmes dérivées
void Algori::Visu_vrml(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesReferences* lesReferences
,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage
,Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts
,Resultats* resultats)
{ // on gère les exceptions éventuelles en mettant le bloc sous surveillance
try
{// écriture de l'en-tête
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== module de visualisation format vrml ========\n";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
// tout d'abord ouverture du fichier de restart si nécessaire
entreePrinc->Ouverture_base_info("lecture");
// récup du flot d'entrée
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// ifstream * entrons = entreePrinc->Ent_BI();
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// def du conteneur des numéros d'incréments
list <int> list_incre = entreePrinc->Liste_increment();
// on informe l'instance de visualisation de la liste des incréments possibles
visualise.List_increment_disponible(list_incre);
// on informe l'instance de visualisation du nombre de maillages possibles
// par défaut tous les maillages seront visualisés, ceci est descidé aussi ici
visualise.List_maillage_disponible(lesMaillages->NbMaillage());
// on demande à l'utilisateur la liste d'incrément pour l'initialisation de la visualisation
const list<int> & list_incre_init = visualise.List_balaie_init();
// on balaie la liste d'initialisation
list<int>::const_iterator itee,itetest,itee_fin = list_incre_init.end();
list<int>::const_iterator iteedeb =list_incre_init.begin();
OrdreVisu::EnumTypeIncre type_incre; // pour qualifier le type d'incrément
for (itee = iteedeb;itee!= itee_fin; itee++)
{ int inc_lu = *itee; // pour + lisible
// on se positionne à l'incrément voulu
entreePrinc->Positionnement_base_info(inc_lu);
// on initialise les ordres disponibles
// par exemple pour les isovaleurs on définit la liste des isovaleurs disponibles
// et les extrémas
// tout d'abord on récupère les infos sauf pour l'incrément 0,
if (inc_lu != 0)
Lecture_base_info(2,lesMaillages,lesReferences,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,
diversStockage,charge,lesCondLim,lesContacts,resultats,-inc_lu);
else // pour l'incrément 0 on a toutes les infos sauf qu'il faut mettre le temps courant à 0
{pa.Modif_Temps(0.);ParaGlob::param->Mise_a_jour_TEMPS_COURANT();};
// puis on initialise
// tout d'abord on définit le type d'incrément
itetest = itee; itetest++;
if (itee==iteedeb) type_incre = OrdreVisu::PREMIER_INCRE;
else if (itetest == itee_fin) type_incre = OrdreVisu::DERNIER_INCRE;
else type_incre = OrdreVisu::INCRE_COURANT;
// et on initialise
bool fil_calcul = false; // ce n'est pas une sortie au fil du calcul
visualise.Initialisation(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,inc_lu
,listeVarGlob,listeVecGlob,fil_calcul);
}
// maintemant on affiche les ordres possibles
// et tant que le retour est différent de -1 (= fin de la visulisation demandée) on boucle
while (visualise.OrdresPossible() != -1)
{ // récup de la list des incréments à balayer
list<int> li_balaie = visualise.List_balaie();
// initialisation de la sortie vrml (fichier)
entreePrinc->Ouverture_fichier_principal_vrml();
entreePrinc->Ouverture_fichier_legende_vrml();
visualise.Contexte_debut_visualisation();
// on balaie la liste et on visualise à chaque passe
list<int>::iterator ik,ikfin=li_balaie.end();
list<int>::iterator iktest,ikdeb=li_balaie.begin();
for (ik=ikdeb;ik!=ikfin;ik++)
{// récupération des information de l'incrément à visualiser
// lorsque l'incrément est différent de 0
// la lecture de l'incrément 0 n'est pas possible car elle conduit à l'initialisation
// du problème d'où des informations en double et éventuellement des disfonctionnements
// de structure
// normalement la visualisation d'info relatives à l'incrément 0 est indépendante en
// fait de l'incrément donc peuve être visualisée avec l'incrément courant
if (*ik != 0)
{ // on repositionne le flot de lecture au début du fichier
entreePrinc->Fermeture_base_info();
entreePrinc->Ouverture_base_info("lecture");
Lecture_base_info(2,lesMaillages,lesReferences,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,
diversStockage,charge,lesCondLim,lesContacts,resultats,*ik);
}
else // pour l'incrément 0 on a toutes les infos sauf qu'il faut mettre le temps courant à 0
{pa.Modif_Temps(0.);ParaGlob::param->Mise_a_jour_TEMPS_COURANT();};
// def du type d'incrément
iktest = ik; iktest++;
if (ik==ikdeb) type_incre = OrdreVisu::PREMIER_INCRE;
else if (iktest == ikfin) type_incre = OrdreVisu::DERNIER_INCRE;
else type_incre = OrdreVisu::INCRE_COURANT;
// appel du programme principal de visualisation
visualise.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,*ik,listeVarGlob,listeVecGlob);
}
// == définition des paramètres de fin de visualisation
visualise.Contexte_fin_visualisation();
// -- maintenant n'est effectué qu'une seule fois à la fin du projet
// // on ferme les sorties vrml (fichier) et appel éventuel du visualisateur
// entreePrinc->Fermeture_fichier_principal_vrml();
// entreePrinc->Fermeture_fichier_legende_vrml();
}
// fin de la visualisation
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== fin du module de visualisation format vrml ========\n";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch ( ... )
{ if (ParaGlob::NiveauImpression() >= 1)
{cout << "\n **** warning: erreur en ecriture pour la visualisation interactive via le format vrml";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
cout << "\n Algori::Visu_vrml(..";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << endl;
};
};
};
// visualisation intéractive via le standard maple ou gnuplot
// la fonction est virtuelle ce qui lui permet d'être éventuellement facilement surchargée
// dans les algorithmes dérivées
void Algori::Visu_maple(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesReferences* lesReferences
,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage
,Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts
,Resultats* resultats)
{ // on gère les exceptions éventuelles en mettant le bloc sous surveillance
try
{// écriture de l'en-tête
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== module de visualisation par fichiers de points au format maple ========\n";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
// tout d'abord ouverture du fichier de restart si nécessaire
entreePrinc->Ouverture_base_info("lecture");
// récup du flot d'entrée
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// ifstream * entrons = entreePrinc->Ent_BI();
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// def du conteneur des numéros d'incréments
list <int> list_incre = entreePrinc->Liste_increment();
// on informe l'instance de visualisation de la liste des incréments possibles
visualise_maple.List_increment_disponible(list_incre);
// on informe l'instance de visualisation du nombre de maillages possibles
// par défaut tous les maillages seront visualisés, ceci est descidé aussi ici
visualise_maple.List_maillage_disponible(lesMaillages->NbMaillage());
// on demande à l'utilisateur la liste d'incrément pour l'initialisation de la visualisation
const list<int> & list_incre_init = visualise_maple.List_balaie_init();
// on balaie la liste d'initialisation
list<int>::const_iterator itee,itetest,itee_fin = list_incre_init.end();
list<int>::const_iterator iteedeb =list_incre_init.begin();
OrdreVisu::EnumTypeIncre type_incre; // pour qualifier le type d'incrément
// dans le cas où il n'y a aucun incrément disponible, on ne peut pas initialiser dans ce cas
// il faut arrêter et mettre un message
if (iteedeb == itee_fin)
{ cout << "\n warning !! il n'y a pas d'increment sauvegarde, dans ce cas"
<< " l'initialisation des differentes grandeurs disponibles pour le post-traitement "
<< " n'est pas disponible, **** la suite n'est pas possible *** "
<< " une solution est de relancer le calcul a minima sur un increment, puis faire au moins"
<< " une sauvegarde via le parametre de controle SAUVEGARDE " << endl;
return;
};
for (itee = iteedeb;itee!= itee_fin; itee++)
{ int inc_lu = *itee; // pour + lisible
// on se positionne à l'incrément voulu
entreePrinc->Positionnement_base_info(inc_lu);
// on initialise les ordres disponibles
// par exemple pour les isovaleurs on définit la liste des isovaleurs disponibles
// et les extrémas
// tout d'abord on récupère les infos sauf pour l'incrément 0
if (inc_lu != 0)
Lecture_base_info(2,lesMaillages,lesReferences,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,
diversStockage,charge,lesCondLim,lesContacts,resultats,-inc_lu);
else // pour l'incrément 0 on a toutes les infos sauf qu'il faut mettre le temps courant à 0
{pa.Modif_Temps(0.);ParaGlob::param->Mise_a_jour_TEMPS_COURANT();};
// puis on initialise
// tout d'abord on définit le type d'incrément
itetest = itee; itetest++;
if (itee==iteedeb) type_incre = OrdreVisu::PREMIER_INCRE;
else if (itetest == itee_fin) type_incre = OrdreVisu::DERNIER_INCRE;
else type_incre = OrdreVisu::INCRE_COURANT;
// et on initialise
bool fil_calcul = false; // ce n'est pas une sortie au fil du calcul
visualise_maple.Initialisation(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,inc_lu
,listeVarGlob,listeVecGlob,fil_calcul);
}
// maintemant on affiche les ordres possibles
// et tant que le retour est différent de -1 (= fin de la visulisation demandée) on boucle
while (visualise_maple.OrdresPossible() != -1)
{ // récup de la list des incréments à balayer
list<int> li_balaie = visualise_maple.List_balaie();
// initialisation de la maple (fichier)
entreePrinc->Ouverture_fichier_principal_maple();
// == définition des paramètres d'entête de visualisation
visualise_maple.Contexte_debut_visualisation();
// on balaie la liste des incréments et on visualise_maple à chaque passe
list<int>::iterator ik,ikfin=li_balaie.end();
list<int>::iterator iktest,ikdeb=li_balaie.begin();
for (ik=ikdeb;ik!=ikfin;ik++)
{// récupération des information de l'incrément à visualiser
// lorsque l'incrément est différent de 0
// la lecture de l'incrément 0 n'est pas possible car elle conduit à l'initialisation
// du problème d'où des informations en double et éventuellement des disfonctionnements
// de structure
// normalement la visualisation d'info relatives à l'incrément 0 est indépendante en
// fait de l'incrément donc peuve être visualisée avec l'incrément courant
if (*ik != 0)
{ // on repositionne le flot de lecture au début du fichier
entreePrinc->Fermeture_base_info();
entreePrinc->Ouverture_base_info("lecture");
Lecture_base_info(2,lesMaillages,lesReferences,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,
diversStockage,charge,lesCondLim,lesContacts,resultats,*ik);
}
else // pour l'incrément 0 on a toutes les infos sauf qu'il faut mettre le temps courant à 0
{pa.Modif_Temps(0.);ParaGlob::param->Mise_a_jour_TEMPS_COURANT();};
// def du type d'incrément
iktest = ik; iktest++;
if (ik==ikdeb) type_incre = OrdreVisu::PREMIER_INCRE;
else if (iktest == ikfin) type_incre = OrdreVisu::DERNIER_INCRE;
else type_incre = OrdreVisu::INCRE_COURANT;
// appel du programme principal de visualisation
visualise_maple.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,*ik,listeVarGlob,listeVecGlob);
}
// == définition des paramètres de fin de visualisation
visualise_maple.Contexte_fin_visualisation();
// -- maintenant n'est effectué qu'une seule fois à la fin du projet
// // on ferme la sortie maple (fichier) et appel éventuel du visualisateur
// entreePrinc->Fermeture_fichier_principal_maple();
}
// fin de la visualisation
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== fin module de visualisation par fichiers de points au format maple ========\n";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch ( ... )
{ if (ParaGlob::NiveauImpression() >= 1)
{cout << "\n **** warning: erreur en ecriture pour la visualisation interactive via le format maple";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
cout << "\n Algori::Visu_maple(..";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << endl;
};
};
};
// visualisation intéractive via geomview
// la fonction est virtuelle ce qui lui permet d'être éventuellement facilement surchargée
// dans les algorithmes dérivées
void Algori::Visu_geomview(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesReferences* lesReferences
,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage
,Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts
,Resultats* resultats)
{ // on gère les exceptions éventuelles en mettant le bloc sous surveillance
try
{// écriture de l'en-tête
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== module de visualisation format geomview ========\n";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
// tout d'abord ouverture du fichier de restart si nécessaire
entreePrinc->Ouverture_base_info("lecture");
// récup du flot d'entrée
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// ifstream * entrons = entreePrinc->Ent_BI();
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// def du conteneur des numéros d'incréments
list <int> list_incre = entreePrinc->Liste_increment();
// on informe l'instance de visualisation de la liste des incréments possibles
visualise_geomview.List_increment_disponible(list_incre);
// on informe l'instance de visualisation du nombre de maillages possibles
// par défaut tous les maillages seront visualisés, ceci est descidé aussi ici
visualise_geomview.List_maillage_disponible(lesMaillages->NbMaillage());
// on demande à l'utilisateur la liste d'incrément pour l'initialisation de la visualisation
const list<int> & list_incre_init = visualise_geomview.List_balaie_init();
// on balaie la liste d'initialisation
list<int>::const_iterator itee,itetest,itee_fin = list_incre_init.end();
list<int>::const_iterator iteedeb =list_incre_init.begin();
OrdreVisu::EnumTypeIncre type_incre; // pour qualifier le type d'incrément
// dans le cas où il n'y a aucun incrément disponible, on ne peut pas initialiser dans ce cas
// il faut arrêter et mettre un message
if (iteedeb == itee_fin)
{ cout << "\n warning !! il n'y a pas d'increment sauvegarde, dans ce cas"
<< " l'initialisation des differentes grandeurs disponibles pour le post-traitement "
<< " n'est pas disponible, **** la suite n'est pas possible *** "
<< " une solution est de relancer le calcul a minima sur un increment, puis faire au moins"
<< " une sauvegarde via le parametre de controle SAUVEGARDE " << endl;
return;
};
for (itee = iteedeb;itee!= itee_fin; itee++)
{ int inc_lu = *itee; // pour + lisible
// on se positionne à l'incrément voulu
entreePrinc->Positionnement_base_info(inc_lu);
// on initialise les ordres disponibles
// par exemple pour les isovaleurs on définit la liste des isovaleurs disponibles
// et les extrémas
// tout d'abord on récupère les infos sauf pour l'incrément 0
if (inc_lu != 0)
Lecture_base_info(2,lesMaillages,lesReferences,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,
diversStockage,charge,lesCondLim,lesContacts,resultats,-inc_lu);
else // pour l'incrément 0 on a toutes les infos sauf qu'il faut mettre le temps courant à 0
{pa.Modif_Temps(0.);ParaGlob::param->Mise_a_jour_TEMPS_COURANT();};
// puis on initialise
// tout d'abord on définit le type d'incrément
itetest = itee; itetest++;
if (itee==iteedeb) type_incre = OrdreVisu::PREMIER_INCRE;
else if (itetest == itee_fin) type_incre = OrdreVisu::DERNIER_INCRE;
else type_incre = OrdreVisu::INCRE_COURANT;
// et on initialise
bool fil_calcul = false; // ce n'est pas une sortie au fil du calcul
visualise_geomview.Initialisation(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,inc_lu
,listeVarGlob,listeVecGlob,fil_calcul);
}
// maintemant on affiche les ordres possibles
// et tant que le retour est différent de -1 (= fin de la visulisation demandée) on boucle
while (visualise_geomview.OrdresPossible() != -1)
{ // récup de la list des incréments à balayer
list<int> li_balaie = visualise_geomview.List_balaie();
// initialisation de la sortie geomview (fichier)
entreePrinc->Ouverture_fichier_principal_geomview();
entreePrinc->Ouverture_fichier_legende_geomview();
visualise_geomview.Contexte_debut_visualisation();
// on balaie la liste et on visualise à chaque passe
list<int>::iterator ik,ikfin=li_balaie.end();
list<int>::iterator iktest,ikdeb=li_balaie.begin();
for (ik=ikdeb;ik!=ikfin;ik++)
{// récupération des information de l'incrément à visualiser
// lorsque l'incrément est différent de 0
// la lecture de l'incrément 0 n'est pas possible car elle conduit à l'initialisation
// du problème d'où des informations en double et éventuellement des disfonctionnements
// de structure
// normalement la visualisation d'info relatives à l'incrément 0 est indépendante en
// fait de l'incrément donc peuve être visualisée avec l'incrément courant
if (*ik != 0)
{ // on repositionne le flot de lecture au début du fichier
entreePrinc->Fermeture_base_info();
entreePrinc->Ouverture_base_info("lecture");
Lecture_base_info(2,lesMaillages,lesReferences,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,
diversStockage,charge,lesCondLim,lesContacts,resultats,*ik);
}
else // pour l'incrément 0 on a toutes les infos sauf qu'il faut mettre le temps courant à 0
{pa.Modif_Temps(0.);ParaGlob::param->Mise_a_jour_TEMPS_COURANT();};
// def du type d'incrément
iktest = ik; iktest++;
if (ik==ikdeb) type_incre = OrdreVisu::PREMIER_INCRE;
else if (iktest == ikfin) type_incre = OrdreVisu::DERNIER_INCRE;
else type_incre = OrdreVisu::INCRE_COURANT;
// temps cpu: passage des temps cpu de leur format natif à un tableau interne de double utilisé
Temps_CPU_HZpp_to_lesTempsCpu(*lesCondLim,*charge,*lesContacts); // pour la visualisation de grandeurs globales
// passage aux noeuds éventuellement des grandeurs globales, pour une sortie de post-traitement par exemple
// le principe est que ce passage s'effectue si les conteneurs existent au niveau des noeuds
// les conteneurs doivent donc avoir été définis dans la phase précédente d'initialisation et de lecture
// a priori n'est disponible que lors d'une visualisation au fil du calcul
Passage_aux_noeuds_grandeurs_globales(lesMaillages);
// passage éventuel de scalaire à vecteur au niveau des noeuds
lesMaillages->PassageInterneDansNoeud_composantes_vers_vectorielles();
// appel du programme principal de visualisation
visualise_geomview.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,*ik
,listeVarGlob,listeVecGlob);
}
// == définition des paramètres de fin de visualisation
visualise_geomview.Contexte_fin_visualisation();
// -- maintenant n'est effectué qu'une seule fois à la fin du projet
// // on ferme les sorties geomview (fichier) et appel éventuel du visualisateur
// entreePrinc->Fermeture_fichier_principal_geomview();
// entreePrinc->Fermeture_fichier_legende_geomview();
}
// fin de la visualisation
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== fin du module de visualisation format geomview ========\n";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch ( ... )
{ if (ParaGlob::NiveauImpression() >= 1)
{cout << "\n **** warning: erreur en ecriture pour la visualisation interactive via le format geomview";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
cout << "\n Algori::Visu_geomview(..";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << endl;
};
};
};
// visualisation intéractive via Gid
// la fonction est virtuelle ce qui lui permet d'être éventuellement facilement surchargée
// dans les algorithmes dérivées
void Algori::Visu_Gid(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesReferences* lesReferences
,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage
,Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts
,Resultats* resultats)
{ // on gère les exceptions éventuelles en mettant le bloc sous surveillance
try
{// écriture de l'en-tête
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== module de visualisation format Gid ========\n";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
// tout d'abord ouverture du fichier de restart si nécessaire
entreePrinc->Ouverture_base_info("lecture");
// récup du flot d'entrée
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// ifstream * entrons = entreePrinc->Ent_BI();
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// def du conteneur des numéros d'incréments
list <int> list_incre = entreePrinc->Liste_increment();
// on informe l'instance de visualisation de la liste des incréments possibles
visualise_Gid.List_increment_disponible(list_incre);
// on informe l'instance de visualisation du nombre de maillages possibles
// par défaut tous les maillages seront visualisés, ceci est descidé aussi ici
visualise_Gid.List_maillage_disponible(lesMaillages->NbMaillage());
// on demande à l'utilisateur la liste d'incrément pour l'initialisation de la visualisation
const list<int> & list_incre_init = visualise_Gid.List_balaie_init();
// on balaie la liste d'initialisation
list<int>::const_iterator itee,itetest,itee_fin = list_incre_init.end();
list<int>::const_iterator iteedeb =list_incre_init.begin();
OrdreVisu::EnumTypeIncre type_incre; // pour qualifier le type d'incrément
// dans le cas où il n'y a aucun incrément disponible, on ne peut pas initialiser dans ce cas
// il faut arrêter et mettre un message
if (iteedeb == itee_fin)
{ cout << "\n warning !! il n'y a pas d'increment sauvegarde, dans ce cas"
<< " l'initialisation des differentes grandeurs disponibles pour le post-traitement "
<< " n'est pas disponible, **** la suite n'est pas possible *** "
<< " une solution est de relancer le calcul a minima sur un increment, puis faire au moins"
<< " une sauvegarde via le parametre de controle SAUVEGARDE " << endl;
return;
};
for (itee = iteedeb;itee!= itee_fin; itee++)
{ int inc_lu = *itee; // pour + lisible
// on se positionne à l'incrément voulu
entreePrinc->Positionnement_base_info(inc_lu);
// on initialise les ordres disponibles
// par exemple pour les isovaleurs on définit la liste des isovaleurs disponibles
// et les extrémas
// tout d'abord on récupère les infos sauf pour l'incrément 0
if (inc_lu != 0)
Lecture_base_info(2,lesMaillages,lesReferences,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,
diversStockage,charge,lesCondLim,lesContacts,resultats,-inc_lu);
else // pour l'incrément 0 on a toutes les infos sauf qu'il faut mettre le temps courant à 0
{pa.Modif_Temps(0.);ParaGlob::param->Mise_a_jour_TEMPS_COURANT();};
// puis on initialise
// tout d'abord on définit le type d'incrément
itetest = itee; itetest++;
if (itee==iteedeb) type_incre = OrdreVisu::PREMIER_INCRE;
else if (itetest == itee_fin) type_incre = OrdreVisu::DERNIER_INCRE;
else type_incre = OrdreVisu::INCRE_COURANT;
// et on initialise
bool fil_calcul = false; // ce n'est pas une sortie au fil du calcul
visualise_Gid.Initialisation(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,inc_lu
,listeVarGlob,listeVecGlob,fil_calcul);
}
// maintemant on affiche les ordres possibles
// et tant que le retour est différent de -1 (= fin de la visulisation demandée) on boucle
while (visualise_Gid.OrdresPossible() != -1)
{ // récup de la list des incréments à balayer
list<int> li_balaie = visualise_Gid.List_balaie();
// initialisation des sorties Gid (fichier)
entreePrinc->Ouverture_fichier_initial_Gid();
entreePrinc->Ouverture_fichier_resultat_Gid();
visualise_Gid.Contexte_debut_visualisation();
// par défaut on sort l'incrément 0
pa.Modif_Temps(0.);// pour l'incrément 0 on a toutes les infos sauf qu'il faut mettre le temps courant à 0
ParaGlob::param->Mise_a_jour_TEMPS_COURANT();
visualise_Gid.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::PREMIER_INCRE,0
,listeVarGlob,listeVecGlob);
// on balaie la liste et on visualise à chaque passe
list<int>::iterator ik,ikfin=li_balaie.end();
list<int>::iterator iktest,ikdeb=li_balaie.begin();
for (ik=ikdeb;ik!=ikfin;ik++)
{// récupération des information de l'incrément à visualiser
// lorsque l'incrément est différent de 0
// la lecture de l'incrément 0 n'est pas possible car elle conduit à l'initialisation
// du problème d'où des informations en double et éventuellement des disfonctionnements
// de structure
// normalement la visualisation d'info relatives à l'incrément 0 est indépendante en
// fait de l'incrément donc peuve être visualisée avec l'incrément courant
if (*ik != 0)
{ // on repositionne le flot de lecture au début du fichier
entreePrinc->Fermeture_base_info();
entreePrinc->Ouverture_base_info("lecture");
Lecture_base_info(2,lesMaillages,lesReferences,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,
diversStockage,charge,lesCondLim,lesContacts,resultats,*ik);
};
// def du type d'incrément
iktest = ik; iktest++;
if (ik==ikdeb) type_incre = OrdreVisu::PREMIER_INCRE;
else if (iktest == ikfin) type_incre = OrdreVisu::DERNIER_INCRE;
else type_incre = OrdreVisu::INCRE_COURANT;
// temps cpu: passage des temps cpu de leur format natif à un tableau interne de double utilisé
Temps_CPU_HZpp_to_lesTempsCpu(*lesCondLim,*charge,*lesContacts); // pour la visualisation de grandeurs globales
// passage aux noeuds éventuellement des grandeurs globales, pour une sortie de post-traitement par exemple
// le principe est que ce passage s'effectue si les conteneurs existent au niveau des noeuds
// les conteneurs doivent donc avoir été définis dans la phase précédente d'initialisation et de lecture
// a priori n'est disponible que lors d'une visualisation au fil du calcul
Passage_aux_noeuds_grandeurs_globales(lesMaillages);
// passage éventuel de scalaire à vecteur au niveau des noeuds
lesMaillages->PassageInterneDansNoeud_composantes_vers_vectorielles();
// appel du programme principal de visualisation
if (*ik != 0) // le cas 0 a déjà été réalisé par défaut avant la boucle
visualise_Gid.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,*ik
,listeVarGlob,listeVecGlob);
;}
// == définition des paramètres de fin de visualisation
visualise_Gid.Contexte_fin_visualisation();
// -- maintenant n'est effectué qu'une seule fois à la fin du projet
// // on ferme les sorties Gid (fichier) et appel éventuel du visualisateur
// entreePrinc->Fermeture_fichier_initial_Gid();
// entreePrinc->Fermeture_fichier_resultat_Gid();
}
// fin de la visualisation
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== fin du module de visualisation format GID ========\n";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch ( ... )
{ if (ParaGlob::NiveauImpression() >= 1)
{cout << "\n **** warning: erreur en ecriture pour la visualisation interactive via le format GID";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
cout << "\n Algori::Visu_Gid(..";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << endl;
};
};
};
// visualisation intéractive via Gmsh
// la fonction est virtuelle ce qui lui permet d'être éventuellement facilement surchargée
// dans les algorithmes dérivées
void Algori::Visu_Gmsh(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesReferences* lesReferences
,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage
,Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts
,Resultats* resultats)
{ // on gère les exceptions éventuelles en mettant le bloc sous surveillance
try
{// écriture de l'en-tête
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== module de visualisation format Gmsh ========\n";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
// tout d'abord ouverture du fichier de restart si nécessaire
entreePrinc->Ouverture_base_info("lecture");
// récup du flot d'entrée
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// ifstream * entrons = entreePrinc->Ent_BI();
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// def du conteneur des numéros d'incréments
list <int> list_incre = entreePrinc->Liste_increment();
// on informe l'instance de visualisation de la liste des incréments possibles
visualise_Gmsh.List_increment_disponible(list_incre);
// on informe l'instance de visualisation du nombre de maillages possibles
// par défaut tous les maillages seront visualisés, ceci est descidé aussi ici
visualise_Gmsh.List_maillage_disponible(lesMaillages->NbMaillage());
// on demande à l'utilisateur la liste d'incrément pour l'initialisation de la visualisation
const list<int> & list_incre_init = visualise_Gmsh.List_balaie_init();
// on balaie la liste d'initialisation
list<int>::const_iterator itee,itetest,itee_fin = list_incre_init.end();
list<int>::const_iterator iteedeb =list_incre_init.begin();
OrdreVisu::EnumTypeIncre type_incre; // pour qualifier le type d'incrément
// dans le cas où il n'y a aucun incrément disponible, on ne peut pas initialiser dans ce cas
// il faut arrêter et mettre un message
if (iteedeb == itee_fin)
{ cout << "\n warning !! il n'y a pas d'increment sauvegarde, dans ce cas"
<< " l'initialisation des differentes grandeurs disponibles pour le post-traitement "
<< " n'est pas disponible, **** la suite n'est pas possible *** "
<< " une solution est de relancer le calcul a minima sur un increment, puis faire au moins"
<< " une sauvegarde via le parametre de controle SAUVEGARDE " << endl;
return;
};
for (itee = iteedeb;itee!= itee_fin; itee++)
{ int inc_lu = *itee; // pour + lisible
// on se positionne à l'incrément voulu
entreePrinc->Positionnement_base_info(inc_lu);
// on initialise les ordres disponibles
// par exemple pour les isovaleurs on définit la liste des isovaleurs disponibles
// et les extrémas
// tout d'abord on récupère les infos sauf pour l'incrément 0
if (inc_lu != 0)
Lecture_base_info(2,lesMaillages,lesReferences,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,
diversStockage,charge,lesCondLim,lesContacts,resultats,-inc_lu);
else // pour l'incrément 0 on a toutes les infos sauf qu'il faut mettre le temps courant à 0
{pa.Modif_Temps(0.);ParaGlob::param->Mise_a_jour_TEMPS_COURANT();};
// puis on initialise
// tout d'abord on définit le type d'incrément
itetest = itee; itetest++;
if (itee==iteedeb) type_incre = OrdreVisu::PREMIER_INCRE;
else if (itetest == itee_fin) type_incre = OrdreVisu::DERNIER_INCRE;
else type_incre = OrdreVisu::INCRE_COURANT;
// et on initialise
bool fil_calcul = false; // ce n'est pas une sortie au fil du calcul
visualise_Gmsh.Initialisation(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,inc_lu
,listeVarGlob,listeVecGlob,fil_calcul);
}
// maintemant on affiche les ordres possibles
// et tant que le retour est différent de -1 (= fin de la visulisation demandée) on boucle
while (visualise_Gmsh.OrdresPossible() != -1)
{ // récup de la list des incréments à balayer
list<int> li_balaie = visualise_Gmsh.List_balaie();
// initialisation des sorties Gmsh (fichier)
entreePrinc->Ouverture_fichier_initial_Gmsh();
entreePrinc->CreationRepertoireResultat();
entreePrinc->Ouverture_fichier_resultat_Gmsh(visualise_Gmsh.NomsTousLesGrandeursSortie());
visualise_Gmsh.Contexte_debut_visualisation();
// par défaut on sort l'incrément 0
pa.Modif_Temps(0.);// pour l'incrément 0 on a toutes les infos sauf qu'il faut mettre le temps courant à 0
ParaGlob::param->Mise_a_jour_TEMPS_COURANT();
visualise_Gmsh.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::PREMIER_INCRE,0
,listeVarGlob,listeVecGlob);
// on balaie la liste et on visualise à chaque passe
list<int>::iterator ik,ikfin=li_balaie.end();
list<int>::iterator iktest,ikdeb=li_balaie.begin();
for (ik=ikdeb;ik!=ikfin;ik++)
{// récupération des information de l'incrément à visualiser
// lorsque l'incrément est différent de 0
// la lecture de l'incrément 0 n'est pas possible car elle conduit à l'initialisation
// du problème d'où des informations en double et éventuellement des disfonctionnements
// de structure
// normalement la visualisation d'info relatives à l'incrément 0 est indépendante en
// fait de l'incrément donc peuve être visualisée avec l'incrément courant
if (*ik != 0)
{ // on repositionne le flot de lecture au début du fichier
entreePrinc->Fermeture_base_info();
entreePrinc->Ouverture_base_info("lecture");
Lecture_base_info(2,lesMaillages,lesReferences,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,
diversStockage,charge,lesCondLim,lesContacts,resultats,*ik);
};
// def du type d'incrément
iktest = ik; iktest++;
if (ik==ikdeb) type_incre = OrdreVisu::PREMIER_INCRE;
else if (iktest == ikfin) type_incre = OrdreVisu::DERNIER_INCRE;
else type_incre = OrdreVisu::INCRE_COURANT;
// temps cpu: passage des temps cpu de leur format natif à un tableau interne de double utilisé
Temps_CPU_HZpp_to_lesTempsCpu(*lesCondLim,*charge,*lesContacts); // pour la visualisation de grandeurs globales
// passage aux noeuds éventuellement des grandeurs globales, pour une sortie de post-traitement par exemple
// le principe est que ce passage s'effectue si les conteneurs existent au niveau des noeuds
// les conteneurs doivent donc avoir été définis dans la phase précédente d'initialisation et de lecture
// a priori n'est disponible que lors d'une visualisation au fil du calcul
Passage_aux_noeuds_grandeurs_globales(lesMaillages);
// passage éventuel de scalaire à vecteur au niveau des noeuds
lesMaillages->PassageInterneDansNoeud_composantes_vers_vectorielles();
// appel du programme principal de visualisation
if (*ik != 0) // le cas 0 a déjà été réalisé par défaut avant la boucle
visualise_Gmsh.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,*ik
,listeVarGlob,listeVecGlob);
}
// == définition des paramètres de fin de visualisation
visualise_Gmsh.Contexte_fin_visualisation();
// -- maintenant n'est effectué qu'une seule fois à la fin du projet
// // on ferme les sorties Gmsh (fichier) et appel éventuel du visualisateur
// entreePrinc->Fermeture_fichier_initial_Gmsh();
// entreePrinc->Fermeture_TousLesFichiersResultats_Gmsh();
}
// fin de la visualisation
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== fin du module de visualisation format Gmsh ========\n";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch ( ... )
{ if (ParaGlob::NiveauImpression() >= 1)
{cout << "\n **** warning: erreur en ecriture pour la visualisation interactive via le format Gmsh";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n Algori::Visu_Gmsh(..";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << endl;
};
};
};
// lecture et visualisation d'informations de visualisation dans un fichier de commande externe
void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesReferences* lesReferences
,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage
,Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts
,Resultats* resultats)
{ // on gère les exceptions éventuelles en mettant le bloc sous surveillance
try
{// ouverture du fichier de commande en lecture
entreePrinc->Ouverture_CommandeVisu("lecture");
// --- on se positionne au début valide du fichier
bool debut = entreePrinc->PositionEtExisteCVisu("debut_fichier_commande_visu");
if (!debut) // cas ou le mot clé de début de fichier n'existe pas
{ cout << "\n erreur en lecture du fichier de commande, on ne trouve pas le mot clee de debut de fichier"
<< " <debut_fichier_commande_visu>, le fichier est non valide";
return;
}
// écriture de l'en-tête
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
cout << "\n ======== lecture du fichier de commande de visualisation ========\n";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
// tout d'abord ouverture du fichier de restart si nécessaire
entreePrinc->Ouverture_base_info("lecture");
// récup du flot d'entrée
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// ifstream * entrons = entreePrinc->Ent_BI();
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// def du conteneur des numéros d'incréments
list <int> list_incre = entreePrinc->Liste_increment();
// on informe les instances de visualisation de la liste des incréments possibles
visualise.List_increment_disponible(list_incre);
visualise_maple.List_increment_disponible(list_incre);
visualise_geomview.List_increment_disponible(list_incre);
visualise_Gid.List_increment_disponible(list_incre);
visualise_Gmsh.List_increment_disponible(list_incre);
// on informe les instances de visualisation du nombre de maillages possibles
// par défaut tous les maillages seront visualisés, ceci est descidé aussi ici
visualise.List_maillage_disponible(lesMaillages->NbMaillage());
visualise_maple.List_maillage_disponible(lesMaillages->NbMaillage());
visualise_geomview.List_maillage_disponible(lesMaillages->NbMaillage());
visualise_Gid.List_maillage_disponible(lesMaillages->NbMaillage());
visualise_Gmsh.List_maillage_disponible(lesMaillages->NbMaillage());
// lecture éventuelle de la liste d'incrément, pour l'initialisation de la visualisation
// indique le choix de la liste d'incrément à visualiser
const list<int> * list_incre_init_inter;
// maintenant on fait une lecture éventuelle
if (entreePrinc->PositionEtExisteCVisu("debut_list_increment"))
{ // cas où une liste existe -> lecture de la liste
list_incre_init_inter = &(visualise.List_balaie_init(0));
}
else
{ // cas où pas de liste -> on initialise à 0 et au dernier incrément si différent
list_incre_init_inter = &(visualise.List_balaie_init(-1));
}
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// const list<int> & list_incre_init = * list_incre_init_inter;
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// on impose la liste pour les autres types de visualisation
visualise_maple.List_balaie_init(*list_incre_init_inter);//list_incre_init);
visualise_geomview.List_balaie_init(*list_incre_init_inter);//list_incre_init);
visualise_Gid.List_balaie_init(*list_incre_init_inter);//list_incre_init);
visualise_Gmsh.List_balaie_init(*list_incre_init_inter);//list_incre_init);
// on balaie la liste d'initialisation
list<int>::const_iterator itee,itetest,itee_fin = list_incre_init_inter->end(); //list_incre_init.end();
list<int>::const_iterator iteedeb =list_incre_init_inter->begin(); //list_incre_init.begin();
OrdreVisu::EnumTypeIncre type_incre; // pour qualifier le type d'incrément
if (list_incre_init_inter->size()==0) // arrêt s'il n'y a aucun incrément à visualiser
{ cout << "\n ****************************************************"
<< "\n **** aucun increment enregistre a visualiser ! *****"
<< "\n ****************************************************\n"; return;};
for (itee = iteedeb;itee!= itee_fin; itee++)
{ int inc_lu = *itee; // pour + lisible
// on se positionne à l'incrément voulu
bool cherche_increment = true; // init par défaut
if (inc_lu != 0) // pour l'incrément 0 on a toutes les infos
cherche_increment= entreePrinc->Positionnement_base_info(inc_lu);
//
if (cherche_increment == false)
{ cout << "\n ****************************************************"
<< "\n on n'a pas trouve l'increment= " << inc_lu << " ???"
<< "\n on ne peut pas continuer la visualisation ! "
<< "\n ****************************************************";
return;
};
// on initialise les ordres disponibles
// par exemple pour les isovaleurs on définit la liste des isovaleurs disponibles
// et les extrémas
// tout d'abord on récupère les infos sauf pour l'incrément 0
if (inc_lu != 0)
Lecture_base_info(2,lesMaillages,lesReferences,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,
diversStockage,charge,lesCondLim,lesContacts,resultats,-inc_lu);
else // pour l'incrément 0 on a toutes les infos sauf qu'il faut mettre le temps courant à 0
{pa.Modif_Temps(0.);ParaGlob::param->Mise_a_jour_TEMPS_COURANT();};
// puis on initialise
// tout d'abord on définit le type d'incrément
itetest = itee; itetest++;
if (itee==iteedeb) type_incre = OrdreVisu::PREMIER_INCRE;
else if (itetest == itee_fin) type_incre = OrdreVisu::DERNIER_INCRE;
else type_incre = OrdreVisu::INCRE_COURANT;
// et on initialise
bool fil_calcul = false; // ce n'est pas une sortie au fil du calcul
visualise.Initialisation(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,inc_lu
,listeVarGlob,listeVecGlob,fil_calcul);
visualise_maple.Initialisation(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,inc_lu
,listeVarGlob,listeVecGlob,fil_calcul);
visualise_geomview.Initialisation(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,inc_lu
,listeVarGlob,listeVecGlob,fil_calcul);
visualise_Gid.Initialisation(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,inc_lu
,listeVarGlob,listeVecGlob,fil_calcul);
visualise_Gmsh.Initialisation(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,inc_lu
,listeVarGlob,listeVecGlob,fil_calcul);
}
// on effectue la lecture des différents types de visualisation jusqu'à la fin du fichier de commande
// --- on verifie que le mot cle de fin de fichier existe
if (!entreePrinc->PositionEtExisteCVisu("fin_fichier_commande_visu"))
{ cout << "\n erreur en lecture du fichier de commande, on ne trouve pas le mot clee de fin de fichier"
<< " <fin_fichier_commande_visu>, le fichier est non valide";
return;
}
// --- on se repositionne au début du fichier
entreePrinc->PositionEtExisteCVisu("debut_fichier_commande_visu");
entreePrinc->NouvelleDonneeCVisu();
// --- lecture
try
{ while (strstr(entreePrinc->tablcarCVisu,"fin_fichier_commande_visu")==NULL)
{ visualise.Lecture_parametres_OrdreVisu(*entreePrinc);
visualise_maple.Lecture_parametres_OrdreVisu(*entreePrinc);
visualise_geomview.Lecture_parametres_OrdreVisu(*entreePrinc);
visualise_Gid.Lecture_parametres_OrdreVisu(*entreePrinc);
visualise_Gmsh.Lecture_parametres_OrdreVisu(*entreePrinc);
}
}
// sortie anormale de la lecture
catch (UtilLecture::ErrNouvelleDonneeCVisu erreur)
{ if ( erreur.lecture == 1) // on a atteind une fin de fichier
{ // fin de fichier atteind sans le mot clé de fin
cout << "\n **** fin du fichier de commande de visualisation, atteinte sans le mot cle"
<< " fin_fichier_commande_visu ! "
<< "\n normalement ce mot cle doit finir le fichier, on continue quand meme, mais"
<< "\n il y a peut-etre un probleme";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n Algori::LectureCommandeVisu(..";
}
else
{ // erreur en lecture
cout << "\n **** ERREUR en lecture du fichier de commande de visualisation "
<< "\n on continue quand meme, mais il y aura peut-etre un probleme de coherence pour la suite";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n Algori::LectureCommandeVisu(..";
}
}
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 inconnue
{ cout << "\n **** ERREUR inconnuee en lecture du fichier de commande de visualisation "
<< "\n on continue quand meme, mais il y aura peut-etre un probleme de coherence pour la suite";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n Algori::LectureCommandeVisu(..";
};
// avertissement de la fin de lecture du fichier de commande
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// if (ParaGlob::NiveauImpression() >= 0)
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n ======== fin de la lecture du fichier de commande de visualisation ========\n";
// visualisation en fonction de l'activité des différents types de sortie
// récup de la list des incréments à balayer
list<int> li_balaie = visualise.List_balaie();
// initialisation de la sortie vrml (fichier) si la sortie vrml est valide
if (visualise.Visu_vrml_valide())
{ entreePrinc->Ouverture_fichier_principal_vrml();
entreePrinc->Ouverture_fichier_legende_vrml();
visualise.Contexte_debut_visualisation();
}
// initialisation de la sortie maple (fichier) si la sortie geomview est valide
if (visualise_maple.Visu_maple_valide())
{ // initialisation de la maple (fichier)
entreePrinc->Ouverture_fichier_principal_maple();
// == définition des paramètres d'entête de visualisation
visualise_maple.Contexte_debut_visualisation();
}
// initialisation de la sortie geomview (fichier) si la sortie geomview est valide
if (visualise_geomview.Visu_geomview_valide())
{ entreePrinc->Ouverture_fichier_principal_geomview();
entreePrinc->Ouverture_fichier_legende_geomview();
visualise_geomview.Contexte_debut_visualisation();
}
// initialisation des sorties Gid (fichier) si la sortie Gid est valide
if (visualise_Gid.Visu_Gid_valide())
{ entreePrinc->Ouverture_fichier_initial_Gid();
entreePrinc->Ouverture_fichier_resultat_Gid();
visualise_Gid.Contexte_debut_visualisation();
}
// dans le cas ou la sortie gid est valide on sort par défaut l'incrément 0
if (visualise_Gid.Visu_Gid_valide())
{ pa.Modif_Temps(0.); // pour l'incrément 0 on a toutes les infos sauf qu'il faut mettre le temps courant à 0
ParaGlob::param->Mise_a_jour_TEMPS_COURANT();
visualise_Gid.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::PREMIER_INCRE,0
,listeVarGlob,listeVecGlob);
};
// initialisation des sorties Gmsh (fichier) si la sortie Gmsh est valide
if (visualise_Gmsh.Visu_Gmsh_valide())
{ entreePrinc->Ouverture_fichier_initial_Gmsh();
entreePrinc->CreationRepertoireResultat();
entreePrinc->Ouverture_fichier_resultat_Gmsh(visualise_Gmsh.NomsTousLesGrandeursSortie());
visualise_Gmsh.Contexte_debut_visualisation();
}
// dans le cas ou la sortie Gmsh est valide on sort par défaut l'incrément 0
if (visualise_Gmsh.Visu_Gmsh_valide())
{ pa.Modif_Temps(0.); // pour l'incrément 0 on a toutes les infos sauf qu'il faut mettre le temps courant à 0
ParaGlob::param->Mise_a_jour_TEMPS_COURANT();
visualise_Gmsh.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::PREMIER_INCRE,0
,listeVarGlob,listeVecGlob);
};
// on balaie la liste et on visualise à chaque passe
list<int>::iterator ik,ikfin=li_balaie.end();
list<int>::iterator iktest,ikdeb=li_balaie.begin();
for (ik=ikdeb;ik!=ikfin;ik++)
{// récupération des information de l'incrément à visualiser
// lorsque l'incrément est différent de 0
// la lecture de l'incrément 0 n'est pas possible car elle conduit à l'initialisation
// du problème d'où des informations en double et éventuellement des disfonctionnements
// de structure
// normalement la visualisation d'info relatives à l'incrément 0 est indépendante en
// fait de l'incrément donc peuve être visualisée avec l'incrément courant
if (*ik != 0)
{ // on repositionne le flot de lecture au début du fichier
entreePrinc->Fermeture_base_info();
entreePrinc->Ouverture_base_info("lecture");
Lecture_base_info(2,lesMaillages,lesReferences,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,
diversStockage,charge,lesCondLim,lesContacts,resultats,*ik);
};
// def du type d'incrément
iktest = ik; iktest++;
if (ik==ikdeb) type_incre = OrdreVisu::PREMIER_INCRE;
else if (iktest == ikfin) type_incre = OrdreVisu::DERNIER_INCRE;
else type_incre = OrdreVisu::INCRE_COURANT;
// temps cpu: passage des temps cpu de leur format natif à un tableau interne de double utilisé
Temps_CPU_HZpp_to_lesTempsCpu(*lesCondLim,*charge,*lesContacts); // pour la visualisation de grandeurs globales
// passage aux noeuds éventuellement des grandeurs globales, pour une sortie de post-traitement par exemple
// le principe est que ce passage s'effectue si les conteneurs existent au niveau des noeuds
// les conteneurs doivent donc avoir été définis dans la phase précédente d'initialisation et de lecture
// a priori n'est disponible que lors d'une visualisation au fil du calcul
Passage_aux_noeuds_grandeurs_globales(lesMaillages);
// passage éventuel de scalaire à vecteur au niveau des noeuds
lesMaillages->PassageInterneDansNoeud_composantes_vers_vectorielles();
// appel du programme principal de visualisation
if (visualise.Visu_vrml_valide())
visualise.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,*ik
,listeVarGlob,listeVecGlob);
if (visualise_maple.Visu_maple_valide())
visualise_maple.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,*ik
,listeVarGlob,listeVecGlob);
if (visualise_geomview.Visu_geomview_valide())
visualise_geomview.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,*ik
,listeVarGlob,listeVecGlob);
if ((visualise_Gid.Visu_Gid_valide())&&(*ik != 0)) // le cas ik == 0 a déjà été étudié
visualise_Gid.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,*ik
,listeVarGlob,listeVecGlob);
if ((visualise_Gmsh.Visu_Gmsh_valide())&&(*ik != 0)) // le cas ik == 0 a déjà été étudié
visualise_Gmsh.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,type_incre,*ik
,listeVarGlob,listeVecGlob);
}
// == définition des paramètres de fin de visualisation
if (visualise.Visu_vrml_valide())
{ visualise.Contexte_fin_visualisation();
// -- maintenant n'est effectué qu'une seule fois à la fin du projet
// // on ferme les sorties vrml (fichier) et appel éventuel du visualisateur
// entreePrinc->Fermeture_fichier_principal_vrml();
// entreePrinc->Fermeture_fichier_legende_vrml();
// fin de la visualisation
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n ======== fin du module de visualisation format vrml ========\n";
}
if (visualise_maple.Visu_maple_valide())
{// == définition des paramètres de fin de visualisation
visualise_maple.Contexte_fin_visualisation();
// -- maintenant n'est effectué qu'une seule fois à la fin du projet
// // on ferme la sortie maple (fichier) et appel éventuel du visualisateur
// entreePrinc->Fermeture_fichier_principal_maple();
// fin de la visualisation
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n ======== fin module de visualisation par fichiers de points au format maple ========\n";
}
if (visualise_geomview.Visu_geomview_valide())
{ visualise_geomview.Contexte_fin_visualisation();
// -- maintenant n'est effectué qu'une seule fois à la fin du projet
// // on ferme les sorties geomview (fichier) et appel éventuel du visualisateur
// entreePrinc->Fermeture_fichier_principal_geomview();
// entreePrinc->Fermeture_fichier_legende_geomview();
// fin de la visualisation
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n ======== fin du module de visualisation format geomview ========\n";
}
if (visualise_Gid.Visu_Gid_valide())
{ visualise_Gid.Contexte_fin_visualisation();
// -- maintenant n'est effectué qu'une seule fois à la fin du projet
// // on ferme les sorties Gid (fichier) et appel éventuel du visualisateur
// entreePrinc->Fermeture_fichier_initial_Gid();
// entreePrinc->Fermeture_fichier_resultat_Gid();
// fin de la visualisation
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n ======== fin du module de visualisation format Gid ========\n";
}
if (visualise_Gmsh.Visu_Gmsh_valide())
{ visualise_Gmsh.Contexte_fin_visualisation();
// -- maintenant n'est effectué qu'une seule fois à la fin du projet
// // on ferme les sorties Gmsh (fichier) et appel éventuel du visualisateur
// entreePrinc->Fermeture_fichier_initial_Gmsh();
// entreePrinc->Fermeture_TousLesFichiersResultats_Gmsh();
// fin de la visualisation
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n ======== fin du module de visualisation format Gmsh ========\n";
}
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch ( ... )
{ if (ParaGlob::NiveauImpression() >= 1)
{cout << "\n **** warning: erreur inconnue en lecture du fichier commande Visu";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
cout << "\n Algori::LectureCommandeVisu(..";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "endl";
};
};
};
// Ecriture des informations de visualisation dans un fichier de commande externe
void Algori::EcritureCommandeVisu()
{ try
{ // ouverture du flot de sortie
entreePrinc->Ouverture_CommandeVisu("ecriture");
// écriture de l'entête du fichier de commande de visualisation
visualise.EcritDebut_fichier_OrdreVisu(*entreePrinc);
// on écrit en fonction de l'activation ou pas de chaque type de visualisation
visualise.Ecriture_parametres_OrdreVisu(*entreePrinc);
visualise_maple.Ecriture_parametres_OrdreVisu(*entreePrinc);
visualise_geomview.Ecriture_parametres_OrdreVisu(*entreePrinc);
visualise_Gid.Ecriture_parametres_OrdreVisu(*entreePrinc);
visualise_Gmsh.Ecriture_parametres_OrdreVisu(*entreePrinc);
// écriture de la fin du fichier de commande de visualisation
visualise.EcritFin_fichier_OrdreVisu(*entreePrinc);
// fermeture du flot de sortie
entreePrinc->Fermeture_CommandeVisu();
}
// sortie anormale de l'écriture
catch (...)// erreur en écriture
{ cout << "\n **** ERREUR en ecriture du fichier de commande de visualisation "
<< "\n on continue quand meme";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n Algori::EcritureCommandeVisu(..";
};
};
// visualisation au fil du calcul à partir d'un fichier de commande externe
// type_incre signal ce qu'il y a a faire, il est modifié dans le programme !! donc le laisser en variable
// en fait après le premier passage
void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesReferences* lesReferences
,LesCourbes1D* ,LesFonctions_nD*
,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage
,Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts
,Resultats* resultats,OrdreVisu::EnumTypeIncre& type_incre,int num_incre)
{
tempsSortieFilCalcul.Mise_en_route_du_comptage(); // temps cpu
// on gère les exceptions éventuelles en mettant le bloc sous surveillance
try
{// s'il s'agit de l'incrément 0 on arrête
if (num_incre == 0) return;
// s'il n'y a pas de sortie au fil du calcul on arrête
if (!(pa.Sortie_fil_calcul()))
{tempsSortieFilCalcul.Arret_du_comptage();
return ;
};
// sinon ...cas normal avec sortie au fil du calcul
// def du conteneur des numéros d'incréments disponible
list <int> list_incre; // par défaut on indique un conteneur vide
// on informe les instances de visualisation de la liste des incréments possibles
// début possible, mais cela n'a pas d'importance pour l'exécution,
// c'est seulement dans le cas d'un choix que cela intervient or ici il n'y a pas de choix
// utilisé pour les méthodes List_increment_disponible( et on le définit en dehors du if
// sinon, il cesse d'exister quand le if est fermé
if (type_incre == OrdreVisu::PREMIER_INCRE)
// ---------- partie initialisation ------------------
{ // on prépare la variable de contrôle dans le cas ou l'on veut une visualisation en cours du calcul
// ouverture du fichier de commande en lecture
entreePrinc->Ouverture_CommandeVisu("lecture");
// --- on se positionne au début valide du fichier
bool debut = entreePrinc->PositionEtExisteCVisu("debut_fichier_commande_visu");
if (!debut) // cas ou le mot clé de début de fichier n'existe pas
{ cout << "\n erreur en lecture du fichier de commande, "
<< " on ne trouve pas le mot clee de debut de fichier"
<< " <debut_fichier_commande_visu>, le fichier est non valide"
<< "\n VisuAuFilDuCalcul(...";
return;
}
// écriture de l'en-tête
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 1)) || (permet_affichage > 2))
{cout << "\n ======== lecture du fichier de commande "
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
<< "de visualisation ========\n";
};
//-- initialisation des grandeurs globales par maillage
// int nb_maille = lesMaillages->NbMaillage();
// List_io < double>::iterator
// for (int i=1; i<= nb_maille; i++)
// { //
//
//
// };
visualise.List_increment_disponible(list_incre);
visualise_maple.List_increment_disponible(list_incre);
visualise_geomview.List_increment_disponible(list_incre);
visualise_Gid.List_increment_disponible(list_incre);
visualise_Gmsh.List_increment_disponible(list_incre);
// on informe les instances de visualisation du nombre de maillages possibles
// par défaut tous les maillages seront visualisés, ceci est descidé aussi ici
visualise.List_maillage_disponible(lesMaillages->NbMaillage());
visualise_maple.List_maillage_disponible(lesMaillages->NbMaillage());
visualise_geomview.List_maillage_disponible(lesMaillages->NbMaillage());
visualise_Gid.List_maillage_disponible(lesMaillages->NbMaillage());
visualise_Gmsh.List_maillage_disponible(lesMaillages->NbMaillage());
};
// ---------- partie traitement courant ------------------
// on test si on doit continuer
// arrivé ici on sait que la fréquence est positive donc valide
if (!(pa.SauvegardeFilCalculAutorisee(num_incre,tempsDerniereSortieFilCalcul,(type_incre==OrdreVisu::DERNIER_INCRE)))
&& (type_incre != OrdreVisu::PREMIER_INCRE)
&& (!pa.EtatSortieEtatActuelDansCVisu())
&& (!mode_debug)
)
{tempsSortieFilCalcul.Arret_du_comptage();
return ;
};
// dans le cas où le temps courant == le dernier temps déjà sauvegardé, ce n'est pas la peine de faire une seconde sauvegarde
// sauf si on a un incrément est sup a 1000000, = un cas particulier utilisé uniquement en debug
// de toute manière, dans le pire des cas, on aura deux fois le meme incrément, ce n'est pas vraiment une erreur
if (num_incre < 1000000)
{if (pa.Variables_de_temps().TempsCourant() == tempsDerniereSortieFilCalcul)
{tempsSortieFilCalcul.Arret_du_comptage();
return ;
};
};
// sinon ...
// indique le choix de la liste d'incrément à visualiser
// par défaut on initialise à 0 et au dernier incrément si différent
const list<int> * list_incre_init_inter = &(visualise.List_balaie_init(-1));
const list<int> & list_incre_init = * list_incre_init_inter;
// on impose la liste pour les autres types de visualisation
visualise_maple.List_balaie_init(list_incre_init);
visualise_geomview.List_balaie_init(list_incre_init);
visualise_Gid.List_balaie_init(list_incre_init);
visualise_Gmsh.List_balaie_init(list_incre_init);
// on initialise à chaque passage en indiquant ici que c'est le premier incrément
// par contre on indique que ce sera uniquement une exécution au fil du calcul
// donc initialisation lite sauf pour le premier passage
{ bool fil_calcul = true; // init
if (type_incre == OrdreVisu::PREMIER_INCRE)
fil_calcul = false;
visualise.Initialisation(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::PREMIER_INCRE,num_incre
,listeVarGlob,listeVecGlob,fil_calcul);
visualise_maple.Initialisation(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::PREMIER_INCRE,num_incre
,listeVarGlob,listeVecGlob,fil_calcul);
visualise_geomview.Initialisation(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::PREMIER_INCRE,num_incre
,listeVarGlob,listeVecGlob,fil_calcul);
visualise_Gid.Initialisation(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::PREMIER_INCRE,num_incre
,listeVarGlob,listeVecGlob,fil_calcul);
visualise_Gmsh.Initialisation(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::PREMIER_INCRE,num_incre
,listeVarGlob,listeVecGlob,fil_calcul);
};
// lecture du fichier de commande au premier passage
if (type_incre == OrdreVisu::PREMIER_INCRE)
{ // on effectue la lecture des différents types de visualisation jusqu'à la fin du fichier de commande
// --- on verifie que le mot cle de fin de fichier existe
if (!entreePrinc->PositionEtExisteCVisu("fin_fichier_commande_visu"))
{ cout << "\n erreur en lecture du fichier de commande, on ne trouve pas le mot clee de fin de fichier"
<< " <fin_fichier_commande_visu>, le fichier est non valide";
tempsSortieFilCalcul.Arret_du_comptage();
return;
}
// --- on se repositionne au début du fichier
entreePrinc->PositionEtExisteCVisu("debut_fichier_commande_visu");
entreePrinc->NouvelleDonneeCVisu();
// --- lecture
try
{ while (strstr(entreePrinc->tablcarCVisu,"fin_fichier_commande_visu")==NULL)
{ visualise.Lecture_parametres_OrdreVisu(*entreePrinc);
visualise_maple.Lecture_parametres_OrdreVisu(*entreePrinc);
visualise_geomview.Lecture_parametres_OrdreVisu(*entreePrinc);
visualise_Gid.Lecture_parametres_OrdreVisu(*entreePrinc);
visualise_Gmsh.Lecture_parametres_OrdreVisu(*entreePrinc);
}
}
// sortie anormale de la lecture
catch (UtilLecture::ErrNouvelleDonneeCVisu erreur)
{ if ( erreur.lecture == 1) // on a atteind une fin de fichier
{ // fin de fichier atteind sans le mot clé de fin
cout << "\n **** fin du fichier de commande de visualisation, atteinte sans le mot cle"
<< " fin_fichier_commande_visu ! "
<< "\n normalement ce mot cle doit finir le fichier, on continue quand meme, mais"
<< "\n il y a peut-etre un probleme";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n Algori::VisuAuFilDuCalcul(..";
}
else if ( erreur.lecture == 0) // on ne peut pas ouvrir le fichier
{ cout << "\n **** erreur en ouverture du fichier ";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n Algori::VisuAuFilDuCalcul(..";
}
else
{ // erreur en lecture
cout << "\n **** ERREUR en lecture du fichier de commande de visualisation "
<< "\n on continue quand meme, mais il y aura peut-etre un probleme de coherence pour la suite";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n Algori::VisuAuFilDuCalcul(..";
}
}
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 inconnue
{ cout << "\n **** ERREUR inconnuee en lecture du fichier de commande de visualisation "
<< "\n on continue quand meme, mais il y aura peut-etre un probleme de coherence pour la suite";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n Algori::VisuAuFilDuCalcul(..";
}
// avertissement de la fin de lecture du fichier de commande
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// if (ParaGlob::NiveauImpression() >= 2)
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 2))
cout << "\n ======== fin de la lecture du fichier de commande de visualisation ========\n";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// initialisation de la sortie vrml (fichier) si la sortie vrml est valide
if (visualise.Visu_vrml_valide())
{ entreePrinc->Ouverture_fichier_principal_vrml();
entreePrinc->Ouverture_fichier_legende_vrml();
visualise.Contexte_debut_visualisation();
};
// initialisation de la sortie maple (fichier) si la sortie maple est valide
if (visualise_maple.Visu_maple_valide())
{ // initialisation de la maple (fichier)
entreePrinc->Ouverture_fichier_principal_maple();
// == définition des paramètres d'entête de visualisation
visualise_maple.Contexte_debut_visualisation();
};
// initialisation de la sortie geomview (fichier) si la sortie geomview est valide
if (visualise_geomview.Visu_geomview_valide())
{ entreePrinc->Ouverture_fichier_principal_geomview();
entreePrinc->Ouverture_fichier_legende_geomview();
visualise_geomview.Contexte_debut_visualisation();
};
// initialisation des sorties Gid (fichier) si la sortie Gid est valide
if (visualise_Gid.Visu_Gid_valide())
{ entreePrinc->Ouverture_fichier_initial_Gid();
entreePrinc->Ouverture_fichier_resultat_Gid();
visualise_Gid.Contexte_debut_visualisation();
};
// dans le cas particulier de la visualisation GID on sort le maillage initial
if (visualise_Gid.Visu_Gid_valide())
visualise_Gid.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::PREMIER_INCRE,0
,listeVarGlob,listeVecGlob);
// initialisation des sorties Gmsh (fichier) si la sortie Gmsh est valide
if (visualise_Gmsh.Visu_Gmsh_valide())
{ entreePrinc->Ouverture_fichier_initial_Gmsh();
entreePrinc->CreationRepertoireResultat();
const list <string >& nomsTousLesGrandeursSortie = visualise_Gmsh.NomsTousLesGrandeursSortie();
////------ debug
//{list <string >::const_iterator ila,ilafin=nomsTousLesGrandeursSortie.end();
//cout << "\n debug Algori::VisuAuFilDuCalcul ";
//for (ila = nomsTousLesGrandeursSortie.begin();ila != ilafin;ila++)
// cout << " " << (*ila);
//cout << endl;
//
//}
////--- fin debug
entreePrinc->Ouverture_fichier_resultat_Gmsh(nomsTousLesGrandeursSortie);
visualise_Gmsh.Contexte_debut_visualisation();
}
// dans le cas particulier de la visualisation Gmsh on sort le maillage initial
if (visualise_Gmsh.Visu_Gmsh_valide())
visualise_Gmsh.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::PREMIER_INCRE,0
,listeVarGlob,listeVecGlob);
// maintenant on modifie le type d'incrément pour les futures sortie
type_incre = OrdreVisu::INCRE_COURANT;
}; //-- fin du if (type_incre == OrdreVisu::PREMIER_INCRE)
// temps cpu: passage des temps cpu de leur format natif à un tableau interne de double utilisé
Temps_CPU_HZpp_to_lesTempsCpu(*lesCondLim,*charge,*lesContacts); // pour la visualisation de grandeurs globales
// passage aux noeuds éventuellement des grandeurs globales, pour une sortie de post-traitement par exemple
// le principe est que ce passage s'effectue si les conteneurs existent au niveau des noeuds
// les conteneurs doivent donc avoir été définis dans la phase précédente d'initialisation et de lecture
// a priori n'est disponible que lors d'une visualisation au fil du calcul
Passage_aux_noeuds_grandeurs_globales(lesMaillages);
// passage éventuel de scalaire à vecteur au niveau des noeuds
lesMaillages->PassageInterneDansNoeud_composantes_vers_vectorielles();
// visualisation en fonction de l'activité des différents types de sortie
// il faut retester l'autorisation de sauvegarde car plus haut on a laissé passer le cas
// du premier incrément, ceci pour permettre l'initialisation, mais cela de veut pas dire
// qu'il faut sortir l'incrément en cours
if ((pa.SauvegardeFilCalculAutorisee(num_incre,tempsDerniereSortieFilCalcul,(type_incre==OrdreVisu::DERNIER_INCRE)))
// && (type_incre != OrdreVisu::PREMIER_INCRE)
|| (pa.EtatSortieEtatActuelDansCVisu())
|| (mode_debug)
)
{
// on visualise le dernier incrément disponible: num_incre
// appel du programme principal de visualisation
// on indique ici que c'est toujours le dernier incrément pour que la visualisation soit possible
bool sortie_valide= false; // pour gagner du temps
if (visualise.Visu_vrml_valide())
{visualise.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::DERNIER_INCRE,num_incre
,listeVarGlob,listeVecGlob);
sortie_valide=true;
};
if (visualise_maple.Visu_maple_valide())
{visualise_maple.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::DERNIER_INCRE,num_incre
,listeVarGlob,listeVecGlob);
sortie_valide=true;
};
if (visualise_geomview.Visu_geomview_valide())
{visualise_geomview.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::DERNIER_INCRE,num_incre
,listeVarGlob,listeVecGlob);
sortie_valide=true;
};
if (visualise_Gid.Visu_Gid_valide())
{visualise_Gid.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::DERNIER_INCRE,num_incre
,listeVarGlob,listeVecGlob);
sortie_valide=true;
};
if (visualise_Gmsh.Visu_Gmsh_valide())
{visualise_Gmsh.Visu(paraGlob,lesMaillages,lesReferences,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::DERNIER_INCRE,num_incre
,listeVarGlob,listeVecGlob);
sortie_valide=true;
};
// si une des sorties a été faite on sauvegarde le temps, au cas où on fait une sortie en delta t
if (sortie_valide)
// mémorisation du temps de la sauvegarde
tempsDerniereSortieFilCalcul=pa.Variables_de_temps().TempsCourant();
};
// fermeture des fichiers si c'est le dernier incrément
if (type_incre == OrdreVisu::DERNIER_INCRE)
{// == définition des paramètres de fin de visualisation
if (visualise.Visu_vrml_valide())
{ visualise.Contexte_fin_visualisation();
// -- maintenant n'est effectué qu'une seule fois à la fin du projet
// // on ferme les sorties vrml (fichier) et appel éventuel du visualisateur
// entreePrinc->Fermeture_fichier_principal_vrml();
// entreePrinc->Fermeture_fichier_legende_vrml();
// fin de la visualisation
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n ======== fin du module de visualisation format vrml ========\n";
};
if (visualise_maple.Visu_maple_valide())
{// == définition des paramètres de fin de visualisation
visualise_maple.Contexte_fin_visualisation();
// -- maintenant n'est effectué qu'une seule fois à la fin du projet
// // on ferme la sortie maple (fichier) et appel éventuel du visualisateur
// entreePrinc->Fermeture_fichier_principal_maple();
// fin de la visualisation
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n ======== fin module de visualisation par fichiers de points au format maple ========\n";
};
if (visualise_geomview.Visu_geomview_valide())
{ visualise_geomview.Contexte_fin_visualisation();
// -- maintenant n'est effectué qu'une seule fois à la fin du projet
// // on ferme les sorties geomview (fichier) et appel éventuel du visualisateur
// entreePrinc->Fermeture_fichier_principal_geomview();
// entreePrinc->Fermeture_fichier_legende_geomview();
// fin de la visualisation
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n ======== fin du module de visualisation format geomview ========\n";
};
if (visualise_Gid.Visu_Gid_valide())
{ visualise_Gid.Contexte_fin_visualisation();
// -- maintenant n'est effectué qu'une seule fois à la fin du projet
// // on ferme les sorties Gid (fichier) et appel éventuel du visualisateur
// entreePrinc->Fermeture_fichier_initial_Gid();
// entreePrinc->Fermeture_fichier_resultat_Gid();
// fin de la visualisation
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n ======== fin du module de visualisation format Gid ========\n";
};
if (visualise_Gmsh.Visu_Gmsh_valide())
{ visualise_Gmsh.Contexte_fin_visualisation();
// -- maintenant n'est effectué qu'une seule fois à la fin du projet
// // on ferme les sorties Gmsh (fichier) et appel éventuel du visualisateur
// entreePrinc->Fermeture_fichier_initial_Gmsh();
// entreePrinc->Fermeture_TousLesFichiersResultats_Gmsh();
// fin de la visualisation
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << "\n ======== fin du module de visualisation format Gmsh ========\n";
};
}; //-- fin du if (type_incre == OrdreVisu::DERNIER_INCRE)
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
tempsSortieFilCalcul.Arret_du_comptage(); // temps cpu
throw (toto);
}
catch ( ... )
mise à jour 7.010
2023-05-03 17:23:49 +02:00
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
{cout << "\n **** warning: erreur en ecriture pour la visualisation au fil du calcul";
mise à jour 7.010
2023-05-03 17:23:49 +02:00
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
cout << "\n Algori::VisuAuFilDuCalcul(..";
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
cout << endl;
};
};
// dans le cas où on a forcé une sortie au fil du calcul, via un drapeau, on le désarme
if (pa.EtatSortieEtatActuelDansCVisu()) // si le drapeau a été enclanché on le désarme
pa.ChangeSortieEtatActuelDansCVisu(false);
tempsSortieFilCalcul.Arret_du_comptage(); // temps cpu
};
// -------------------- Méthodes protégées --------------------------
// sauvegarde propre de l'élément sur base info
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
// incre : numero d'incrément auquel on sauvegarde
// éventuellement est définit de manière spécifique pour chaque algorithme
// dans les classes filles
void Algori::Ecriture_base_info
(ofstream& sort,const int cas)
{switch (cas)
{ case 1 : // on sauvegarde tout
{
// --- écriture éventuelle des paramètres de l'algorithme et informations particulières
sort << "\n -----parametre_et_variables_particulieres_algo: " << Nom_TypeCalcul(typeCalcul);
//cout << "\n debug algori::ecriture_base_info "
// << "\n -----parametre_et_variables_particulieres_algo: Nom_TypeCalcul(typeCalcul)= "<< Nom_TypeCalcul(typeCalcul)
// << flush;
//sort << "\n debug algori::ecriture_base_info "
// << "\n -----parametre_et_variables_particulieres_algo: Nom_TypeCalcul(typeCalcul)= "<< Nom_TypeCalcul(typeCalcul)
// << flush;
Ecrit_Base_info_Parametre(*entreePrinc,cas);
sort << "\n -----FIN_parametre_et_variables_particulieres_algo: " << Nom_TypeCalcul(typeCalcul);
sort << "\n mode_debug= " << mode_debug << " ";
//--- amortissement cinétique
if (amortissement_cinetique)
{ sort << "\n " << amortissement_cinetique << " ---algorithme_avec_amortissement_cinetique--- "
<< "\n max_nb_decroit_pourRelaxDyn_ " << max_nb_decroit_pourRelaxDyn
<< "\n inter_nb_entre_relax_ " << inter_nb_entre_relax;
// fonction nD éventuelle
if (nom_fct_nD_inter_nb_entre_relax.length())
{sort << " nom_fct_nD_inter_nb_entre_relax: "<< nom_fct_nD_inter_nb_entre_relax;}
else
{sort << " pas_de_fct_nD_inter_nb_entre_relax ";};
sort << "\n taille_moyenne_glissante_ " << taille_moyenne_glissante
<< "\n test_fraction_energie_ " << test_fraction_energie
<< "\n coef_arret_pourRelaxDyn_ " << coef_arret_pourRelaxDyn
<< "\n coef_redemarrage_pourRelaxDyn_ " << coef_redemarrage_pourRelaxDyn
<< "\n max_deltaX_pourRelaxDyn_ " << max_deltaX_pourRelaxDyn
<< "\n nb_max_dX_OK_pourRelaxDyn_ " << nb_max_dX_OK_pourRelaxDyn
<< "\n nb_deb_testfin_pourRelaxDyn_ " << nb_deb_testfin_pourRelaxDyn
<< "\n nb_deb_test_amort_cinetique_ " << nb_deb_test_amort_cinetique;
}
else {sort << "\n " << amortissement_cinetique << " --pas_de_amortissement_cinetique--";};
//---- amortissement critique pour par exemple relaxation dynamique
if (type_calcul_visqu_critique)
{ sort << " type_calcul_visqu_critique= " << type_calcul_visqu_critique
<< " opt_cal_C_critique= " << opt_cal_C_critique
<< " f_= " << f_
<< " ampli_visco= " << ampli_visco << " ";
}
else {sort << "\n " << type_calcul_visqu_critique << " --pas_de_amortissement_visqueux_critique--";};
//-------- arrêt sur équilibre statique sans la partie visqueuse
sort << "\n arret_a_equilibre_statique= " << arret_a_equilibre_statique;
//------- modulation de la précision d'équilibre ---
if (nom_modulation_precision.length())
{sort << "\n fct_nD_modulation_precision: "<< nom_modulation_precision;}
else
{sort << "\n pas_de_fct_nD_de_modulation_precision ";};
//------ écriture des différentes énergies
sort << "\n energies:_cin= "<< setprecision(ParaGlob::NbdigdoCA()) << E_cin_t
<< " int= " << setprecision(ParaGlob::NbdigdoCA()) << E_int_t
<< " ext= " << setprecision(ParaGlob::NbdigdoCA()) << E_ext_t
<< " balance= " << setprecision(ParaGlob::NbdigdoCA()) << bilan_E;
// la quantité de mouvement globale
sort << "\n quantite_mouvement= " << setprecision(ParaGlob::NbdigdoCA()) << q_mov_t ;
// énergies internes aux éléments
sort << "\n energie_elastique= " << setprecision(ParaGlob::NbdigdoCA()) << energTotal.EnergieElastique()
<< " energie_plastique= " << setprecision(ParaGlob::NbdigdoCA()) << energTotal.DissipationPlastique()
<< " energie_visqueuse= " << setprecision(ParaGlob::NbdigdoCA()) << energTotal.DissipationVisqueuse();
// énergies dues aux contact - frottement
sort << "\n energie_contact_elastique= " << setprecision(ParaGlob::NbdigdoCA()) << energFrottement.EnergieElastique()
<< " energie_frot_plastique= " << setprecision(ParaGlob::NbdigdoCA()) << energFrottement.DissipationPlastique()
<< " energie_frot_visqueuse= " << setprecision(ParaGlob::NbdigdoCA()) << energFrottement.DissipationVisqueuse();
sort << "\n energie_Penalisation_contact= " << setprecision(ParaGlob::NbdigdoCA()) << energPenalisation;
// écriture des différentes puissances
sort << "\n puissances:_acc= "<< setprecision(ParaGlob::NbdigdoCA()) << P_acc_t
<< " int= " << setprecision(ParaGlob::NbdigdoCA()) << P_int_t
<< " ext= " << setprecision(ParaGlob::NbdigdoCA()) << P_ext_t
<< " balance= " << setprecision(ParaGlob::NbdigdoCA()) << bilan_P_t;
// écriture des énergies et puissances numériques (non physique)
sort << "\n E_visco_numerique_t= "<< setprecision(ParaGlob::NbdigdoCA()) << E_visco_numerique_t;
sort << "\n E_bulk= "<< setprecision(ParaGlob::NbdigdoCA()) << E_bulk;
sort << " P_bulk= "<< setprecision(ParaGlob::NbdigdoCA()) << P_bulk;
// dans le cas particulier de cette classe il y a les paramètres
// du calcul à sauvegarder
pa.Ecriture_base_info_Para(sort,cas);
sort << flush;
break;
}
case 2 : // on sauvegarde ce qui varie
{ // écriture des temps cpu :
sort << "\n temps_cpu_en_nanoseconde: ";
// --- a) la partie spécifique à l'algo
// si ptalgo est non nulle, on a une sortie des temps cpu, spécifique
// à la classe AlgoriCombine pointée
if (ptalgocombi == NULL)
{
sort << "\n tps_InitAlgo " << tempsInitialisation;
sort << "\n tps_MiseAJourAlgo "<< tempsMiseAjourAlgo;
sort << "\n tps_CalEquilibre "<< tempsCalEquilibre;
sort << "\n tps_MatSmLoc "<< tempsRaidSmEner;
sort << "\n tps_SmLoc "<< tempsSecondMembreEnerg;
sort << "\n tps_ResSystLineaire "<< tempsResolSystemLineaire;
sort << "\n tps_Sauvegarde "<< tempsSauvegarde;
sort << "\n tps_SortieFilCalcul "<< tempsSortieFilCalcul;
sort << "\n tps_contactMatSmLoc "<< tempsRaidSmEnerContact;
sort << "\n tps_contactSmLoc "<< tempsSecondMembreEnergContact;
}
else
{ptalgocombi->AutreSortieTempsCPU(sort,cas); };
// --- b) parties extérieures à l'algo
sort << "\n tps_CL "<< temps_CL;
sort << "\n tps_CLL "<< temps_CLL;
sort << "\n tps_lois_comp "<< temps_lois_comportement;
sort << "\n tps_metrique_KSM "<< temps_metrique_K_SM;
sort << "\n tps_chargement "<< temps_chargement;
sort << "\n tps_rech_contact "<< temps_rech_contact;
mise à jour 7.010
2023-05-03 17:23:49 +02:00
#ifdef UTILISATION_MPI
sort << "\n tps_transfert_court_proc "<< temps_transfert_court;
sort << "\n tps_transfert_long_proc "<< temps_transfert_long;
sort << "\n tps_attente_proc "<< temps_attente;
#endif
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// ----- écriture éventuelle des paramètres de l'algorithme et informations particulières
sort << "\n -----parametre_et_variables_particulieres_algo: " << Nom_TypeCalcul(typeCalcul);
Ecrit_Base_info_Parametre(*entreePrinc,cas);
sort << " \n -----FIN_parametre_et_variables_particulieres_algo: " << Nom_TypeCalcul(typeCalcul) ;
//------- modulation de la précision d'équilibre ---
if (modulation_precision != NULL)
{sort << "\n modulation_precision: "<< (modulation_precision->Valeur_pour_variables_globales())(1);}
else
{sort << "\n modulation_precision: 0 ";};
// ---- écriture des différentes énergies
sort << "\n energies:_cin= "<< setprecision(ParaGlob::NbdigdoCA()) << E_cin_t
<< " int= " << setprecision(ParaGlob::NbdigdoCA()) << E_int_t
<< " ext= " << setprecision(ParaGlob::NbdigdoCA()) << E_ext_t
<< " balance= " << setprecision(ParaGlob::NbdigdoCA()) << bilan_E;
// la quantité de mouvement globale
sort << "\n quantite_mouvement= " << setprecision(ParaGlob::NbdigdoCA()) << q_mov_t ;
// énergies internes aux éléments
sort << "\n energie_elastique= " << setprecision(ParaGlob::NbdigdoCA()) << energTotal.EnergieElastique()
<< " energie_plastique= " << setprecision(ParaGlob::NbdigdoCA()) << energTotal.DissipationPlastique()
<< " energie_visqueuse= " << setprecision(ParaGlob::NbdigdoCA()) << energTotal.DissipationVisqueuse();
// énergies dues aux contact - frottement
sort << "\n energie_contact_elastique= " << setprecision(ParaGlob::NbdigdoCA())
<< energFrottement.EnergieElastique()
<< " energie_frot_plastique= " << setprecision(ParaGlob::NbdigdoCA()) << energFrottement.DissipationPlastique()
<< " energie_frot_visqueuse= " << setprecision(ParaGlob::NbdigdoCA()) << energFrottement.DissipationVisqueuse();
sort << "\n energie_Penalisation_contact= " << setprecision(ParaGlob::NbdigdoCA()) << energPenalisation;
// écriture des différentes puissances
sort << "\n puissances:_acc= "<< setprecision(ParaGlob::NbdigdoCA()) << P_acc_t
<< " int= " << setprecision(ParaGlob::NbdigdoCA()) << P_int_t
<< " ext= " << setprecision(ParaGlob::NbdigdoCA()) << P_ext_t
<< " balance= " << setprecision(ParaGlob::NbdigdoCA()) << bilan_P_t;
// écriture des énergies et puissances numériques (non physique)
sort << "\n E_visco_numerique_t= "<< setprecision(ParaGlob::NbdigdoCA()) << E_visco_numerique_t;
sort << "\n E_bulk= "<< setprecision(ParaGlob::NbdigdoCA()) << E_bulk;
sort << " P_bulk= "<< setprecision(ParaGlob::NbdigdoCA()) << P_bulk;
// dans le cas particulier de cette classe il y a les paramètres
// de calcul à sauvegarder
pa.Ecriture_base_info_Para(sort,cas);
break;
}
}
};
// cas de la lecture spécifique à l'algorithme dans base_info
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Algori::Lecture_base_info(ifstream& ent,const int cas)
{ switch (cas)
{ case 1 : // on récupère tout
{ // ----- lecture éventuelle des paramètres de l'algorithme
// on regarde tout d'abord si l'algo en lecture correspond
string nom1,nom2;
ent >> nom1 ;
if (nom1 == "-----parametre_et_variables_particulieres_algo:")
{ // lecture du nom de l'algo
ent >> nom2;
if (Id_nom_TypeCalcul(nom2.c_str()) == typeCalcul)
{ // les données sauvegardées correspondent à l'algo en cours, on peut les récupérer
Lecture_Base_info_Parametre(*entreePrinc,cas,true);
// on finit la lecture en passant les dernières lignes jusqu'au mot clé
ent >> nom1;
while (nom1 != "-----FIN_parametre_et_variables_particulieres_algo:")
ent >> nom1;
ent >> nom1; // enfin on passe le nom de l'algo
}
else
{ // l'algo ne correspond pas, on passe les informations correspondants
while (nom1 != "-----FIN_parametre_et_variables_particulieres_algo:")
ent >> nom1;
ent >> nom1; // enfin on passe le nom de l'algo
// on demande à l'agorithme de faire une initialisation sans lecture
Lecture_Base_info_Parametre(*entreePrinc,cas,false);
};
}
else
{ // erreur on est mal positionné dans le fichier
cout << "\n *** erreur en lecture des parametres specifiques de l'algorithme"
<< " on attendait le mot cle -----parametre_et_variables_particulieres_algo: "
<< " et on a lue "<< nom1
<< "\n Algori::Lecture_base_info(...";
// dans le cas où un comptage du calcul est en cours on l'arrête
if (tempsInitialisation.Comptage_en_cours()) tempsInitialisation.Arret_du_comptage();
if (tempsMiseAjourAlgo.Comptage_en_cours()) tempsMiseAjourAlgo.Arret_du_comptage();
Sortie(1);
};
string nominter;
ent >> nominter >> mode_debug ;
//--- amortissement cinétique
ent >> amortissement_cinetique >> nominter;
if (amortissement_cinetique)
{ ent >> nominter >> max_nb_decroit_pourRelaxDyn
>> nominter >> inter_nb_entre_relax
>> nominter;
if (nominter == "nom_fct_nD_inter_nb_entre_relax:")
{ent >> nom_fct_nD_inter_nb_entre_relax; };
// sinon on n'a rien n'a lire
ent >> nominter >> taille_moyenne_glissante
>> nominter >> test_fraction_energie
>> nominter >> coef_arret_pourRelaxDyn
>> nominter >> coef_redemarrage_pourRelaxDyn
>> nominter >> max_deltaX_pourRelaxDyn
>> nominter >> nb_max_dX_OK_pourRelaxDyn
>> nominter >> nb_deb_testfin_pourRelaxDyn
>> nominter >> nb_deb_test_amort_cinetique;
};
//---- amortissement critique pour par exemple relaxation dynamique
ent >> type_calcul_visqu_critique >> nominter;
if (type_calcul_visqu_critique)
{ ent >> nominter >> type_calcul_visqu_critique
>> nominter >> opt_cal_C_critique
>> nominter >> f_
>> nominter >> ampli_visco;
};
//-------- arrêt sur équilibre statique sans la partie visqueuse
ent >> nominter >> arret_a_equilibre_statique; // pour retirer éventuellement la partie visqueuse numérique
// si le paramètre est activé, on définit le vecteur intermédiaire de sauvegarde du résidu statique
if ( (arret_a_equilibre_statique ) // le dimensionnement se fera à l'affectation (=)
&& (type_calcul_visqu_critique || pa.Amort_visco_artificielle()))
{ if (vglob_stat == NULL)
vglob_stat = new Vecteur();}
else // dans le cas on ne veut pas un arret statique spécifique sans viscosité numérique
{ if (vglob_stat != NULL) {delete vglob_stat; vglob_stat=NULL ;};};
//------- lecture modulation de la précision d'équilibre ---
string toto;
ent >> toto;
if (toto == "fct_nD_modulation_precision:")
{ent >> nom_modulation_precision;};
// sinon on n'a rien n'a lire
// ---- lecture des différentes énergies globales
ent >> toto >> E_cin_t >> toto >> E_int_t >> toto >> E_ext_t >> toto >> bilan_E;
E_cin_0 = E_cin_t - bilan_E + E_int_t - E_ext_t;
// la quantité de mouvement globale
ent >> toto >> q_mov_t;
double ener_elas, ener_plas, ener_visc;
ent >> toto >> ener_elas >> toto >> ener_plas >> toto >> ener_visc;
// énergies internes aux éléments
energTotal.ChangeEnergieElastique(ener_elas);
energTotal.ChangeDissipationPlastique(ener_plas);
energTotal.ChangeDissipationVisqueuse(ener_visc);
// énergies dues aux contact - frottement
ent >> toto >> ener_elas >> toto >> ener_plas >> toto >> ener_visc;
energFrottement.ChangeEnergieElastique(ener_elas);
energFrottement.ChangeDissipationPlastique(ener_plas);
energFrottement.ChangeDissipationVisqueuse(ener_visc);
ent >> toto >> energPenalisation;
// lecture des différentes puissances
ent >> toto >> P_acc_t >> toto >> P_int_t >> toto >> P_ext_t >> toto >> bilan_P_t;
// lecture des énergies et puissances numériques (non physique)
ent >> toto >> E_visco_numerique_t;
ent >> toto >> E_bulk >> toto >> P_bulk; // énergie et puissance bulk
//----- dans le cas particulier de cette classe il y a les paramètres
// du calcul qu'il faut lire
pa.Lecture_base_info_Para(ent,cas);
break;
}
case 2 : // on ce qui varie
{
string nom1,nom2;
// lecture des temps cpu de l'algo:
ent >> nom1;
ent >> nom1 >> tempsInitialisation;
ent >> nom1 >> tempsMiseAjourAlgo;
ent >> nom1 >> tempsCalEquilibre;
ent >> nom1 >> tempsRaidSmEner;
ent >> nom1 >> tempsSecondMembreEnerg;
ent >> nom1 >> tempsResolSystemLineaire;
ent >> nom1 >> tempsSauvegarde;
ent >> nom1 >> tempsSortieFilCalcul;
ent >> nom1 >> tempsRaidSmEnerContact;
ent >> nom1 >> tempsSecondMembreEnergContact;
// --- b) parties extérieures à l'algo
ent >> nom1 >> temps_CL;
ent >> nom1 >> temps_CLL;
ent >> nom1 >> temps_lois_comportement;
ent >> nom1 >> temps_metrique_K_SM;
ent >> nom1 >> temps_chargement;
ent >> nom1 >> temps_rech_contact;
mise à jour 7.010
2023-05-03 17:23:49 +02:00
#ifdef UTILISATION_MPI
ent >> nom1 >> temps_transfert_court;
ent >> nom1 >> temps_transfert_long;
ent >> nom1 >> temps_attente;
#endif
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +02:00
// --- lecture éventuelle des paramètres de l'algorithme
// on regarde tout d'abord si l'algo en lecture correspond
ent >> nom1 ;
if (nom1 == "-----parametre_et_variables_particulieres_algo:")
{ // lecture du nom de l'algo
ent >> nom2;
if (Id_nom_TypeCalcul(nom2.c_str()) == typeCalcul)
{ // les données sauvegardées correspondent à l'algo en cours, on peut les récupérer
Lecture_Base_info_Parametre(*entreePrinc,cas,true);
// on finit la lecture en passant les dernières lignes jusqu'au mot clé
ent >> nom1;
while (nom1 != "-----FIN_parametre_et_variables_particulieres_algo:")
ent >> nom1;
ent >> nom1; // enfin on passe le nom de l'algo
}
else
{ // l'algo ne correspond pas, on passe les informations correspondants
while (nom1 != "-----FIN_parametre_et_variables_particulieres_algo:")
ent >> nom1;
ent >> nom1; // enfin on passe le nom de l'algo
// on demande à l'agorithme de faire une initialisation sans lecture
Lecture_Base_info_Parametre(*entreePrinc,cas,false);
};
}
else
{ // erreur on est mal positionné dans le fichier
cout << "\n *** erreur en lecture des parametres specifiques de l'algorithme"
<< " on attendait le mot cle -----parametre_et_variables_particulieres_algo: "
<< " et on a lue "<< nom1
<< "\n Algori::Lecture_base_info(...";
// dans le cas où un comptage du calcul est en cours on l'arrête
if (tempsInitialisation.Comptage_en_cours()) tempsInitialisation.Arret_du_comptage();
if (tempsMiseAjourAlgo.Comptage_en_cours()) tempsMiseAjourAlgo.Arret_du_comptage();
Sortie(1);
};
//------- lecture modulation de la précision d'équilibre ---
{// en fait on passe l'information car elle sera recalculée au moment de son utilisation
string toto;double truc;
ent >> toto >> truc;
};
// ---- lecture des différentes énergies
string toto,toto2; //ent >> toto >> E_cin_tdt >> toto >> E_int_t >> toto >> E_ext_t;
ent >> toto2 >> E_cin_t >> toto >> E_int_t >> toto >> E_ext_t >> toto >> bilan_E;; // puis petite vérif ??
#ifdef MISE_AU_POINT
if (toto2 != "energies:_cin=")
{ cout << "\n erreur en entree de l'energie cinetique, chaine lue: " << toto2;
// dans le cas où un comptage du calcul est en cours on l'arrête
if (tempsInitialisation.Comptage_en_cours()) tempsInitialisation.Arret_du_comptage();
if (tempsMiseAjourAlgo.Comptage_en_cours()) tempsMiseAjourAlgo.Arret_du_comptage();
Sortie(1);
}
#endif
// lecture des énergies globales
// ent >> E_cin_t ;
// ent >> toto >> E_int_t ;
// ent >> toto >> E_ext_t ;
// ent >> toto >> bilan_E;
E_cin_0 = E_cin_t - bilan_E + E_int_t - E_ext_t;
E_cin_t=E_cin_tdt; // on initialise car E_cin_t n'est pas sauvegardée
// la quantité de mouvement globale
ent >> toto >> q_mov_t;
// énergies internes aux éléments
double ener_elas, ener_plas, ener_visc;
ent >> toto >> ener_elas >> toto >> ener_plas >> toto >> ener_visc;
energTotal.ChangeEnergieElastique(ener_elas);
energTotal.ChangeDissipationPlastique(ener_plas);
energTotal.ChangeDissipationVisqueuse(ener_visc);
// énergies dues aux contact - frottement
ent >> toto >> ener_elas >> toto >> ener_plas >> toto >> ener_visc;
energFrottement.ChangeEnergieElastique(ener_elas);
energFrottement.ChangeDissipationPlastique(ener_plas);
energFrottement.ChangeDissipationVisqueuse(ener_visc);
ent >> toto >> energPenalisation;
// lecture des différentes puissances
ent >> toto >> P_acc_t >> toto >> P_int_t >> toto >> P_ext_t >> toto >> bilan_P_t;
// lecture des énergies numériques (non physique)
ent >> toto >> E_visco_numerique_t;
ent >> toto >> E_bulk >> toto >> P_bulk; // énergie et puissance bulk
// --- dans le cas particulier de cette classe il y a les paramètres
// du calcul qu'il faut lire
pa.Lecture_base_info_Para(ent,cas);
break;
}
} // --- fin du switch
};
Reference in a new issue Copy permalink