2599 lines
150 KiB
C++
Executable file
2599 lines
150 KiB
C++
Executable file
|
|
// This file is part of the Herezh++ application.
|
|
//
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
// of mechanics for large transformations of solid structures.
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
//
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
//
|
|
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
|
// AUTHOR : Gérard Rio
|
|
// E-MAIL : gerardrio56@free.fr
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License,
|
|
// or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
//
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
|
|
|
#include "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
|
|
// -------------------------------------------------------------------------------------------------
|
|
CalculAuxPtInteg(tab_mail,lesMail);
|
|
CalculAuxElemAuxNoeuds(tab_mail,lesMail);
|
|
// -------------------------------------------------------
|
|
// 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)
|
|
|
|
};
|
|
|
|
|