Herezh_dev/Resultats/Gmsh/Isovaleurs_Gmsh.cc
2023-05-03 17:23:49 +02:00

2610 lines
150 KiB
C++

// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Isovaleurs_Gmsh.h"
// pour le tableau de connection herezh -> gmsh
#include "Visualisation_Gmsh.h"
using namespace std;
#include <iomanip>
#include <algorithm>
#include "CharUtil.h"
#include "Coordonnee2.h"
#include "ConstMath.h"
#include "MathUtil.h"
#include "Banniere.h"
#include "TypeQuelconqueParticulier.h"
#include "Visualisation_Gmsh.h"
// ------- les variables statiques ---------
Isovaleurs_Gmsh::ConstructTabScalVecTensGmsh Isovaleurs_Gmsh::tabScalVecTensGmsh;
// constructeur pour la variable statique
Isovaleurs_Gmsh::ConstructTabScalVecTensGmsh::ConstructTabScalVecTensGmsh():
// il y a 15 types d'éléments possibles en sortie d'isovaleurs dans gmsh, les linéaires
// et les quadratiques, + du texte en 2D ou 3D
scalar_pourView(15),vector_pourView(15),tensor_pourView(15),text_pourView(2)
{
scalar_pourView(15)="SP"; // Scalar point SP 3 1 * nb-time-steps
vector_pourView(15)="VP"; //Vector point VP 3 3 * nb-time-steps
tensor_pourView(15)="TP"; //Tensor point TP 3 9 * nb-time-steps
scalar_pourView(1)="SL"; // Scalar line SL 6 2 * nb-time-steps
vector_pourView(1)="VL"; //Vector line VL 6 6 * nb-time-steps
tensor_pourView(1)="TL"; //Tensor line TL 6 18 * nb-time-steps
scalar_pourView(2)="ST"; // Scalar triangle ST 9 3 * nb-time-steps
vector_pourView(2)="VT"; //Vector triangle VT 9 9 * nb-time-steps
tensor_pourView(2)="TP"; //Tensor triangle TT 9 27 * nb-time-steps
scalar_pourView(3)="SQ"; // Scalar quadrangle SQ 12 4 * nb-time-steps
vector_pourView(3)="VQ"; //Vector quadrangle VQ 12 12 * nb-time-steps
tensor_pourView(3)="TQ"; //Tensor quadrangle TQ 12 36 * nb-time-steps
scalar_pourView(4)="SS"; // Scalar tetrahedron SS 12 4 * nb-time-steps
vector_pourView(4)="VS"; //Vector tetrahedron VS 12 12 * nb-time-steps
tensor_pourView(4)="TS"; //Tensor tetrahedron TS 12 36 * nb-time-steps
scalar_pourView(5)="SH"; // Scalar hexahedron SH 24 8 * nb-time-steps
vector_pourView(5)="VH"; //Vector hexahedron VH 24 24 * nb-time-steps
tensor_pourView(5)="TH"; //Tensor hexahedron TH 24 72 * nb-time-steps
scalar_pourView(6)="SI"; // Scalar prism SI 18 6 * nb-time-steps
vector_pourView(6)="VI"; //Vector prism VI 18 18 * nb-time-steps
tensor_pourView(6)="TI"; //Tensor prism TI 18 54 * nb-time-steps
scalar_pourView(7)="SY"; // Scalar pyramid SY 15 5 * nb-time-steps
vector_pourView(7)="VY"; //Vector pyramid VY 15 15 * nb-time-steps
tensor_pourView(7)="TY"; //Tensor pyramid TY 15 45 * nb-time-steps
scalar_pourView(8)="SL2"; // Second order scalar line SL2 9 3 * nb-time-steps
vector_pourView(8)="VL2"; //Second order vector line VL2 9 9 * nb-time-steps
tensor_pourView(8)="TL2"; //Second order tensor line TL2 9 27 * nb-time-steps
scalar_pourView(9)="ST2"; // Second order scalar triangle ST2 18 6 * nb-time-steps
vector_pourView(9)="VT2"; //Second order vector triangle VT2 18 18 * nb-time-steps
tensor_pourView(9)="TT2"; //Second order tensor triangle TT2 18 54 * nb-time-steps
scalar_pourView(10)="SQ2"; // Second order scalar quadrangle SQ2 27 9 * nb-time-steps
vector_pourView(10)="VQ2"; //Second order vector quadrangle VQ2 27 27 * nb-time-steps
tensor_pourView(10)="TQ2"; //Second order tensor quadrangle TQ2 27 81 * nb-time-steps
scalar_pourView(11)="SS2"; // Second order scalar tetrahedron SS2 30 10 * nb-time-steps
vector_pourView(11)="VS2"; //Second order vector tetrahedron VS2 30 30 * nb-time-steps
tensor_pourView(11)="TS2"; //Second order tensor tetrahedron TS2 30 90 * nb-time-steps
scalar_pourView(12)="SH2"; // Second order scalar hexahedron SH2 81 27 * nb-time-steps
vector_pourView(12)="VH2"; //Second order vector hexahedron VH2 81 81 * nb-time-steps
tensor_pourView(12)="TH2"; //Second order tensor hexahedron TH2 81 243* nb-time-steps
scalar_pourView(13)="SI2"; // Second order scalar prism SI2 54 18 * nb-time-steps
vector_pourView(13)="VI2"; //Second order vector prism VI2 54 54 * nb-time-steps
tensor_pourView(13)="TI2"; //Second order tensor prism TI2 54 162* nb-time-steps
scalar_pourView(14)="SY2"; // Second order scalar pyramid SY2 42 14 * nb-time-steps
vector_pourView(14)="VY2"; //Second order vector pyramid VY2 42 42 * nb-time-steps
tensor_pourView(14)="TY2"; //Second order tensor pyramid TY2 42 126* nb-time-steps
text_pourView(1) = "T2"; //2D text T2 3 arbitrary
text_pourView(2) = "T3"; //3D text T3 4 arbitrary
};
// ------- fin des variables statiques -----
// CONSTRUCTEURS :
// par defaut
Isovaleurs_Gmsh::Isovaleurs_Gmsh () :
OrdreVisu("........................................isovaleurs"
,"visualisation des isovaleurs","iso")
,li_P_gauss_total()//,tab_point_enum()
,tp_tp_tp_gauss_base(),map_gauss_base(),map_gauss_basePQ(),map_gauss_baseEVol()
,map_gauss_tab_baseEVol(),map_gauss_tab_basePQ()
,tabnoeud_type_ddl(),tabnoeud_type_ddl_retenu(),choix_var_ddl()
,tabnoeud_type_ddlEtendu(),tabnoeud_type_ddlEtendu_retenu()
,a_accumuler_tabnoeud_type_ddlEtendu_retenu()
,a_accumuler_tabnoeud_type_ddlEtendu()
,tabnoeud_evoluee(),tabnoeud_evoluee_retenu()
,a_accumuler_tabnoeud_evoluee_retenu(),a_accumuler_tabnoeud_evoluee()
,list_vect_globalPourNoeud(),list_vect_globalPourNoeud_retenu()
,tabelement_type_ddl(),tabelement_type_ddl_retenu()
,tabelement_evoluee(),tabelement_evoluee_retenu()
,tabelement_typeParti(),tabelement_typeParti_retenu()
,mailInitial(NULL),lesMail(NULL)
,cas_transfert(1)
,glob_noe_ddl_retenu(),t_g_noeud_ddl_asortir()
,glob_noeud_ddl_etendu_retenu(),t_g_noeud_ddl_etendu_asortir()
,glob_noeud_evol_retenu(),t_g_noeud_evoluee_asortir()
,glob_elem_ddl_retenu(),t_g_elem_ddl_asortir()
,glob_elem_evol_retenu(),t_g_elem_evoluee_asortir()
,glob_elem_Parti_retenu(),t_g_elem_typeParti_asortir(),tab_quelconque(2)
,nomsGrandeursSortie(),use_hold_gmsh_format(false)
,absolue(true),li_glob_restreinte_TQ()
{ for (int i=1; i<=2; i++) tab_quelconque(i)=NULL;
};
// constructeur de copie
Isovaleurs_Gmsh::Isovaleurs_Gmsh (const Isovaleurs_Gmsh& ord) :
OrdreVisu(ord)
,li_P_gauss_total(ord.li_P_gauss_total)
// ,tab_point_enum(ord.tab_point_enum)
,tp_tp_tp_gauss_base(ord.tp_tp_tp_gauss_base)
// ,map_gauss_base(ord.map_gauss_base) // PB ???
// ,map_gauss_basePQ(ord.map_gauss_basePQ),map_gauss_baseEVol(ord.map_gauss_baseEVol) // pb ???
,map_gauss_base()
,map_gauss_basePQ(),map_gauss_baseEVol()
,map_gauss_tab_baseEVol(),map_gauss_tab_basePQ()
,tabnoeud_type_ddl(),tabnoeud_type_ddl_retenu(),choix_var_ddl()
,tabelement_type_ddl(),tabelement_type_ddl_retenu()
,tabnoeud_type_ddlEtendu(ord.tabnoeud_type_ddlEtendu)
,tabnoeud_type_ddlEtendu_retenu(ord.tabnoeud_type_ddlEtendu_retenu)
,a_accumuler_tabnoeud_type_ddlEtendu_retenu(ord.a_accumuler_tabnoeud_type_ddlEtendu_retenu)
,a_accumuler_tabnoeud_type_ddlEtendu(ord.a_accumuler_tabnoeud_type_ddlEtendu)
,tabnoeud_evoluee(ord.tabnoeud_evoluee)
,tabnoeud_evoluee_retenu(ord.tabnoeud_evoluee_retenu)
,a_accumuler_tabnoeud_evoluee(ord.a_accumuler_tabnoeud_evoluee)
,a_accumuler_tabnoeud_evoluee_retenu(ord.a_accumuler_tabnoeud_evoluee_retenu)
,list_vect_globalPourNoeud(ord.list_vect_globalPourNoeud)
,list_vect_globalPourNoeud_retenu(ord.list_vect_globalPourNoeud_retenu)
,tabelement_evoluee(ord.tabelement_evoluee)
,tabelement_evoluee_retenu(ord.tabelement_evoluee_retenu)
,tabelement_typeParti(ord.tabelement_typeParti)
,tabelement_typeParti_retenu(ord.tabelement_typeParti_retenu)
,mailInitial(ord.mailInitial),lesMail(ord.lesMail)
,cas_transfert(ord.cas_transfert)
,glob_noe_ddl_retenu(),t_g_noeud_ddl_asortir()
,glob_noeud_ddl_etendu_retenu(),t_g_noeud_ddl_etendu_asortir()
,glob_noeud_evol_retenu(),t_g_noeud_evoluee_asortir()
,glob_elem_ddl_retenu(),t_g_elem_ddl_asortir()
,glob_elem_evol_retenu(),t_g_elem_evoluee_asortir()
,glob_elem_Parti_retenu(),t_g_elem_typeParti_asortir(),tab_quelconque(2)
,nomsGrandeursSortie(ord.nomsGrandeursSortie)
,use_hold_gmsh_format(ord.use_hold_gmsh_format)
,absolue(ord.absolue)
,li_glob_restreinte_TQ(ord.li_glob_restreinte_TQ)
{ // il y a un pb avec les maps au niveau du constructeur de copie ??
// impossible de comprendre, mais comme d'une part on ne s'en sert pas souvent et d'autre part à terme on utilisera
// des tables de hashage, on implante une fonction ayant le même effet mais plus longue
// cas de map_gauss_base
map < string, List_io < Ddl_enum_etendu > , std::less <string> >::const_iterator im,imfin=ord.map_gauss_base.end();
for (im = ord.map_gauss_base.begin();im!=imfin;im++)
map_gauss_base[(*im).first]=(*im).second;
// cas de map_gauss_baseEVol
map < string, List_io < TypeQuelconque > , std::less <string> >::const_iterator im2,im2fin=ord.map_gauss_baseEVol.end();
for (im2 = ord.map_gauss_baseEVol.begin();im2!=im2fin;im2++)
map_gauss_baseEVol[(*im2).first]=(*im2).second;
// cas de map_gauss_basePQ
map < string, List_io < TypeQuelconque > , std::less <string> >::const_iterator im3,im3fin=ord.map_gauss_basePQ.end();
for (im3 = ord.map_gauss_basePQ.begin();im3!=im3fin;im3++)
map_gauss_basePQ[(*im3).first]=(*im3).second;
// mise à jour du tableau de pointeur
for (int i=1; i<=2; i++) tab_quelconque(i)=NULL;
};
// DESTRUCTEUR :
Isovaleurs_Gmsh::~Isovaleurs_Gmsh ()
{ };
// METHODES PUBLIQUES :
// execution de l'ordre
// tab_mail : donne les numéros de maillage concerné
// incre : numéro d'incrément qui en cours
// type_incre : indique si c'est le premier le dernier ou l'incrément courant a visualiser ou pas
// animation : indique si l'on est en animation ou pas
// unseul_incre : indique si oui ou non il y a un seul increment à visualiser
void Isovaleurs_Gmsh::ExeOrdre(ParaGlob * ,const Tableau <int>& tab_mail
,LesMaillages * lesMail,bool ,LesReferences*
,LesLoisDeComp* ,DiversStockage*,Charge*,LesCondLim*
,LesContacts* lesContacts,Resultats*,UtilLecture & entreePrinc
,OrdreVisu::EnumTypeIncre type_incre,int incre
,bool ,const map < string, const double * , std::less <string> >&
,const List_io < TypeQuelconque >& listeVecGlob)
{// pour simplifier
// visualisation du maillage pointé si actif
if (actif)
{ // cas du premier passage , on définit les types de points de gauss associé aux infos à sortir
if (type_incre == PREMIER_INCRE)
{ExeOrdrePremierIncrement(tab_mail,lesMail); // ne concerne que les grandeurs définies aux pti
InitPremierIncrExecutionTransfertAuxNoeuds(); // init pour les transferts aux noeuds, uniquement pour les grandeurs aux pti
if(!use_hold_gmsh_format)
// dans le cas du nouveau format, on sort au début du fichier : le maillage initiale: noeuds et éléments
// ensuite à chaque incrément on ne sortira que les valeurs aux noeuds ou aux éléments
// -- ici l'objectif est de tout mettre dans un seul groupe de résultat de manière à pouvoir tout
// -- visualiser en même temps
// --on ne traite que s'il y a des ddl
{ bool atraiter = false;
{if ( (glob_noe_ddl_retenu.size() != 0)
|| (glob_noeud_ddl_etendu_retenu.size() != 0)
|| (glob_noeud_evol_retenu.size() != 0)
|| (glob_elem_ddl_retenu.size() != 0)
|| (glob_elem_evol_retenu.size() != 0)
|| (glob_elem_Parti_retenu.size() != 0)
)
atraiter = true;
};
if (atraiter)
{ // on balaie la liste des noms des différentes grandeurs à sortir en résultat
// car on doit sortir le maillage initiale pour chaque grandeur, mais ceci une seule fois
list <string>::const_iterator ili,ilifin = nomsGrandeursSortie.end();
for (ili=nomsGrandeursSortie.begin();ili != ilifin; ili++)
{ ostream &sort = entreePrinc.Sort_resultat_Gmsh((*ili));
mailInitial->sortie_maillage_initial(tab_mail,lesMail,sort);
};
// dans le cas de contact on alimente des listes particulières
lesContacts->List_reduite_aux_contact(glob_noeud_evol_retenu
,li_glob_restreinte_TQ
);
// ajout des conteneurs de manière systématique
Tableau <List_io < TypeQuelconque > * > tabQ(2);
tabQ(1)= &li_glob_restreinte_TQ; tabQ(2)=NULL;
List_io < Ddl_enum_etendu > vide;
lesMail->AjoutConteneurAuNoeud(vide,tabQ);
};
};
};
// cas général
// -------------------------------------------------------------------------------------------------
// I - On commence par s'occuper des ddl aux pt d'integ
// ensuite les noeuds car pendant le calcul aux pt integ, on fait le transfert aux noeuds
// qui ensuite sera traité pour la visualisation par les noeuds
// -------------------------------------------------------------------------------------------------
try
{ CalculAuxPtInteg(tab_mail,lesMail);}
catch ( ... )
{ cout << "\n erreur dans le calcul aux points d'integration, pour la sortie d'isovaleur "
<< " les fichiers de sortie seront errones "<< endl;
};
try
{ CalculAuxElemAuxNoeuds(tab_mail,lesMail);}
catch ( ... )
{ cout << "\n erreur dans le calcul aux elements ou aux noeuds, pour la sortie d'isovaleur "
<< " les fichiers de sortie seront errones "<< endl;
};
// -------------------------------------------------------
// II - traitement des degrés de libertés aux noeuds
// -------------------------------------------------------
// dans le cas de contact du aux stockages des infos de contact aux noeuds
// on fait un prétraitement
// -> on initialise par défaut les conteneurs
lesMail->Init_par_defaut_conteneurs(li_glob_restreinte_TQ);
// -> alimentation par le contact des conteneurs
lesContacts->Mise_a_jour_Pour_Grandeur_particuliere(li_glob_restreinte_TQ);
if(use_hold_gmsh_format) // choix entre ancien et nouveau format
{EcritureAuxNoeuds_ancien_format(tab_mail,lesMail,incre,entreePrinc);}
else
{EcritureAuxNoeuds(tab_mail,lesMail,incre,entreePrinc);}
}; //-- fin du choix actif ou pas
};
// choix de l'ordre, cet méthode peut entraîner la demande d'informations
// supplémentaires si nécessaire. qui sont ensuite gérer par la classe elle même
void Isovaleurs_Gmsh::ChoixOrdre()
{ bool choix_valide = false;
cout << "\n ---- isovaleurs ---- ";
string rep;
while (!choix_valide)
{
try
{ if (ParaGlob::Francais())
{cout
<< "\n (0 ou f ou fin) fin modif"
<< "\n (1) ou (de) parametres par defaut: "
<< "\n (2) ou (to) toutes les isovaleurs "
<< "\n (3) parametres generaux pour la sortie "
<< "\n (4) ddl naturellement defini aux noeuds "
<< "\n (5) grandeurs scalaires venant des pts integ "
<< "\n (6) grandeurs tensoriel venant des pts integ "
<< "\n (7) grandeurs particulieres venant des pts integ "
<< "\n (8) choix de l'ancien format gmsh (faux par defaut) "
<< "\n (9) ddl etendu aux noeuds "
<< "\n (10) grandeurs evoluees aux noeuds ";
cout << "\n \n reponse ? ";
}
else
{cout
<< "\n (0 or f or fin) end "
<< "\n (1) or (de) default parameters: "
<< "\n (2) or (to) all the isovalues (not a good idea) "
<< "\n (3) main parameters for the output "
<< "\n (4) principal dof at the nodes "
<< "\n (5) scalar value from the integration points "
<< "\n (6) tensorial values from the integration points "
<< "\n (7) specific values from the integration points "
<< "\n (8) new ou old output format (default new) "
<< "\n (9) extended dof at nodes "
<< "\n (10) tensorial values at nodes ";
cout << "\n \n reponse ? ";
}
rep = lect_return_defaut(false,"f");
if (rep == "fin_prog") Sortie(1);
// sinon
int num = ChangeEntier(rep);
if ((rep == "0")||(rep == "f")||(rep == "fin"))
{ choix_valide=true; }
else if ((rep=="to")||(rep=="2"))
{ ChoixIsovaleur_noeud("to");
ChoixIsovaleur_ddl_etendu_noeud("to");
ChoixIsovaleur_evoluee_noeud("to");
ChoixIsovaleur_ddl_ptinteg("to");
ChoixIsovaleur_tensorielle_ptinteg("to");
ChoixIsovaleur_quelc_ptinteg("to");
ParametresGeneraux("to");
}
else if ((rep=="de")||(rep=="1"))
{ ChoixIsovaleur_noeud("de");
ChoixIsovaleur_ddl_etendu_noeud("de");
ChoixIsovaleur_evoluee_noeud("de");
ChoixIsovaleur_ddl_ptinteg("de");
ChoixIsovaleur_tensorielle_ptinteg("de");
ChoixIsovaleur_quelc_ptinteg("de");
ParametresGeneraux("de");
use_hold_gmsh_format=false;
}
else if ((num >= 3)&&(num<=10))
{ choix_valide=false;
switch (num)
{ case 4: // "choix des isovaleurs aux noeuds"
{ChoixIsovaleur_noeud(" ");
break;}
case 5: // "choix des isovaleurs scalaires aux pts integ"
{ChoixIsovaleur_ddl_ptinteg(" ");
break;}
case 6: // "choix des isovaleurs tensorielles aux pts integ"
{ChoixIsovaleur_tensorielle_ptinteg(" ");
break;}
case 7: // "choix des grandeurs particulières aux pts integ"
{ChoixIsovaleur_quelc_ptinteg(" ");
break;}
case 3: //"definition des parametres generaux"
{ ParametresGeneraux(" "); break;}
case 8: // utilisation de l'ancien format gmsh
{ bool choix_val = false;
cout << "\n -- par defaut on utilise le nouveau format gmsh (version > = 2.5) ";
string rep;
while (!choix_val)
{ cout << "\n (0 ou f ou fin) fin modif"
<< "\n (1) utilisation de l'ancien format "
<< "\n (2) utilisation du nouveau format (valeur par defaut) ";
cout << "\n \n reponse ? ";
rep = lect_return_defaut(false,"f");
// sinon
int num = ChangeEntier(rep);
if ((rep == "0")||(rep == "f")||(rep == "fin"))
{ choix_val=true; }
else
{ // def du format
if (num == 1) { use_hold_gmsh_format = true;}
else if (num == 2) { use_hold_gmsh_format = false;}
else
{ cout << "\n Erreur on attendait un entier entre 0 et 1 !!, "
<< "\n redonnez une bonne valeur";
choix_val=false;
};
};
}; //-- fin du while
break;
}
case 9: // "choix des isovaleurs ddl étendus aux noeuds"
{ChoixIsovaleur_ddl_etendu_noeud(" ");
break;}
case 10: // "choix des isovaleurs quelconque aux noeuds"
{ChoixIsovaleur_evoluee_noeud(" ");
break;}
}
}
else { cout << "\n Erreur on attendait un entier entre 3 et 10 !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper fin_prog pour arreter le programme";
choix_valide=false;
};
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch (...)// erreur de lecture
{ cout << "\n Erreur on attendait un des mots cles proposés !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper fin_prog pour arreter le programme";
choix_valide=false;
};
}; //-- fin du while
// appel de la méthode de la classe mère
OrdreVisu::ChoixOrdre();
// on introduit certains conteneurs internes des maillages si besoin est en fonction
// des choix de l'utilisateurs: utiles uniquement pour certaines grandeurs
lesMail->Intro_Conteneurs_internes_noeud_relier_auto_autres_grandeur(tabnoeud_evoluee_retenu);
// passage des grandeurs choisies venant des éléments, aux noeuds, lorsque ces grandeurs sont
// directement diponibles aux noeuds
Passage_grandeursRetenuesAuxNoeuds_elementsVersNoeuds();
// on vérifie qu'il n'y a pas de doublon de grandeurs
VerificationTransfertPossible_et_doublon();
// %% cas des noeuds %% on initialise les différentes listes internes qui globalisent tous les maillages
// on le fait ici, plutôt que dans l'exécution, pour faciliter la méthode CreatListNomsTousLesGrandeurs
GlobalisationListSurTousLesMaillagesPourLesNoeuds();
// on ajoute les conteneurs internes des maillages si besoin est en fonction
// des choix de l'utilisateurs
{Tableau <List_io < TypeQuelconque > * > tabQ(2);
tabQ(1) = &glob_noeud_evol_retenu; tabQ(2) = NULL;
lesMail->AjoutConteneurAuNoeud(glob_noeud_ddl_etendu_retenu,tabQ);
};
// création de la liste des noms correspondants à tous les grandeurs à sortir (nécessaire pour
// l'ouverture des fichiers de résultats
CreatListNomsTousLesGrandeurs();
//----- debug
//cout << "\n debug: Isovaleurs_Gmsh::ChoixOrdre ";
//list <string>::iterator iti,itifin=nomsGrandeursSortie.end();
//cout << "\n la liste des noms ";
//for (iti=nomsGrandeursSortie.begin();iti != itifin;iti++)
// cout << (*iti) << " ";
//cout << endl;
//----- fin debug
};
// initialisation : permet d'initialiser les différents paramètres de l'ordre
// lors d'un premier passage des différents incréments
// en virtuelle, a priori est défini si nécessaire dans les classes dérivées
void Isovaleurs_Gmsh::Initialisation(ParaGlob * paraGlob,LesMaillages * lesmail,LesReferences* lesRef
,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage,Charge* charge
,LesCondLim* lesCondLim,LesContacts* lesContacts
,Resultats* resultats,EnumTypeIncre type_incre,int incre
,const map < string, const double * , std::less <string> >& listeVarGlob
,const List_io < TypeQuelconque >& listeVecGlob
,bool fil_calcul)
{ // initialisation de la liste des différentes isovaleurs possibles
// uniquement lors du premier et du dernier passage pour économiser
if ((type_incre == OrdreVisu::DERNIER_INCRE) || (type_incre == OrdreVisu::PREMIER_INCRE))
{Init_liste_isovaleur(lesmail,lesContacts,fil_calcul);}
//appel de l'ordre d'initialisation de la classe mère
OrdreVisu::Initialisation(paraGlob,lesmail,lesRef,lesLoisDeComp,diversStockage,charge
,lesCondLim,lesContacts,resultats,type_incre,incre
,listeVarGlob,listeVecGlob,fil_calcul);
choix_var_ddl.Change_taille(lesmail->NbMaillage());
// récup de l'adresse des maillages
lesMail = lesmail;
// récupération de la liste des vecteurs globaux
list_vect_globalPourNoeud = listeVecGlob;
};
// initialisation de la liste des différentes isovaleurs possibles
void Isovaleurs_Gmsh::Init_liste_isovaleur(LesMaillages * lesMail
,LesContacts* lesContacts,bool fil_calcul)
{
// cas des contacts: a priori il n'y a que des grandeurs définies aux noeuds
// on définit des conteneurs ad hoc aux noeud
int nb_maillage = lesMail->NbMaillage();
if (!fil_calcul)
{
{List_io<TypeQuelconque> liste_inter = lesContacts->ListeGrandeurs_particulieres(absolue);
// on abonde donc le tableau précédent et ceci pour chaque maillage
// de plus on définie éventuellement les conteneurs aux noeuds
List_io < Ddl_enum_etendu > li1; // liste vide pour l'appel de AjoutConteneurAuNoeud
Tableau <List_io < TypeQuelconque > * > tabQ(2); tabQ(1)=&liste_inter;tabQ(2)=NULL;
for (int i=1;i<=nb_maillage;i++)
lesMail->AjoutConteneurAuNoeud(li1,tabQ); // ajout éventuel de conteneur
};
// récupération des ddl présents dans les maillages aux noeuds: ordonnées et sans doublon
tabnoeud_type_ddl = lesMail->Les_type_de_ddl_par_noeud(absolue);
tabelement_type_ddl = lesMail->Les_type_de_ddl_par_element(absolue);
tabnoeud_type_ddlEtendu = lesMail->Les_type_de_ddl_etendu_par_noeud(absolue);
// pour les grandeurs quelconques, il faut d'abord effacer les listes, dans dans l'opération
// d'affectation, il faut exactement les mêmes types de chaque coté du = , ce qui peut ne pas être le cas
// si d'un appel d'init_liste_isovaleur à l'autre, la liste à changée, ce qui est le cas pour des grandeurs qui
// apparaissent pendant le calcul
////debug
//cout << "\n debug Isovaleurs_Gmsh::Init_liste_isovaleur( "
//// << "\n lesMail->Les_type_de_TypeQuelconque_par_noeud() " << lesMail->Les_type_de_TypeQuelconque_par_noeud() << endl;
// << " absolue= "<< absolue << endl;
////fin debug
tabnoeud_evoluee.Change_taille(0);
tabnoeud_evoluee = lesMail->Les_type_de_TypeQuelconque_par_noeud(absolue);
// maintenant pour les éléments: idem mais sous forme de grandeurs évoluées
tabelement_evoluee.Change_taille(0);
tabelement_evoluee = lesMail->Les_type_de_donnees_evolues_internes_par_element(absolue);
// récupération des grandeurs particulières
tabelement_typeParti.Change_taille(0);
tabelement_typeParti = lesMail->Les_type_de_donnees_particulieres_par_element(absolue);
// initialisation des tableaux, si c'est déjà fait, ne fait rien
if (tabnoeud_type_ddl_retenu.Taille() == 0)
{ tabnoeud_type_ddl_retenu.Change_taille(nb_maillage);// initialisation
tabnoeud_type_ddlEtendu_retenu.Change_taille(nb_maillage);// initialisation
a_accumuler_tabnoeud_type_ddlEtendu_retenu.Change_taille(nb_maillage);
a_accumuler_tabnoeud_type_ddlEtendu.Change_taille(nb_maillage);
tabnoeud_evoluee_retenu.Change_taille(nb_maillage);
a_accumuler_tabnoeud_evoluee_retenu.Change_taille(nb_maillage);
a_accumuler_tabnoeud_evoluee.Change_taille(nb_maillage);
choix_var_ddl.Change_taille(nb_maillage);// initialisation
tabelement_type_ddl_retenu.Change_taille(nb_maillage);// initialisation
tabelement_evoluee_retenu.Change_taille(nb_maillage);// initialisation
tabelement_typeParti_retenu.Change_taille(nb_maillage);// initialisation
};
// passage des grandeurs disponibles venant des éléments, aux noeuds, lorsque ces grandeurs sont
// directement disponibles aux noeuds
Passage_grandeursDisponiblesAuxNoeuds_elementsVersNoeuds();
//debug
//cout << "\n debug Isovaleurs_Gmsh::Init_liste_isovaleur "
// << "\n tabnoeud_type_ddlEtendu " << tabnoeud_type_ddlEtendu(1) << endl;
//fin debug
// cas des tableaux d'indicateurs
t_g_noeud_ddl_asortir.Change_taille(nb_maillage);
t_g_noeud_ddl_etendu_asortir.Change_taille(nb_maillage);
t_g_noeud_evoluee_asortir.Change_taille(nb_maillage);
t_g_elem_ddl_asortir.Change_taille(nb_maillage);
t_g_elem_evoluee_asortir.Change_taille(nb_maillage);
t_g_elem_typeParti_asortir.Change_taille(nb_maillage);
};
};
// lecture des paramètres de l'ordre dans un flux
void Isovaleurs_Gmsh::Lecture_parametres_OrdreVisu(UtilLecture & entreePrinc)
{ // si dans le flot il existe l'identificateur adoc on lit sinon on passe
if (strstr(entreePrinc.tablcarCVisu,"debut_isovaleur_Gmsh")!=NULL)
{// sauvegarde des parametres actuels
Tableau < List_io < Ddl_enum_etendu> > tabnoeud_type_ddl_retenu_s(tabnoeud_type_ddl_retenu);
Tableau <List_io <bool> > choix_var_ddl_s=choix_var_ddl;
Tableau <List_io < Ddl_enum_etendu > > tabnoeud_type_ddlEtendu_retenu_sauve(tabnoeud_type_ddlEtendu_retenu); // ddl etendu aux noeuds à visualiser
Tableau <List_io < TypeQuelconque > > tabnoeud_evoluee_retenu_sauve(tabnoeud_evoluee_retenu); // grandeurs évoluées aux noeuds
Tableau <List_io < Ddl_enum_etendu > > tabelement_type_ddl_retenu_s(tabelement_type_ddl_retenu);
Tableau <List_io < TypeQuelconque > > tabelement_evoluee_retenu_s(tabelement_evoluee_retenu);
Tableau <List_io < TypeQuelconque > > tabelement_typeParti_retenu_s(tabelement_typeParti_retenu);
bool use_hold_gmsh_format_s = use_hold_gmsh_format;
// essaie de lecture
try
{ string nom,nom1;
(*entreePrinc.entCVisu) >> nom ;
if (nom != "debut_isovaleur_Gmsh")
{ cout << "\n Erreur en lecture des parametres pour les isovaleurs a partir d'un fichier .CVisu,"
<< " le premier enregistrement doit etre le mot clef: debut_isovaleur_Gmsh "
<< " on ne tiens pas compte des parametres fournis !! ";
}
else
{ // appel de l'ordre de la classe mère
OrdreVisu::Lect_para_OrdreVisu_general(entreePrinc);
// choix entre nouveau ou ancien maillage
if (strstr(entreePrinc.tablcarCVisu,"ancien_format_")!=NULL)
{(*entreePrinc.entCVisu) >> nom >> use_hold_gmsh_format;
if (nom != "ancien_format_")
{ cout << "\n lecture de l'indicateur d'ancien format, on a lue ( "<< nom
<< " ) et on attendait ancien_format_"
<< " la suite de la lecture du .CVisu risque d'etre completement fausse, on arrete !!" ;
cout << "\n Isovaleurs_Gmsh::Lecture_parametres_OrdreVisu(... ";
UtilLecture::ErrNouvelEnregCVisu sortie(-1) ; throw (sortie);
}
else // sinon c'est ok
{entreePrinc.NouvelleDonneeCVisu();}; // on passe un enregistrement
};
// lecture du type de sortie des tenseurs
if (strstr(entreePrinc.tablcarCVisu,"tenseur_en_absolue_")!=NULL)
{(*entreePrinc.entCVisu) >> nom >> absolue;
if (nom != "tenseur_en_absolue_")
{ cout << "\n lecture de l'indicateur de type de tensue, on a lue ( "<< nom
<< " ) et on attendait tenseur_en_absolue_"
<< " la suite de la lecture du .CVisu risque d'etre completement fausse, on arrete !!" ;
cout << "\n Isovaleurs_Gmsh::Lecture_parametres_OrdreVisu(... ";
UtilLecture::ErrNouvelEnregCVisu sortie(-1) ; throw (sortie);
}
else // sinon c'est ok
{entreePrinc.NouvelleDonneeCVisu();}; // on passe un enregistrement
};
// puis lecture des parametres propres
int nb_maillage = lesMail->NbMaillage(); int imail;
while (strstr(entreePrinc.tablcarCVisu,"fin_isovaleur_Gmsh")==NULL)
{ (*entreePrinc.entCVisu) >> imail; // lecture du numero de maillage
if ((imail > nb_maillage)||(imail < 1)) // vérif de la validité du numéro de maillage
// si nb maillage trop grand, erreur, on génère une erreur pour arrêter la lecture
{ cout << "\n erreur, le numero de maillage est errone !! nombre lu " << imail
<< " alors que nb_maillage enregistre: " << nb_maillage ;
cout << "\n Isovaleurs_Gmsh::Lecture_parametres_OrdreVisu(... ";
UtilLecture::ErrNouvelEnregCVisu sortie(-1) ; throw (sortie);
};
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
// ---- les ddl aux noeuds a visualiser
if (strstr(entreePrinc.tablcarCVisu,"debut_tableau_ddl_aux_noeuds")!=NULL)
{ // lecture de la liste des ddl
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface la liste actuelle
List_io <Ddl_enum_etendu>& lis_sor = tabnoeud_type_ddl_retenu(imail);
lis_sor.clear();
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom ; compteur++;
if (nom != "fin_tableau_ddl_aux_noeuds")
{if (find(lis_sor.begin(),lis_sor.end(),Ddl_enum_etendu(nom))==lis_sor.end())
// il n'existe pas, on le rajoute
lis_sor.push_back(Ddl_enum_etendu(nom));
}
else break;
};
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
}
// variation ou valeur de chaque ddl
if (strstr(entreePrinc.tablcarCVisu,"debut_tableau_choix_var_ddl_aux_noeuds")!=NULL)
{ // lecture de la liste des variations de ddl
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface la liste actuelle
List_io <bool>& choix_v_dd = choix_var_ddl(imail);
choix_v_dd.clear();
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom ; compteur++;
if (nom != "fin_tableau_choix_var_ddl_aux_noeuds")
{ choix_v_dd.push_back(ChangeEntier(nom));
}
else break;
};
// on vérifie qu'il y a le même nombre que de ddl
if ( (choix_var_ddl(imail)).size() != (tabnoeud_type_ddl_retenu(imail)).size())
{ cout << " \n erreur en lecture du fichier .CVisu dans le cas d'une sortie gmsh "
<< " le nombre de ddl lue au noeud " << (tabnoeud_type_ddl_retenu(imail)).size()
<< " est different du nombre de choix de variation " << (choix_var_ddl(imail)).size()
<< " corriger le fichier !! (ou en faire un nouveau via herezh) ";
Sortie(1);
};
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
}
// ** lecture des ddl etendus aux noeuds
if (strstr(entreePrinc.tablcarCVisu,"debut_tableau_ddl_etendu_aux_noeuds")!=NULL)
{ // lecture de la liste des ddl
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface la liste actuelle
List_io <Ddl_enum_etendu>& lis_sor = tabnoeud_type_ddlEtendu_retenu(imail);
lis_sor.clear();
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_tableau_ddl_etendu_aux_noeuds")
{if (find(lis_sor.begin(),lis_sor.end(),Ddl_enum_etendu(nom))==lis_sor.end())
// il n'existe pas, on le rajoute
lis_sor.push_back(Ddl_enum_etendu(nom));
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
// ** les grandeurs évoluées aux noeuds
if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandEvoluee_noeud")!=NULL)
{ // lecture de la liste des grandeurs évoluées
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface la liste actuelle
List_io<TypeQuelconque>& tpg_ret = (tabnoeud_evoluee_retenu(imail)); // pour simplifier
tpg_ret.clear();
list_vect_globalPourNoeud_retenu.clear(); // idem
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
List_io<TypeQuelconque>& tpg = (tabnoeud_evoluee(imail)); // pour simplifier
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_GrandEvoluee_noeud")
{ TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom)); // création d'un type quelconque sans grandeur
List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
bool trouve = false;
bool dans_global=false; // pour savoir si c'est dans le vecteur global ou pas
// si la grandeur n'existe pas au niveau de tabnoeud_evoluee on essaie au niveau des
// vecteur globaux
if (il == tpg.end())
{il = find(list_vect_globalPourNoeud.begin(),list_vect_globalPourNoeud.end(),a);
if (il != list_vect_globalPourNoeud.end())
trouve = true;dans_global=true;
}
else // sinon c'est bon on a trouvé
{trouve = true;};
// si la grandeur existe on essaie de l'enregistrer sinon on passe
if (trouve)
{// s'il n'existe pas déjà on l'enregistre vraiment
if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
{ tpg_ret.push_back(*il);
if (dans_global) list_vect_globalPourNoeud_retenu.push_back(*il);
}
};
}
else break;
};
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
//debug
//cout << "\n debug Isovaleurs_Gmsh::Lecture_parametres_OrdreVisu "
// << "\n tabnoeud_evoluee_retenu(imail) "<< tabnoeud_evoluee_retenu(imail)
// << "\n tabnoeud_evoluee(imail) "<<tabnoeud_evoluee(imail)<< endl;
//fin debug
// ---- les ddl aux éléments a visualiser
if (strstr(entreePrinc.tablcarCVisu,"debut_tableau_ddl_aux_elements")!=NULL)
{ // lecture de la liste des ddl
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface la liste actuelle
List_io <Ddl_enum_etendu>& lis_sor = tabelement_type_ddl_retenu(imail);
lis_sor.clear();
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_tableau_ddl_aux_elements")
{if (find(lis_sor.begin(),lis_sor.end(),Ddl_enum_etendu(nom))==lis_sor.end())
// il n'existe pas, on le rajoute
lis_sor.push_back(Ddl_enum_etendu(nom));
}
else break;
};
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
//debug
//cout << "\n debug Isovaleurs_Gmsh::Lecture_parametres_OrdreVisu "
// << tabelement_type_ddl_retenu(imail) << endl;
//fin debug
};
// ---- les grandeurs évoluées aux éléments a visualiser
if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandEvoluee_element")!=NULL)
{ // lecture de la liste des grandeurs particulières
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface la liste actuelle
List_io<TypeQuelconque>& tpg_ret = (tabelement_evoluee_retenu(imail)); // pour simplifier
tpg_ret.clear();
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
List_io<TypeQuelconque>& tpg = (tabelement_evoluee(imail)); // pour simplifier
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_GrandEvoluee_element")
{ TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom)); // création d'un type quelconque sans grandeur
List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
if (il == tpg.end())
{cout << "\n ** attention la grandeur "<<nom
<<" n'est pas presente au niveau des grandeurs evoluees aux elements "
<< " on n'en tient pas compte "<<flush;
}
else // c'est ok
// s'il n'existe pas déjà on l'enregistre vraiment
{if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
{ tpg_ret.push_back(*il);}
};
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
// ---- les grandeurs particulières aux éléments a visualiser
if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandParticuliere_element")!=NULL)
{ // lecture de la liste des grandeurs particulières
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface la liste actuelle
List_io<TypeQuelconque>& tpg_ret = (tabelement_typeParti_retenu(imail)); // pour simplifier
tpg_ret.clear();
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
List_io<TypeQuelconque>& tpg = (tabelement_typeParti(imail)); // pour simplifier
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_GrandParticuliere_element")
{ // ici on est obliger de tester l'existence du type particulier, s'il n'existe
// pas on le crée, car c'est peut-être un type automatique
// ensuite à la sortie il y aura une vérification d'existence
// pour l'instant on regarde uniquement le mot clé INTEG_SUR_VOLUME
TypeQuelconque_enum_etendu tq; // init par défaut
if (!TypeQuelconque_enum_etendu::VerifExistence(nom))
{ // on regarde si le nom contient la partie INTEG_SUR_VOLUME
if (nom.find("INTEG_SUR_VOLUME_ET_TEMPS") != std::string::npos)
{tq =TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(INTEG_SUR_VOLUME_ET_TEMPS,nom,RIEN_TYPEGRANDEUR);
}
else if (nom.find("INTEG_SUR_VOLUME") != std::string::npos)
{tq =TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(INTEG_SUR_VOLUME,nom,RIEN_TYPEGRANDEUR);
}
else // sinon on met un message et on met un type par défaut
cout << "\n *** attention le type quelconque "<< nom
<< " n'est pas reconnu, aucune sortie prevu pour lui "
<< endl;
}
else
{tq = TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom);};
TypeQuelconque a(tq); // création d'un type quelconque sans grandeur
List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
// si la grandeur existe on essaie de l'enregistrer sinon on passe
if (il != tpg.end())
{// s'il n'existe pas déjà on l'enregistre vraiment
if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
{ tpg_ret.push_back(*il);}
};
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
//debug
//cout << "\n debug Isovaleurs_Gmsh::Lecture_parametres_OrdreVisu "
// << "\n 2: tabelement_evoluee_retenu(imail) " << tabelement_type_ddl_retenu(imail)
// << "\n 3: a_accumuler_tabnoeud_evoluee_retenu(imail) "<<a_accumuler_tabnoeud_evoluee_retenu(imail)<< endl;
//fin debug
};// -- fin du while sur les maillages
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
}; // -- fin du if then else sur "debut_isovaleur_Gmsh"
} // -- fin du try
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch (...)// erreur de lecture
{ cout << "\n Erreur en lecture des parametres pour les isovaleurs a partir d'un fichier .CVisu,"
<< " on ne tiens pas compte des parametres fournis !! ";
// récup des parametres sauvées
tabnoeud_type_ddl_retenu = tabnoeud_type_ddl_retenu_s;
choix_var_ddl=choix_var_ddl_s;
tabnoeud_type_ddlEtendu_retenu=tabnoeud_type_ddlEtendu_retenu_sauve;
tabnoeud_evoluee_retenu=tabnoeud_evoluee_retenu_sauve;
tabelement_type_ddl_retenu = tabelement_type_ddl_retenu_s;
tabelement_evoluee_retenu = tabelement_evoluee_retenu_s;
tabelement_typeParti_retenu = tabelement_typeParti_retenu_s;
use_hold_gmsh_format = use_hold_gmsh_format_s;
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n Isovaleurs_Gmsh::Lecture_parametres_OrdreVisu(..";
};
};
// dans le cas où il y a des vecteurs globaux qui ont été retenus,
// il faut définir aux noeuds des conteneurs adéquates
if (list_vect_globalPourNoeud_retenu.size() != 0)
{ // def de conteneurs pour le passage d'infos
List_io < Ddl_enum_etendu > lienu; // une liste vide
List_io < TypeQuelconque > litq; // une autre pour les quelconques
Tableau <List_io < TypeQuelconque > * > tabQ(2);
tabQ(1)= &list_vect_globalPourNoeud_retenu;tabQ(2)=&litq;
// on est obligé d'utiliser un tableau dont le second terme est nul,
// ceci pour pouvoir utiliser "AjoutConteneurAuNoeud" tel quel
int nbmail_total = lesMail->NbMaillage();
for (int imail=1;imail <= nbmail_total;imail++)
lesMail->AjoutConteneurAuNoeud(imail,lienu,tabQ);
};
// on introduit certains conteneurs internes des maillages si besoin est en fonction
// des choix de l'utilisateurs: utiles uniquement pour certaines grandeurs
lesMail->Intro_Conteneurs_internes_noeud_relier_auto_autres_grandeur(tabnoeud_evoluee_retenu);
// passage des grandeurs choisies venant des éléments, aux noeuds, lorsque ces grandeurs sont
// directement diponibles aux noeuds
Passage_grandeursRetenuesAuxNoeuds_elementsVersNoeuds();
// on vérifie qu'il n'y a pas de doublon de grandeurs
VerificationTransfertPossible_et_doublon();
// %% cas des noeuds %% on initialise les différentes listes internes qui globalisent tous les maillages
// on le fait ici, plutôt que dans l'exécution, pour faciliter la méthode CreatListNomsTousLesGrandeurs
GlobalisationListSurTousLesMaillagesPourLesNoeuds();
// on ajoute les conteneurs internes des maillages si besoin est en fonction
// des choix de l'utilisateurs
{Tableau <List_io < TypeQuelconque > * > tabQ(2);
tabQ(1) = &glob_noeud_evol_retenu; tabQ(2) = NULL;
lesMail->AjoutConteneurAuNoeud(glob_noeud_ddl_etendu_retenu,tabQ);
};
// création de la liste des noms correspondants à tous les grandeurs à sortir (nécessaire pour
// l'ouverture des fichiers de résultats
CreatListNomsTousLesGrandeurs();
};
// écriture des paramètres de l'ordre dans un flux
void Isovaleurs_Gmsh::Ecriture_parametres_OrdreVisu(UtilLecture & entreePrinc)
{ // récup du flot
ostream & sort = (*(entreePrinc.Sort_CommandeVisu()));
// on commente le fonctionnement
sort << "\n # ----------------------------- definition des parametres pour les isovaleurs : ---------------- ";
// mot clé de démarrage
sort << "\n debut_isovaleur_Gmsh # mot cle de debut des parametres pour les isovaleurs";
// appel de l'ordre de la classe mère
OrdreVisu::Ecrit_para_OrdreVisu_general(entreePrinc);
// choix entre nouveau ou ancien format
sort << "\n ancien_format_ " << use_hold_gmsh_format
<< " # 1 = ancien format, 0 = nouveau format ";
// le type de sortie des tenseurs
sort << "\n# un parametre indiquant si les tenseurs sont en absolue (rep 1) ou suivant un repere ad hoc"
<< "\n# (tangent pour les coques, suivant la fibre moyenne pour les element 1D ) ";
sort << "\n tenseur_en_absolue_ " << absolue;
// puis les paramètres
int nb_mail = tabnoeud_type_ddl_retenu.Taille();
for (int imail=1;imail<=nb_mail;imail++)
{ // ** le numero de maillage
sort << "\n " << imail << " # le numero de maillage";
//---- les grandeurs aux noeuds venant des noeuds ----
// ** ddl aux noeuds
{sort << "\n # tableau des ddl aux noeuds a visualiser, un par maillage";
sort << "\n debut_tableau_ddl_aux_noeuds " ;
List_io < Ddl_enum_etendu >::iterator ild,ildfin = tabnoeud_type_ddl_retenu(imail).end();
for (ild=tabnoeud_type_ddl_retenu(imail).begin();ild!=ildfin;ild++)
{ sort << (*ild) << " " ;};
sort << " fin_tableau_ddl_aux_noeuds " ;
};
// ** variation ou valeur de chaque ddl
{sort << "\n # tableau des choix_var aux noeuds a visualiser, un par maillage";
sort << "\n # choix_var (=1 ou 0) indique si oui ou non il s'agit de la variation ";
sort << "\n debut_tableau_choix_var_ddl_aux_noeuds " ;
List_io <bool>::iterator ilbo,ilbofin=choix_var_ddl(imail).end();
for (ilbo=choix_var_ddl(imail).begin();ilbo!=ilbofin;ilbo++)
{ sort << (*ilbo) << " " ;};
sort << " fin_tableau_choix_var_ddl_aux_noeuds " ;
}
// ** les ddl étendus des noeuds
{sort << "\n # tableau des ddl_etendu aux noeuds a visualiser, un par maillage";
sort << "\n debut_tableau_ddl_etendu_aux_noeuds " ;
List_io < Ddl_enum_etendu >::iterator ild,ildfin = tabnoeud_type_ddlEtendu_retenu(imail).end();
for (ild=tabnoeud_type_ddlEtendu_retenu(imail).begin();ild!=ildfin;ild++)
{ sort << (*ild) << " " ;};
sort << " fin_tableau_ddl_etendu_aux_noeuds " ;
}
// ** les grandeurs evoluées aux noeuds
{sort << "\n # tableau de grandeurs evoluees aux noeuds a visualiser, un par maillage";
sort << "\n deb_list_GrandEvoluee_noeud " ;
List_io < TypeQuelconque >::iterator ilq,ilqfin=tabnoeud_evoluee_retenu(imail).end();
for (ilq=tabnoeud_evoluee_retenu(imail).begin();ilq!=ilqfin;ilq++)
{ sort << ((*ilq).EnuTypeQuelconque().NomPlein()) << " " ;};
sort << " fin_list_GrandEvoluee_noeud " ;
}
//---- fin des grandeurs aux noeuds venant des noeuds ----
// ---- les ddl aux éléments a visualiser au noeuds par transfert
// ** les ddl aux éléments
{sort << "\n # tableau de ddl aux elements a visualiser, un par maillage";
sort << "\n debut_tableau_ddl_aux_elements " ;
List_io < Ddl_enum_etendu >::iterator ild,ildfin = tabelement_type_ddl_retenu(imail).end();
for (ild=tabelement_type_ddl_retenu(imail).begin();ild!=ildfin;ild++)
{ sort << (*ild) << " " ;};
sort << " fin_tableau_ddl_aux_elements " ;
}
// ** les grandeurs évoluées aux éléments a visualiser
{sort << "\n # tableau de grandeurs evoluees aux elements a visualiser, un par maillage";
sort << "\n deb_list_GrandEvoluee_element " ;
List_io < TypeQuelconque >::iterator ilq,ilqfin=tabelement_evoluee_retenu(imail).end();
for (ilq=tabelement_evoluee_retenu(imail).begin();ilq!=ilqfin;ilq++)
{ sort << ((*ilq).EnuTypeQuelconque().NomPlein()) << " " ;};
sort << " fin_list_GrandEvoluee_element " ;
};
// ** les grandeurs particulières aux éléments a visualiser
{sort << "\n # tableau de grandeurs particulieres aux elements a visualiser, un par maillage";
sort << "\n deb_list_GrandParticuliere_element " ;
List_io < TypeQuelconque >::iterator ilq,ilqfin=tabelement_typeParti_retenu(imail).end();
for (ilq=tabelement_typeParti_retenu(imail).begin();ilq!=ilqfin;ilq++)
{ sort << ((*ilq).EnuTypeQuelconque().NomPlein()) << " " ;};
sort << " fin_list_GrandParticuliere_element " ;
}
}; // fin de la boucle sur les maillages
// mot clé de fin
sort << "\n fin_isovaleur_Gmsh # mot cle de fin des parametres pour les isovaleurs \n";
};
// ======================================== méthodes privées =====================================
// choix de l'isovaleur à visualiser calculée à partir des ddl naturels aux noeuds
void Isovaleurs_Gmsh::ChoixIsovaleur_noeud(const string& choix)
{ // tout d'abord on traite le cas de tous les isovaleurs ou para par défaut
// ici idem pour les noeuds
if ((choix=="to")||(choix=="de"))
{ tabnoeud_type_ddl_retenu = tabnoeud_type_ddl;
// on rempli choix_var_ddl à false par défaut
int nbmail = tabnoeud_type_ddl.Taille();
for (int imail = 1;imail<=nbmail;imail++)
{ List_io < Ddl_enum_etendu >& noeud_type_ddl_retenu = tabnoeud_type_ddl_retenu(imail);
List_io < Ddl_enum_etendu >::iterator ili,ilideb,ilifin=noeud_type_ddl_retenu.end();
ilideb = noeud_type_ddl_retenu.begin();
List_io <bool>& choix_v_ddl = choix_var_ddl(imail);
choix_v_ddl.clear(); // mise à zéro de la liste
// maintenant on la remplie de valeurs par défaut
for(ili=ilideb;ili!=ilifin;ili++) choix_v_ddl.push_back(true);
}
return;
};
// maintenant on traite le cas interactif
int dim = ParaGlob::Dimension();
bool choix_valide = false;
string rep;
cout << "\n choix d'isovaleur a visualiser ";
int nbmail = tabnoeud_type_ddl.Taille();
// update du tableau de ddl à visualiser si nécessaire
if (tabnoeud_type_ddl_retenu.Taille() != nbmail)
tabnoeud_type_ddl_retenu.Change_taille(nbmail);
for (int imail = 1;imail<=nbmail;imail++)
{choix_valide=false;
while (!choix_valide) // premier while
{try
{ cout << "\n listes de type de ddl a visualiser ";
cout << "\n Maillage nb: " << imail << " liste des types de ddl disponibles "
<< "\n" << tabnoeud_type_ddl(imail);
// affichage des ddl retenues si la liste n'est pas vide
if (tabnoeud_type_ddl_retenu(imail).size() != 0)
cout << "\n Maillage nb: " << imail << " liste des types de ddl enregistres "
<< "\n" << tabnoeud_type_ddl_retenu(imail);
cout << "\n donner le ddl a visulaliser "
<< "\n (to) tous les ddl "
<< "\n ou une liste de ddl "
<< "\n (0 ou f ou fin) fin choix ddl "
<< "\n reponse ? ";
cout << "\n donnez la ou les grandeurs que vous voulez visualiser (rep grandeurs?) "
<< "\n ou toutes les grandeurs sans les reactions (rep : to) "
<< "\n ou toutes les grandeurs (rep : tr) "
<< "\n effacer la liste actuelle (rep : ef) "
<< "\n (pour terminer tapez : fin (ou f)) ";
rep = lect_return_defaut(false,"f");
if (rep == "fin_prog") Sortie(1);
bool deplace_ou_valeur_a_demander = false; // pour la gestion
List_io<Ddl_enum_etendu> nouveau_ddl_a_demander;
if (rep == "to")
// cas de toutes les grandeurs sans les réactions
{// on commence par sauvegarder les variations pour tous les ddl de type réaction
list<bool> sauve_var_reac;List_io < Ddl_enum_etendu > sauve_ddl;
List_io < Ddl_enum_etendu >::iterator idro,idrofin=(tabnoeud_type_ddl_retenu(imail)).end();
List_io <bool>::iterator ifo=(choix_var_ddl(imail)).begin();
for(idro=(tabnoeud_type_ddl_retenu(imail)).begin();idro != idrofin;idro++,ifo++)
if (Ddl_reaction((*idro).Enum()))
{sauve_ddl.push_back(*idro); sauve_var_reac.push_back(*ifo);};
// on vide les listes
(tabnoeud_type_ddl_retenu(imail)).clear();
(choix_var_ddl(imail)).clear();
// on rerempli avec les grandeurs réaction
idrofin=sauve_ddl.end();ifo=sauve_var_reac.begin();
for (idro=sauve_ddl.begin();idro!=idrofin;idro++,ifo++)
{(tabnoeud_type_ddl_retenu(imail)).push_back(*idro);
(choix_var_ddl(imail)).push_back(*ifo);
};
// maintenant on ajoute les ddl non réaction
List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddl(imail).end();
for (ite = tabnoeud_type_ddl(imail).begin();ite != itefin; ite++)
if ( !Ddl_reaction((*ite).Enum()))
{tabnoeud_type_ddl_retenu(imail).push_back(*ite);
nouveau_ddl_a_demander.push_back(*ite);
};
// on n'ordonne pas ni supprime les doublons car a priori tabnoeud_type_ddl(imail) ne comporte pas de doublon
choix_valide=false; deplace_ou_valeur_a_demander=true;
}
else if (rep == "tr")
// cas de toutes les grandeurs avec les réactions
{// on prévient que si on veut une grandeur sous forme de vecteur il faut la demander spécifiquement
cout << "\n attention, si vous voulez une grandeur vectorielle ou tensorielle: ex: les vecteurs reactions "
<< "\n il faut refaire un passage en demandant cette grandeur spedifiquement ";
// on vide les listes
(tabnoeud_type_ddl_retenu(imail)).clear();
(choix_var_ddl(imail)).clear();
// maintenant on ajoute les ddl non réaction
List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddl(imail).end();
for (ite = tabnoeud_type_ddl(imail).begin();ite != itefin; ite++)
{tabnoeud_type_ddl_retenu(imail).push_back(*ite);
nouveau_ddl_a_demander.push_back(*ite);
};
// on n'ordonne pas ni supprime les doublons car a priori tabnoeud_type_ddl(imail) ne comporte pas de doublon
// si car l'utilisateur peut faire deux appels consécutifs ...
nouveau_ddl_a_demander.sort();
nouveau_ddl_a_demander.unique();
choix_valide=false; deplace_ou_valeur_a_demander=true;
}
else if (rep == "ef")
{// on efface la liste
(tabnoeud_type_ddl_retenu(imail)).clear();
(choix_var_ddl(imail)).clear();
choix_valide=false;
};
// sinon
if ((rep == "0") || (rep == "f") || (rep == "fin"))
{choix_valide=true;}
// else if (ExisteEnum_ddl(rep.c_str())) // test pour savoir si c'est vraiment un ddl
else if (Ddl_enum_etendu::VerifExistence(rep)) // test pour savoir si c'est vraiment un ddl
{ //Enum_ddl enum_d = Id_nom_ddl(rep.c_str());
//Ddl_enum_etendu ddl_enu_etendue(enum_d);
Ddl_enum_etendu ddl_enu_etendue(rep);
// on vérifie si le ddl existe dans la liste proposée
if (Ddl_enum_etendu::Existe_dans_la_liste(tabnoeud_type_ddl(imail),ddl_enu_etendue))
{ // on regarde si l'on veut uniquement la grandeur scalaire ou tout
bool choix_var_valide=false;
bool choixScalaireUniquement = true;
while (!choix_var_valide)
{try
{ cout << "\n voulez vous uniquement la grandeur scalaire (rep 1) ou toutes les composantes de la grandeur (rep 2) ? \n"
<< "\n reponse ? ";
rep = lect_chaine();
if (rep == "1") {choixScalaireUniquement=true;choix_var_valide=true;}
else if (rep == "2") {choixScalaireUniquement=false;choix_var_valide=true;}
else {cout << "\n mauvais choix, recommencez";choix_var_valide=false;}
}
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 en lecture
{ cout << "\n Erreur dans le choix scalaire ou non !!, "
<< "\n redonnez une bonne valeur";
choix_var_valide=false;
};
}; //-- fin du second while
// dans le cas où le ddl est de type vecteur, on ajoute toutes les composantes
EnumTypeGrandeur type_grandeur = ddl_enu_etendue.TypeDeGrandeur(); // le premier type de grandeur
if ((!choixScalaireUniquement) && ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE)
|| (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH)))
{ // cas d'un type vecteur
Enum_ddl enu_type_famille = PremierDdlFamille(ddl_enu_etendue.Enum());
// pour l'instant ***** on ne sort que des iso de ddl non étendue donc on peut constituer les
// ddl du vecteur qui est forcément de dim 3
switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
{ case 3: tabnoeud_type_ddl_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-3)));
nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-3)));
case 2: tabnoeud_type_ddl_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-2)));
nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-2)));
case 1: tabnoeud_type_ddl_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-1)));
nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-1)));
};
}
else // cas d'une grandeur scalaire simple
{ tabnoeud_type_ddl_retenu(imail).push_back(ddl_enu_etendue);
nouveau_ddl_a_demander.push_back(ddl_enu_etendue);
};
deplace_ou_valeur_a_demander=true;
}
/* else if ( Existe_typeQuelconque(rep)) // cas où c'est un type quelconque
{ //Enum_ddl enum_d = Id_nom_ddl(rep.c_str());
//Ddl_enum_etendu ddl_enu_etendue(enum_d);
Ddl_enum_etendu ddl_enu_etendue(rep);
// on vérifie si le ddl existe dans la liste proposée
if ( (Ddl_enum_etendu::Existe_dans_la_liste(tabnoeud_type_ddl(imail),ddl_enu_etendue))
|| (Ddl_enum_etendu::Existe_dans_la_liste(list_vect_globalPourNoeud,ddl_enu_etendue))
)
{ // on regarde si l'on veut uniquement la grandeur scalaire ou tout
bool choix_var_valide=false;
bool choixScalaireUniquement = true;
while (!choix_var_valide)
{try
{ cout << "\n voulez vous uniquement la grandeur scalaire (rep 1) ou toutes les composantes de la grandeur (rep 2) ? \n"
<< "\n reponse ? ";
cin >> rep;
if (rep == "1") {choixScalaireUniquement=true;choix_var_valide=true;}
else if (rep == "2") {choixScalaireUniquement=false;choix_var_valide=true;}
else {cout << "\n mauvais choix, recommencez";choix_var_valide=false;}
}
catch (...)// erreur en lecture
{ cout << "\n Erreur dans le choix scalaire ou non !!, "
<< "\n redonnez une bonne valeur";
choix_var_valide=false;
};
}; //-- fin du second while
// dans le cas où le ddl est de type vecteur, on ajoute toutes les composantes
EnumTypeGrandeur type_grandeur = ddl_enu_etendue.TypeDeGrandeur(); // le premier type de grandeur
if ((!choixScalaireUniquement) && ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE)
|| (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH)))
{ // cas d'un type vecteur
Enum_ddl enu_type_famille = PremierDdlFamille(ddl_enu_etendue.Enum());
// pour l'instant ***** on ne sort que des iso de ddl non étendue donc on peut constituer les
// ddl du vecteur qui est forcément de dim 3
switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
{ case 3: tabnoeud_type_ddl_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-3)));
nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-3)));
case 2: tabnoeud_type_ddl_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-2)));
nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-2)));
case 1: tabnoeud_type_ddl_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-1)));
nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-1)));
};
}
else // cas d'une grandeur scalaire simple
{ tabnoeud_type_ddl_retenu(imail).push_back(ddl_enu_etendue);
nouveau_ddl_a_demander.push_back(ddl_enu_etendue);
};
deplace_ou_valeur_a_demander=true;
} */
else
{cout << "\n ddl inexistant dans la liste proposee, recommencez";
choix_valide=false;
};
};
// maintenant on regarde si c'est le ddl on sa variation qui est intéressante
if (deplace_ou_valeur_a_demander)
{ // on boucle sur les nouveaux ddl scalaire a demander
List_io<Ddl_enum_etendu>::iterator uto,utofin=nouveau_ddl_a_demander.end();
for (uto=nouveau_ddl_a_demander.begin();uto!=utofin;uto++)
{// le choix n'est possible que pour les ddl de base, pas les étendues
if ((*uto).Nom_vide())
{ bool choix_var_valide=false;
while (!choix_var_valide)
{try
{ cout << "\n valeur du ddl" << *uto << " ou variation entre t=0 et t (rep 1 ou 0 ) ? \n"
<< "\n reponse ? ";
rep = lect_chaine();
if (rep == "1") {choix_var_ddl(imail).push_back(false);choix_var_valide=true;}
else if (rep == "0") {choix_var_ddl(imail).push_back(true);choix_var_valide=true;}
else {cout << "\n mauvais choix, recommencez";choix_var_valide=false;}
}
catch (...)// erreur en lecture
{ cout << "\n Erreur dans le choix de la variation ou non des ddl !!, "
<< "\n redonnez une bonne valeur";
choix_var_valide=false;
}
}; //-- fin du second while
}
else //sinon c'est un ddl étendue, on le met systématiquement à false, ne servira pas après
{ choix_var_ddl(imail).push_back(false);};
};
};
}
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 en lecture
{ cout << "\n Erreur dans la lecture de ddl !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper fin_prog pour arreter le programme";
choix_valide=false;
};
// maintenant avant d'ordonner et de supprimer les doublons on sauvegarde dans un tableau
Tableau <bool> tab_varrr(Ddl_enum_etendu::NBmax_ddl_enum_etendue());
List_io <bool>::iterator ifo=(choix_var_ddl(imail)).begin();
List_io<Ddl_enum_etendu>::iterator utoo,utoofin=tabnoeud_type_ddl_retenu(imail).end();
for (utoo=tabnoeud_type_ddl_retenu(imail).begin();utoo!=utoofin;utoo++,ifo++)
tab_varrr((*utoo).Position())=*ifo;
// on supprime les indications de variation qui viennent d'être sauvegardé
(choix_var_ddl(imail)).clear();
//maintenant on traite la liste des ddl_enum_etendu
tabnoeud_type_ddl_retenu(imail).sort(); // on ordonne
tabnoeud_type_ddl_retenu(imail).unique();// on supprime les doublons
// et on met les bonnes variation pour les ddl
utoofin=tabnoeud_type_ddl_retenu(imail).end();
for (utoo=tabnoeud_type_ddl_retenu(imail).begin();utoo!=utoofin;utoo++,ifo++)
(choix_var_ddl(imail)).push_back(tab_varrr((*utoo).Position()));
// debug cout << "\n" << tabnoeud_type_ddl_retenu(imail) << "\n et les choix " << choix_var_ddl(imail) << endl;
}; //-- fin du premier while
// on vérifie qu'il y a le même nombre que de ddl
if ( (choix_var_ddl(imail)).size() != (tabnoeud_type_ddl_retenu(imail)).size())
{ cout << " \n erreur**** anormale le nombre de ddl au noeud "
<< (tabnoeud_type_ddl_retenu(imail)).size()
<< " est different du nombre de choix de variation "
<< (choix_var_ddl(imail)).size()
<< " Isovaleurs_Gmsh::ChoixIsovaleur_noeud(const string& choix) ";
Sortie(1);
};
};//-- fin de la boucle sur les maillages
};
// choix de l'isovaleur à visualiser calculée à partir des ddl etendu aux noeuds
void Isovaleurs_Gmsh::ChoixIsovaleur_ddl_etendu_noeud(const string& choix)
{ // tout d'abord on traite le cas de tous les isovaleurs ou para par défaut
// ici idem pour les noeuds
if ((choix=="to")||(choix=="de"))
{ tabnoeud_type_ddlEtendu_retenu = tabnoeud_type_ddlEtendu;
a_accumuler_tabnoeud_type_ddlEtendu_retenu=a_accumuler_tabnoeud_type_ddlEtendu;
return;
};
// maintenant on traite le cas interactif
int dim = ParaGlob::Dimension();
bool choix_valide = false;
string rep;
cout << "\n choix d'isovaleur a visualiser ";
int nbmail = tabnoeud_type_ddlEtendu.Taille();
// update du tableau de ddl à visualiser si nécessaire
if (tabnoeud_type_ddlEtendu_retenu.Taille() != nbmail)
{tabnoeud_type_ddlEtendu_retenu.Change_taille(nbmail);
a_accumuler_tabnoeud_type_ddlEtendu_retenu.Change_taille(nbmail);
};
for (int imail = 1;imail<=nbmail;imail++)
{choix_valide=false;
// dans le cas où il n'y a rien n'a visualiser on passe
if (tabnoeud_type_ddlEtendu(imail).size() == 0)
{cout << "\n *** aucune grandeur a visualiser pour le maillage "<< imail << endl;
}
else
while (!choix_valide) // premier while
{try
{ cout << "\n listes de type de ddl a visualiser ";
cout << "\n Maillage nb: " << imail << " liste des types de ddl disponibles "
<< "\n" << tabnoeud_type_ddlEtendu(imail);
// affichage des ddl retenues si la liste n'est pas vide
if (tabnoeud_type_ddlEtendu_retenu(imail).size() != 0)
cout << "\n Maillage nb: " << imail << " liste des types de ddl enregistres "
<< "\n" << tabnoeud_type_ddlEtendu_retenu(imail);
cout << "\n donnez la ou les grandeurs que vous voulez visualiser (rep grandeurs?) "
<< "\n ou toutes les grandeurs (rep : to) "
<< "\n effacer la liste actuelle (rep : ef) "
<< "\n fin (pour terminer tapez : fin (ou f ou 0)) "
<< "\n reponse ? ";
rep = lect_return_defaut(false,"f");
if (rep == "fin_prog") Sortie(1);
List_io<Ddl_enum_etendu> nouveau_ddl_a_demander;
if (rep == "to")
// cas de toutes les grandeurs
{// on prévient que si on veut une grandeur sous forme de vecteur il faut la demander spécifiquement
cout << "\n attention, si vous voulez une grandeur vectorielle ou tensorielle "
<< "\n il faut refaire un passage en demandant cette grandeur specifiquement ";
// on vide les listes
(tabnoeud_type_ddlEtendu_retenu(imail)).clear();
// maintenant on ajoute les ddl
List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddlEtendu(imail).end();
for (ite = tabnoeud_type_ddlEtendu(imail).begin();ite != itefin; ite++)
{tabnoeud_type_ddlEtendu_retenu(imail).push_back(*ite);
nouveau_ddl_a_demander.push_back(*ite);
// si c'est un ddl a accumuler directement aux noeuds, on enregistre
if (find(a_accumuler_tabnoeud_type_ddlEtendu(imail).begin(),a_accumuler_tabnoeud_type_ddlEtendu(imail).end()
,(*ite)) != a_accumuler_tabnoeud_type_ddlEtendu(imail).end())
a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail).push_back((*ite));
};
// on n'ordonne pas ni supprime les doublons car a priori tabnoeud_type_ddlEtendu(imail) ne comporte pas de doublon
// si car l'utilisateur peut faire deux appels consécutifs ...
nouveau_ddl_a_demander.sort();nouveau_ddl_a_demander.unique();
choix_valide=false;
}
else if (rep == "ef")
{// on efface la liste
(tabnoeud_type_ddlEtendu_retenu(imail)).clear();
(a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail)).clear();
choix_valide=false;
};
// sinon
if ((rep == "0") || (rep == "f") || (rep == "fin"))
{choix_valide=true;}
else if (Ddl_enum_etendu::VerifExistence(rep)) // test pour savoir si c'est vraiment un ddl
{ //Enum_ddl enum_d = Id_nom_ddl(rep.c_str());
//Ddl_enum_etendu ddl_enu_etendue(enum_d);
Ddl_enum_etendu ddl_enu_etendue(rep);
// on vérifie si le ddl existe dans la liste proposée
if (Ddl_enum_etendu::Existe_dans_la_liste(tabnoeud_type_ddlEtendu(imail),ddl_enu_etendue))
{ // on regarde si l'on veut uniquement la grandeur scalaire ou tout
bool choix_var_valide=false;
bool choixScalaireUniquement = true;
if (ddl_enu_etendue.TypeDeGrandeur() != SCALAIRE)
while (!choix_var_valide)
{try
{ cout << "\n voulez vous uniquement la grandeur scalaire (rep 1) ou toutes les composantes de la grandeur (rep 2) ? \n"
<< "\n reponse ? ";
rep = lect_chaine();
if (rep == "1") {choixScalaireUniquement=true;choix_var_valide=true;}
else if (rep == "2") {choixScalaireUniquement=false;choix_var_valide=true;}
else {cout << "\n mauvais choix, recommencez";choix_var_valide=false;}
}
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 en lecture
{ cout << "\n Erreur dans le choix scalaire ou non !!, "
<< "\n redonnez une bonne valeur";
choix_var_valide=false;
};
}; //-- fin du second while
// dans le cas où le ddl est de type vecteur, on ajoute toutes les composantes
EnumTypeGrandeur type_grandeur = ddl_enu_etendue.TypeDeGrandeur(); // le premier type de grandeur
List_io<Ddl_enum_etendu>& aaccumuler_inter_retenu = a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail); // pour simplifier
List_io<Ddl_enum_etendu>& aaccumuler_inter = a_accumuler_tabnoeud_type_ddlEtendu(imail); // pour simplifier
if ((!choixScalaireUniquement) && ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE)
|| (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH)))
{ // cas d'un type vecteur
Enum_ddl enu_type_famille = PremierDdlFamille(ddl_enu_etendue.Enum());
// pour l'instant ***** on ne sort que des iso de ddl non étendue donc on peut constituer les
// ddl du vecteur qui est forcément de dim 3
switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
{ case 3:{Ddl_enum_etendu ddl_enum(Enum_ddl(enu_type_famille+dim-3));
tabnoeud_type_ddlEtendu_retenu(imail).push_back(ddl_enum);
nouveau_ddl_a_demander.push_back(ddl_enum);
if (find(aaccumuler_inter.begin(),aaccumuler_inter.end(),ddl_enum) != aaccumuler_inter.end())
aaccumuler_inter_retenu.push_back(ddl_enum);
}
case 2:{Ddl_enum_etendu ddl_enum(Enum_ddl(enu_type_famille+dim-2));
tabnoeud_type_ddlEtendu_retenu(imail).push_back(ddl_enum);
nouveau_ddl_a_demander.push_back(ddl_enum);
if (find(aaccumuler_inter.begin(),aaccumuler_inter.end(),ddl_enum) != aaccumuler_inter.end())
aaccumuler_inter_retenu.push_back(ddl_enum);
}
case 1:{Ddl_enum_etendu ddl_enum(Enum_ddl(enu_type_famille+dim-1));
tabnoeud_type_ddlEtendu_retenu(imail).push_back(ddl_enum);
nouveau_ddl_a_demander.push_back(ddl_enum);
if (find(aaccumuler_inter.begin(),aaccumuler_inter.end(),ddl_enum) != aaccumuler_inter.end())
aaccumuler_inter_retenu.push_back(ddl_enum);
}
};
}
else // cas d'une grandeur scalaire simple
{ tabnoeud_type_ddlEtendu_retenu(imail).push_back(ddl_enu_etendue);
nouveau_ddl_a_demander.push_back(ddl_enu_etendue);
if (find(aaccumuler_inter.begin(),aaccumuler_inter.end(),ddl_enu_etendue) != aaccumuler_inter.end())
aaccumuler_inter_retenu.push_back(ddl_enu_etendue);
};
}
/* else if ( Existe_typeQuelconque(rep)) // cas où c'est un type quelconque
{ //Enum_ddl enum_d = Id_nom_ddl(rep.c_str());
//Ddl_enum_etendu ddl_enu_etendue(enum_d);
Ddl_enum_etendu ddl_enu_etendue(rep);
// on vérifie si le ddl existe dans la liste proposée
if ( (Ddl_enum_etendu::Existe_dans_la_liste(tabnoeud_type_ddlEtendu(imail),ddl_enu_etendue))
|| (Ddl_enum_etendu::Existe_dans_la_liste(list_vect_globalPourNoeud,ddl_enu_etendue))
)
{ // on regarde si l'on veut uniquement la grandeur scalaire ou tout
bool choix_var_valide=false;
bool choixScalaireUniquement = true;
while (!choix_var_valide)
{try
{ cout << "\n voulez vous uniquement la grandeur scalaire (rep 1) ou toutes les composantes de la grandeur (rep 2) ? \n"
<< "\n reponse ? ";
cin >> rep;
if (rep == "1") {choixScalaireUniquement=true;choix_var_valide=true;}
else if (rep == "2") {choixScalaireUniquement=false;choix_var_valide=true;}
else {cout << "\n mauvais choix, recommencez";choix_var_valide=false;}
}
catch (...)// erreur en lecture
{ cout << "\n Erreur dans le choix scalaire ou non !!, "
<< "\n redonnez une bonne valeur";
choix_var_valide=false;
};
}; //-- fin du second while
// dans le cas où le ddl est de type vecteur, on ajoute toutes les composantes
EnumTypeGrandeur type_grandeur = ddl_enu_etendue.TypeDeGrandeur(); // le premier type de grandeur
if ((!choixScalaireUniquement) && ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE)
|| (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH)))
{ // cas d'un type vecteur
Enum_ddl enu_type_famille = PremierDdlFamille(ddl_enu_etendue.Enum());
// pour l'instant ***** on ne sort que des iso de ddl non étendue donc on peut constituer les
// ddl du vecteur qui est forcément de dim 3
switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
{ case 3: tabnoeud_type_ddlEtendu_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-3)));
nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-3)));
case 2: tabnoeud_type_ddlEtendu_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-2)));
nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-2)));
case 1: tabnoeud_type_ddlEtendu_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-1)));
nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-1)));
};
}
else // cas d'une grandeur scalaire simple
{ tabnoeud_type_ddlEtendu_retenu(imail).push_back(ddl_enu_etendue);
nouveau_ddl_a_demander.push_back(ddl_enu_etendue);
};
deplace_ou_valeur_a_demander=true;
} */
else
{cout << "\n ddl inexistant dans la liste proposee, recommencez";
choix_valide=false;
};
};
}
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 en lecture
{ cout << "\n Erreur dans la lecture de ddl !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper fin_prog pour arreter le programme";
choix_valide=false;
};
// on ordonne et supprime les doublons
tabnoeud_type_ddlEtendu_retenu(imail).sort(); // on ordonne
tabnoeud_type_ddlEtendu_retenu(imail).unique();// on supprime les doublons
a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail).sort(); // on ordonne
a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail).unique();// on supprime les doublons
// debug cout << "\n" << tabnoeud_type_ddlEtendu_retenu(imail) << "\n et les choix " << choix_var_ddl(imail) << endl;
}; //-- fin du premier while
};//-- fin de la boucle sur les maillages
};
// choix de l'isovaleur à visualiser calculée à partir de grandeurs évoluées aux noeuds
void Isovaleurs_Gmsh::ChoixIsovaleur_evoluee_noeud(const string& choix)
{ // tout d'abord on traite le cas de tous les isovaleurs
if (choix=="to")
{ tabnoeud_evoluee_retenu = tabnoeud_evoluee;
return;
}
else if (choix=="de")
{ // on prend le premier élément de chaque maillage et on statut en fonction de son type
int nbmail = tabnoeud_evoluee.Taille();
for (int imail = 1;imail<=nbmail;imail++)
{List_io < TypeQuelconque >& element_evoluee = tabnoeud_evoluee(imail); // pour simplifier
List_io < TypeQuelconque >& element_evoluee_retenu = tabnoeud_evoluee_retenu(imail); // pour simplifier
List_io < TypeQuelconque >::iterator iq,iqfin=element_evoluee.end();
List_io < TypeQuelconque >::iterator iqev,iqevfin;
Element& ele = lesMail->Element_LesMaille(imail,1);
Element::Signature signa = ele.Signature_element();
switch (signa.id_problem)
{case MECA_SOLIDE_DEFORMABLE:
{// c'est avec les types évoluées que l'on travaille, on sort les forces internes et externes globales // tout d'abord les grandeurs communes:
// a) on sort les forces externes
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
{if ((*iq).EnuTypeQuelconque()== FORCE_GENE_EXT) break;};
if (iq != iqfin)
{ // on enregistre s'il n'existe pas déjà
iqevfin=element_evoluee_retenu.end();
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
{if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_EXT) break;};
if (iqev == iqevfin)element_evoluee_retenu.push_back(*iq);
};
// b) et les forces internes
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
{if ((*iq).EnuTypeQuelconque()== FORCE_GENE_INT) break;};
if (iq != iqfin)
{ // on enregistre s'il n'existe pas déjà
iqevfin=element_evoluee_retenu.end();
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
{if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_INT) break;};
if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
};
// c) les forces internes + externes
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
{if ((*iq).EnuTypeQuelconque()== FORCE_GENE_TOT) break;};
if (iq != iqfin)
{ // on enregistre s'il n'existe pas déjà
iqevfin=element_evoluee_retenu.end();
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
{if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_TOT) break;};
if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
};
// d) les forces résidues d'équilibre
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
{if ((*iq).EnuTypeQuelconque()== RESIDU_GLOBAL) break;};
if (iq != iqfin)
{ // on enregistre s'il n'existe pas déjà
iqevfin=element_evoluee_retenu.end();
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
{if ((*iqev).EnuTypeQuelconque()== RESIDU_GLOBAL) break;};
if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
};
// puis choix en fonction de l'évolution temporelle
switch (Evolution_temporelle_du_calcul(ParaGlob::param->TypeCalcul_maitre()))
{ case DYNAMIQUE:
{ // on sort les vitesses de déformation
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
{if ((*iq).EnuTypeQuelconque()== VITESSE_DEFORMATION_COURANTE) break;};
if (iq != iqfin)
{ // on enregistre s'il n'existe pas déjà
iqevfin=element_evoluee_retenu.end();
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
{if ((*iqev).EnuTypeQuelconque()== VITESSE_DEFORMATION_COURANTE) break;};
if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
};
break;
default:
// on ne fait rien
break;
}
};
break;
} //-- fin du cas MECA_SOLIDE_DEFORMABLE
default:
cout << "\n pour l'instant pas de parametre par defaut pour les noeuds !! "
<< "\n pour le type de problem : " << NomElemTypeProblem(signa.id_problem)
<< "\n on continue sur le cas general ";
};
}; //-- fin de la boucle sur les maillages
return;
};
// maintenant on traite le cas interactif
string rep;
bool choix_valide = false;
cout << "\n choix d'isovaleur (grandeurs evoluees) defini aux noeuds, a visualiser ";
int nbmail = tabnoeud_evoluee.Taille();
// update du tableau evolues à visualiser si nécessaire
if (tabnoeud_evoluee_retenu.Taille() != nbmail)
tabnoeud_evoluee_retenu.Change_taille(nbmail);
for (int imail = 1;imail<=nbmail;imail++)
{// on ne traite que s'il y a des grandeurs disponibles
if ( (tabnoeud_evoluee(imail).size() == 0 )
&& (list_vect_globalPourNoeud.size() == 0))
{ cout << "\n aucune grandeur n'est definit, donc aucune proposition ";}
else
{choix_valide=false;
while (!choix_valide) // premier while
{try
{ cout << "\n (0 ou f ou fin) fin choix grandeurs evoluees ";
cout << "\n listes de type de grandeur evoluees a visualiser ";
// affichage des grandeurs retenues si la liste n'est pas vide
if ((tabnoeud_evoluee_retenu(imail)).size())
{ cout << "\n Maillage nb: " << imail << "\n liste des types de grandeurs enregistres: ";
List_io < TypeQuelconque >::iterator iet,ietfin = (tabnoeud_evoluee_retenu(imail)).end();
for (iet=(tabnoeud_evoluee_retenu(imail)).begin();iet!=ietfin;iet++)
cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
cout << endl;
};
cout << "\n Maillage nb: " << imail << " liste des types de grandeurs evoluees disponibles ";
// tout d'abord celles venant du maillage
List_io < TypeQuelconque >::iterator iet,ietfin = (tabnoeud_evoluee(imail)).end();
for (iet=(tabnoeud_evoluee(imail)).begin();iet!=ietfin;iet++)
cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
// puis celles venant de l'algorithme
{List_io < TypeQuelconque >::iterator iet,ietfin = list_vect_globalPourNoeud.end();
List_io<TypeQuelconque>& tpg = (tabnoeud_evoluee(imail));
for (iet=list_vect_globalPourNoeud.begin();iet!=ietfin;iet++)
{ if ( find(tpg.begin(),tpg.end(),(*iet)) == tpg.end()) // on ne sort que si ça n'a pas déjà été sorti
cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
};
};
// le menu
cout << "\n donner la grandeur a visualiser "
<< "\n (to) toutes les grandeurs "
<< "\n (de) les grandeurs par defaut"
<< "\n (une liste de grandeurs evoluees) "
<< "\n (ef) pour effacer la liste "
<< "\n (0 ou f ou fin) fin choix grandeur tensorielle "
<< "\n reponse ? ";
rep = lect_return_defaut(false,"f");
if (rep == "fin_prog") Sortie(1);
if (rep == "to")
{// cas de toutes les grandeurs
// tout d'abord venant des maillages
tabnoeud_evoluee_retenu(imail).clear(); // avec les types évolués il vaut vider avant la recopie
tabnoeud_evoluee_retenu(imail) = tabnoeud_evoluee(imail);
// puis celles venant de l'algorithme
{List_io<TypeQuelconque>& tpg_ret = (tabnoeud_evoluee_retenu(imail)); // pour simplifier
List_io<TypeQuelconque>& tpg = list_vect_globalPourNoeud; // pour simplifier
List_io<TypeQuelconque>::iterator il,ilfin = list_vect_globalPourNoeud.end();
for (il=list_vect_globalPourNoeud.begin();il != ilfin;il++)
{ tpg_ret.push_back(*il);
list_vect_globalPourNoeud_retenu.push_back(*il); // sert pour ajouter les conteneurs aux noeuds
};
};
choix_valide=false;
};
// sinon
if ((rep == "0") || (rep == "f") || (rep == "fin"))
{choix_valide=true;}
else if (rep=="ef")
{ tabnoeud_evoluee_retenu(imail).clear();
list_vect_globalPourNoeud_retenu.clear();
}
else if (rep=="de")
{List_io < TypeQuelconque >& element_evoluee = tabnoeud_evoluee(imail); // pour simplifier
List_io < TypeQuelconque >& element_evoluee_retenu = tabnoeud_evoluee_retenu(imail); // pour simplifier
List_io < TypeQuelconque >::iterator iq,iqfin=element_evoluee.end();
List_io < TypeQuelconque >::iterator iqev,iqevfin;
Element& ele = lesMail->Element_LesMaille(imail,1);
Element::Signature signa = ele.Signature_element();
switch (signa.id_problem)
{case MECA_SOLIDE_DEFORMABLE:
{// c'est avec les types évoluées que l'on travaille, on sort les forces internes et externes globales // tout d'abord les grandeurs communes:
// a) on sort les forces externes
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
{if ((*iq).EnuTypeQuelconque()== FORCE_GENE_EXT) break;};
if (iq != iqfin)
{ // on enregistre s'il n'existe pas déjà
iqevfin=element_evoluee_retenu.end();
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
{if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_EXT) break;};
if (iqev == iqevfin)element_evoluee_retenu.push_back(*iq);
};
// b) et les forces internes
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
{if ((*iq).EnuTypeQuelconque()== FORCE_GENE_INT) break;};
if (iq != iqfin)
{ // on enregistre s'il n'existe pas déjà
iqevfin=element_evoluee_retenu.end();
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
{if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_INT) break;};
if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
};
// c) les forces internes + externes
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
{if ((*iq).EnuTypeQuelconque()== FORCE_GENE_TOT) break;};
if (iq != iqfin)
{ // on enregistre s'il n'existe pas déjà
iqevfin=element_evoluee_retenu.end();
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
{if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_TOT) break;};
if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
};
// d) les forces résidues d'équilibre
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
{if ((*iq).EnuTypeQuelconque()== RESIDU_GLOBAL) break;};
if (iq != iqfin)
{ // on enregistre s'il n'existe pas déjà
iqevfin=element_evoluee_retenu.end();
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
{if ((*iqev).EnuTypeQuelconque()== RESIDU_GLOBAL) break;};
if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
};
// puis choix en fonction de l'évolution temporelle
switch (Evolution_temporelle_du_calcul(ParaGlob::param->TypeCalcul_maitre()))
{ case DYNAMIQUE:
{ // on sort les vitesses de déformation
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
{if ((*iq).EnuTypeQuelconque()== VITESSE_DEFORMATION_COURANTE) break;};
if (iq != iqfin)
{ // on enregistre s'il n'existe pas déjà
iqevfin=element_evoluee_retenu.end();
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
{if ((*iqev).EnuTypeQuelconque()== VITESSE_DEFORMATION_COURANTE) break;};
if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
};
break;
default:
// on ne fait rien
break;
}
};
break;
} //-- fin du cas MECA_SOLIDE_DEFORMABLE
default:
cout << "\n pour l'instant pas de parametre par defaut pour les noeuds !! "
<< "\n pour le type de problem : " << NomElemTypeProblem(signa.id_problem)
<< "\n on continue sur le cas general ";
};
}
else if (TypeQuelconque_enum_etendu::VerifExistence(rep) ) // vérif que c'est une grandeur possible
{ // maintenant on vérifie qu'elle appartient à la liste des grandeurs disponibles
TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
bool trouve=false; // init pour le message d'erreur
// tout d'abord vérif pour celles venant du maillage
{List_io<TypeQuelconque>& tpg_ret = (tabnoeud_evoluee_retenu(imail)); // pour simplifier
List_io<TypeQuelconque>& tpg = (tabnoeud_evoluee(imail)); // pour simplifier
if (find(tpg.begin(),tpg.end(),a) != tpg.end())
{ // il existe -> enregistrement
List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
// s'il n'existe pas déjà on l'enregistre vraiment
if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
tpg_ret.push_back(*il);
trouve = true; // on a bien trouvé une grandeur
};
};
// puis vérif pour celles venant de l'algorithme
{List_io<TypeQuelconque>& tpg_ret = (tabnoeud_evoluee_retenu(imail)); // pour simplifier
List_io<TypeQuelconque>& tpg = list_vect_globalPourNoeud; // pour simplifier
if (find(tpg.begin(),tpg.end(),a) != tpg.end())
{ // il existe -> enregistrement
List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
// s'il n'existe pas déjà on l'enregistre vraiment
if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
{ tpg_ret.push_back(*il);
list_vect_globalPourNoeud_retenu.push_back(*il); // sert pour ajouter les conteneurs aux noeuds
};
trouve = true; // on a bien trouvé une grandeur
// on sort un message pour indiquer que la grandeur globale ne sera
// disponible qu'au fil du calcul
{cout << "\n ---- attention, la grandeur suivante ne sera disponible qu'au fil du calcul ----";
cout << "\n " << ((*il).EnuTypeQuelconque().NomPlein()) ;
};
};
};
if (!trouve)
{ cout << "\n erreur, grandeur non disponible !, recommencez ";};
};
// on supprime les doublons dans la liste retenue
(tabnoeud_evoluee_retenu(imail)).sort();
(tabnoeud_evoluee_retenu(imail)).unique();
list_vect_globalPourNoeud.sort();
list_vect_globalPourNoeud.unique();
}
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 en lecture
{ cout << "\n Erreur dans la lecture evolues !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper fin_prog pour arreter le programme";
choix_valide=false;
};
}; //-- fin du premier while
tabnoeud_evoluee_retenu(imail).sort(); // on ordonne
tabnoeud_evoluee_retenu(imail).unique();// on supprime les doublons
// on parcours la liste a_accumuler_tabnoeud_evoluee pour savoir le type d'accumulation à mettre en place
{List_io<TypeQuelconque>& aaccum_ret = (a_accumuler_tabnoeud_evoluee_retenu(imail)); // pour simplifier
List_io<TypeQuelconque>& aaccum = (a_accumuler_tabnoeud_evoluee(imail)); // pour simplifier
List_io<TypeQuelconque>& tpg_ret = (tabnoeud_evoluee_retenu(imail)); // pour simplifier
List_io < TypeQuelconque >::iterator iq,iqfin=tpg_ret.end();
for (iq=tpg_ret.begin();iq!=iqfin;iq++)
if (find(aaccum.begin(),aaccum.end(),(*iq)) != aaccum.end())
aaccum_ret.push_back(*iq);// accumulation simple
//on ordonne et supprime les doublons
aaccum_ret.sort();aaccum_ret.unique();
};
}; //-- fin de if (tabelement_typeParti(imail).size() != 0 )
};//-- fin de la boucle sur les maillages
};
// choix de l'isovaleur à visualiser calculée à partir des ddl aux points d'intégrations
void Isovaleurs_Gmsh::ChoixIsovaleur_ddl_ptinteg(const string& choix)
{ // tout d'abord on traite le cas de tous les isovaleurs
if (choix=="to")
{ tabelement_type_ddl_retenu = tabelement_type_ddl;
return;
}
else if (choix=="de")
{ // pour l'instant aucun éléments par défaut
return;
};
// maintenant on traite le cas interactif
string rep;
bool choix_valide = false;
cout << "\n choix d'isovaleur (grandeurs scalaires) venant des pts d'integ a visualiser ";
int nbmail = tabelement_type_ddl.Taille();
// update du tableau de ddl à visualiser si nécessaire
if (tabelement_type_ddl_retenu.Taille() != nbmail)
tabelement_type_ddl_retenu.Change_taille(nbmail);
for (int imail = 1;imail<=nbmail;imail++)
{// on ne traite que s'il y a des grandeurs disponibles
if (tabelement_type_ddl(imail).size() != 0 )
{choix_valide=false;
while (!choix_valide) // premier while
{try
{ cout << "\n listes de type de ddl a visualiser ";
cout << "\n Maillage nb: " << imail << " liste des types de ddl disponibles "
<< "\n" << tabelement_type_ddl(imail);
// affichage des ddl retenues si la liste n'est pas vide
if (tabelement_type_ddl_retenu(imail).size() != 0)
cout << "\n Maillage nb: " << imail << " liste des types de ddl enregistres "
<< "\n" << tabelement_type_ddl_retenu(imail);
cout << "\n donner le ddl a visulaliser "
<< "\n (to) tous les ddl "
<< "\n (une liste de ddl) "
<< "\n (ef) pour effacer la liste "
<< "\n (ef1) effacer un ddl de la liste "
<< "\n (0 ou f ou fin) fin choix ddl "
<< "\n reponse ? ";
rep = lect_return_defaut(false,"f");
if (rep == "fin_prog") Sortie(1);
if (rep == "to")
{// cas de tous les ddl
tabelement_type_ddl_retenu(imail) = tabelement_type_ddl(imail);
choix_valide=false;
};
// sinon
if ((rep == "0") || (rep == "f") || (rep == "fin"))
{choix_valide=true;}
else if (rep=="ef")
{ tabelement_type_ddl_retenu(imail).clear();
}
else if (rep=="ef1")
{ cout << "\n donnez le ddl "; rep = lect_chaine();
if(Ddl_enum_etendu::VerifExistence(rep))
{Ddl_enum_etendu ddl_enu_etendue(rep);
List_io < Ddl_enum_etendu >::iterator position=
find (tabelement_type_ddl_retenu(imail).begin(),tabelement_type_ddl_retenu(imail).end(),ddl_enu_etendue);
if (position!=tabelement_type_ddl_retenu(imail).end())
{tabelement_type_ddl_retenu(imail).erase(position);}
else
{cout << "\n ddl inexistant dans la liste proposee, recommencez";};
}
else
{cout << "\n ddl inexistant dans la liste proposee, recommencez";};
}
else if (Ddl_enum_etendu::VerifExistence(rep)) // test pour savoir si c'est vraiment un ddl
{ Ddl_enum_etendu ddl_enu_etendue(rep);
// on vérifie si le ddl existe dans la liste proposée
if (Ddl_enum_etendu::Existe_dans_la_liste(tabelement_type_ddl(imail),ddl_enu_etendue))
{tabelement_type_ddl_retenu(imail).push_back(ddl_enu_etendue);
}
else
{cout << "\n ddl inexistant dans la liste proposee, recommencez";
choix_valide=false;
}
}
}
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 en lecture
{ cout << "\n Erreur dans la lecture de ddl !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper fin_prog pour arreter le programme";
choix_valide=false;
}
} //-- fin du premier while
tabelement_type_ddl_retenu(imail).sort(); // on ordonne
tabelement_type_ddl_retenu(imail).unique();// on supprime les doublons
}; //-- fin de if (tabelement_typeParti(imail).size() != 0 )
};//-- fin de la boucle sur les maillages
};
// exeoOrdre: cas du premier increments
// ne concerne que les grandeurs définies aux pti
void Isovaleurs_Gmsh::ExeOrdrePremierIncrement(const Tableau <int>& tab_mail,LesMaillages * )
{ // pour simplifier
int nbmail = tab_mail.Taille();
// dimensionnement en taille
tp_tp_tp_gauss_base.Change_taille(nbmail);
// intialisation de li_P_gauss_total
li_P_gauss_total.clear();
// idem pour map_gauss_base
map_gauss_base.clear();
map_gauss_basePQ.clear();
map_gauss_baseEVol.clear();
// --- boucle sur les maillages ---
for (int im=1;im<=nbmail;im++)
{int numMail=tab_mail(im);
Tableau < Tableau < P_gauss > >& tp_tp_gauss_base = tp_tp_tp_gauss_base(im); // pour simplifier
// 1) on récupère tout d'abord le nombre d'éléments différents dans le maillage
const List_io <Element::Signature>& li_sig_elem = (mailInitial->Tab_liste_type_element())(numMail);
// 2) on cherche la liste des types de ddl différents associés à des pt de gauss
List_io < Enum_ddl > lisEnumDdl; // liste de tous les premiers ddl différents
// 2-A) cas des ddl étendue
List_io < Ddl_enum_etendu >& element_type_ddl_retenu=tabelement_type_ddl_retenu(numMail); // pour simplifier
List_io < Ddl_enum_etendu >::iterator iel,ielfin=element_type_ddl_retenu.end();
for (iel=element_type_ddl_retenu.begin();iel!=ielfin;iel++)
{ Enum_ddl pr_ddl = PremierDdlFamille((*iel).Enum()); // récup du premier ddl
if (find(lisEnumDdl.begin(),lisEnumDdl.end(),pr_ddl)== lisEnumDdl.end())
lisEnumDdl.push_back(pr_ddl);
};
// 2-B) cas des grandeurs quelconques pour les grandeurs évoluées: tensorielles
List_io < TypeQuelconque >& element_evoluee_retenu=tabelement_evoluee_retenu(numMail); // pour simplifier
List_io < TypeQuelconque >::iterator ielEV,ielfinEV=element_evoluee_retenu.end();
for (ielEV=element_evoluee_retenu.begin();ielEV!=ielfinEV;ielEV++)
{ Enum_ddl pr_ddl = PremierDdlFamille((*ielEV).Enum()); // récup du premier ddl
if (find(lisEnumDdl.begin(),lisEnumDdl.end(),pr_ddl)== lisEnumDdl.end())
lisEnumDdl.push_back(pr_ddl);
};
// 2-C) cas des grandeurs quelconques pour les grandeurs particulières
List_io < TypeQuelconque >& element_typeParti_retenu=tabelement_typeParti_retenu(numMail); // pour simplifier
List_io < TypeQuelconque >::iterator ielPQ,ielfinPQ=element_typeParti_retenu.end();
for (ielPQ=element_typeParti_retenu.begin();ielPQ!=ielfinPQ;ielPQ++)
{ Enum_ddl pr_ddl = PremierDdlFamille((*ielPQ).Enum()); // récup du premier ddl
if (find(lisEnumDdl.begin(),lisEnumDdl.end(),pr_ddl)== lisEnumDdl.end())
lisEnumDdl.push_back(pr_ddl);
};
// 3) maintenant on boucle sur les types de ddl différents et sur les types d'éléments pour construire
// la définition des pt d'integ associés aux infos à sortir
List_io <Element::Signature>::const_iterator ifin=li_sig_elem.end();
List_io < Enum_ddl >::iterator iddle,iddlefin= lisEnumDdl.end();
List_io <Element::Signature>::const_iterator ipos;
// récup du tableau de sous maillages
const Tableau < List_io < Element* > > & tab_sous_mesh
= (mailInitial->Tableau_de_sous_maillage())(numMail);
int nbsmax = tab_sous_mesh.Taille(); // récup du nombre de sous maillage
// définition d'un tableau intermédiaire permettant de retrouver le P_gauss dans la liste li_P_gauss_total
Tableau < Tableau < P_gauss *> > tab_point_enum(nbsmax);
// récup de la liste de noms de sous maillage
const List_io <string>& li_nom_sous_mesh
= (mailInitial->Tab_listes_nom_sousMaillage())(numMail);
// important: *** on boucle d'abord sur les types d'éléments c'est-à-dire les sous maillages
// et à l'intérieur on boucle sur les ddl, because, c'est dans cet ordre que l'on sort les résultats
// --> l'enjeux c'est l'ordre des éléments de tp_gauss_base
tp_tp_gauss_base.Change_taille(li_sig_elem.size());
int ism = 1; // init numéro de sous maillage
// init nom de sous maillage
List_io <string>::const_iterator inom=li_nom_sous_mesh.begin();
for (ipos= li_sig_elem.begin();ipos!=ifin;ipos++,ism++,inom++)
{List_io < P_gauss > lip_gauss_base ; // intermédiaire pour construire le tableau tp_gauss_base
int numero_ddl = 1;
for (iddle=lisEnumDdl.begin();iddle!=iddlefin;iddle++,numero_ddl++)
{ // récup du premier élément qui sert d'élément courant
const Element & ele = (*(*(tab_sous_mesh(ism).begin())));
tab_point_enum(ism).Change_taille(nombre_maxi_de_type_de_ddl); // dimensionnement du tableau indirecte
// on commence par regarder s'il n'y a pas déjà un groupe de pt_integ qui convient
// le nombre de pt d'integ est contenu dans l'élément géométrique associé
Isovaleurs_Gmsh::P_gauss pt_gauss_inter // ici seule compte le pointeur de géométrie
(&(ele.ElementGeometrie(*iddle)),"toto",(*iddle),numMail);
// car lorsque l'on a créer le groupe on a demander l'élément géométrique
// relatif au ddl, donc contenant le bon nombre de pt d'integ
list < Isovaleurs_Gmsh::P_gauss >::iterator
li_P=find(li_P_gauss_total.begin(),li_P_gauss_total.end(),pt_gauss_inter);
if (li_P != li_P_gauss_total.end())
{// cas ou un group existant existe déjà, enregistrement
li_P_gauss_total.push_front(Isovaleurs_Gmsh::P_gauss
((*li_P).elemgeom,(*li_P).nom_groupe_pt_integ,(*iddle),numMail));
tab_point_enum(ism)(*iddle)=&(*(li_P_gauss_total.begin()));
// si ce groupe de point de gauss n'est pas enregistré pour ce maillage on l'enregistre
// mais on n'enregistre que les groupes avec des noms différents et/ou des
list < Isovaleurs_Gmsh::P_gauss >::iterator
li_gb=find(lip_gauss_base.begin(),lip_gauss_base.end(),pt_gauss_inter);
if (li_gb == lip_gauss_base.end())
lip_gauss_base.push_front((*(li_P_gauss_total.begin()))); // remplissage de la liste mini
}
else
{// sinon on en construit un autre
// création du nom de référence pour le groupe de pt d'integ
// ce nom intègre également le nom de l'élément geométrique, le type d'interpolation, le nb de pt
// d'integ -> ainsi il ne doit jamais y avoir deux noms identiques pour des éléments géométriques différents
// par contre on peut avoir le même nom pour deux Enum_ddl associés différents, ça veut dire que ces enum
// utilisent les mêmes pt d'integ
ostrstream tab_out;
ElemGeomC0& elegeom = (ele.ElementGeometrie(*iddle));
tab_out << "gr_ptInteg_:" << (*inom) << "_nbddl_" << numero_ddl << "_m_" << numMail << "_"
// volontairement on ne sort que des chiffres (correspondant au type enuméré) par concision
<< int(elegeom.TypeGeometrie()) << int(elegeom.TypeInterpolation()) << elegeom.Nbi() << ends;
string nom_pt_integ_sous_maillage = tab_out.str() ; // le nom
li_P_gauss_total.push_front(Isovaleurs_Gmsh::P_gauss
(&elegeom,nom_pt_integ_sous_maillage,(*iddle),numMail));
tab_point_enum(ism)(*iddle)=&(*(li_P_gauss_total.begin()));
lip_gauss_base.push_front((*(li_P_gauss_total.begin()))); // remplissage de la liste mini
// fin
}; //-- fin de la construction d'un nouveau groupe
}; //-- fin de la boucle sur les types différents d'énum ddl
// e >> ---- construction de tp_tp_gauss_base
Tableau < P_gauss >& tp_gauss_base = tp_tp_gauss_base(ism);
list < P_gauss >::iterator inga,ingafin=lip_gauss_base.end();
tp_gauss_base.Change_taille(lip_gauss_base.size());
int nbpg=lip_gauss_base.size(); // si l'on veut garder le même ordre que durant la création de lip_gauss_base
// il faut décroitre (car lip_gauss_base est rempli par des push_front)
for (inga=lip_gauss_base.begin();inga!=ingafin;inga++,nbpg--)
tp_gauss_base(nbpg)=(*inga);
}; //-- fin de la boucle sur les types différents d'éléments, donc de sous maillage
// a >> ---- maintenant on définit le tableau tab_point_enum
// ou on met à jour s'il y a plusieurs maillage
// b >> ----- calcul de la liste des ddl étendues associé aux groupes de pt_gauss
// on passe en revue tous les ddl étendue
for (iel=element_type_ddl_retenu.begin();iel!=ielfin;iel++)
{ Enum_ddl pr_ddl = PremierDdlFamille((*iel).Enum()); // récup du premier ddl
for (int jsm =1; jsm <= nbsmax; jsm++)
map_gauss_base[tab_point_enum(jsm)(pr_ddl)->nom_groupe_pt_integ].push_back((*iel));
};
// c >> ----- idem pour les types évolués tensorielles
// on passe en revue tous les types quelconques
for (ielEV=element_evoluee_retenu.begin();ielEV!=ielfinEV;ielEV++)
{ Enum_ddl pr_ddl = PremierDdlFamille((*ielEV).Enum()); // récup du premier ddl
for (int jsm =1; jsm <= nbsmax; jsm++)
map_gauss_baseEVol[tab_point_enum(jsm)(pr_ddl)->nom_groupe_pt_integ].push_back((*ielEV));
};
// d >> ----- idem pour les types quelconques pour les grandeurs particulières
// on passe en revue tous les types quelconques
for (ielPQ=element_typeParti_retenu.begin();ielPQ!=ielfinPQ;ielPQ++)
{ //cout << "\n debug de isoGmsh " << (*((*ielPQ).Grandeur_pointee())) << endl; // débug
Enum_ddl pr_ddl = PremierDdlFamille((*ielPQ).Enum()); // récup du premier ddl
for (int jsm =1; jsm <= nbsmax; jsm++)
map_gauss_basePQ[tab_point_enum(jsm)(pr_ddl)->nom_groupe_pt_integ].push_back((*ielPQ));
};
// débug
//{
//cout << "\n " << tp_tp_gauss_base << endl; //// débug
//int nbsmax = tab_sous_mesh.Taille(); // récup du nombre de sous maillage
//for (int ism=1;ism<=nbsmax;ism++)
// { // récup du premier élément qui sert d'élément courant
// const Element & ele = (*(*(tab_sous_mesh(ism).begin())));
// ElemGeomC0& elegeom = (ele.ElementGeometrie(SIG11));
// cout << "\n" <<elegeom.TypeGeometrie() << elegeom.TypeInterpolation() << elegeom.Nbi() << endl;
// };
//}
// fin débug
}; //-- fin de la boucle sur les maillages
// ----- maintenant pour les types évoluées et quelconques on construit les map de tableaux de listes ---
map_gauss_tab_baseEVol.clear();
map_gauss_tab_basePQ.clear();
// on boucle sur les maillages puis les sous_maillages puis sur les groupes de pt de gauss
for (int im=1;im<=nbmail;im++)
{Tableau < Tableau < P_gauss > > & tp_tp_gauss_base = tp_tp_tp_gauss_base(im);
int nbsmax = tp_tp_gauss_base.Taille(); // récup en fait du nombre de sous maillage
for (int ism = 1; ism<= nbsmax; ism++)
{Tableau < P_gauss >& tp_gauss_base = tp_tp_gauss_base(ism);
int tp_taille=tp_gauss_base.Taille();
for (int ing=1;ing<=tp_taille;ing++)
{P_gauss& gauss_enCours = (tp_gauss_base(ing)); // pour simplifier
string& nom = gauss_enCours.nom_groupe_pt_integ; // pour simplifier
int nb_ptinteg = gauss_enCours.elemgeom->Nbi();
// si la liste existe on crée un tableau de liste identique: ceci pour les évoluées
if (map_gauss_baseEVol.find(nom)!=map_gauss_baseEVol.end())
map_gauss_tab_baseEVol[nom] // en l'adressant on le crée s'il n'existe pas
.Change_taille(nb_ptinteg,map_gauss_baseEVol[nom]); // def du tableau de listes
// idem pour les listes de grandeurs quelconques
if (map_gauss_basePQ.find(nom)!=map_gauss_basePQ.end())
map_gauss_tab_basePQ[nom] // en l'adressant on le crée s'il n'existe pas
.Change_taille(nb_ptinteg,map_gauss_basePQ[nom]); // def du tableau de listes
// cout << "\n debug de isoGmsh " << (*((*map_gauss_basePQ[nom].begin()).Grandeur_pointee())) << endl; // débug
// cout << "\n debug de isoGmsh " << (*((*map_gauss_tab_basePQ[nom](1).begin()).Grandeur_pointee())) << endl; // débug
}
};
};
};
// calcul des grandeurs aux points d'intégration
void Isovaleurs_Gmsh::CalculAuxPtInteg(const Tableau <int>& tab_mail,LesMaillages * lesMail)
{ // dans le cas où l'on transfert aux noeuds, on initialise les compteurs
lesMail->InitUpdateAuNoeud(glob_elem_ddl_retenu,tab_quelconque,cas_transfert);
int nbmail = tab_mail.Taille();
for (int im=1;im<=nbmail;im++) // on boucle sur les maillages
{int numMail=tab_mail(im);
Tableau < Tableau < P_gauss > >& tp_tp_gauss_base = tp_tp_tp_gauss_base(im);
{ // on cré un bloc pour éviter d'utiliser des variables en dehors
// récup du tableau de sous maillages
const Tableau < List_io < Element* > > & tab_sous_mesh
= (mailInitial->Tableau_de_sous_maillage())(numMail);
int nbsmax = tab_sous_mesh.Taille(); // récup du nombre de sous maillage
// 1- on boucle sur les différents sous maillages
for (int ism=1;ism<=nbsmax;ism++)
{ // on boucle sur les groupes de pt de gauss relatifs à ce sous-maillage
Tableau < P_gauss >& tp_gauss_base = tp_tp_gauss_base(ism);
int tp_taille=tp_gauss_base.Taille();
Tableau <Tableau <double> > tab_val; // tableau de travail
for (int ing=1;ing<=tp_taille;ing++)
{P_gauss& gauss_enCours = (tp_gauss_base(ing)); // pour simplifier
// on recherche les liste de ddl étendue et/ou de type quelconque à sortir
// a) cas des ddl étendue
List_io < Ddl_enum_etendu >* lidsor = NULL;
if (map_gauss_base.find(gauss_enCours.nom_groupe_pt_integ)!=map_gauss_base.end())
lidsor=&(map_gauss_base[gauss_enCours.nom_groupe_pt_integ]);
// b) cas des types évoluées tensorielles
List_io < TypeQuelconque > * lidsorEV = NULL;
Tableau < List_io < TypeQuelconque > >* tablidsorEV = NULL;
if (map_gauss_tab_baseEVol.find(gauss_enCours.nom_groupe_pt_integ)!=map_gauss_tab_baseEVol.end())
{tablidsorEV=&(map_gauss_tab_baseEVol[gauss_enCours.nom_groupe_pt_integ]);
// pour la liste on pointe via la map de liste simple, la liste servira d'une part
// pour les identificateurs (enum), et d'autre part de liste de travail pour le passage au noeud
lidsorEV = &(map_gauss_baseEVol[gauss_enCours.nom_groupe_pt_integ]);
};
// c) cas des types quelconques pour les grandeurs particulières
List_io < TypeQuelconque >* lidsorPQ = NULL;
Tableau < List_io < TypeQuelconque > >* tablidsorPQ = NULL;
if (map_gauss_basePQ.find(gauss_enCours.nom_groupe_pt_integ)!=map_gauss_basePQ.end())
{tablidsorPQ=&(map_gauss_tab_basePQ[gauss_enCours.nom_groupe_pt_integ]);
// pour la liste on pointe via la map de liste simple, la liste servira d'une part
// pour les identificateurs (enum), et d'autre part de liste de travail pour le passage au noeud
lidsorPQ = &(map_gauss_basePQ[gauss_enCours.nom_groupe_pt_integ]);
};
// --- on balaie tous les éléments du sous_maillage pour calculer les valeurs aux pts d'integ
List_io < Element* >& sous_mesh = tab_sous_mesh(ism);
List_io < Element* >::const_iterator ils,ilsfin=sous_mesh.end();
for (ils=sous_mesh.begin();ils!=ilsfin;ils++)
{ // recup de l'element
Element & ele = *(*ils);
// contrairement au cas de Gid, ici il n'y a pas de sortie aux points d'integ, car gmsh ne gère
// pas les points d'intégration donc on utilise directement la numérotation d'herezh
int nb_pt_gauss = gauss_enCours.elemgeom->Nbi(); // récup du nombre de pt d'integ
// dimensionnement des tableaux de sortie
tab_val.Change_taille(nb_pt_gauss);
// on balaie le nombre de pt d'integ
for (int iptinteg=1;iptinteg<=nb_pt_gauss;iptinteg++)
{ bool sortie_retour_a_la_ligne=false;
Tableau <double > & tab = tab_val(iptinteg); // pour simplifier
// on récupère les infos correspondant aux ddl
// si les grandeurs n'existent pas, elles sont initialisées dans la méthode
if (lidsor != NULL)
tab = ele.Valeur_a_diff_temps(absolue,TEMPS_tdt,*lidsor,iptinteg);
// idem pour les grandeurs évoluées tensorielle
// ici lidsorEV ne sert que de drapeau, le véritable conteneur c'est tablidsorEV
// qui va contenir à la fin, les data pour "tous" les pt d'integ
// ** pour les grandeurs tensorielles exprimées avec gmsh, elles doivent-être obligatoirement
// ** exprimées dans le repère global, donc en absolue, car sinon cela n'a pas de sens car on ne
// ** connait pas le repère local, donc on force la sortie en absolue
bool absolue_tensorielle_gmsh = true;
if (lidsorEV != NULL)
{ List_io < TypeQuelconque > & listsorEVduPtInteg = (*tablidsorEV)(iptinteg);
ele.ValTensorielle_a_diff_temps(absolue_tensorielle_gmsh,TEMPS_tdt,listsorEVduPtInteg,iptinteg);
//---- pour le debug
//cout << " \n Isovaleurs_Gmsh::EcritureAuxPtInteg listsorEVduPtInteg" << listsorEVduPtInteg << endl;
//--- fin pour le debug
};
// idem pour les grandeurs quelconque
// ici lidsorPQ ne sert que de drapeau, le véritable conteneur c'est tablidsorPQ
// qui va contenir à la fin, les data pour "tous" les pt d'integ
if (lidsorPQ != NULL)
{ List_io < TypeQuelconque >& listsorPQduPtInteg = (*tablidsorPQ)(iptinteg);
ele.Grandeur_particuliere(absolue,listsorPQduPtInteg,iptinteg);
};
}; //-- fin de boucle sur les pt de gauss
// transert aux noeuds
{int cas_transfert=1; // pour l'instant le seul mis en place
// cas des ddl
if (lidsor != NULL)
lesMail->TransfertPtIntegAuNoeud(numMail,ele,*lidsor,tab_val,cas_transfert);
// cas des grandeurs évoluées tensorielles
if (lidsorEV != NULL)
// ici la liste pointée par lidsorEV sert de liste de travail pour TransfertPtIntegAuNoeud
lesMail->TransfertPtIntegAuNoeud(numMail,ele,(*tablidsorEV),*lidsorEV,cas_transfert);
// cas des grandeurs quelconques
//---- pour le debug
//cout << " \n Isovaleurs_Gmsh::EcritureAuxPtInteg " << (*tablidsorPQ) << endl;
//--- fin pour le debug
if (lidsorPQ != NULL)
// ici la liste pointée par lidsorPQ sert de liste de travail pour TransfertPtIntegAuNoeud
lesMail->TransfertPtIntegAuNoeud(numMail,ele,(*tablidsorPQ),*lidsorPQ,cas_transfert);
};
}; //fin boucle sur element
}; //-- fin boucle sur les groupes de pt de gauss
};//-- fin de la boucle sur les sous maillages
}; // fin du bloc relatif aux sorties aux pt d'intégration
}; //-- fin de la boucle sur les maillages
// transfert aux noeuds: on effectue la dernière étape
lesMail->FinTransfertPtIntegAuNoeud(glob_elem_ddl_retenu,tab_quelconque,cas_transfert);
};
// écriture des grandeurs aux noeuds à l'ancien format
void Isovaleurs_Gmsh::EcritureAuxNoeuds_ancien_format(const Tableau <int>& tab_mail,LesMaillages * lesMail
,int incre,UtilLecture & entreePrinc)
{ // pour simplifier
int nbmail = tab_mail.Taille();
// ici l'objectif est de tout mettre dans un seul groupe de résultat de manière à pouvoir tout
// visualiser en même temps
// on ne traite que s'il y a des ddl
bool atraiter = false;
if ( (glob_noe_ddl_retenu.size() != 0)
|| (glob_noeud_ddl_etendu_retenu.size() != 0)
|| (glob_noeud_evol_retenu.size() != 0)
|| (glob_elem_ddl_retenu.size() != 0)
|| (glob_elem_evol_retenu.size() != 0)
|| (glob_elem_Parti_retenu.size() != 0)
)
atraiter = true;
if (atraiter)
{
// on balaie la liste des noms des différentes grandeurs à sortir en résultat
// car on doit sortir les coordonnées pour chaque grandeur !! pas très performant
list <string>::const_iterator ili,ilifin = nomsGrandeursSortie.end();
for (ili=nomsGrandeursSortie.begin();ili != ilifin; ili++)
{ ostream &sort = entreePrinc.Sort_resultat_Gmsh((*ili));
// ------- entete commenter du numéro d'incrément (ne sert pas pour gmsh) --------------------
sort << "\n//------------------- increment "<<incre<<" ----------------------------\n";
// ----- on commence par sortir les noeuds avec un identificateur, pour optimiser la taille fichier
SortieDefCoordonnees_old_format(sort,incre,nbmail,tab_mail,lesMail);
};
// ramène le tableau t_Egmsh
// t_Egmsh(im)(ie): donne pour le maillage im, et pour l'élément ie, le numéro gmsh de l'élément
const Tableau < Tableau < int > >& t_Egmsh = mailInitial->TabEgmsh();
// récup de la connection herezh->gmsh
// t_GmshHer(i)(j) : donne pour le noeud j de l'élément i de gmsh, le numéro d'herezh
const Tableau < Tableau < int > >& tGmshHer = Visualisation_Gmsh::Tab_GmshHer();
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
// a) cas des ddl initiaux définis aux noeuds
if (glob_noe_ddl_retenu.size() != 0)
{// on utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
// maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
List_io < Ddl_enum_etendu >::iterator il,ilfin=glob_noe_ddl_retenu.end();
Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
Tableau <List_io < bool >::iterator > t_choix_var_ddl(nbmail);
for (int im =1; im <= nbmail; im++)
{t_indic_sortie(im)=t_g_noeud_ddl_asortir(im).begin();
t_choix_var_ddl(im)=choix_var_ddl(im).begin();
};
int numero = 0; // car ce n'est pas un tableau, cf. utilisation d'EnteteView
for (il=glob_noe_ddl_retenu.begin();il != ilfin;il++)
{ Enum_ddl ddl = (*il).Enum(); // récup du ddl de base
Ddl_enum_etendu ddl_etendu = (*il); // le ddl étendue associé
bool ddl_basique = (*il).Nom_vide();
string nom_sortie;
if (ddl_basique)
nom_sortie = Nom_ddl(ddl);
else
nom_sortie = ddl_etendu.Nom();
ostream& sort = entreePrinc.Sort_resultat_Gmsh(nom_sortie+"_ddl_noe");
// def de l'entete
EnteteView(sort,incre,nom_sortie,numero);
// -- sortie des grandeurs
// on balaie les maillages
for (int im =1; im <= nbmail; im++)
{// on ne continue que si le ddl est à sortir
if (*(t_indic_sortie(im)))
{int numMail = tab_mail(im);
List_io <bool>& choix_var_ddl_unMail = choix_var_ddl(numMail);
int nbmaxelem = lesMail->Nombre_element(numMail);
int dcaN = mailInitial->DecalNumNoeud(numMail);
for (int numElem = 1; numElem <= nbmaxelem; numElem++)
{Element& elem = lesMail->Element_LesMaille(numMail,numElem); // récup de l'élément
Tableau<Noeud *>& t_n = elem.Tab_noeud();
int num_elem_gmsh = t_Egmsh(im)(numElem); // numéro de classement du type d'élément gmsh
// maintenant on sort en fonction de d'élément
//-- 1) le type
// ***** a complèter pour les éléments quadratiques incomplet et les autres non possibles *****
sort << "\n" << tabScalVecTensGmsh.scalar_pourView(num_elem_gmsh)<< "(";
//-- 2) les coordonnées des noeuds
// on considère le nombre de noeuds de la sortie gmsh, et non celui de l'élément (qui peut-être
// plus grand dans le cas d'un sfe, ou plus petit dans le cas d'un quadratique incomplet !)
int nbNmax = tGmshHer(num_elem_gmsh).Taille(); //t_n.Taille();
for (int ino=1;ino<=nbNmax;ino++) // ino = numéro gmsh
{ int num_her = tGmshHer(num_elem_gmsh)(ino); // --> num HZpp
int num_N = t_n(num_her)->Num_noeud()+dcaN; // num global
SortieUseUneCoordonnee(incre,sort,(ino == nbNmax),num_N);
};
//-- 3) les grandeurs
bool varddl = *(t_choix_var_ddl(im)); // variation ou pas
for (int ino=1;ino<nbNmax;ino++) // sortie des grandeurs sauf la dernière
{ int num_her = tGmshHer(num_elem_gmsh)(ino); // --> num HZpp
// il y a un choix suivant que c'est un ddl de base ou un ddl étendu
if (ddl_basique)
{ if (t_n(num_her)->Existe_ici(ddl))
{ if (varddl) // cas de la variation
{sort << (t_n(num_her)->Valeur_tdt(ddl)-t_n(num_her)->Valeur_0(ddl))
<<",";}
else { sort << t_n(num_her)->Valeur_tdt(ddl) <<",";}
}
else // si la valeur n'existe pas on sort 0
{sort << 0 <<",";};
}
else // sinon c'est un ddl étendue
{ if (t_n(num_her)->Existe_ici_ddlEtendu(ddl_etendu))
{ sort << (t_n(num_her)->DdlEtendue(ddl_etendu).ConstValeur()) <<",";}
else // si la valeur n'existe pas on sort 0
{sort << 0 <<",";};
};
};
// puis la dernière valeur
int num_her_max = tGmshHer(num_elem_gmsh)(nbNmax); // --> num HZpp
if (ddl_basique)
{ if (t_n(num_her_max)->Existe_ici(ddl))
{if (varddl) // cas de la variation
{sort << (t_n(num_her_max)->Valeur_tdt(ddl)-t_n(num_her_max)->Valeur_0(ddl))
<<"};";}
else { sort << t_n(num_her_max)->Valeur_tdt(ddl) <<"};";};
}
else // si la valeur n'existe pas on sort 0
{sort << 0 <<"};";};
}
else // sinon c'est un ddl étendue
{ if (t_n(num_her_max)->Existe_ici_ddlEtendu(ddl_etendu))
{ sort << (t_n(num_her_max)->DdlEtendue(ddl_etendu).ConstValeur()) <<"};";}
else // si la valeur n'existe pas on sort 0
{sort << 0 <<"};";};
};
};
};
};
// fin de la view
sort << "\n }; ";
// mise à jour des pointeurs de choix
for (int im =1; im <= nbmail; im++)
{t_indic_sortie(im)++;t_choix_var_ddl(im)++;}
}; //-- fin de la boucle sur les enum aux noeud
}; //--// fin du test s'il y a des enum à sortir ou nom
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
// b) cas des ddl venant d'un transfert aux noeuds des grandeurs aux pt d'integ
// on ne sort que les incréments différents de 0, car pour l'incrément 0 pas de grandeurs licites aux pt integ
if ((glob_elem_ddl_retenu.size() != 0) && (incre != 0))
{// on utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
// maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
List_io < Ddl_enum_etendu >::iterator il,ilfin=glob_elem_ddl_retenu.end();
Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
for (int im =1; im <= nbmail; im++)
t_indic_sortie(im)=t_g_elem_ddl_asortir(im).begin();
int numero = 0; // car ce n'est pas un tableau, cf. utilisation d'EnteteView
for (il=glob_elem_ddl_retenu.begin();il != ilfin;il++)
{Ddl_enum_etendu& ddlEtendu = (*il); // pour simplifier
ostream *sorti;
// def de l'entete
if (ddlEtendu.Nom_vide())
{ sorti = &(entreePrinc.Sort_resultat_Gmsh(Nom_ddl(ddlEtendu.Enum())+"_pti"));
EnteteView(*sorti,incre,Nom_ddl(ddlEtendu.Enum()),numero);}
else
{ sorti = &(entreePrinc.Sort_resultat_Gmsh(ddlEtendu.Nom()+"_pti"));
EnteteView(*sorti,incre,ddlEtendu.Nom(),numero);};
ostream& sort = *sorti;
// -- sortie des grandeurs
// on balaie les maillages
for (int im =1; im <= nbmail; im++)
{// on ne continue que si le ddl est à sortir
if (*(t_indic_sortie(im)))
{int numMail = tab_mail(im);
int nbmaxelem = lesMail->Nombre_element(numMail);
int dcaN = mailInitial->DecalNumNoeud(numMail);
for (int numElem = 1; numElem <= nbmaxelem; numElem++)
{ Element& elem = lesMail->Element_LesMaille(numMail,numElem); // récup de l'élément
Tableau<Noeud *>& t_n = elem.Tab_noeud();
int num_elem_gmsh = t_Egmsh(im)(numElem); // numéro de classement du type d'élément gmsh
// maintenant on sort en fonction de d'élément
// ***** a complèter pour les éléments quadratiques incomplet et les autres non possibles *****
sort << "\n" << tabScalVecTensGmsh.scalar_pourView(num_elem_gmsh)<< "(";
// on considère le nombre de noeuds de la sortie gmsh, et non celui de l'élément (qui peut-être
// plus grand dans le cas d'un sfe, ou plus petit dans le cas d'un quadratique incomplet !)
int nbNmax = tGmshHer(num_elem_gmsh).Taille(); //t_n.Taille();
for (int ino=1;ino<=nbNmax;ino++) // ino = numéro gmsh
{ int num_her = tGmshHer(num_elem_gmsh)(ino); // --> num HZpp
int num_N = t_n(num_her)->Num_noeud()+dcaN; // num global
SortieUseUneCoordonnee(incre,sort,(ino == nbNmax),num_N);
};
// maintenant les grandeurs
for (int ino=1;ino<nbNmax;ino++) // sortie des grandeurs sauf la dernière
{int num_her = tGmshHer(num_elem_gmsh)(ino); // --> num HZpp
sort << t_n(num_her)->DdlEtendue(ddlEtendu).ConstValeur() <<",";
};
// puis la dernière valeur
int num_her_max = tGmshHer(num_elem_gmsh)(nbNmax); // --> num HZpp
sort << t_n(num_her_max)->DdlEtendue(ddlEtendu).ConstValeur() <<"};";
};
};
};
// fin de la view
sort << "\n }; ";
// mise à jour des pointeurs de choix
for (int im =1; im <= nbmail; im++)
t_indic_sortie(im)++;
}; //--// fin de la boucle sur les enum
}; //--// fin du test d'existance d'énum à sortir venant d'un transfert aux noeuds des grandeurs aux pt d'integ
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
// c) cas des types évoluées venant d'un transfert aux noeuds des grandeurs aux pt d'integ
// on ne sort que les incréments différents de 0, car pour l'incrément 0 pas de grandeurs licites aux pt integ
if ((glob_elem_evol_retenu.size() != 0) && (incre != 0))
{// on utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
// maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
List_io < TypeQuelconque >::iterator il,ilfin=glob_elem_evol_retenu.end();
Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
for (int im =1; im <= nbmail; im++)
t_indic_sortie(im)=t_g_elem_evoluee_asortir(im).begin();
for (il=glob_elem_evol_retenu.begin();il != ilfin;il++)
{TypeQuelconque& typ = (*il); // pour simplifier
ostream &sort = entreePrinc.Sort_resultat_Gmsh((typ.EnuTypeQuelconque().NomPlein())+"_evolue_pti");
// -- choix entre grandeur simple ou complexe
EnumTypeGrandeur enugrandeur = typ.EnuTypeGrandeur();
EnumType2Niveau enuStructure = typ.Const_Grandeur_pointee()->Type_structure_grandeurAssocie();
switch (enuStructure)
{ case TYPE_SIMPLE:
{ // appel directe de la routine adoc
int numero = 0;
SortirUneViewTypeQuelconque_old_format(sort,typ.EnuTypeQuelconque(),enuStructure,numero
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case TABLEAU_T:
{ // dans le cas d'un tableau on boucle sur les éléments du tableau
switch (enugrandeur)
{ case TENSEURHH:
{Tab_Grandeur_TenseurHH& tab_tensHH = *((Tab_Grandeur_TenseurHH*) typ.Const_Grandeur_pointee());
int taille = tab_tensHH.Taille();
// on boucle, et on sort chaque tenseur
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque_old_format(sort,typ.EnuTypeQuelconque(),enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case SCALAIRE: case SCALAIRE_ENTIER: case SCALAIRE_DOUBLE:
{Tab_Grandeur_scalaire_double& tab_Gdouble = *((Tab_Grandeur_scalaire_double*) typ.Const_Grandeur_pointee());
int taille = tab_Gdouble.Taille();
// on boucle, et on sort chaque scalaire
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque_old_format(sort,typ.EnuTypeQuelconque(),enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
default:
cout << "\n attention : cas de sortie de grandeur tableau non implantee (mais il suffit de le demander !!) ";
typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
cout << "\n EcritureAuxNoeuds_ancien_format::EcritureAuxNoeuds(... ";
};//-- fin du switch (enugrandeur)
break;
}
default:
cout << "\n attention : cas de sortie de grandeur de type secondaire " << NomType2Niveau(enuStructure)
<< " non implantee (mais il suffit de le demander !!) ";
typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
cout << "\n EcritureAuxNoeuds_ancien_format::EcritureAuxNoeuds(... ";
};
// mise à jour des pointeurs de choix
for (int im =1; im <= nbmail; im++)
t_indic_sortie(im)++;
}; //--// fin de la boucle sur les enum
}; //--// fin du test d'existance de type évolué venant d'un transfert aux noeuds des grandeurs aux pt d'integ
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
// d) cas des types particuliers aux elements venant d'un transfert aux noeuds
// on ne sort que les incréments différents de 0, car pour l'incrément 0 pas de grandeurs licites aux pt integ
if ((glob_elem_Parti_retenu.size() != 0) && (incre != 0))
{// on utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
// maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
List_io < TypeQuelconque >::iterator il,ilfin=glob_elem_Parti_retenu.end();
Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
for (int im =1; im <= nbmail; im++)
t_indic_sortie(im)=t_g_elem_typeParti_asortir(im).begin();
for (il=glob_elem_Parti_retenu.begin();il != ilfin;il++)
{TypeQuelconque& typ = (*il); // pour simplifier
ostream &sort = entreePrinc.Sort_resultat_Gmsh((typ.EnuTypeQuelconque().NomPlein())+"_particulier_pti");
// -- choix entre grandeur simple ou complexe
EnumTypeGrandeur enugrandeur = typ.EnuTypeGrandeur();
EnumType2Niveau enuStructure = typ.Const_Grandeur_pointee()->Type_structure_grandeurAssocie();
switch (enuStructure)
{ case TYPE_SIMPLE:
{ // appel directe de la routine adoc
int numero = 0;
SortirUneViewTypeQuelconque_old_format(sort,typ.EnuTypeQuelconque(),enuStructure,numero
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case TABLEAU_T:
{ // dans le cas d'un tableau on boucle sur les éléments du tableau
switch (enugrandeur)
{ case TENSEURHH:
{Tab_Grandeur_TenseurHH& tab_tensHH = *((Tab_Grandeur_TenseurHH*) typ.Const_Grandeur_pointee());
int taille = tab_tensHH.Taille();
// on boucle, et on sort chaque tenseur
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque_old_format(sort,typ.EnuTypeQuelconque(),enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case SCALAIRE: case SCALAIRE_ENTIER: case SCALAIRE_DOUBLE:
{Tab_Grandeur_scalaire_double& tab_Gdouble = *((Tab_Grandeur_scalaire_double*) typ.Const_Grandeur_pointee());
int taille = tab_Gdouble.Taille();
// on boucle, et on sort chaque scalaire
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque_old_format(sort,typ.EnuTypeQuelconque(),enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
default:
cout << "\n attention : cas de sortie de grandeur tableau non implantee (mais il suffit de le demander !!) ";
typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
cout << "\n EcritureAuxNoeuds_ancien_format::EcritureAuxNoeuds(... ";
};//-- fin du switch (enugrandeur)
break;
}
default:
cout << "\n attention : cas de sortie de grandeur de type secondaire " << NomType2Niveau(enuStructure)
<< " non implantee (mais il suffit de le demander !!) ";
typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
cout << "\n EcritureAuxNoeuds_ancien_format::EcritureAuxNoeuds(... ";
};
// mise à jour des pointeurs de choix
for (int im =1; im <= nbmail; im++)
t_indic_sortie(im)++;
}; //--// fin de la boucle sur les enum
}; //--// fin du test d'existance de type évolué venant d'un transfert aux noeuds des grandeurs aux pt d'integ
}; //-- fin du cas if (atraiter)
};