rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Resultats/MAPLE/Choix_grandeurs_maple.cc

4079 lines
261 KiB
C++
Raw Normal View History

ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Choix_grandeurs_maple.h"
#include "CharUtil.h"
#include "ReferenceNE.h"
#include "ReferencePtiAF.h"
#include "ParaGlob.h"
#include <iomanip>
#include "TypeQuelconqueParticulier.h"
/*
// -> face d'éléments
Tableau <List_io < TypeQuelconque > > tab_F_element_TypeQuelconque; // TypeQuelconque aux faces d'elements possibles à visualiser
Tableau <List_io < TypeQuelconque > > tab_F_element_TypeQuelconque_retenu; // TypeQuelconque aux faces d'elements à visualiser
Tableau <List_io < TypeQuelconque > > tab_F_element_TypeQuelconque_retenu_pourSM; // idem pour somme, moy etc. sur une ref
// -> arête d'éléments
Tableau <List_io < TypeQuelconque > > tab_A_element_TypeQuelconque; // TypeQuelconque aux arêtes d'elements possibles à visualiser
Tableau <List_io < TypeQuelconque > > tab_A_element_TypeQuelconque_retenu; // TypeQuelconque aux arête d'elements à visualiser
Tableau <List_io < TypeQuelconque > > tab_A_element_TypeQuelconque_retenu_pourSM; // idem pour somme, moy etc. sur une ref
Tableau <List_io <BlocScal> > tab_nomDeRef_F_E_SM; // list de nom de références de faces d'élément et de point d'intégration associé
Tableau <List_io <string> > tab_nomDeRef_F_ptinteg_SM; // list de nom de références de pt d'integ de faces d'éléments
Tableau <List_io <BlocScal> > tab_nomDeRef_A_E_SM; // list de nom de références d'arêtes d'élément et de point d'intégration associé
Tableau <List_io <string> > tab_nomDeRef_A_ptinteg_SM; // list de nom de références de pt d'integ d'arêtes d'élément
// -> les pti de face d'éléments
Tableau <List_io <int> > tab_num_F_element; // liste des éléments à visualiser
Tableau <List_io <int> > tab_num_F; // liste des num de face ou arêtes d'éléments à visualiser
Tableau <List_io <int> > tab_num_F_integ; // liste des numéros de point d'integration à visualiser associé à tab_num_F_element
Tableau <List_io <BlocScal> > nomDeRef_F_E; // list de nom de références face d'éléments associés
Tableau <List_io <string> > nomDeRef_F_ptinteg; // list de nom de références de pt d'integ de face d'éléments
// -> les pti d'arête d'éléments
Tableau <List_io <int> > tab_num_A_element; // liste des éléments à visualiser
Tableau <List_io <int> > tab_num_A; // liste des num d'arêtes d'éléments à visualiser
Tableau <List_io <int> > tab_num_A_integ; // liste des numéros de point d'integration à visualiser associé à tab_num_A_element
Tableau <List_io <BlocScal> > nomDeRef_A_E; // list de nom de références d'arête d'éléments associé
Tableau <List_io <string> > nomDeRef_A_ptinteg; // list de nom de références de pt d'integ d'arête d'éléments
*/
// CONSTRUCTEURS :
// par defaut
Choix_grandeurs_maple::Choix_grandeurs_maple () :
OrdreVisu("...................................choix grandeurs" // de 15 à 65
,"choix des grandeurs a visualiser","cg")
,tabnoeud_type_ddl(),tabnoeud_type_ddl_retenu(),type_sortie_ddl_retenue(0)
,tabnoeud_type_ddlEtendu(),tabnoeud_type_ddlEtendu_retenu()
,tabnoeud_TypeQuelconque(),tabnoeud_TypeQuelconque_retenu()
,lesMail(NULL),lesRef(NULL),nomDeRef(),nomDeRef_E(),nomDeRef_ptinteg()
// -> les pti de face d'éléments
,tab_num_F_element(),tab_num_F(),tab_num_F_integ()
,nomDeRef_F_E(),nomDeRef_F_ptinteg()
,tab_F_element_TypeQuelconque(),tab_F_element_TypeQuelconque_retenu()
// -> les pti d'arête d'éléments
,tab_num_A_element(),tab_num_A(),tab_num_A_integ()
,nomDeRef_A_E(),nomDeRef_A_ptinteg()
,tab_A_element_TypeQuelconque(),tab_A_element_TypeQuelconque_retenu()
,tabelement_type_ddl(),tabelement_type_ddl_retenu()
,tabelement_typeParti(),tabelement_typeParti_retenu()
,tabelement_evoluee(),tabelement_evoluee_retenu()
,tab_num_noeud(),tab_num_element(),tab_num_integ()
,list_grandeur_global(),list_grand_global_retenu()
,listeVecGlobbal(),listeVecGlobbal_retenu()
,tab_list_torseur_condLim(),tab_list_torseur_condLim_retenu()
,x1(),x2(),accroi_x1(false),accroi_x2(true),type_xi(true)
,xx1(),xx2(),ddl_etpas_TQ_1(1),ddl_etpas_TQ_2(1),nb_ordre_1(1),nb_ordre_2(1)
,animation_maple(NULL),choix_mail(NULL),style_de_sortie(1)
,der_numero_mail(0),absolue(false)
// --- pour les sorties concernant les sommes et moyennes etc. relativement à des références
,tab_nomDeRef_SM(),tab_nomDeRef_E_SM(),tab_nomDeRef_ptinteg_SM() // noeuds et éléments
,tab_nomDeRef_F_E_SM(),tab_nomDeRef_F_ptinteg_SM() // faces d'éléments
,tab_nomDeRef_A_E_SM(),tab_nomDeRef_A_ptinteg_SM() // arêtes d'éléments
,tabnoeud_type_ddl_retenu_pourSM()
,tabnoeud_type_ddlEtendu_retenu_pourSM(),tabnoeud_TypeQuelconque_retenu_pourSM()
,tabelement_type_ddl_retenu_pourSM(),tabelement_typeParti_retenu_pourSM()
,tabelement_evoluee_retenu_pourSM()
,tab_F_element_TypeQuelconque_retenu_pourSM() // face d'éléments
,tab_A_element_TypeQuelconque_retenu_pourSM() // arêtes d'éléments
{if (ParaGlob::Anglais())
OrdreVisu::changeLibelle("..............................choice of quantities" // de 15 à 65
," choice of the quantities for visualisation ","cg");
};
// constructeur de copie
Choix_grandeurs_maple::Choix_grandeurs_maple (const Choix_grandeurs_maple& ord) :
OrdreVisu(ord)
,tabnoeud_type_ddl(ord.tabnoeud_type_ddl)
,tabnoeud_type_ddl_retenu(ord.tabnoeud_type_ddl_retenu)
,type_sortie_ddl_retenue(ord.type_sortie_ddl_retenue)
,tabnoeud_type_ddlEtendu(ord.tabnoeud_type_ddlEtendu)
,tabnoeud_type_ddlEtendu_retenu(ord.tabnoeud_type_ddlEtendu_retenu)
,tabnoeud_TypeQuelconque(ord.tabnoeud_TypeQuelconque)
,tabnoeud_TypeQuelconque_retenu(ord.tabnoeud_TypeQuelconque_retenu)
,lesMail(ord.lesMail),lesRef(ord.lesRef),nomDeRef(ord.nomDeRef)
,nomDeRef_E(ord.nomDeRef_E),nomDeRef_ptinteg(ord.nomDeRef_ptinteg)
// -> les pti de face d'éléments
,tab_num_F_element(ord.tab_num_F_element)
,tab_num_F(ord.tab_num_F),tab_num_F_integ(ord.tab_num_F_integ)
,nomDeRef_F_E(ord.nomDeRef_F_E),nomDeRef_F_ptinteg(ord.nomDeRef_F_ptinteg)
,tab_F_element_TypeQuelconque(ord.tab_F_element_TypeQuelconque)
,tab_F_element_TypeQuelconque_retenu(ord.tab_F_element_TypeQuelconque_retenu)
// -> les pti d'arête d'éléments
,tab_num_A_element(ord.tab_num_A_element)
,tab_num_A(ord.tab_num_A),tab_num_A_integ(ord.tab_num_A_integ)
,nomDeRef_A_E(ord.nomDeRef_A_E),nomDeRef_A_ptinteg(ord.nomDeRef_A_ptinteg)
,tab_A_element_TypeQuelconque(ord.tab_A_element_TypeQuelconque)
,tab_A_element_TypeQuelconque_retenu(ord.tab_A_element_TypeQuelconque_retenu)
,tabelement_type_ddl(ord.tabelement_type_ddl)
,tabelement_type_ddl_retenu(ord.tabelement_type_ddl_retenu)
,tabelement_typeParti(ord.tabelement_typeParti)
,tabelement_typeParti_retenu(ord.tabelement_typeParti_retenu)
,tabelement_evoluee(ord.tabelement_evoluee)
,tabelement_evoluee_retenu(ord.tabelement_evoluee_retenu)
,tab_num_noeud(ord.tab_num_noeud),tab_num_element(ord.tab_num_element)
,tab_num_integ(ord.tab_num_integ)
,list_grandeur_global(ord.list_grandeur_global)
,list_grand_global_retenu(ord.list_grand_global_retenu)
,listeVecGlobbal(ord.listeVecGlobbal),listeVecGlobbal_retenu(ord.listeVecGlobbal_retenu)
,tab_list_torseur_condLim(ord.tab_list_torseur_condLim)
,tab_list_torseur_condLim_retenu(ord.tab_list_torseur_condLim_retenu)
,x1(ord.x1),x2(ord.x2),accroi_x1(ord.accroi_x1),accroi_x2(ord.accroi_x2)
,type_xi(ord.type_xi)
,xx1(ord.xx1),xx2(ord.xx2),ddl_etpas_TQ_1(ord.ddl_etpas_TQ_1),ddl_etpas_TQ_2(ord.ddl_etpas_TQ_2)
,nb_ordre_1(ord.nb_ordre_1),nb_ordre_2(ord.nb_ordre_2)
,animation_maple(ord.animation_maple),choix_mail(ord.choix_mail),style_de_sortie(ord.style_de_sortie)
,der_numero_mail(ord.der_numero_mail),absolue(ord.absolue)
// --- pour les sorties concernant les sommes et moyennes etc. relativement à des références
,tab_nomDeRef_SM(ord.tab_nomDeRef_SM)
,tab_nomDeRef_E_SM(ord.tab_nomDeRef_E_SM)
,tab_nomDeRef_ptinteg_SM(ord.tab_nomDeRef_ptinteg_SM)
,tab_nomDeRef_F_E_SM(ord.tab_nomDeRef_F_E_SM) // faces d'éléments
,tab_nomDeRef_F_ptinteg_SM(ord.tab_nomDeRef_F_ptinteg_SM) // faces d'éléments
,tab_nomDeRef_A_E_SM(ord.tab_nomDeRef_A_E_SM) // arêtes d'éléments
,tab_nomDeRef_A_ptinteg_SM(ord.tab_nomDeRef_A_ptinteg_SM) // arêtes d'éléments
,tabnoeud_type_ddl_retenu_pourSM(ord.tabnoeud_type_ddl_retenu_pourSM)
,tabnoeud_type_ddlEtendu_retenu_pourSM(ord.tabnoeud_type_ddlEtendu_retenu_pourSM)
,tabnoeud_TypeQuelconque_retenu_pourSM(ord.tabnoeud_TypeQuelconque_retenu_pourSM)
,tabelement_type_ddl_retenu_pourSM(ord.tabelement_type_ddl_retenu_pourSM)
,tabelement_typeParti_retenu_pourSM(ord.tabelement_typeParti_retenu_pourSM)
,tabelement_evoluee_retenu_pourSM(ord.tabelement_evoluee_retenu_pourSM)
,tab_F_element_TypeQuelconque_retenu_pourSM(ord.tab_F_element_TypeQuelconque_retenu_pourSM) // face d'éléments
,tab_A_element_TypeQuelconque_retenu_pourSM(ord.tab_A_element_TypeQuelconque_retenu_pourSM) // arêtes d'éléments
{};
// DESTRUCTEUR :
Choix_grandeurs_maple::~Choix_grandeurs_maple ()
{};
// METHODES PUBLIQUES :
// initialisation : permet d'initialiser les différents paramètres de l'ordre
// lors d'un premier passage des différents incréments
// en virtuelle, a priori est défini si nécessaire dans les classes dérivées
void Choix_grandeurs_maple::Initialisation(ParaGlob * paraGlob,LesMaillages * lesmail,LesReferences* lesRefer
,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)
{
// récupération de la liste des vecteurs globaux
listeVecGlobbal = listeVecGlob;
// initialisation de la liste des différentes isovaleurs possibles
Init_liste_grandeurs(lesmail,lesCondLim,lesContacts,fil_calcul);
// récup de l'adresse des maillages
lesMail = lesmail;
// récup de la liste de référence
lesRef = lesRefer;
//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);
// récupération de la liste des grandeurs globales
map < string, const double * , std::less <string> >::const_iterator il,ilfin= listeVarGlob.end();
for (il=listeVarGlob.begin();il != ilfin; il++)
{ // on rempli si ce n'est pas déjà présent
if (find(list_grandeur_global.begin(),list_grandeur_global.end(),(*il).first) == list_grandeur_global.end())
list_grandeur_global.push_back((*il).first);
};
// récupération de la liste des torseurs de réaction
tab_list_torseur_condLim = lesCondLim->TabListTorseurReaction(*lesmail);
// on redimensionne la liste de sortie au cas où
tab_list_torseur_condLim_retenu.Change_taille(tab_list_torseur_condLim.Taille());
// init par defaut
Ddl_enum_etendu x; x1 = x; x2 = x; accroi_x1 = false; accroi_x2 = true; type_xi = true;
};
// 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 Choix_grandeurs_maple::ExeOrdre(ParaGlob * ,const Tableau <int>& tab_mail ,LesMaillages * lesMail,bool unseul_incre,LesReferences*
,LesLoisDeComp* ,DiversStockage*,Charge* charge,LesCondLim* lesCondLim
,LesContacts* lesContacts,Resultats*,UtilLecture & entreePrinc,OrdreVisu::EnumTypeIncre type_incre ,int
,bool animation,const map < string,const double * , std::less <string> >& listeVarGlob
,const List_io < TypeQuelconque >& listeVecGlob)
{// pour simplifier
int nbdigit = ParaGlob::NbdigdoGR();
int nbmail = tab_mail.Taille();
int dima = ParaGlob::Dimension();
// visualisation du maillage pointé si actif
if ((actif) && animation)
{// dans le cas d'une animation, il n'y a pas de sortie directe mais la création de listes qui sont transmises
// à animation_maple
for (int i=1;i<=nbmail;i++)
Construction_liste_pour_animation(tab_mail(i),lesMail,charge);
return;
}
else if (actif)
{ // cas du premier passage , pour les contacts on définit aux noeuds les conteneurs ad hoc
// 14 oct 2016 je commente la suite car je ne sais pas si c'est ici ou dans initialisation qu'il faut
// intervenir (cf. pense bête)
// if (type_incre == PREMIER_INCRE)
// { // initialisation de la liste de grandeurs qui sont effectivement gérées par le contact
// List_io<TypeQuelconque> list_gere_par_lesContacts
// = lesContacts->Init_list_grandeur_contact_a_sortir(tabnoeud_TypeQuelconque_retenu);
// // maintenant on ajoute les conteneurs ah hoc
// List_io < Ddl_enum_etendu > vide; // ne sert à rien ici car vide
// Tableau <List_io < TypeQuelconque > * > tabQ(2); // tableau transitoire
// tabQ(1) = &list_gere_par_lesContacts; tabQ(2)= NULL; // init
// lesMail->AjoutConteneurAuNoeud(vide,tabQ);
// };
ostream &sort = entreePrinc.Sort_princ_maple();
// on statue que les sorties seront de type affichage scientifique
sort.setf(ios::scientific);
// on balaie la liste des grandeurs a visualiser, toutes les données sont sur une même ligne
// sauf s'il y a un seul incrément
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// --- tout d'abord les grandeurs globales
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
if (list_grand_global_retenu.size() != 0)
{ List_io <string>::iterator jeint,jeintfin = list_grand_global_retenu.end();
sort << setprecision(nbdigit) << charge->Temps_courant() << " "; // le temps courant donc à tdt
for (jeint=list_grand_global_retenu.begin();jeint!=jeintfin;jeint++)
{ // récup de la grandeur
map < string,const double * , std::less <string> >::const_iterator jei = listeVarGlob.find(*jeint);
if (jei != listeVarGlob.end())
{sort << setprecision(nbdigit) << (*((*jei).second)) << " ";}
else
{// on essaie alors au niveau des adressages directement avec un string
const void * pointe = ParaGlob::param->GrandeurGlobal(*jeint);
// si cela n'a pas fonctionné on essaie avec l'énuméré
if ((pointe == NULL)
&& EstUneGrandeurGlobale(*jeint)
)
pointe = ParaGlob::param->GrandeurGlobal(Id_nom_GrandeurGlobale(*jeint) );
if (pointe != NULL)
{TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
switch(gr_quelc->Grandeur_pointee()->Type_structure_grandeurAssocie())
{ case TYPE_SIMPLE:
{ switch(gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere())
{case PARTICULIER_SCALAIRE_ENTIER:
{Grandeur_scalaire_entier& gr
= *((Grandeur_scalaire_entier*) gr_quelc->Grandeur_pointee()); // pour simplifier
sort << setprecision(nbdigit) << *(gr.ConteneurEntier())<< " ";
break;
}
case PARTICULIER_SCALAIRE_DOUBLE:
{Grandeur_scalaire_double& gr
= *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
sort << setprecision(nbdigit) << *(gr.ConteneurDouble())<< " ";
break;
}
case PARTICULIER_DDL_ETENDU:
{Grandeur_Ddl_etendu& gr
= *((Grandeur_Ddl_etendu*) gr_quelc->Grandeur_pointee()); // pour simplifier
sort << setprecision(nbdigit) << (gr.GrandeurNumOrdre(1))<< " ";
break;
}
case PARTICULIER_VECTEUR_NOMMER:
{Grandeur_Vecteur_Nommer& gr
= *((Grandeur_Vecteur_Nommer*) gr_quelc->Grandeur_pointee()); // pour simplifier
Vecteur& V = gr.ConteneurVecteur();
int taille = V.Taille();
for (int i=1;i<=taille;i++)
sort << setprecision(nbdigit) << V(i)<< " ";
break;
}
case PARTICULIER_VECTEUR:
{Grandeur_Vecteur& gr
= *((Grandeur_Vecteur*) gr_quelc->Grandeur_pointee()); // pour simplifier
Vecteur* V = gr.ConteneurVecteur();
int taille = V->Taille();
for (int i=1;i<=taille;i++)
sort << setprecision(nbdigit) << (*V)(i)<< " ";
break;
}
default:
{cout << "\n erreur en sortant la grandeur globale: " << (*jeint) << " on met 0 a la place ";}
}
break;
}
default:
{cout << "\n erreur en sortant la grandeur globale: " << (*jeint) << " on met 0 a la place ";};
};
}
else
{if (ParaGlob::Francais())
{cout << "\n erreur en sortant la grandeur globale: " << (*jeint) << " on met 0 a la place ";}
else {cout << "\n error for outputting the global quantity : " << (*jeint) << " the output will be 0 ";};
sort << setprecision(nbdigit) << 0. << " ";
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n Choix_grandeurs_maple::ExeOrdre(....)";
};
};
};
}; //-- fin des grandeurs globales
// --- puis les torseurs de reaction
int nb_maillage = tab_list_torseur_condLim_retenu.Taille();
for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
{ // pour simplifier
List_io <String_et_entier >& list_torseur_condLim_retenu = tab_list_torseur_condLim_retenu(n_mail);
// écriture du temps que si il y a des torseurs et que l'on n'est pas avec un seul incrément
// sinon on écrit le temps également en commentaire
// à moins que le style de sortie force une sortie sur une seule ligne
if ((list_torseur_condLim_retenu.size() != 0) && ((!unseul_incre) || (style_de_sortie==1)))
{ sort << setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
else if (list_torseur_condLim_retenu.size() != 0)
// ici on écrit une fois le temps en commentaire
{ sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
// maintenant on sort les torseurs
List_io <String_et_entier>::iterator jfint,jfintfin = list_torseur_condLim_retenu.end();
for (jfint=list_torseur_condLim_retenu.begin();jfint!=jfintfin;jfint++)
{ int indice = (*jfint).n;
lesCondLim->Torseur_de_reaction(indice).resultante.Affiche(sort,nbdigit);
int dim = dima;
// dans le cas axi c'est comme en 2D pour les torseurs
if (ParaGlob::AxiSymetrie()) dim--;
switch (dim)
{ case 1: break; // pas de moment en dimension 1
case 2: sort << setprecision(nbdigit) // la première composante est le moment
<< lesCondLim->Torseur_de_reaction(indice).moment(1) << " ";
break;
case 3: lesCondLim->Torseur_de_reaction(indice).moment.Affiche(sort,nbdigit);
break;
};
// s'il n'y a qu'un seul incrément on met un retour à la ligne
if ((unseul_incre) && (style_de_sortie==0)) sort << "\n";
};
};
// --- puis les grandeurs sommes, moyennes, maxi etc.
// sortie pour les ref N
Sortie_somme_moy_N(sort,charge,unseul_incre);
// sortie pour les ref E
Sortie_somme_moy_E(sort,charge,unseul_incre);
// sortie pour les ref de face E
Sortie_somme_moy_face_E(sort,charge,unseul_incre);
// sortie pour les ref d'arete E
Sortie_somme_moy_arete_E(sort,charge,unseul_incre);
// --- puis les grandeurs aux noeuds
nb_maillage = tabnoeud_type_ddl.Taille();
for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
{List_io<int>::iterator inoeud,inoeudfin=tab_num_noeud(n_mail).end();
// on crée une liste intermédiaire qui contient tous les noeuds à sortir,
List_io <int> tab_total_noeud = tab_num_noeud(n_mail); // tout d'abord récup de la liste de noeuds
// puis les références de listes de noeuds
List_io <string >::iterator idl,idlfin= nomDeRef(n_mail).end();
for (idl=nomDeRef(n_mail).begin();idl!=idlfin;idl++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve(*idl,n_mail);
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref de noeud
int taillen=reff.Taille();
for (int inoeu=1;inoeu<=taillen;inoeu++) // on boucle et enregistre les noeuds
tab_total_noeud.push_back(reff.Numero(inoeu));
};
inoeudfin=tab_total_noeud.end();
// écriture du temps que si il y a des noeuds et que l'on n'est pas avec un seul incrément
// sinon on écrit le temps également en commentaire
// à moins que le style de sortie force une sortie sur une seule ligne
if ((tab_total_noeud.begin() != inoeudfin) && ((!unseul_incre) || (style_de_sortie==1)))
{ sort << setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
else if (tab_total_noeud.begin() != inoeudfin)
// ici on écrit une fois le temps en commentaire
{ sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
// maintenant on affiche les infos pour la liste totale de noeuds
for (inoeud = tab_total_noeud.begin();inoeud!=inoeudfin;inoeud++)
{ Noeud& noe=lesMail->Noeud_LesMaille(n_mail,*inoeud);
Coordonnee ncor = noe.Coord0(); // par défaut dans le cas où les coordonnées à t n'existent pas
if (noe.ExisteCoord2()) { ncor = noe.Coord2() ;} // cas normal: coordonnées du noeud à tdt
else if (noe.ExisteCoord1()) { ncor = noe.Coord1() ;}; // cas les coordonnées à tdt n'existent pas mais que celles à t existent
for (int ic=1;ic<=ncor.Dimension();ic++) sort << setprecision(nbdigit) << ncor(ic) << " ";
// .... sortie des ddl principaux .....
{List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabnoeud_type_ddl_retenu(n_mail).end();
//debug
//if ((*inoeud)==1)
// noe.Affiche();
//fin debug
switch(type_sortie_ddl_retenue)
{ case 0: // cas où on ne sort que la grandeur
for (ienu = tabnoeud_type_ddl_retenu(n_mail).begin();ienu!=ienufin;ienu++)
{ bool asortir = true; double val_a_sortir=0.;
if (!noe.Existe_ici((*ienu).Enum()))
{ asortir=false;
#ifdef MISE_AU_POINT // on regarde si la grandeur existe
if (ParaGlob::NiveauImpression() >= 2)
{if (ParaGlob::Francais())
{cout << "\n attention la grandeur " << (*ienu).Nom_plein() << " n'est pas disponible, on met 0 a la place";}
else
{cout << "\n Warning the quantity " << (*ienu).Nom_plein() << " is not available, the output will be 0 ";};
};
#endif
};
if (asortir) // puis la valeur finale de la grandeur
{ if (charge->Temps_courant() == 0.) {val_a_sortir = noe.Valeur_0((*ienu).Enum());}
else if (noe.Tdt()) {val_a_sortir = noe.Valeur_tdt((*ienu).Enum());}
else {val_a_sortir = noe.Valeur_t((*ienu).Enum());};
};
sort << setprecision(nbdigit) << val_a_sortir << " ";
};
break;
case 1: // cas où on ne sort que la variation de la grandeur entre 0 et tdt ou t
for (ienu = tabnoeud_type_ddl_retenu(n_mail).begin();ienu!=ienufin;ienu++)
{ bool asortir = true; double val_a_sortir=0.;
if (!noe.Existe_ici((*ienu).Enum()))
{ asortir=false;
#ifdef MISE_AU_POINT // on regarde si la grandeur existe
if (ParaGlob::NiveauImpression() >= 2)
{if (ParaGlob::Francais())
{cout << "\n attention la grandeur " << (*ienu).Nom_plein() << " n'est pas disponible, on met 0 a la place";}
else
{cout << "\n Warning the quantity " << (*ienu).Nom_plein() << " is not available, the output will be 0 ";};
};
#endif
};
if (asortir) // puis la valeur finale de la grandeur
{ if (charge->Temps_courant() == 0.) {val_a_sortir = 0.;}
else if (noe.Tdt()) {val_a_sortir = noe.Valeur_tdt((*ienu).Enum())-noe.Valeur_0((*ienu).Enum());}
else {val_a_sortir = noe.Valeur_t((*ienu).Enum())-noe.Valeur_0((*ienu).Enum());};
};
sort << setprecision(nbdigit) << val_a_sortir << " ";
};
break;
case 2: // cas où on sort les grandeurs à 0 et à tdt ou t
for (ienu = tabnoeud_type_ddl_retenu(n_mail).begin();ienu!=ienufin;ienu++)
{ bool asortir = true; double val_a_sortir=0.;double val_init=0.;
if (!noe.Existe_ici((*ienu).Enum()))
{ asortir=false;
#ifdef MISE_AU_POINT // on regarde si la grandeur existe
if (ParaGlob::Francais())
{cout << "\n attention la grandeur " << (*ienu).Nom_plein() << " n'est pas disponible, on met 0 a la place";}
else
{cout << "\n Warning the quantity " << (*ienu).Nom_plein() << " is not available, the output will be 0 ";};
#endif
}
if (asortir) // puis la valeur finale de la grandeur
{ if (charge->Temps_courant() == 0.)
{val_init = val_a_sortir = noe.Valeur_0((*ienu).Enum());}
else if (noe.Tdt())
{val_a_sortir = noe.Valeur_tdt((*ienu).Enum());
val_init = noe.Valeur_0((*ienu).Enum());}
else
{val_a_sortir = noe.Valeur_t((*ienu).Enum());
val_init = noe.Valeur_0((*ienu).Enum());};
};
sort << setprecision(nbdigit) << val_init << " "<< val_a_sortir << " ";
};
break;
}; // fin du switch sur type_sortie_ddl_retenue
};
// .... sortie des ddl étendus .....
{List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabnoeud_type_ddlEtendu_retenu(n_mail).end();
for (ienu = tabnoeud_type_ddlEtendu_retenu(n_mail).begin();ienu!=ienufin;ienu++)
{double val_a_sortir=0.;
#ifdef MISE_AU_POINT // on regarde si la grandeur existe
if (!noe.Existe_ici_ddlEtendu((*ienu)))
{ if (ParaGlob::NiveauImpression() >= 2)
{if (ParaGlob::Francais())
{cout << "\n attention la grandeur " << (*ienu).Nom_plein() << " n'est pas disponible, on met 0 a la place";}
else
{cout << "\n Warning the quantity " << (*ienu).Nom_plein() << " is not available, the output will be 0 ";};
};
}
#endif
if (noe.Existe_ici_ddlEtendu((*ienu))) {val_a_sortir = noe.DdlEtendue(*ienu).ConstValeur();}
sort << setprecision(nbdigit) << val_a_sortir << " ";
};
};
// .... sortie des grandeurs quelconque aux noeud .....
{List_io<TypeQuelconque>::iterator ienu,ienufin=tabnoeud_TypeQuelconque_retenu(n_mail).end();
for (ienu = tabnoeud_TypeQuelconque_retenu(n_mail).begin();ienu!=ienufin;ienu++)
{ // récup de l'énuméré
TypeQuelconque_enum_etendu enuq = (*ienu).EnuTypeQuelconque();
#ifdef MISE_AU_POINT // on regarde si la grandeur existe
if (!noe.Existe_ici(enuq))
{ if (ParaGlob::NiveauImpression() >= 2)
{if (ParaGlob::Francais())
{cout << "\n attention la grandeur " << (enuq.NomPlein()) << " n'est pas disponible, on met 0 a la place";}
else
{cout << "\n Warning the quantity " << (enuq.NomPlein()) << " is not available, the output will be 0 ";};
};
}
#endif
if (noe.Existe_ici(enuq))
{ const TypeQuelconque& grand_quelconque_noe = noe.Grandeur_quelconque(enuq);
grand_quelconque_noe.Grandeur_brut(sort,ParaGlob::NbdigdoGR());
}
else
{// dans le cas où la grandeur n'existe pas on sort des 0
int nb_val = (*ienu).NbMaxiNumeroOrdre();
for (int j=1;j<= nb_val;j++)
sort << " 0 ";
};
};
};
// s'il n'y a qu'un seul incrément on met un retour à la ligne
if ((unseul_incre) && (style_de_sortie==0)) sort << "\n";
};
};
// --- puis les grandeurs aux éléments
nb_maillage = tabelement_type_ddl.Taille();
for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
{ List_io<int>::iterator ielement,ielementfin=tab_num_element(n_mail).end();
// on crée une liste intermédiaire qui contient tous les éléments et point d'integ à sortir,
List_io <int> tab_total_elem = tab_num_element(n_mail); // tout d'abord récup de la liste des éléments
List_io <int> tab_total_ptint = tab_num_integ(n_mail); // et les points d'intégration correspondant
// puis les références de listes d'éléments
{List_io <BlocScal>::iterator idl,idlfin= nomDeRef_E(n_mail).end();
for (idl=nomDeRef_E(n_mail).begin();idl!=idlfin;idl++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*idl).NomRef(),n_mail);
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'éléments
int taillen=reff.Taille(); // nombre d'éléments dans la liste
for (int ielem=1;ielem<=taillen;ielem++) // on boucle et enregistre les elements et le point
{ tab_total_elem.push_back(reff.Numero(ielem)); // d'intégration
tab_total_ptint.push_back((int) ((*idl).Val())); // associé (le même pour toute la référence)
};
};
}; // encapsulé
// ---- puis les références de listes de points d'intégration d'éléments
{
{List_io <string>::iterator ids,idsfin= nomDeRef_ptinteg(n_mail).end();
for (ids=nomDeRef_ptinteg(n_mail).begin();ids!=idsfin;ids++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*ids),n_mail);
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de pt d'integ
int taillen=reff.Taille(); // nombre d'éléments dans la liste
for (int ielem=1;ielem<=taillen;ielem++) // on boucle et enregistre les elements et le point
{ tab_total_elem.push_back(reff.NumeroElem(ielem)); // d'intégration
tab_total_ptint.push_back(reff.NumeroFA(ielem)); // associé (le même pour toute la référence)
};
};
}; // encapsulé
ielementfin=tab_total_elem.end();
// écriture du temps que s 'il y a des éléments et que l'on n'est pas avec un seul incrément
// sinon on écrit le temps également en commentaire
// à moins que le style de sortie force une sortie sur une seule ligne
if ((tab_total_elem.begin() != ielementfin) && ((!unseul_incre) || (style_de_sortie==1)))
{sort << setw(3) // minimum sur 3 caractères
<< setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
else if (tab_total_elem.begin() != ielementfin)
// ici on écrit une fois le temps en commentaire
{sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
// maintenant on affiche les infos pour la liste totale d'éléments
// cout << " \n liste de pt integ " << tab_total_ptint; // pour le débug
List_io <int>::iterator iptinteg = tab_total_ptint.begin();
for (ielement = tab_total_elem.begin();ielement!=ielementfin;ielement++,iptinteg++)
{ // a) on s'occupe des Ddl_enum_etendu
List_io<Ddl_enum_etendu>::iterator ienufin=tabelement_type_ddl_retenu(n_mail).end();
List_io<Ddl_enum_etendu>::iterator ienu_deb=tabelement_type_ddl_retenu(n_mail).begin();
if (ienu_deb != ienufin) // c'est a dire: cas où existe une grandeur
{ // coordonnées du point d'integ où sont données les grandeurs, systématiquement à tdt
bool erreur=false; // ici on n'en tiend pas compte car déjà testé
Coordonnee ncor = lesMail->Element_LesMaille(n_mail,*ielement).CoordPtInteg(TEMPS_tdt,(*ienu_deb).Enum(),*iptinteg,erreur);
for (int ic=1;ic<=ncor.Dimension();ic++) sort << setprecision(nbdigit) << ncor(ic) << " ";
// puis les grandeurs
Tableau <double> tab=
lesMail->Element_LesMaille(n_mail,*ielement).Valeur_a_diff_temps(absolue,TEMPS_tdt,tabelement_type_ddl_retenu(n_mail),*iptinteg);
int tabtaille = tab.Taille();
for (int k=1;k<= tabtaille;k++)
sort << setprecision(nbdigit) << (double) tab(k) << " ";
};
// b) on s'occupe des données particulières de type quelconque
List_io<TypeQuelconque>::iterator iquefin=tabelement_typeParti_retenu(n_mail).end();
List_io<TypeQuelconque>::iterator ique,ique_deb=tabelement_typeParti_retenu(n_mail).begin();
if (ique_deb != iquefin) // c'est a dire: cas où existe une grandeur
{ // coordonnées du point d'integ où sont données les grandeurs, systématiquement à tdt
bool erreur=false; // ici on n'en tiend pas compte car déjà testé
Coordonnee ncor = lesMail->Element_LesMaille(n_mail,*ielement).CoordPtInteg(TEMPS_tdt,(*ique_deb).Enum(),*iptinteg,erreur);
for (int ic=1;ic<=ncor.Dimension();ic++)
sort << setw(nbdigit) << setprecision(nbdigit) << ncor(ic) << " ";
// puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
lesMail->Element_LesMaille(n_mail,*ielement).Grandeur_particuliere(absolue,tabelement_typeParti_retenu(n_mail),*iptinteg);
// sortie
for (ique=ique_deb;ique!=iquefin;ique++) (*ique).Grandeur_brut(sort,ParaGlob::NbdigdoGR());
};
// c) on s'occupe des données évoluées de type quelconque
List_io<TypeQuelconque>::iterator jquefin=tabelement_evoluee_retenu(n_mail).end();
List_io<TypeQuelconque>::iterator jque,jque_deb=tabelement_evoluee_retenu(n_mail).begin();
if (jque_deb != jquefin) // c'est a dire: cas où existe une grandeur
{ // coordonnées du point d'integ où sont données les grandeurs, systématiquement à tdt
bool erreur=false; // ici on n'en tiend pas compte car déjà testé
Coordonnee ncor = lesMail->Element_LesMaille(n_mail,*ielement).CoordPtInteg(TEMPS_tdt,(*jque_deb).Enum(),*iptinteg,erreur);
for (int ic=1;ic<=ncor.Dimension();ic++)
sort << setw(nbdigit) << setprecision(nbdigit) << ncor(ic) << " ";
// puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
lesMail->Element_LesMaille(n_mail,*ielement).ValTensorielle_a_diff_temps
(absolue,TEMPS_tdt,tabelement_evoluee_retenu(n_mail),*iptinteg);
// sortie
for (jque=jque_deb;jque!=jquefin;jque++) (*jque).Grandeur_brut(sort,ParaGlob::NbdigdoGR());
};
// s'il n'y a qu'un seul incrément on met un retour à la ligne
if ((unseul_incre) && (style_de_sortie==0)) sort << "\n";
};
};
};
// --- puis les grandeurs aux faces d'éléments
nb_maillage = tab_F_element_TypeQuelconque.Taille();
for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
{ List_io<int>::iterator ielement,ielementfin=tab_num_F_element(n_mail).end();
// on crée une liste intermédiaire qui contient toutes les faces éléments et point d'integ à sortir,
List_io <int> tab_total_elem = tab_num_F_element(n_mail); // tout d'abord récup de la liste des éléments
List_io <int> tab_total_face = tab_num_F(n_mail); // les numéros de face
List_io <int> tab_total_ptint = tab_num_F_integ(n_mail); // et les points d'intégration correspondant
// puis les références de listes de faces d'élément
{List_io <BlocScal>::iterator idl,idlfin= nomDeRef_F_E(n_mail).end();
for (idl=nomDeRef_F_E(n_mail).begin();idl!=idlfin;idl++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*idl).NomRef(),n_mail);
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de faces d'élément
int taillen=reff.Taille(); // nombre d'éléments dans la liste
for (int ielem=1;ielem<=taillen;ielem++) // on boucle et enregistre les elements, face et le point
{ tab_total_elem.push_back(reff.NumeroElem(ielem)); // d'intégration
tab_total_face.push_back(reff.NumeroFA(ielem));
tab_total_ptint.push_back((int) ((*idl).Val())); // associé (le même pour toute la référence)
};
};
};
// ---- puis les références de listes de points d'intégration de faces d'élément
{List_io <string>::iterator ids,idsfin= nomDeRef_F_ptinteg(n_mail).end();
for (ids=nomDeRef_F_ptinteg(n_mail).begin();ids!=idsfin;ids++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*ids),n_mail);
const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref de pt d'integ
int taillen=reff.Taille(); // nombre faces d'élément dans la liste
for (int ielem=1;ielem<=taillen;ielem++) // on boucle et enregistre les
{ tab_total_elem.push_back(reff.NumeroElem(ielem)); // éléments
tab_total_face.push_back(reff.NumeroFA(ielem)); // faces
tab_total_ptint.push_back(reff.NumeroPti(ielem)); // ptis associés (le même pour toute la référence)
};
};
}; // encapsulé
ielementfin=tab_total_elem.end();
// écriture du temps que s 'il y a des éléments et que l'on n'est pas avec un seul incrément
// sinon on écrit le temps également en commentaire
// à moins que le style de sortie force une sortie sur une seule ligne
if ((tab_total_elem.begin() != ielementfin) && ((!unseul_incre) || (style_de_sortie==1)))
{sort << setw(3) // minimum sur 3 caractères
<< setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
else if (tab_total_elem.begin() != ielementfin)
// ici on écrit une fois le temps en commentaire
{sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
// maintenant on affiche les infos pour la liste totale d'éléments
// cout << " \n liste de pt integ " << tab_total_ptint; // pour le débug
List_io <int>::iterator iptinteg = tab_total_ptint.begin();
List_io <int>::iterator iptface = tab_total_face.begin();
for (ielement = tab_total_elem.begin();ielement!=ielementfin;ielement++,iptinteg++,iptface++)
{ // on s'occupe des données de type quelconque
List_io<TypeQuelconque>::iterator iquefin=tab_F_element_TypeQuelconque_retenu(n_mail).end();
List_io<TypeQuelconque>::iterator ique,ique_deb=tab_F_element_TypeQuelconque_retenu(n_mail).begin();
if (ique_deb != iquefin) // c'est a dire: cas où existe une grandeur
{ // coordonnées du point d'integ où sont données les grandeurs, systématiquement à tdt
bool erreur=false;
Coordonnee ncor = lesMail->Element_LesMaille(n_mail,*ielement).CoordPtIntFace(*iptface,TEMPS_tdt,*iptinteg,erreur);
#ifdef MISE_AU_POINT
if ((ParaGlob::NiveauImpression() > 0)&& erreur)
{ cout << "\n *** attention, les coordonnees du pti " << *iptinteg << " de la face " << *iptface
<< " de l'element " << *ielement << " du maillage " << n_mail
<< " n'est pas disponible "
<< " peut etre que la face n'est pas utilisee ?? "<< endl;
}
#endif
for (int ic=1;ic<=ncor.Dimension();ic++)
sort << setw(nbdigit) << setprecision(nbdigit) << ncor(ic) << " ";
// puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
lesMail->Element_LesMaille(n_mail,*ielement).Grandeur_particuliere_face(absolue,tab_F_element_TypeQuelconque_retenu(n_mail),*iptface,*iptinteg);
// sortie
for (ique=ique_deb;ique!=iquefin;ique++) (*ique).Grandeur_brut(sort,ParaGlob::NbdigdoGR());
};
// s'il n'y a qu'un seul incrément on met un retour à la ligne
if ((unseul_incre) && (style_de_sortie==0)) sort << "\n";
};
};
// --- puis les grandeurs aux arêtes d'élément
nb_maillage = tab_A_element_TypeQuelconque.Taille();
for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
{ List_io<int>::iterator ielement,ielementfin=tab_num_A_element(n_mail).end();
// on crée une liste intermédiaire qui contient toutes les arêtes élément et point d'integ à sortir,
List_io <int> tab_total_elem = tab_num_A_element(n_mail); // tout d'abord récup de la liste des éléments
List_io <int> tab_total_arete = tab_num_A(n_mail); // les numéros d'arêtes
List_io <int> tab_total_ptint = tab_num_A_integ(n_mail); // et les points d'intégration correspondant
// puis les références de listes d'arêtes d'élément
{List_io <BlocScal>::iterator idl,idlfin= nomDeRef_A_E(n_mail).end();
for (idl=nomDeRef_A_E(n_mail).begin();idl!=idlfin;idl++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*idl).NomRef(),n_mail);
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'élément
int taillen=reff.Taille(); // nombre d'éléments dans la liste
for (int ielem=1;ielem<=taillen;ielem++) // on boucle et enregistre les elements, arete et le point
{ tab_total_elem.push_back(reff.NumeroElem(ielem)); // d'intégration
tab_total_arete.push_back(reff.NumeroFA(ielem));
tab_total_ptint.push_back((int) ((*idl).Val())); // associé (le même pour toute la référence)
};
};
};
// ---- puis les références de listes de points d'intégration d'arêtes d'élément
{List_io <string>::iterator ids,idsfin= nomDeRef_A_ptinteg(n_mail).end();
for (ids=nomDeRef_A_ptinteg(n_mail).begin();ids!=idsfin;ids++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*ids),n_mail);
const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref de pt d'integ
int taillen=reff.Taille(); // nombre faces d'élément dans la liste
for (int ielem=1;ielem<=taillen;ielem++) // on boucle et enregistre les
{ tab_total_elem.push_back(reff.NumeroElem(ielem)); // éléments
tab_total_arete.push_back(reff.NumeroFA(ielem)); // arêtes
tab_total_ptint.push_back(reff.NumeroPti(ielem)); // ptis associés (le même pour toute la référence)
};
};
}; // encapsulé
ielementfin=tab_total_elem.end();
// écriture du temps que s 'il y a des éléments et que l'on n'est pas avec un seul incrément
// sinon on écrit le temps également en commentaire
// à moins que le style de sortie force une sortie sur une seule ligne
if ((tab_total_elem.begin() != ielementfin) && ((!unseul_incre) || (style_de_sortie==1)))
{sort << setw(3) // minimum sur 3 caractères
<< setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
else if (tab_total_elem.begin() != ielementfin)
// ici on écrit une fois le temps en commentaire
{sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
// maintenant on affiche les infos pour la liste totale d'éléments
// cout << " \n liste de pt integ " << tab_total_ptint; // pour le débug
List_io <int>::iterator iptinteg = tab_total_ptint.begin();
List_io <int>::iterator iptarete = tab_total_arete.begin();
for (ielement = tab_total_elem.begin();ielement!=ielementfin;ielement++,iptinteg++)
{ // on s'occupe des données de type quelconque
List_io<TypeQuelconque>::iterator iquefin=tab_A_element_TypeQuelconque_retenu(n_mail).end();
List_io<TypeQuelconque>::iterator ique,ique_deb=tab_A_element_TypeQuelconque_retenu(n_mail).begin();
if (ique_deb != iquefin) // c'est a dire: cas où existe une grandeur
{ // coordonnées du point d'integ où sont données les grandeurs, systématiquement à tdt
bool erreur=false;
Coordonnee ncor = lesMail->Element_LesMaille(n_mail,*ielement).CoordPtIntArete(*iptarete,TEMPS_tdt,*iptinteg,erreur);
#ifdef MISE_AU_POINT
if ((ParaGlob::NiveauImpression() > 0)&& erreur)
{ cout << "\n *** attention, les coordonnees du pti " << *iptinteg << " de l'arete " << *iptarete
<< " de l'element " << *ielement << " du maillage " << n_mail
<< " n'est pas disponible "
<< " peut etre que l'arete n'est pas utilisee ?? "<< endl;
}
#endif
for (int ic=1;ic<=ncor.Dimension();ic++)
sort << setw(nbdigit) << setprecision(nbdigit) << ncor(ic) << " ";
// puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
lesMail->Element_LesMaille(n_mail,*ielement).Grandeur_particuliere_arete(absolue,tab_A_element_TypeQuelconque_retenu(n_mail),*iptarete,*iptinteg);
// sortie
for (ique=ique_deb;ique!=iquefin;ique++) (*ique).Grandeur_brut(sort,ParaGlob::NbdigdoGR());
};
// s'il n'y a qu'un seul incrément on met un retour à la ligne
if ((unseul_incre) && (style_de_sortie==0)) sort << "\n";
};
};
};
};
// 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 Choix_grandeurs_maple::ChoixOrdre()
{ // demande de précision
mise à jour 7.010
2023-05-03 17:23:49 +02:00
//int dim = ParaGlob::Dimension();
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
bool choix_valide = false;
while (!choix_valide)
{ // premier choix : grandeurs aux noeuds et/ou aux éléments
if (ParaGlob::Francais())
{cout << "\n grandeurs globales -> rep : glo "
<< "\n torseurs de reactions -> rep : tre "
<< "\n moyenne, maxi, mini etc. sur ref N -> rep : smN "
<< "\n moyenne, maxi, mini etc. sur ref E -> rep : smE "
<< "\n moyenne, maxi, mini etc. ref face E -> rep : smFE "
<< "\n moyenne, maxi, mini etc. ref arete E -> rep : smAE "
<< "\n ddl aux noeuds -> rep : noe ?"
<< "\n ddl etendu aux noeuds -> rep : net ?"
<< "\n grandeur particuliere aux noeuds -> rep : nop ?"
<< "\n grandeurs generique aux elements -> rep : ele "
<< "\n grandeurs particulieres aux elements -> rep : elp "
<< "\n grandeurs tensorielles aux elements -> rep : elt "
<< "\n grandeurs aux faces d'elements -> rep : elF "
<< "\n grandeurs aux aretes d'elements -> rep : elA "
<< "\n style de sortie -> rep : sty "
<< "\n pour accepter la valeur par defaut -> rep : o "
<< "\n pour arreter les questions -> rep : fin (ou f) ";
}
else
{cout << "\n global quantities -> rep : glo "
<< "\n reaction wrench -> rep : tre " // on dit aussi screws pour les torseurs en général
<< "\n average, maxi, mini etc. for ref N -> rep : smN "
<< "\n average, maxi, mini etc. for ref E -> rep : smE "
<< "\n average, maxi, mini etc. ref facet E -> rep : smFE "
<< "\n average, maxi, mini etc. ref edge E -> rep : smAE "
<< "\n main dof at nodes (default) -> rep : noe " // mais pour le torseur : force et moment c'est wrench
<< "\n secondary extend dof at nodes -> rep : net "
<< "\n specific dof at nodes -> rep : nop "
<< "\n classical quantities at elements -> rep : ele "
<< "\n specific quantities at elements -> rep : elp "
<< "\n tensorial values from elements -> rep : elt "
<< "\n values from facets of elements -> rep : elF "
<< "\n values from edges of elements -> rep : elA "
<< "\n style of output -> rep : sty "
<< "\n for taking the default value -> rep : o "
<< "\n for stopping the questions -> rep : fin (ou f) ";
};
string rep;
if (ParaGlob::Francais())
{cout << "\n reponse ? ";}else {cout << "\n answer ? ";}
rep = lect_return_defaut(false,"f");
if ((rep == "o") || (rep == "noe"))
{ // cas de grandeurs aux noeuds,
Entree_grandeur_principale_aux_noeuds(rep);
} // -- fin du cas des grandeurs aux noeuds
else if (rep == "net")
{ // cas de grandeurs étendus secondaires aux noeuds
Entree_grandeur_etendue_secondaire_aux_noeuds(rep);
} // -- fin du cas des grandeurs étendus secondaires aux noeuds
else if (rep == "nop")
{ // cas de grandeurs particuliére aux noeuds
Entree_grandeur_TypeQuelconque_secondaire_aux_noeuds(rep);
} // -- fin du cas des grandeurs particulières aux noeuds
else if (rep == "ele")
{ // cas de grandeurs génériques aux éléments,
Entree_grandeur_aux_elements(rep);
} // -- fin du cas génériques des éléments
else if (rep == "elp")
{ // cas de grandeurs particulières aux éléments,
Entree_grandeur_particuliere_aux_elements(rep);
} // -- fin du cas des éléments
else if (rep == "elt")
{ // cas de grandeurs tensorielles aux éléments,
Entree_grandeur_tensorielle_aux_elements(rep);
} // -- fin du cas des éléments
else if (rep == "elF")
{ // cas de grandeurs aux faces d'éléments,
Entree_grandeur_quelconque_aux_faces_element(rep);
} // -- fin du cas des faces aux éléments
else if (rep == "elA")
{ // cas de grandeurs aux arêtes d'éléments,
Entree_grandeur_quelconque_aux_aretes_element(rep);
} // -- fin du cas des arêtes d'éléments
else if (rep == "glo")
{// cas de la sortie de grandeurs globales qui sont gérées au niveau de l'algorithme: par exemple les énergies
Entree_grandeur_gobal(rep);
}
else if (rep == "tre")
{// cas de la sortie des torseurs de réaction
Entree_torseurs_reaction(rep);
}
else if (rep == "smN")
{// cas du choix pour les moyennes sommes etc. sur ref N
Entree_somme_moy_N(rep);
}
else if (rep == "smE")
{// cas du choix pour les moyennes sommes etc. sur ref E
Entree_somme_moy_E(rep);
}
else if (rep == "smFE")
{// cas du choix pour les moyennes sommes etc. sur ref de face E
Entree_somme_moy_F_E(rep);
}
else if (rep == "smAE")
{// cas du choix pour les moyennes sommes etc. sur ref d'arêtes E
Entree_somme_moy_A_E(rep);
}
else if (rep == "sty")
{// entrée du choix de l'utilisation sur le style de sortie
Style_de_sortie(rep);
}
else if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f"))
choix_valide = true;
else
if (ParaGlob::Francais()) {cout << "\n choix non valide, recommencez !";}
else {cout << "\n the choice is not valide, starts again ! ";};
}; // -- fin de la boucle infinie sur le choix noeud/élément ou arrêt
// 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_TypeQuelconque_retenu);
// appel de la méthode de la classe mère
OrdreVisu::ChoixOrdre();
};
// initialisation de la liste des différentes isovaleurs possibles
void Choix_grandeurs_maple::Init_liste_grandeurs(LesMaillages * lesMail,LesCondLim*
,LesContacts* lesContacts,bool fil_calcul)
{
// on n'initialise que si on n'est pas au fil du calcul
if (!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();
{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
tabnoeud_type_ddl = lesMail->Les_type_de_ddl_par_noeud(absolue);
tabnoeud_type_ddlEtendu = lesMail->Les_type_de_ddl_etendu_par_noeud(absolue);
// attention **** pour les grandeurs quelconques, il faudrait d'abord effacer les listes, dans dans l'opération
// d'affectation, car il faut exactement les mêmes types de chaque coté du = , ce qui peut ne pas être le cas
// si d'un appel à l'autre, la liste à changée, ce qui est le cas pour des grandeurs qui
// apparaissent pendant le calcul, il y aura un pb donc il faut surveiller ce point !!
tabnoeud_TypeQuelconque.Change_taille(0);
tabnoeud_TypeQuelconque = lesMail->Les_type_de_TypeQuelconque_par_noeud(absolue);
tabelement_type_ddl = lesMail->Les_type_de_ddl_par_element(absolue);
tabelement_typeParti = lesMail->Les_type_de_donnees_particulieres_par_element(absolue);
// 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);
// pour les faces et arêtes
tab_F_element_TypeQuelconque = lesMail->Les_type_de_donnees_evolues_internes_par_face_element(absolue);
tab_A_element_TypeQuelconque = lesMail->Les_type_de_donnees_evolues_internes_par_arete_element(absolue);
// initialisation des tableaux, si c'est déjà fait, ne fait rien
if (tabnoeud_type_ddl_retenu.Taille() == 0)
{ //int nb_maillage = tabnoeud_type_ddl.Taille();
tabnoeud_type_ddl_retenu.Change_taille(nb_maillage);// initialisation
tabnoeud_type_ddlEtendu_retenu.Change_taille(nb_maillage);// initialisation
tabnoeud_TypeQuelconque_retenu.Change_taille(nb_maillage);
tab_num_noeud.Change_taille(nb_maillage);// initialisation
nomDeRef.Change_taille(nb_maillage); // init
nomDeRef_E.Change_taille(nb_maillage); // init
nomDeRef_ptinteg.Change_taille(nb_maillage); // init
// pour les ref de face d'éléments
tab_num_F_element.Change_taille(nb_maillage);
tab_num_F.Change_taille(nb_maillage);
tab_num_F_integ.Change_taille(nb_maillage);
nomDeRef_F_E.Change_taille(nb_maillage);
nomDeRef_F_ptinteg.Change_taille(nb_maillage);
// pour les ref d'arête d'éléments
tab_num_A_element.Change_taille(nb_maillage);
tab_num_A.Change_taille(nb_maillage);
tab_num_A_integ.Change_taille(nb_maillage);
nomDeRef_A_E.Change_taille(nb_maillage);
nomDeRef_A_ptinteg.Change_taille(nb_maillage);
tabelement_type_ddl_retenu.Change_taille(nb_maillage);// initialisation
tabelement_typeParti_retenu.Change_taille(nb_maillage);// initialisation
tabelement_evoluee_retenu.Change_taille(nb_maillage);// initialisation
tab_num_element.Change_taille(nb_maillage);// initialisation
tab_num_integ.Change_taille(nb_maillage);// initialisation
// pour les faces et arêtes
tab_F_element_TypeQuelconque.Change_taille(nb_maillage);
tab_F_element_TypeQuelconque_retenu.Change_taille(nb_maillage);
tab_A_element_TypeQuelconque.Change_taille(nb_maillage);
tab_A_element_TypeQuelconque_retenu.Change_taille(nb_maillage);
// --- pour les sorties concernant les sommes et moyennes etc. relativement à des références
tab_nomDeRef_SM.Change_taille(nb_maillage);
tab_nomDeRef_E_SM.Change_taille(nb_maillage);
tab_nomDeRef_ptinteg_SM.Change_taille(nb_maillage);
// faces d'éléments
tab_nomDeRef_F_E_SM.Change_taille(nb_maillage);tab_nomDeRef_F_ptinteg_SM.Change_taille(nb_maillage);
tab_F_element_TypeQuelconque_retenu_pourSM.Change_taille(nb_maillage);
// arêtes d'éléments
tab_nomDeRef_A_E_SM.Change_taille(nb_maillage);tab_nomDeRef_A_ptinteg_SM.Change_taille(nb_maillage);
tab_A_element_TypeQuelconque_retenu_pourSM.Change_taille(nb_maillage);
tabnoeud_type_ddl_retenu_pourSM.Change_taille(nb_maillage);
tabnoeud_type_ddlEtendu_retenu_pourSM.Change_taille(nb_maillage);
tabnoeud_TypeQuelconque_retenu_pourSM.Change_taille(nb_maillage);
tabelement_type_ddl_retenu_pourSM.Change_taille(nb_maillage);
tabelement_typeParti_retenu_pourSM.Change_taille(nb_maillage);
tabelement_evoluee_retenu_pourSM.Change_taille(nb_maillage);
};
};// fin du cas différent du fil du calcul
};
// écriture des informations d'entête, renseigne sur les infos du fichier, ceci
// pour permettre l'exploitation par le programme en maple
// en entrée : list_mail = la liste des maillages à visualiser
void Choix_grandeurs_maple::Entete_fichier_maple(const list<int>& list_mail,ostream & sort)
{if (!(animation_maple->Actif()))
{// le détails des grandeurs
if (ParaGlob::Francais())
{sort << "\n # entete des donnees : informations gererales: on trouve successivement: ";
sort << "\n # >> le nombre de grandeurs globales (peut etre nul) suivi des identificateurs "
<< "\n # precedes du numero de colonne entre crochet"
<< "\n # >> le nombre de maillages m, et dimension de l'espace de travail "
<< "\n # puis pour chaque maillage, "
<< "\n # >> le nombre de torseurs de reaction (peut etre nul), le nombre total de reel qui va etre ecrit "
<< "\n # correspondant aux composantes des torseurs, puis les noms de ref associee suivi des positions "
<< "\n # des composantes entre crochet accolees a un identificateur: R pour reaction, M pour moment "
<< "\n # ensuite pour les moyennes, sommes, maxi etc. calculees sur des references de noeuds "
<< "\n # >> le nombre de ref de noeuds, nombre total de grandeurs associees "
<< "\n # puis pour chaque maillage "
<< "\n # le numero de maillage puis pour chaque reference de noeuds"
<< "\n # le nom de la reference, le nombre de noeud de la ref, le nombre de grandeurs qui vont etre ecrites "
<< "\n # puis entre crochet la position suivi de la signification de chaque grandeur "
<< "\n # "
<< "\n # ensuite pour les moyennes, sommes, maxi etc. calculees sur des references d'elements ou de pti"
<< "\n # >> le nombre de ref d'element+ref de pti, nombre total de grandeurs associees "
<< "\n # puis pour chaque maillage "
<< "\n # le numero de maillage puis pour chaque reference d'element et de pti"
<< "\n # le nom de la reference, le nombre d'element de la ref, le nombre de grandeurs qui vont etre ecrites "
<< "\n # puis entre crochet la position suivi de la signification de chaque grandeur "
<< "\n # "
<< "\n # ensuite pour les moyennes, sommes, maxi etc. calculees sur des references de faces d'element ou de pti"
<< "\n # >> le nombre de ref de face + ref de pti de face, nombre total de grandeurs associees "
<< "\n # puis pour chaque maillage "
<< "\n # le numero de maillage puis pour chaque reference de face et de pti de face "
<< "\n # le nom de la reference, le nombre de face de la ref, le nombre de grandeurs qui vont etre ecrites "
<< "\n # puis entre crochet la position suivi de la signification de chaque grandeur "
<< "\n # "
<< "\n # ensuite pour les moyennes, sommes, maxi etc. calculees sur des references d'arete d'element ou de pti"
<< "\n # >> le nombre de ref d'arete + ref de pti d'arete, nombre total de grandeurs associees "
<< "\n # puis pour chaque maillage "
<< "\n # le numero de maillage puis pour chaque reference d'arete et de pti d'arete "
<< "\n # le nom de la reference, le nombre d'arete de la ref, le nombre de grandeurs qui vont etre ecrites "
<< "\n # puis entre crochet la position suivi de la signification de chaque grandeur "
<< "\n # "
<< "\n # puis pour chaque maillage "
<< "\n # >> le nombre de noeud n (peut etre nul) ou il y a des grandeurs en sortie , "
<< "\n # puis le nombre des grandeurs p1 correspondantes, la position entre crochet des coordonnees "
<< "\n # et enfin l'idendificateur de ces grandeurs(p1 chaines de caractere) "
<< "\n # precedes du numero de colonne correspondant entre crochet"
<< "\n # puis pour chaque maillage "
<< "\n # >> le nombre de couples element-pt_integ (peut etre nulle) ou il y a des grandeurs en sortie , "
<< "\n # les grandeurs aux elements sont decomposees en 2 listes: la premiere de quantite P2 correspondant "
<< "\n # a des grandeurs generiques, la seconde de quantite P3 corresponds aux grandeurs specifiques, "
<< "\n # on trouve donc a la suite du nombre d'element: le nombre P2, suivi de P2 identificateurs de ddl"
<< "\n # chacun precedes du numero de colonne entre crochet"
<< "\n # puis le nombre P3, suivi de P3 identificateurs+categorie+type (chaines de caracteres),"
<< "\n # suivi entre crochet, de la plage des numeros de colonnes, correspondant "
<< "\n # chacun sur une ligne differentes "
<< "\n # puis pour chaque maillage "
<< "\n # >> le nombre de triplets element-nb_face-pt_integ (peut etre nulle) ou il y a des grandeurs en sortie , "
<< "\n # puis le nombre grandeurs, suivi des identificateurs+categorie+type (chaines de caracteres),"
<< "\n # suivi entre crochet, de la plage des numeros de colonnes, correspondant "
<< "\n # chacun sur une ligne differentes "
<< "\n # puis pour chaque maillage "
<< "\n # >> le nombre de triplets element-nb_arete-pt_integ (peut etre nulle) ou il y a des grandeurs en sortie , "
<< "\n # puis le nombre grandeurs, suivi des identificateurs+categorie+type (chaines de caracteres),"
<< "\n # suivi entre crochet, de la plage des numeros de colonnes, correspondant "
<< "\n # chacun sur une ligne differentes "
<< "\n # ==== NB: pour les grandeurs specifique tensorielle: exemple d'ordre en 2D: "
<< "\n # tenseur symetrique, A(1,1) A(2,1) A(2,2), non symetrique A(1,1) A(1,2) A(2,1) A(2,2)"
<< "\n # en 3D c'est: tenseur symetrique, A(1,1) A(2,1) A(2,2) A(3,1) A(3,2) A(3,3) "
<< "\n # non symetrique A(1,1) A(1,2) A(2,1) A(2,2) A(2,3) A(3,1) A(3,2) A(3,3) "
<< "\n # ** dans le cas ou il n'y a qu'un seul increment en sortie, pour les grandeurs aux noeuds et aux elements, "
<< "\n # ** les informations peuvent etre decoupees selon: une ligne = un noeud, et le temps n'est pas indique "
<< "\n # ** ( cf: parametre_style_de_sortie = 0) \n";
}
else
{sort << "\n # The heading of the data : general informations: we will find successively: ";
sort << "\n # >> the number of global values (can be zero), followed by identifiers "
<< "\n # preceded by the corresponding column number, surrounded by brackets "
<< "\n # >> the number of mesh m, and the dimension of the working space "
<< "\n # then for each mesh, "
<< "\n # >> the numer of reaction wrench (can be zero), the total number of real, which will be writen "
<< "\n # it correspond to the wrench components, then the names of the associated references, followed by the positions "
<< "\n # of the components surrounded by brackets and the identifiers: R for the reaction vector, M for the torque "
<< "\n # then for each mesh "
<< "\n # >> the number of nodes n (can be zero) where there are output values , "
<< "\n # then the number of corresponding values p1 , the position between bracket of the components "
<< "\n # and finally the identifier of these quantities (p1 strings) "
<< "\n # preceded by their column number between brackets"
<< "\n # then for each mesh "
<< "\n # >> the number of couples element-integretion-point (can be zero) where there are output values , "
<< "\n # the values at elements are composed by two lists : the first one, of P2 quantities, corresponds "
<< "\n # to generic quantities , the second, of P3 quantities, corresponds to specific quantities, "
<< "\n # so, we find after the number of element : the number P2, followed by P2 identifiers of dof"
<< "\n # each is preceded by a column number between brackets "
<< "\n # then the number P3, followed by P3 identifiers+category+type (string),"
<< "\n # followed, between brackets, of the corresponding range of column numbers "
<< "\n # each on a different line "
<< "\n # ==== NB: for second order tensor specific values: for instance in 2D, the order of componants is: "
<< "\n # for symetric tensor, A(1,1) A(2,1) A(2,2), for non symetric A(1,1) A(1,2) A(2,1) A(2,2)"
<< "\n # in 3D it is: symetric tensor, A(1,1) A(2,1) A(2,2) A(3,1) A(3,2) A(3,3) "
<< "\n # non symetric A(1,1) A(1,2) A(2,1) A(2,2) A(2,3) A(3,1) A(3,2) A(3,3) "
<< "\n # ** in the case of only one output increment, for values at nodes and at elements, "
<< "\n # ** the informations can be presented as: one line = one node, and the time is not indicated "
<< "\n # ** (parametre_style_de_sortie = 0) \n";
};
// ---- grandeur globales
if (ParaGlob::Francais())
{ sort << "\n#====================================================================";
sort << "\n#|| recapitulatif des differentes grandeurs par colonne ||";
sort << "\n#====================================================================";
sort << "\n#---------------------------------- grandeur globales ------------------------------------";
sort << "\n#" << list_grand_global_retenu.size() << " (nombre de grandeurs globales) ";
}
else
{ sort << "\n#====================================================================";
sort << "\n#|| global checkup of the output quantities by column ||";
sort << "\n#====================================================================";
sort << "\n#---------------------------------- global quantities ------------------------------------";
sort << "\n#" << list_grand_global_retenu.size() << " (number of global quantities ) ";
};
List_io <string >::iterator ilg,ilgfin=list_grand_global_retenu.end();
int num_col=1 ; // le numéro des colonnes, la première colonne = temps, donc la première grandeur est en col 2
if (list_grand_global_retenu.size() != 0)
num_col++; // on passe l'affichage du temps
for (ilg=list_grand_global_retenu.begin();ilg != ilgfin; ilg++)//,num_col++)
{sort << " ["<<num_col<<"]" << (*ilg) ;
// soit c'est une grandeur scalaire soit une grandeur vectorielle !! il faut que l'on teste
// récup de la grandeur
const void * pointe = NULL; // init
if (EstUneGrandeurGlobale(*ilg))
{Enum_GrandeurGlobale idGR = Id_nom_GrandeurGlobale(*ilg);
pointe = ParaGlob::param->GrandeurGlobal(idGR);
};
if (pointe == NULL)
{// on essaie alors au niveau des adressages directement avec un string
pointe = ParaGlob::param->GrandeurGlobal(*ilg);
};
if (pointe != NULL)
{TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
//// --- debug
//cout << "\n debug Choix_grandeurs_maple::Entete_fichier_maple(..."
// << "\n Type_enumGrandeurParticuliere= "
// << NomTypeQuelParticulier(gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere())
// << "\n Type_structure_grandeurAssocie= "
// << NomType2Niveau(gr_quelc->Grandeur_pointee()->Type_structure_grandeurAssocie())
// << flush;
//
//// ---- fin debug
switch(gr_quelc->Grandeur_pointee()->Type_structure_grandeurAssocie())
{ case TYPE_SIMPLE: // pour les grandeurs globales a priori que des types simples
{ switch(gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere())
{case PARTICULIER_SCALAIRE_ENTIER: case PARTICULIER_SCALAIRE_DOUBLE:
case PARTICULIER_DDL_ETENDU:
{num_col++; break;}
case PARTICULIER_VECTEUR_NOMMER:
{Grandeur_Vecteur_Nommer& gr
= *((Grandeur_Vecteur_Nommer*) gr_quelc->Grandeur_pointee()); // pour simplifier
Vecteur& V = gr.ConteneurVecteur();
int taille = V.Taille();
num_col += taille;
break;
}
case PARTICULIER_VECTEUR:
{Grandeur_Vecteur& gr
= *((Grandeur_Vecteur*) gr_quelc->Grandeur_pointee()); // pour simplifier
Vecteur* V = gr.ConteneurVecteur();
int taille = V->Taille();
num_col += taille;
break;
}
default:
{cout << "\n erreur en sortant la grandeur globale: " << (*ilg) << " on met 0 a la place ";}
}
break;
}
default:
{cout << "\n erreur en sortant la grandeur globale: " << (*ilg) << " on met 0 a la place ";};
};
}
else
{if (ParaGlob::Francais())
{cout << "\n erreur en sortant la grandeur globale: " << (*ilg) << " on met 0 a la place ";}
else {cout << "\n error for outputting the global quantity : " << (*ilg) << " the output will be 0 ";
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n Choix_grandeurs_maple::Entete_fichier_maple(....)";
};
};
};
// ----- maillage et dimension
if (ParaGlob::Francais())
{ sort << "\n#---------------------------------- maillage et dimension --------------------------------";
sort << "\n#" << list_mail.size() << " " << ParaGlob::Dimension() << " (nombre de maillages et dimension) " ;
// --- cas des torseurs de réaction
sort << "\n#---------------------------------- torseurs de reactions --------------------------------";
}
else
{ sort << "\n#---------------------------------- mesh and dimension ----------------------------------";
sort << "\n#" << list_mail.size() << " " << ParaGlob::Dimension() << " (number of mesh and dimension) " ;
// --- cas des torseurs de réaction
sort << "\n#---------------------------------- reaction wrench --------------------------------------";
};
int nb_maillage = tab_list_torseur_condLim_retenu.Taille();
for (int n_mail = 1; n_mail<= nb_maillage; n_mail++)
{ if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
else {sort << "\n# mesh_" << n_mail << " : "; };
List_io <String_et_entier >& list_torseur_condLim_retenu = tab_list_torseur_condLim_retenu(n_mail);
sort << list_torseur_condLim_retenu.size() << " ";
// le nombre de réel correspondant
switch (ParaGlob::Dimension())
{case 1: sort << list_torseur_condLim_retenu.size() << " "; break;
case 2: sort << 3 * list_torseur_condLim_retenu.size() << " "; break;
case 3: sort << 6 * list_torseur_condLim_retenu.size() << " "; break;
};
if (ParaGlob::Francais())
{sort << " (nombre de torseurs et nombre total de grandeurs associees) "; }
else
{sort << " (number of wrench and global number of associated values ) "; }
// if ((list_torseur_condLim_retenu.size() != 0)&&(tab_list_torseur_condLim_retenu.Taille()>1))
// {if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
// else {sort << "\n# mesh_" << n_mail << " : "; };
// }
sort << "\n# ";
if (list_torseur_condLim_retenu.size() != 0)
num_col++; // on passe l'affichage du temps
// puis les ref
List_io <String_et_entier>::iterator jeint,jeintfin = list_torseur_condLim_retenu.end();
for (jeint=list_torseur_condLim_retenu.begin();jeint!=jeintfin;jeint++)
{ sort << (*jeint).nom << " ";
int dim = ParaGlob::Dimension(); if (ParaGlob::AxiSymetrie()) dim--;
switch (dim)
{case 1: sort << " ["<<num_col<<"]Rx "; num_col++; break;
case 2: sort << " ["<<num_col<<"]Rx " << " ["<<num_col+1<<"]Ry "<< " ["<<num_col+2<<"]Mz " ;num_col+=3; break;
case 3: sort << " ["<<num_col<<"]Rx " << " ["<<num_col+1<<"]Ry "<< " ["<<num_col+2<<"]Rz "
<< " ["<<num_col+3<<"]Mx "<< " ["<<num_col+4<<"]My "<< " ["<<num_col+5<<"]Mz " ;num_col+=6; break;
};
sort << ";\n# ";
};
};
// --- cas des grandeurs sommes, moyennes, maxi etc. pour les références de noeuds ---
list<int>::const_iterator imail,imailfin=list_mail.end();
if (ParaGlob::Francais()) {sort << "\n#-------- moyenne, somme, maxi etc. de grandeurs aux noeuds pour des ref ---------------";}
else {sort << "\n#--------- average, sum, maxi etc. of values at nodes for ref ------------------";}
// sortie de l'entete pour les moyennes sommes etc. sur ref N
Sortie_entete_somme_moy_N(sort,num_col);
// --- cas des grandeurs sommes, moyennes, maxi etc. pour les références d'éléments ---
if (ParaGlob::Francais()) {sort << "\n#-------- moyenne, somme, maxi etc. de grandeurs aux elements pour des ref ---------------";}
else {sort << "\n#--------- average, sum, maxi etc. of values at element for ref ------------------";}
// sortie de l'entete pour les moyennes sommes etc. sur ref E
Sortie_entete_somme_moy_E(sort,num_col);
// --- cas des grandeurs sommes, moyennes, maxi etc. pour les références de faces d'élément ---
if (ParaGlob::Francais()) {sort << "\n#-------- moyenne, somme, maxi etc. de grandeurs aux faces d'elements pour des ref ---------------";}
else {sort << "\n#--------- average, sum, maxi etc. of values at element facets for ref ------------------";}
// sortie de l'entete pour les moyennes sommes etc. sur ref face E
Sortie_entete_somme_moy_face_E(sort,num_col);
// --- cas des grandeurs sommes, moyennes, maxi etc. pour les références d'arêtes d'élément ---
if (ParaGlob::Francais()) {sort << "\n#-------- moyenne, somme, maxi etc. de grandeurs aux aretes d'element pour des ref ---------------";}
else {sort << "\n#--------- average, sum, maxi etc. of values at element edges for ref ------------------";}
// sortie de l'entete pour les moyennes sommes etc. sur ref face E
Sortie_entete_somme_moy_arete_E(sort,num_col);
// --- cas des noeuds
if (ParaGlob::Francais()) {sort << "\n#---------------------------------- grandeurs aux noeuds --------------------------------";}
else {sort << "\n#-------------------------------------- values at nodes --------------------------------";}
for (imail = list_mail.begin();imail!=imailfin;imail++)
{ // on calcul le nombre total de noeud: en incluant les noeuds des liste
int nombre_noeud = tab_num_noeud(*imail).size(); // d'abord les noeuds
// puis les références de listes de noeuds
List_io <string >::iterator idl,idlfin= nomDeRef(*imail).end();
for (idl=nomDeRef(*imail).begin();idl!=idlfin;idl++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve(*idl,*imail);
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref de noeud
nombre_noeud+=reff.Taille();
};
// affichage
if (nombre_noeud != 0) // on n'écrit que s'il y a des noeuds
{sort << "\n#" << nombre_noeud << " " ;
// on calcul le nombre de grandeurs à sortir en fonction de type_sortie_ddl_retenue
int nb_type_ddl_retenu = tabnoeud_type_ddl_retenu(*imail).size();
int nb_type_ddlEtendu_retenu = tabnoeud_type_ddlEtendu_retenu(*imail).size();
// pour les types quelconques il faut faire un petit calcul pour savoir combien de grandeurs scalaires il y a
int nb_noe_TypeQuelconque_ret = 0; // init
{ List_io<TypeQuelconque>::iterator iquefin=tabnoeud_TypeQuelconque_retenu(*imail).end();
List_io<TypeQuelconque>::iterator ique,ique_deb=tabnoeud_TypeQuelconque_retenu(*imail).begin();
for (ique = ique_deb;ique != iquefin;ique++)
nb_noe_TypeQuelconque_ret += (*ique).NbMaxiNumeroOrdre();
};
switch (type_sortie_ddl_retenue)
{ case 0: sort << nb_type_ddl_retenu + nb_type_ddlEtendu_retenu + nb_noe_TypeQuelconque_ret << " ";break;
case 1: sort << nb_type_ddl_retenu + nb_type_ddlEtendu_retenu + nb_noe_TypeQuelconque_ret << " ";break;
case 2: sort << 2*nb_type_ddl_retenu + nb_type_ddlEtendu_retenu + nb_noe_TypeQuelconque_ret << " ";break;
};
if (ParaGlob::Francais()) {sort << " (nombre de noeuds, nombre total de grandeurs associees) "; }
else {sort << " (number of nodes, total number of associated quatities) "; };
if (nombre_noeud != 0)
{ num_col++; // on passe l'affichage du temps
if (list_mail.size() > 1)
{ if (ParaGlob::Francais()) {sort << "\n# maillage_" << *imail << " : ";}
else {sort << "\n# mesh_" << *imail << " : ";};
};
sort << "\n# ";
// on sort tout d'abord les noeuds identifiés par un numéro seulement
{List_io<int>::iterator inoeud,inoeudfin=tab_num_noeud(*imail).end();
for (inoeud = tab_num_noeud(*imail).begin(); inoeud != inoeudfin; inoeud++)
{ if (ParaGlob::Francais()) {sort << "noeud_"<<(*inoeud)<<" ";}
else {sort << "node_"<<(*inoeud)<<" ";};
Sortie_entete_noeud_unitaire(imail,sort,num_col);
}; //-- fin de la boucle sur les noeuds seuls
};
// on sort maintenant les noeuds qui font partie d'une référence
List_io <string >::iterator idl,idlfin= nomDeRef(*imail).end();
for (idl=nomDeRef(*imail).begin();idl!=idlfin;idl++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve(*idl,*imail);
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref de noeud
int taillen=reff.Taille();
sort << " reference " << reff.Nom() <<" : ";
for (int inoeu=1;inoeu<=taillen;inoeu++) // on boucle
{ // on sort la position des xyz
if (ParaGlob::Francais()) {sort << "noeud_"<<reff.Numero(inoeu)<<" ";}
else {sort << "node_"<<reff.Numero(inoeu)<<" ";};
Sortie_entete_noeud_unitaire(imail,sort,num_col);
}; // fin de la boucle sur les noeuds de la référence
}; // fin de la boucle sur les référence
};
}
else
{if (ParaGlob::Francais())
{ sort << "\n# maillage_" << *imail << " : "
<< 0 << " " << 0 << " (nombre de noeuds, nombre total de grandeurs associees) ";}
else
{ sort << "\n# maillage_" << *imail << " : "
<< 0 << " " << 0 << " (number of nodes, total number of associated quantities) ";};
};
// sauvegarde du nombre maxi de maillage à visualiser pour l'exécution
der_numero_mail = *imail; // seul le dernier numéro est sauvegardé
};
// ----- les éléments
if (ParaGlob::Francais())
{sort << "\n#---------------------------------- grandeurs aux elements ------------------------------";}
else {sort << "\n#--------------------------------------- values at elements ------------------------------";}
for (imail = list_mail.begin();imail!=imailfin;imail++)
{ // on calcul le nombre total d'élément: en incluant les éléments des listes
int nombre_element = tab_num_element(*imail).size(); // d'abord les éléments unitaires
// puis les références de listes d'élément
{List_io <BlocScal >::iterator idl,idlfin= nomDeRef_E(*imail).end();
for (idl=nomDeRef_E(*imail).begin();idl!=idlfin;idl++)
{// recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*idl).NomRef(),*imail);
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
nombre_element+=reff.Taille();
};
}; // encapsulage
// puis les références de listes de points d'intégration d'élément
{List_io <string >::iterator ids,idsfin= nomDeRef_ptinteg(*imail).end();
for (ids=nomDeRef_ptinteg(*imail).begin();ids!=idsfin;ids++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve(*ids,*imail);
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'élément
nombre_element+=reff.Taille();
};
}; // encapsulage
// affichage
if (nombre_element != 0) // on n'écrit que s'il y a des éléments à sortir
{sort << "\n#" << nombre_element << " " << tabelement_type_ddl_retenu(*imail).size() << " "
<< tabelement_typeParti_retenu(*imail).size()
<< tabelement_evoluee_retenu(*imail).size() << " ";
if (ParaGlob::Francais())
{sort << " (nombre total d'elements, nombre totale de grandeurs associees, nombre de grandeurs particulieres"
<< ", nombre de grandeurs tensorielles) ";}
else {sort << " (total number of elements, total number of associated quantities, number of specific quantities"
<< " number of tensorial values ) ";};
if (nombre_element != 0)
{bool temps_deja_affiche = false;
if (list_mail.size() > 1)
{if (ParaGlob::Francais()) {sort << "\n# maillage_" << *imail << " : ";}
else {sort << "\n# mesh_" << *imail << " : ";};
};
sort << "\n# ";
// affichage des éléments identifié uniquement pas un numéro
List_io <int> tab_elem = tab_num_element(*imail); // tout d'abord récup de la liste des éléments
List_io <int> tab_ptint = tab_num_integ(*imail); // et les points d'intégration correspondant
int nb_element = tab_elem.size(); // d'abord les éléments unitaires
List_io <int>::iterator i_elem = tab_elem.begin();
List_io <int>::iterator i_ptint = tab_ptint.begin();
for (int ine = 1;ine<= nb_element; ine++,i_elem++,i_ptint++)
{ sort << "element_"<<*i_elem<<" pt_integ_"<<*i_ptint << ": ";
Sortie_entete_element_unitaire(imail,sort,num_col,temps_deja_affiche);
};
// puis les listes d'éléments par référence
{List_io <BlocScal>::iterator idl,idlfin= nomDeRef_E(*imail).end();
for (idl=nomDeRef_E(*imail).begin();idl!=idlfin;idl++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*idl).NomRef(),*imail);
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'éléments
sort << " reference " << reff.Nom() <<" : ";
int taillen=reff.Taille(); // nombre d'éléments dans la liste
for (int ielem=1;ielem<=taillen;ielem++) // on boucle et enregistre les elements et le point
{ sort << "element_"<<reff.Numero(ielem)<<" pt_integ_"<<((int) ((*idl).Val())) << ": ";
Sortie_entete_element_unitaire(imail,sort,num_col,temps_deja_affiche);
};
};
}; // encapsulé
// puis les références de listes de points d'intégration d'éléments
{List_io <string>::iterator ids,idsfin= nomDeRef_ptinteg(*imail).end();
for (ids=nomDeRef_ptinteg(*imail).begin();ids!=idsfin;ids++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*ids),*imail);
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de pt d'integ
sort << " reference " << reff.Nom() <<" : ";
int taillen=reff.Taille(); // nombre d'éléments dans la liste
for (int ielem=1;ielem<=taillen;ielem++) // on boucle et enregistre les elements et le point
{ sort << "element_"<<reff.NumeroElem(ielem)<<" pt_integ_"<<reff.NumeroFA(ielem) << ": ";
Sortie_entete_element_unitaire(imail,sort,num_col,temps_deja_affiche);
};
};
}; // encapsulé
};
sort << "\n# ";
}
else
{ if (ParaGlob::Francais())
{sort << "\n# maillage_" << *imail << " : " << 0 << " " << 0
<< " (nombre total d'elements, nombre totale de grandeurs associees) ";
}
else
{sort << "\n# mesh_" << *imail << " : " << 0 << " " << 0
<< " (total number of elements, total number of associated quantities) ";
};
};
};
// ----- les faces d'éléments
if (ParaGlob::Francais())
{sort << "\n#---------------------------------- grandeurs aux faces d'elements ------------------------------";}
else {sort << "\n#--------------------------------------- values at facet of elements ------------------------------";}
for (imail = list_mail.begin();imail!=imailfin;imail++)
{ // on calcul le nombre total de faces d'élément: en incluant les éléments des listes
int nombre_face = tab_num_F_element(*imail).size(); // d'abord les éléments unitaires
// puis les références de listes de face d'élément
{List_io <BlocScal >::iterator idl,idlfin= nomDeRef_F_E(*imail).end();
for (idl=nomDeRef_F_E(*imail).begin();idl!=idlfin;idl++)
{// recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*idl).NomRef(),*imail);
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref ad hoc
nombre_face+=reff.Taille();
};
}; // encapsulage
// puis les références de listes de points d'intégration de face d'élément
{List_io <string >::iterator ids,idsfin= nomDeRef_F_ptinteg(*imail).end();
for (ids=nomDeRef_F_ptinteg(*imail).begin();ids!=idsfin;ids++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve(*ids,*imail);
const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref d'élément
nombre_face+=reff.Taille();
};
}; // encapsulage
// affichage
if (ParaGlob::Francais()) {sort << "\n# maillage_" << *imail << " : "; }
else {sort << "\n# mesh_" << *imail << " : "; };
if (nombre_face != 0) // on n'écrit que s'il y a des éléments à sortir
{sort << nombre_face << " " << tab_F_element_TypeQuelconque_retenu(*imail).size() << " ";
if (ParaGlob::Francais())
{sort << " (nombre total de faces d'element, nombre totale de grandeurs associees ";}
else {sort << " (total number of element facets, total number of associated quantities ";};
if (nombre_face != 0)
{bool temps_deja_affiche = false;
// if (list_mail.size() > 1)
// {if (ParaGlob::Francais()) {sort << "\n# maillage_" << *imail << " : ";}
// else {sort << "\n# mesh_" << *imail << " : ";};
// };
sort << "\n# ";
// affichage des éléments identifié uniquement pas un numéro
List_io <int> tab_elem = tab_num_F_element(*imail); // tout d'abord récup de la liste des éléments
List_io <int> tab_face_elem = tab_num_F(*imail); // liste des faces d'élément
List_io <int> tab_ptint = tab_num_F_integ(*imail); // et les points d'intégration correspondant
int nb_element = tab_elem.size(); // d'abord les éléments unitaires
List_io <int>::iterator i_elem = tab_elem.begin();
List_io <int>::iterator i_F_elem = tab_face_elem.begin();
List_io <int>::iterator i_ptint = tab_ptint.begin();
for (int ine = 1;ine<= nb_element; ine++,i_elem++,i_F_elem++,i_ptint++)
{ sort << "element_"<<*i_elem << " face_"<<*i_F_elem <<" pt_integ_"<<*i_ptint << ": ";
Sortie_entete_face_element_unitaire(imail,sort,num_col,temps_deja_affiche);
};
// puis les listes d'éléments par référence
{List_io <BlocScal>::iterator idl,idlfin= nomDeRef_F_E(*imail).end();
for (idl=nomDeRef_F_E(*imail).begin();idl!=idlfin;idl++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*idl).NomRef(),*imail);
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de faces d'éléments
sort << " reference " << reff.Nom() <<" : ";
int taillen=reff.Taille(); // nombre d'éléments dans la liste
for (int ielem=1;ielem<=taillen;ielem++) // on boucle et enregistre les elements et le point
{ sort << "element_"<<reff.NumeroElem(ielem) << " face_"<< reff.NumeroFA(ielem)
<<" pt_integ_"<<((int) ((*idl).Val())) << ": ";
Sortie_entete_face_element_unitaire(imail,sort,num_col,temps_deja_affiche);
};
};
}; // encapsulé
// puis les références de listes de points d'intégration d'éléments
{List_io <string>::iterator ids,idsfin= nomDeRef_F_ptinteg(*imail).end();
for (ids=nomDeRef_F_ptinteg(*imail).begin();ids!=idsfin;ids++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*ids),*imail);
const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref de pt d'integ
sort << " reference " << reff.Nom() <<" : ";
int taillen=reff.Taille(); // nombre d'éléments dans la liste
for (int ielem=1;ielem<=taillen;ielem++) // on boucle et enregistre les elements et le point
{ sort << "element_"<<reff.NumeroElem(ielem)
<< " face_"<< reff.NumeroFA(ielem)
<<" pt_integ_"<<reff.NumeroPti(ielem) << ": ";
Sortie_entete_face_element_unitaire(imail,sort,num_col,temps_deja_affiche);
};
};
}; // encapsulé
};
sort << "\n# ";
}
else
{sort << "\n#" << 0 << " " << 0 << " (nombre total de faces d'elements, nombre totale de grandeurs associees) ";
};
};
// ----- les arêtes d'éléments
if (ParaGlob::Francais())
{sort << "\n#---------------------------------- grandeurs aux aretes d'elements ------------------------------";}
else {sort << "\n#--------------------------------------- values at edge of elements ------------------------------";}
for (imail = list_mail.begin();imail!=imailfin;imail++)
{ // on calcul le nombre total d'arêtes d'élément: en incluant les éléments des listes
int nombre_element = tab_num_A_element(*imail).size(); // d'abord les éléments unitaires
// puis les références de listes d'arêtes d'élément
{List_io <BlocScal >::iterator idl,idlfin= nomDeRef_A_E(*imail).end();
for (idl=nomDeRef_A_E(*imail).begin();idl!=idlfin;idl++)
{// recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*idl).NomRef(),*imail);
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref ad hoc
nombre_element+=reff.Taille();
};
}; // encapsulage
// puis les références de listes de points d'intégration d'arêtes d'élément
{List_io <string >::iterator ids,idsfin= nomDeRef_A_ptinteg(*imail).end();
for (ids=nomDeRef_A_ptinteg(*imail).begin();ids!=idsfin;ids++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve(*ids,*imail);
const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref d'élément
nombre_element+=reff.Taille();
};
}; // encapsulage
// affichage
if (ParaGlob::Francais()) {sort << "\n# maillage_" << *imail << " : "; }
else {sort << "\n# mesh_" << *imail << " : "; };
if (nombre_element != 0) // on n'écrit que s'il y a des éléments à sortir
{sort << nombre_element << " " << tab_A_element_TypeQuelconque_retenu(*imail).size() << " ";
if (ParaGlob::Francais())
{sort << " (nombre total d'aretes d'element, nombre totale de grandeurs associees ";}
else {sort << " (total number of edge of elements, total number of associated quantities ";};
if (nombre_element != 0)
{bool temps_deja_affiche = false;
// if (list_mail.size() > 1)
// {if (ParaGlob::Francais()) {sort << "\n# maillage_" << *imail << " : ";}
// else {sort << "\n# mesh_" << *imail << " : ";};
// };
sort << "\n# ";
// affichage des éléments identifié uniquement pas un numéro
List_io <int> tab_elem = tab_num_A_element(*imail); // tout d'abord récup de la liste des éléments
List_io <int> tab_face_elem = tab_num_A(*imail); // liste des arêtes d'élément
List_io <int> tab_ptint = tab_num_A_integ(*imail); // et les points d'intégration correspondant
int nb_element = tab_elem.size(); // d'abord les éléments unitaires
List_io <int>::iterator i_elem = tab_elem.begin();
List_io <int>::iterator i_A_elem = tab_face_elem.begin();
List_io <int>::iterator i_ptint = tab_ptint.begin();
for (int ine = 1;ine<= nb_element; ine++,i_elem++,i_A_elem++,i_ptint++)
{ sort << "element_"<<*i_elem << " arete_"<<*i_A_elem <<" pt_integ_"<<*i_ptint << ": ";
Sortie_entete_arete_element_unitaire(imail,sort,num_col,temps_deja_affiche);
};
// puis les listes d'éléments par référence
{List_io <BlocScal>::iterator idl,idlfin= nomDeRef_A_E(*imail).end();
for (idl=nomDeRef_A_E(*imail).begin();idl!=idlfin;idl++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*idl).NomRef(),*imail);
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'éléments
sort << " reference " << reff.Nom() <<" : ";
int taillen=reff.Taille(); // nombre d'éléments dans la liste
for (int ielem=1;ielem<=taillen;ielem++) // on boucle et enregistre les elements et le point
{ sort << "element_"<<reff.NumeroElem(ielem) << " arete_"<< reff.NumeroFA(ielem)
<<" pt_integ_"<<((int) ((*idl).Val())) << ": ";
Sortie_entete_arete_element_unitaire(imail,sort,num_col,temps_deja_affiche);
};
};
}; // encapsulé
// puis les références de listes de points d'intégration d'éléments
{List_io <string>::iterator ids,idsfin= nomDeRef_A_ptinteg(*imail).end();
for (ids=nomDeRef_A_ptinteg(*imail).begin();ids!=idsfin;ids++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*ids),*imail);
const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref de pt d'integ
sort << " reference " << reff.Nom() <<" : ";
int taillen=reff.Taille(); // nombre d'éléments dans la liste
for (int ielem=1;ielem<=taillen;ielem++) // on boucle et enregistre les elements et le point
{ sort << "element_"<<reff.NumeroElem(ielem)
<< " arete_"<< reff.NumeroFA(ielem)
<<" pt_integ_"<<reff.NumeroPti(ielem) << ": ";
Sortie_entete_arete_element_unitaire(imail,sort,num_col,temps_deja_affiche);
};
};
}; // encapsulé
};
sort << "\n# ";
}
else
{sort << "\n#" << 0 << " " << 0 << " (nombre total d'aretes d'elements, nombre totale de grandeurs associees) ";
};
};
if (ParaGlob::Francais())
{ sort << "\n#====================================================================";
sort << "\n#|| fin du recapitulatif des differentes grandeurs ||";
sort << "\n#====================================================================";
// explication de la structuration des datas qui vont suivre
sort << "\n \n # ensuite les donnees sont organisees sur differentes lignes, chaques lignes correspondant "
<< "\n # a un calcul (par exemple un pas de temps), sur chaque ligne il y a m enregistrement, chacun "
<< "\n # correspondant a un maillage. On trouve pour chaque enregistrement successivement : "
<< "\n # s'il y a des grandeurs globales: le temps puis les grandeurs globales, "
<< "\n # puis s'il y a des torseurs de reaction : "
<< "\n # de nouveau le temps, les composantes de la resultante puis les composantes du moments "
<< "\n # donc en 1D -> 1 reels (resultante), en 2D -> 3 reels (resultante 2, moment 1) et en 3D 6 reels "
<< "\n # puis s'il y a des grandeurs aux noeuds: de nouveau le temps "
<< "\n # les coordonnees a t du premier noeud suivi des p1 grandeurs correspondant au premier noeud"
<< "\n # puis les coordonnees du second noeud, les p1 grandeurs etc. pour tous les noeuds"
<< "\n # puis s'il y a des grandeur aux elements: "
<< "\n # le temps, puis les coordonnees a t du point d'integration d'un element (pour les grandeurs generiques) "
<< "\n # suivi des p2 grandeurs correspondantes puis les coordonnees a t du point d'integration "
<< "\n # correspondant aux grandeurs specifiques suivi des p3 grandeurs correspondantes "
<< "\n # puis les coordonnees d'un second point d'integration d'un element, les p2 grandeurs "
<< "\n # etc. pour tous les points d'integration - element "
<< "\n \n ";
}
else
{ sort << "\n#====================================================================";
sort << "\n#|| end of the global checkup of the output quantities ||";
sort << "\n#====================================================================";
// explication de la structuration des datas qui vont suivre
sort << "\n \n # then the data are organised on different lines, each lines corresponds "
<< "\n # to a calculus (for instance a step of time), on each line there are m recordings, each of them"
<< "\n # corresponding to a mesh. We will find successively, for each recording: "
<< "\n # if there are global quantities: the time then the global data, "
<< "\n # then if the are wrench of reaction : "
<< "\n # again the time, the components of the reaction vector, then the component of the reaction torque "
<< "\n # so in 1D -> 1 real (vector), in 2D -> 3 reels (vector 2, torque 1) and in 3D 6 reals "
<< "\n # then if there are data at nodes, again the time "
<< "\n # the coordinates at t for the first node followed by the p1 data corresponding to this first node "
<< "\n # then the coordinate for the second node, the p1 values etc. for all the nodes "
<< "\n # then, if there are quantities at elements: "
<< "\n # again the time, the coordinates at t, for an integration point of the element (for the generic quantities) "
<< "\n # followed by the p2 corresponding values, then, the coordinates at t of the integration point "
<< "\n # corresponding to the specific quantities (if there is) followed by the p3 corresponding values "
<< "\n # then the coordinates of the second integration point of an element, the p2 corresponding values "
<< "\n # etc. for all the integration points of element "
<< "\n \n ";
}
}
else
{ // cas d'une animation
if (ParaGlob::Francais())
{sort << "\n # les donnees en sortie sont: en x ";
if (accroi_x1) sort <<" variation de ";
sort << x1 << " en y " ;
if (accroi_x2) sort <<" variation de ";
sort << x2;
if (type_xi)
// il s'agit de grandeurs aux noeuds
{sort << "\n # il s'agit de grandeurs aux noeuds";}
else
// il s'agit de grandeurs aux éléments
{sort << "\n # il s'agit de grandeurs aux elements";}
}
else
{sort << "\n # the output values are: for x ";
if (accroi_x1) sort <<" variation of ";
sort << x1 << " for y " ;
if (accroi_x2) sort <<" variation of ";
sort << x2;
if (type_xi)
// il s'agit de grandeurs aux noeuds
{sort << "\n # they are values at nodes ";}
else
// il s'agit de grandeurs aux éléments
{sort << "\n # they are values at elements";}
};
// maillage et dimension
sort << "\n # nb_maillage= " << list_mail.size() << " dimension= " << ParaGlob::Dimension();
// numéros des maillages
list<int>::const_iterator imail,imailfin=list_mail.end();
for (imail = list_mail.begin();imail!=imailfin;imail++)
sort << "\n # Numero_de_maillage: " << (*imail) << " ";
sort << "\n \n ";
}
};
// demande de choix d'uniquement 2 grandeurs à visualiser: aux noeuds ou (exclusif) aux éléments
// retourne un booléen indiquant si l'opération est un succes ou pas
bool Choix_grandeurs_maple::Choix_deux_grandeurs(int num_mail)
{ // affichage du maillage à considérer
cout << "\n ----- cas du maillage num: " << num_mail;
// tout d'abord on regarde s'il y a au moins une grandeur à visualiser
if ( (tabnoeud_type_ddl_retenu(num_mail).size() == 0)
&& (tabnoeud_type_ddlEtendu_retenu(num_mail).size()==0)
&& (tabnoeud_TypeQuelconque_retenu(num_mail).size()==0)
&& (tabelement_type_ddl_retenu(num_mail).size()==0)
&& (tabelement_typeParti_retenu(num_mail).size()==0)
)
{ cout << "\n pour l'instant aucune grandeur aux noeuds ou aux elements ne sont definit,"
<< " il faut en definir deux au minimum (une pour x et une pour y) \n";
return false;
};
string rep;
// ensuite on affiche les possibilités
// choix dans tous les cas de x2, et par la même occasion de type_xi qui dit si les grandeurs sont aux
// noeuds ou aux éléments:
bool choix_valide = false;
while (!choix_valide)
{cout << "\n ------- choix de la grandeur en ordonnee ----------"
<< "\n ddl aux noeuds -> rep : noe ?"
<< "\n ddl etendu aux noeuds -> rep : net ?"
<< "\n grandeur particuliere aux noeuds -> rep : nop ?"
<< "\n ou grandeurs aux elements(generique) -> rep : ele ?"
<< "\n ou grandeurs aux elements(particuliere) -> rep : elp ?"
<< "\n ou grandeurs aux elements(tensorielle) -> rep : elt ?"
<< "\n arret de la manip -> rep : f ?";
cout << "\n reponse ? "; rep = lect_return_defaut(false,"f");
if (rep == "noe")
{ cout << "\n choisissez une grandeur dans la liste des ddl actuellement enregistrees : ";
List_io < Ddl_enum_etendu>& lista = tabnoeud_type_ddl_retenu(num_mail);
List_io < Ddl_enum_etendu>:: iterator iddl,iddlfin = lista.end();
for (iddl=lista.begin();iddl != iddlfin; iddl++)
cout << (*iddl) << " ";
cout << "\n reponse ? "; rep = lect_return_defaut(false,"f"); bool trouve = false;
// on vérifie que le nom fourni appartient bien à la liste
if (Ddl_enum_etendu::VerifExistence(rep))
{ // on vérifie qu'il appartiend à la liste des ddl proposés
Ddl_enum_etendu enu_etendu(rep);
if (Ddl_enum_etendu::Existe_dans_la_liste
(tabnoeud_type_ddl_retenu(num_mail),enu_etendu))
{trouve = true; x2=enu_etendu;}}; // x2 contient la grandeur à visualiser
if (!trouve)
{ cout << "\n choix non valide, recommencez !"; choix_valide = false;}
else // on indique avec type_xi que les grandeurs sont aux noeuds et qu'il s'agit d'un ddl
{choix_valide = true; type_xi=true;ddl_etpas_TQ_2=1;};
}
else if (rep == "net")
{ cout << "\n choisissez une grandeur dans la liste des ddl etendus actuellement enregistrees : ";
List_io < Ddl_enum_etendu>& lista = tabnoeud_type_ddlEtendu_retenu(num_mail);
List_io < Ddl_enum_etendu>:: iterator iddl,iddlfin = lista.end();
for (iddl=lista.begin();iddl != iddlfin; iddl++)
cout << (*iddl) << " ";
cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
// on vérifie que le nom fourni appartient bien à la liste
if (Ddl_enum_etendu::VerifExistence(rep))
{ // on vérifie qu'il appartiend à la liste des ddl proposés
Ddl_enum_etendu enu_etendu(rep);
if (Ddl_enum_etendu::Existe_dans_la_liste
(tabnoeud_type_ddlEtendu_retenu(num_mail),enu_etendu))
{trouve = true; x2=enu_etendu;}};
if (!trouve)
{ cout << "\n choix non valide, recommencez !"; choix_valide = false;}
else // on indique avec type_xi que les grandeurs sont aux noeuds et qu'il s'agit d'un ddl
{choix_valide = true; type_xi=true;ddl_etpas_TQ_2=2;};
}
else if (rep == "nop")
{ cout << "\n choisissez une grandeur dans la liste de grandeur particulieres actuellement enregistrees : ";
List_io < TypeQuelconque>& listb = tabnoeud_TypeQuelconque_retenu(num_mail);
List_io < TypeQuelconque>:: iterator iddl,iddlfin = listb.end();
for (iddl=listb.begin();iddl != iddlfin; iddl++)
cout << ((*iddl).EnuTypeQuelconque().NomPlein()) << " ";
cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
// on ne continue que si le type quelconque existe
if (TypeQuelconque_enum_etendu::VerifExistence(rep))
{// on regarde si c'est un type numérique
TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
if (a.Type_numerique()) // cas d'un type numérique
{ int nbordre = a.NbMaxiNumeroOrdre(); // récup du nombre de numéro d'ordre
if (nbordre != 1)
{ // dans le cas où il y a plusieurs grandeurs scalaires il faut choisir
cout << "\n grandeur avec plusieurs composantes: donnez un numero ? "
<< "\n pour un tableau, vecteur, liste: il s'agit de l'ordre de la grandeur "
<< "\n pour un tenseur, un tableau multi-dim, c'est le dernier indice qui varie d'abord";
rep = lect_chaine(); int nn = ChangeEntier(rep);
if ((nn>=0) && (nn<=nbordre)) { if (nn==nbordre) {nb_ordre_2 = 0;} else {nb_ordre_2 = nn;};}
else { cout << "\n choix non valide, doit etre compris entre " << 1 << " et " << nbordre << " ";}
}
else { nb_ordre_2=1;}; // cas où il n'y qu'une seule valeur scalaire
// on vérifie que le nom fourni appartient bien à la liste
List_io<TypeQuelconque>& tpg_ret = (tabnoeud_TypeQuelconque_retenu(num_mail)); // pour simplifier
List_io<TypeQuelconque>::iterator itq=find(tpg_ret.begin(),tpg_ret.end(),a);
if (find(tpg_ret.begin(),tpg_ret.end(),a) != tpg_ret.end())
{trouve = true; xx2=*itq;}
if (!trouve)
{ cout << "\n choix non valide, recommencez !"; choix_valide = false;}
else // on indique avec type_xi que les grandeurs sont aux éléments et que c'est une grandeur particuliere
{choix_valide = true; type_xi = false;ddl_etpas_TQ_2=0;};
}
else
{ cout << "\n type non numerique, courbe imporssible, donnez un autre type ";choix_valide = false;};
}
else
{ cout << "\n type inexistant, verifiez votre syntaxe ";choix_valide = false;};
}
else if (rep == "ele")
{ cout << "\n choisissez une grandeur dans la liste de grandeur actuellement enregistrees : ";
List_io < Ddl_enum_etendu>& listb = tabelement_type_ddl_retenu(num_mail);
List_io < Ddl_enum_etendu>:: iterator iddl,iddlfin = listb.end();
for (iddl=listb.begin();iddl != iddlfin; iddl++)
cout << (*iddl) << " ";
cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
// on vérifie que le nom fourni appartient bien à la liste
if (Ddl_enum_etendu::VerifExistence(rep))
{ // on vérifie qu'il appartient à la liste des ddl proposés
Ddl_enum_etendu enu_etendu(rep);
if (Ddl_enum_etendu::Existe_dans_la_liste
(tabelement_type_ddl_retenu(num_mail),enu_etendu))
{trouve = true; x2=enu_etendu;}};
if (!trouve)
{ cout << "\n choix non valide, recommencez !"; choix_valide = false;}
else // on indique avec type_xi que les grandeurs sont aux éléments, qu'il s'agit d'un ddl
{choix_valide = true; type_xi = false;ddl_etpas_TQ_2=3;};
}
else if (rep == "elp")
{ cout << "\n choisissez une grandeur dans la liste de grandeur particulieres actuellement enregistrees : ";
List_io < TypeQuelconque>& listb = tabelement_typeParti_retenu(num_mail);
List_io < TypeQuelconque>:: iterator iddl,iddlfin = listb.end();
for (iddl=listb.begin();iddl != iddlfin; iddl++)
cout << ((*iddl).EnuTypeQuelconque().NomPlein()) << " ";
cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
// on ne continue que si le type quelconque existe
if (TypeQuelconque_enum_etendu::VerifExistence(rep))
{// on regarde si c'est un type numérique
TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
if (a.Type_numerique()) // cas d'un type numérique
{ int nbordre = a.NbMaxiNumeroOrdre(); // récup du nombre de numéro d'ordre
if (nbordre != 1)
{ // dans le cas où il y a plusieurs grandeurs scalaires il faut choisir
cout << "\n grandeur avec plusieurs composantes: donnez un numero ? "
<< "\n pour un tableau, vecteur, liste: il s'agit de l'ordre de la grandeur "
<< "\n pour un tenseur, un tableau multi-dim, c'est le dernier indice qui varie d'abord";
rep = lect_chaine(); int nn = ChangeEntier(rep);
if ((nn>=0) && (nn<=nbordre)) { if (nn==nbordre) {nb_ordre_2 = 0;} else {nb_ordre_2 = nn;};}
else { cout << "\n choix non valide, doit etre compris entre " << 1 << " et " << nbordre << " ";}
}
else { nb_ordre_2=1;}; // cas où il n'y qu'une seule valeur scalaire
// on vérifie que le nom fourni appartient bien à la liste
List_io<TypeQuelconque>& tpg_ret = (tabelement_typeParti_retenu(num_mail)); // pour simplifier
List_io<TypeQuelconque>::iterator itq=find(tpg_ret.begin(),tpg_ret.end(),a);
if (find(tpg_ret.begin(),tpg_ret.end(),a) != tpg_ret.end())
{trouve = true; xx2=*itq;}
if (!trouve)
{ cout << "\n choix non valide, recommencez !"; choix_valide = false;}
else // on indique avec type_xi que les grandeurs sont aux éléments et que c'est une grandeur particuliere
{choix_valide = true; type_xi = false;ddl_etpas_TQ_2=0;};
}
else
{ cout << "\n type non numerique, courbe imporssible, donnez un autre type ";choix_valide = false;};
}
else
{ cout << "\n type inexistant, verifiez votre syntaxe ";choix_valide = false;};
}
else if (rep == "elt")
{ cout << "\n choisissez une grandeur dans la liste de grandeur tensorielle actuellement enregistrees : ";
List_io < TypeQuelconque>& listb = tabelement_evoluee_retenu(num_mail);
List_io < TypeQuelconque>:: iterator iddl,iddlfin = listb.end();
for (iddl=listb.begin();iddl != iddlfin; iddl++)
cout << ((*iddl).EnuTypeQuelconque().NomPlein()) << " ";
cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
// on ne continue que si le type quelconque existe
if (TypeQuelconque_enum_etendu::VerifExistence(rep))
{// on regarde si c'est un type numérique
TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
if (a.Type_numerique()) // cas d'un type numérique
{ int nbordre = a.NbMaxiNumeroOrdre(); // récup du nombre de numéro d'ordre
if (nbordre != 1)
{ // dans le cas où il y a plusieurs grandeurs scalaires il faut choisir
cout << "\n grandeur avec plusieurs composantes: donnez un numero ? "
<< "\n pour un tableau, vecteur, liste: il s'agit de l'ordre de la grandeur "
<< "\n pour un tenseur, un tableau multi-dim, c'est le dernier indice qui varie d'abord";
rep = lect_chaine(); int nn = ChangeEntier(rep);
if ((nn>=0) && (nn<=nbordre)) { if (nn==nbordre) {nb_ordre_2 = 0;} else {nb_ordre_2 = nn;};}
else { cout << "\n choix non valide, doit etre compris entre " << 1 << " et " << nbordre << " ";}
}
else { nb_ordre_2=1;}; // cas où il n'y qu'une seule valeur scalaire
// on vérifie que le nom fourni appartient bien à la liste
List_io<TypeQuelconque>& tpg_ret = (tabelement_evoluee_retenu(num_mail)); // pour simplifier
List_io<TypeQuelconque>::iterator itq=find(tpg_ret.begin(),tpg_ret.end(),a);
if (find(tpg_ret.begin(),tpg_ret.end(),a) != tpg_ret.end())
{trouve = true; xx2=*itq;}
if (!trouve)
{ cout << "\n choix non valide, recommencez !"; choix_valide = false;}
else // on indique avec type_xi que les grandeurs sont aux éléments et que c'est une grandeur particuliere
{choix_valide = true; type_xi = false;ddl_etpas_TQ_2=0;};
}
else
{ cout << "\n type non numerique, courbe imporssible, donnez un autre type ";choix_valide = false;};
}
else
{ cout << "\n type inexistant, verifiez votre syntaxe ";choix_valide = false;};
}
else if (rep == "f")
{ cout << "\n arret de la procedure .... ";
return false;
}
else
{ cout << "\n choix non valide, recommencez ! ";choix_valide = false;
}
} // fin du choix de x2
// on regarde s'il s'agit de la grandeur ou de son accroissement de o à t
cout << "\n en ordonnee: grandeur ou variation entre 0 et t de la grandeur ? (rep: 1 ou 0) ";
cout << "\n reponse ? "; rep = lect_chaine();
if (rep == "1") accroi_x2=false; else accroi_x2 = true;
// --- maintenant on s'occupe de x1 ---
{bool choix_valide = false;
while (!choix_valide)
{cout << "\n ------- choix de la grandeur en abscisse ----------";
if (type_xi)
{cout << "\n ddl aux noeuds -> rep : noe ?"
<< "\n ddl etendu aux noeuds -> rep : net ?"
<< "\n grandeur particuliere aux noeuds -> rep : nop ?"
<< "\n arret de la manip -> rep : f ?";
cout << "\n reponse ? "; rep = lect_return_defaut(false,"f");
if (rep == "noe")
{ cout << "\n choisissez une grandeur dans la liste des ddl actuellement enregistrees : ";
List_io < Ddl_enum_etendu>& lista = tabnoeud_type_ddl_retenu(num_mail);
List_io < Ddl_enum_etendu>:: iterator iddl,iddlfin = lista.end();
for (iddl=lista.begin();iddl != iddlfin; iddl++)
cout << (*iddl) << " ";
cout << "\n reponse ? "; rep = lect_return_defaut(false,"f"); bool trouve = false;
// on vérifie que le nom fourni appartient bien à la liste
if (Ddl_enum_etendu::VerifExistence(rep))
{ // on vérifie qu'il appartiend à la liste des ddl proposés
Ddl_enum_etendu enu_etendu(rep);
if (Ddl_enum_etendu::Existe_dans_la_liste
(tabnoeud_type_ddl_retenu(num_mail),enu_etendu))
{trouve = true; x1=enu_etendu;}
}; // x1 contient la grandeur à visualiser
if (!trouve)
{ cout << "\n choix non valide, recommencez !"; choix_valide = false;}
else // on indique avec ddl_etpas_TQ_1 qu'il s'agit d'un ddl principal au noeud
{choix_valide = true; ddl_etpas_TQ_1=1;};
}
else if (rep == "net")
{ cout << "\n choisissez une grandeur dans la liste des ddl etendus actuellement enregistrees : ";
List_io < Ddl_enum_etendu>& lista = tabnoeud_type_ddlEtendu_retenu(num_mail);
List_io < Ddl_enum_etendu>:: iterator iddl,iddlfin = lista.end();
for (iddl=lista.begin();iddl != iddlfin; iddl++)
cout << (*iddl) << " ";
cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
// on vérifie que le nom fourni appartient bien à la liste
if (Ddl_enum_etendu::VerifExistence(rep))
{ // on vérifie qu'il appartiend à la liste des ddl proposés
Ddl_enum_etendu enu_etendu(rep);
if (Ddl_enum_etendu::Existe_dans_la_liste
(tabnoeud_type_ddlEtendu_retenu(num_mail),enu_etendu))
{trouve = true; x1=enu_etendu;}
};
if (!trouve)
{ cout << "\n choix non valide, recommencez !"; choix_valide = false;}
else // on indique avec ddl_etpas_TQ_1 qu'il s'agit d'un ddl étendu secondaire
{choix_valide = true; ddl_etpas_TQ_1=2;};
}
else if (rep == "nop")
{ cout << "\n choisissez une grandeur dans la liste de grandeur actuellement enregistrees : ";
List_io < TypeQuelconque>& listb = tabnoeud_TypeQuelconque_retenu(num_mail);
List_io < TypeQuelconque>:: iterator iddl,iddlfin = listb.end();
for (iddl=listb.begin();iddl != iddlfin; iddl++)
cout << ((*iddl).EnuTypeQuelconque().NomPlein()) << " ";
cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
// on ne continue que si le type quelconque existe
if (TypeQuelconque_enum_etendu::VerifExistence(rep))
{// on regarde si c'est un type numérique
TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
if (a.Type_numerique()) // cas d'un type numérique
{ int nbordre = a.NbMaxiNumeroOrdre(); // récup du nombre de numéro d'ordre
if (nbordre != 1)
{ // dans le cas où il y a plusieurs grandeurs scalaires il faut choisir
cout << "\n grandeur avec plusieurs composantes: donnez un numero ? "
<< "\n pour un tableau, vecteur, liste: il s'agit de l'ordre de la grandeur "
<< "\n pour un tenseur, un tableau multi-dim, c'est le dernier indice qui varie d'abord";
rep = lect_chaine(); int nn = ChangeEntier(rep);
if ((nn>=0) && (nn<=nbordre)) { if (nn==nbordre) {nb_ordre_1 = 0;} else {nb_ordre_1 = nn;};}
else { cout << "\n choix non valide, doit etre compris entre " << 1 << " et " << nbordre << " ";}
}
else { nb_ordre_1=1;}; // cas où il n'y qu'une seule valeur scalaire
// on vérifie que le nom fourni appartient bien à la liste
List_io<TypeQuelconque>& tpg_ret = (tabnoeud_TypeQuelconque_retenu(num_mail)); // pour simplifier
List_io<TypeQuelconque>::iterator itq=find(tpg_ret.begin(),tpg_ret.end(),a);
if (find(tpg_ret.begin(),tpg_ret.end(),a) != tpg_ret.end())
{trouve = true; xx1=*itq;}
if (!trouve)
{ cout << "\n choix non valide, recommencez !"; choix_valide = false;}
else // on indique avec type_xi que les grandeurs sont aux éléments et que c'est une grandeur particuliere
{choix_valide = true; type_xi = false;ddl_etpas_TQ_1=0;};
}
else
{ cout << "\n type non numerique, courbe imporssible, donnez un autre type ";choix_valide = false;};
}
else
{ cout << "\n type inexistant, verifiez votre syntaxe ";choix_valide = false;};
}
else if (rep == "f")
{ cout << "\n arret de la procedure .... ";
return false;
}
else
{ cout << "\n choix non valide, recommencez ! ";choix_valide = false;
};
}
else
{ cout << "\n grandeurs aux elements(generique) -> rep : ele ?"
<< "\n ou grandeurs aux elements(particuliere) -> rep : elp ?"
<< "\n ou grandeurs aux elements(tensorielle) -> rep : elt ?"
;
int dima = ParaGlob::Dimension();
cout << "\n ou position du point: " ;
for (int i=1; i<= dima;i++) cout << " X" << i <<" ";
cout << " -> rep : ?";
cout << "\n arret de la manip -> rep : f ?";
cout << "\n reponse ? "; rep = lect_return_defaut(false,"f");
// tout d'abord on vérifie que ce n'est pas une position sur les axes de base
if ((rep == "X1") || (rep == "X2") || (rep == "X3"))
{ // on vérifie que la dimension est ok
if (((rep == "X3")&&(dima<3)) || ((rep == "X2")&&(dima==1)))
{cout << "\n choix non valide, " << rep << " ne convient pas pour la dimension du probleme "
<< dima << " recommencez ";
choix_valide = false;
}
else
{Ddl_enum_etendu enu_etendu(rep);
x1=enu_etendu;
choix_valide = true;
ddl_etpas_TQ_1=3; // il s'agit de ddl étendue
type_xi = false; // car il s'agit des coordonnées du points d'integ par exemple
};
}
else if (rep == "f")
{ cout << "\n arret de la procedure .... ";
return false;
}
else if (rep == "ele") // car d'une grandeur de type ddl générique
{ cout << "\n choisissez une grandeur dans la liste de grandeur actuellement enregistrees : ";
List_io < Ddl_enum_etendu>& listb = tabelement_type_ddl_retenu(num_mail);
List_io < Ddl_enum_etendu>:: iterator iddl,iddlfin = listb.end();
for (iddl=listb.begin();iddl != iddlfin; iddl++)
cout << (*iddl).Nom() << " ";
rep = lect_chaine(); bool trouve = false;
// on vérifie que le nom fourni appartient bien à la liste possible
if (Ddl_enum_etendu::VerifExistence(rep))
{ // on vérifie qu'il appartiend à la liste des ddl proposés
Ddl_enum_etendu enu_etendu(rep);
if (Ddl_enum_etendu::Existe_dans_la_liste
(tabelement_type_ddl_retenu(num_mail),enu_etendu))
{trouve = true; x1=enu_etendu;}
};
if (!trouve)
{ cout << "\n choix non valide, recommencez !"; choix_valide = false;}
else // sinon on valide le choix et on indique qu'il s'agit d'un ddl et non d'une grandeur particulière
{choix_valide = true;ddl_etpas_TQ_1=3; };
}
else if (rep == "elp") // cas d'une grandeur de type particulière
{ cout << "\n choisissez une grandeur dans la liste de grandeur actuellement enregistrees : ";
List_io < TypeQuelconque>& listb = tabelement_typeParti_retenu(num_mail);
List_io < TypeQuelconque>:: iterator iddl,iddlfin = listb.end();
for (iddl=listb.begin();iddl != iddlfin; iddl++)
cout << ((*iddl).EnuTypeQuelconque().NomPlein()) << " ";
cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
// on ne continue que si le type quelconque existe
if (TypeQuelconque_enum_etendu::VerifExistence(rep))
{// on regarde si c'est un type numérique
TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
if (a.Type_numerique()) // cas d'un type numérique
{ int nbordre = a.NbMaxiNumeroOrdre(); // récup du nombre de numéro d'ordre
if (nbordre != 1)
{ // dans le cas où il y a plusieurs grandeurs scalaires il faut choisir
cout << "\n grandeur avec plusieurs composantes: donnez un numero ? "
<< "\n pour un tableau, vecteur, liste: il s'agit de l'ordre de la grandeur "
<< "\n pour un tenseur, un tableau multi-dim, c'est le dernier indice qui varie d'abord";
rep = lect_chaine(); int nn = ChangeEntier(rep);
if ((nn>=0) && (nn<=nbordre)) { if (nn==nbordre) {nb_ordre_1 = 0;} else {nb_ordre_1 = nn;};}
else { cout << "\n choix non valide, doit etre compris entre " << 1 << " et " << nbordre << " ";}
}
else { nb_ordre_1=1;}; // cas où il n'y qu'une seule valeur scalaire
// on vérifie que le nom fourni appartient bien à la liste
List_io<TypeQuelconque>& tpg_ret = (tabelement_typeParti_retenu(num_mail)); // pour simplifier
List_io<TypeQuelconque>::iterator itq=find(tpg_ret.begin(),tpg_ret.end(),a);
if (find(tpg_ret.begin(),tpg_ret.end(),a) != tpg_ret.end())
{trouve = true; xx1=*itq;}
if (!trouve)
{ cout << "\n choix non valide, recommencez !"; choix_valide = false;}
else // on indique avec type_xi que les grandeurs sont aux éléments et que c'est une grandeur particuliere
{choix_valide = true; type_xi = false;ddl_etpas_TQ_1=0;};
}
else
{ cout << "\n type non numerique, courbe imporssible, donnez un autre type ";choix_valide = false;};
}
else
{ cout << "\n type inexistant, verifiez votre syntaxe ";choix_valide = false;};
}
else if (rep == "elt") // cas d'une grandeur de type tensorielle
{ cout << "\n choisissez une grandeur dans la liste de grandeur actuellement enregistrees : ";
List_io < TypeQuelconque>& listb = tabelement_evoluee_retenu(num_mail);
List_io < TypeQuelconque>:: iterator iddl,iddlfin = listb.end();
for (iddl=listb.begin();iddl != iddlfin; iddl++)
cout << ((*iddl).EnuTypeQuelconque().NomPlein()) << " ";
cout << "\n reponse ? "; rep = lect_chaine(); bool trouve = false;
// on ne continue que si le type quelconque existe
if (TypeQuelconque_enum_etendu::VerifExistence(rep))
{// on regarde si c'est un type numérique
TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
if (a.Type_numerique()) // cas d'un type numérique
{ int nbordre = a.NbMaxiNumeroOrdre(); // récup du nombre de numéro d'ordre
if (nbordre != 1)
{ // dans le cas où il y a plusieurs grandeurs scalaires il faut choisir
cout << "\n grandeur avec plusieurs composantes: donnez un numero ? "
<< "\n pour un tableau, vecteur, liste: il s'agit de l'ordre de la grandeur "
<< "\n pour un tenseur, un tableau multi-dim, c'est le dernier indice qui varie d'abord";
rep = lect_chaine(); int nn = ChangeEntier(rep);
if ((nn>=0) && (nn<=nbordre)) { if (nn==nbordre) {nb_ordre_1 = 0;} else {nb_ordre_1 = nn;};}
else { cout << "\n choix non valide, doit etre compris entre " << 1 << " et " << nbordre << " ";}
}
else { nb_ordre_1=1;}; // cas où il n'y qu'une seule valeur scalaire
// on vérifie que le nom fourni appartient bien à la liste
List_io<TypeQuelconque>& tpg_ret = (tabelement_evoluee_retenu(num_mail)); // pour simplifier
List_io<TypeQuelconque>::iterator itq=find(tpg_ret.begin(),tpg_ret.end(),a);
if (find(tpg_ret.begin(),tpg_ret.end(),a) != tpg_ret.end())
{trouve = true; xx1=*itq;}
if (!trouve)
{ cout << "\n choix non valide, recommencez !"; choix_valide = false;}
else // on indique avec type_xi que les grandeurs sont aux éléments et que c'est une grandeur evoluée
{choix_valide = true; type_xi = false;ddl_etpas_TQ_1=0;};
}
else
{ cout << "\n type non numerique, courbe imporssible, donnez un autre type ";choix_valide = false;};
}
else
{ cout << "\n type inexistant, verifiez votre syntaxe ";choix_valide = false;};
}
else if (rep == "f")
{ cout << "\n arret de la procedure .... ";
return false;
}
};//-- fin du choix ele ou elp pour x1
}; //-- fin du while choix_valide pour x1
}; // fin du choix de x1
// on regarde s'il s'agit de la grandeur ou de son accroissement de o à t
cout << "\n en abscisse: grandeur ou variation entre 0 et t de la grandeur ? (rep: 1 ou 0) ";
cout << "\n reponse ? "; rep = lect_1_0(false);
if (rep == "1") accroi_x1=false; else accroi_x1 = true;
// appel de la méthode de la classe mère
OrdreVisu::ChoixOrdre();
return true;
};
// lecture des paramètres de l'ordre dans un flux
void Choix_grandeurs_maple::Lecture_parametres_OrdreVisu(UtilLecture & entreePrinc)
{ // si dans le flot il existe l'identificateur adoc on lit sinon on passe
if (strstr(entreePrinc.tablcarCVisu,"debut_grandeurs_maple")!=NULL)
{// sauvegarde des listes actuelles
Tableau <List_io < Ddl_enum_etendu > > tabnoeud_type_ddl_retenu_sauve(tabnoeud_type_ddl_retenu); // ddl principaux aux noeuds à visualiser
int type_sortie_ddl_retenue_sauve = type_sortie_ddl_retenue;
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_TypeQuelconque_retenu_sauve(tabnoeud_TypeQuelconque_retenu); // grandeurs particulières aux noeuds
Tableau <List_io < Ddl_enum_etendu > > tabelement_type_ddl_retenu_sauve(tabelement_type_ddl_retenu); // ddl aux elements à visualiser
// -> face d'éléments
Tableau <List_io < TypeQuelconque > > tab_F_element_TypeQuelconque_retenu_sauve(tab_F_element_TypeQuelconque_retenu);
Tableau <List_io < TypeQuelconque > > tab_F_element_TypeQuelconque_retenu_pourSM_sauve(tab_F_element_TypeQuelconque_retenu_pourSM);
// -> arête d'éléments
Tableau <List_io < TypeQuelconque > > tab_A_element_TypeQuelconque_retenu_sauve(tab_A_element_TypeQuelconque_retenu);
Tableau <List_io < TypeQuelconque > > tab_A_element_TypeQuelconque_retenu_pourSM_sauve(tab_A_element_TypeQuelconque_retenu_pourSM);
Tableau <List_io <int> > tab_num_noeud_sauve(tab_num_noeud); // liste des noeuds à visualiser
Tableau <List_io <int> > tab_num_element_sauve(tab_num_element); // liste des éléments à visualiser
Tableau <List_io <int> > tab_num_integ_sauve(tab_num_integ); // liste des numéros de point d'integration à visualiser
// -> les pti de face d'éléments
Tableau <List_io <int> > tab_num_F_element_sauve(tab_num_F_element); // liste des éléments à visualiser
Tableau <List_io <int> > tab_num_F_sauve(tab_num_F); // liste des num de face ou arêtes d'éléments à visualiser
Tableau <List_io <int> > tab_num_F_integ_sauve(tab_num_F_integ); // liste des numéros de point d'integration à visualiser associé à tab_num_F_element
Tableau <List_io <BlocScal> > nomDeRef_F_E_sauve(nomDeRef_F_E); // list de nom de références face d'éléments associés
Tableau <List_io <string> > nomDeRef_F_ptinteg_sauve(nomDeRef_F_ptinteg); // list de nom de références de pt d'integ de face d'éléments
// -> les pti d'arête d'éléments
Tableau <List_io <int> > tab_num_A_element_sauve(tab_num_A_element); // liste des éléments à visualiser
Tableau <List_io <int> > tab_num_A_sauve(tab_num_A); // liste des num d'arêtes d'éléments à visualiser
Tableau <List_io <int> > tab_num_A_integ_sauve(tab_num_A_integ); // liste des numéros de point d'integration à visualiser associé à tab_num_A_element
Tableau <List_io <BlocScal> > nomDeRef_A_E_sauve(nomDeRef_A_E); // list de nom de références d'arête d'éléments associé
Tableau <List_io <string> > nomDeRef_A_ptinteg_sauve(nomDeRef_A_ptinteg); // list de nom de références de pt d'integ d'arête d'éléments
Tableau < List_io <String_et_entier > > // les torseurs associées aux conditions limite, à visualiser
tab_list_torseur_condLim_retenu_sauve(tab_list_torseur_condLim_retenu);
Tableau <List_io < TypeQuelconque > > tabelement_evoluee_retenu_s(tabelement_evoluee_retenu);
Tableau <List_io <string> > nomDeRef_sauve(nomDeRef); // list de nom de références de noeuds
Tableau <List_io <BlocScal> > nomDeRef_E_sauve(nomDeRef_E); // list de nom de références d'éléments et de point d'intégration associé
Tableau <List_io <string> > nomDeRef_ptinteg_sauve(nomDeRef_ptinteg); // list de nom de références de pt d'integ d'éléments
List_io <TypeQuelconque > listeVecGlobbal_retenu_sauve(listeVecGlobbal_retenu); // les vecteurs globaux à visualiser
listeVecGlobbal_retenu.clear(); // initialisation
// ------parties moyennes et sommes
Tableau <List_io <string> > tab_nomDeRef_SM_sauve(tab_nomDeRef_SM);
Tableau <List_io <BlocScal> > tab_nomDeRef_E_SM_sauve(tab_nomDeRef_E_SM);
Tableau <List_io <string> > tab_nomDeRef_ptinteg_SM_sauve(tab_nomDeRef_ptinteg_SM);
Tableau <List_io < Ddl_enum_etendu > > tabnoeud_type_ddl_retenu_pourSM_sauve(tabnoeud_type_ddl_retenu_pourSM);
Tableau <List_io < Ddl_enum_etendu > > tabnoeud_type_ddlEtendu_retenu_pourSM_sauve(tabnoeud_type_ddlEtendu_retenu_pourSM);
Tableau <List_io < TypeQuelconque > > tabnoeud_TypeQuelconque_retenu_pourSM_sauve(tabnoeud_TypeQuelconque_retenu_pourSM);
Tableau <List_io < Ddl_enum_etendu > > tabelement_type_ddl_retenu_pourSM_sauve(tabelement_type_ddl_retenu_pourSM);
Tableau <List_io < TypeQuelconque > > tabelement_typeParti_retenu_pourSM_sauve(tabelement_typeParti_retenu_pourSM);
Tableau <List_io < TypeQuelconque > > tabelement_evoluee_retenu_pourSM_sauve(tabelement_evoluee_retenu_pourSM);
// concernant les faces et arêtes
Tableau <List_io <BlocScal> > tab_nomDeRef_F_E_SM_sauve(tab_nomDeRef_F_E_SM);
Tableau <List_io <string> > tab_nomDeRef_F_ptinteg_SM_sauve(tab_nomDeRef_F_ptinteg_SM);
Tableau <List_io <BlocScal> > tab_nomDeRef_A_E_SM_sauve(tab_nomDeRef_A_E_SM);
Tableau <List_io <string> > tab_nomDeRef_A_ptinteg_SM_sauve(tab_nomDeRef_A_ptinteg_SM);
// il faut que l'on remette à jour les grandeurs globales car elles peuvent avoir été abondées
// pendant le calcul ex: Iteration, compteur divers ...
// comme on est en interactif le cout cpu a moins d'importance
ParaGlob::param->Recup_list_GrandeurGlobal(list_grandeur_global);
// essaie de lecture
try
{ string nom,nom2;
(*entreePrinc.entCVisu) >> nom ;
if (nom != "debut_grandeurs_maple")
{ cout << "\n Erreur en lecture des grandeurs a visualiser au format maple a partir d'un fichier .CVisu,"
<< " le premier enregistrement doit etre le mot clef: debut_grandeurs_maple "
<< " on ne tiens pas compte de la liste fournie !! ";
}
else
{ // appel de l'ordre de la classe mère
OrdreVisu::Lect_para_OrdreVisu_general(entreePrinc);
// lecture des grandeurs globales éventuelles
if (strstr(entreePrinc.tablcarCVisu,"debut_grandeurs_globales")!=NULL)
{ // lecture de la liste des grandeurs
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface la liste actuelle
list_grand_global_retenu.erase(list_grand_global_retenu.begin(),list_grand_global_retenu.end());
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_grandeurs_globales")
{ // on vérifie que le nom lu est acceptable
// if (find(list_grandeur_global.begin(),list_grandeur_global.end(),nom) != list_grandeur_global.end())
bool grandeur_ok = false; // init par défaut
// 1) on regarde dans la liste des grandeurs globales normales (inscrits en dur)
if (find(list_grandeur_global.begin(),list_grandeur_global.end(),nom) != list_grandeur_global.end())
grandeur_ok=true;
// 2) on regarde dans la liste réelle s'il ne s'agit pas d'une grandeur en string
if (ParaGlob::param->GrandeurGlobal(nom) != NULL)
grandeur_ok = true;
//en dernier lieu on fait un traitement spécial dans le cas où il s'agit d'intégrales
// même si les variables ne sont pas valides,
if (nom.find("INTEG_SUR_VOLUME_ET_TEMPS") != std::string::npos)
{grandeur_ok = true;}
else if (nom.find("INTEG_SUR_VOLUME") != std::string::npos)
{grandeur_ok = true;};
// enregistrement
if (grandeur_ok)
list_grand_global_retenu.push_back(nom);
else
cout << "\n lecture d'un nom de grandeur global ( "<< nom << " ) errone ! on n'en tiens pas compte";
}
else break;
};
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
int nb_maillage = lesMail->NbMaillage(); int imail;
// redimentionnement éventuelle
tab_list_torseur_condLim_retenu.Change_taille(nb_maillage);
while (strstr(entreePrinc.tablcarCVisu,"fin_grandeurs_maple")==NULL)
{ (*entreePrinc.entCVisu) >> imail; // lecture du numero de maillage
if (imail > nb_maillage) // 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 trop grand !! nombre lu " << imail
<< " alors que nb_maillage enregistre: " << nb_maillage ;
cout << "\n Choix_grandeurs_maple::Lecture_parametres_OrdreVisu(... ";
UtilLecture::ErrNouvelEnregCVisu sortie(-1) ; throw (sortie);
};
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
//---- lecture des torseurs ----
if (strstr(entreePrinc.tablcarCVisu,"debut_list_torseur_reaction")!=NULL)
{// lecture de la liste des références
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
List_io <String_et_entier >& list_torseur_condLim = tab_list_torseur_condLim(imail);
List_io <String_et_entier >& list_torseur_condLim_retenu = tab_list_torseur_condLim_retenu(imail);
List_io <String_et_entier>::iterator jeint,jeintfin = list_torseur_condLim.end();
// on efface la liste actuelle
list_torseur_condLim_retenu.erase(list_torseur_condLim_retenu.begin(),list_torseur_condLim_retenu.end());
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_torseur_reaction")
{ // on vérifie que le nom lu est acceptable
bool choix_valide = false;
for (jeint=list_torseur_condLim.begin();jeint!=jeintfin;jeint++)
{ if ((*jeint).nom == nom)
{ list_torseur_condLim_retenu.push_back(*jeint);
choix_valide = true;
break;
};
};
if (!choix_valide)
cout << "\n lecture d'un nom de ref de torseur de reaction ( "
<< nom << " ) qui ne fait pas partie des refs de ddl bloque !"
<< " \n on n'en tiens pas compte car il n'y aura pas de reactions classiques "
<< " pour cette reference ";
}
else break;
};
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
// === cas des sommes, moyennes etc. relativement à des références ===
// --- les références des régions en noeuds
if (strstr(entreePrinc.tablcarCVisu,"debut_list_SM_sur_refN")!=NULL)
{ // lecture de la liste de références de noeuds
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface la liste actuelle
List_io <string>& lis_nomref = tab_nomDeRef_SM(imail);
lis_nomref.erase(lis_nomref.begin(),lis_nomref.end());
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list__SM_sur_refN")
{ if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 1))
{ cout << "\n erreur de nom: " << nom << ": ne correspond pas a une reference de noeud correcte "
<< " on passe ! ";
}
else
{lis_nomref.push_back(nom);}
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
//---- les grandeurs à considérer aux noeuds ----
// ** les ddl principaux aux noeuds
if (strstr(entreePrinc.tablcarCVisu,"deb_list_ddl_SM_sur_refN")!=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_pourSM(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_list_ddl_SM_sur_refN")
{ lis_sor.push_back(Ddl_enum_etendu(nom));}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
// ** les ddl étendus des noeuds
if (strstr(entreePrinc.tablcarCVisu,"deb_list_ddl_etendu__SM_sur_refN")!=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_pourSM(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_list_ddl_etendu__SM_sur_refN")
{ lis_sor.push_back(Ddl_enum_etendu(nom));}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
// ** les grandeurs particulières aux noeuds
if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandParticuliere__SM_sur_refN")!=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 = (tabnoeud_TypeQuelconque_retenu_pourSM(imail)); // pour simplifier
tpg_ret.clear(); // on vide les listes
//listeVecGlobbal_retenu.clear(); // déjà fait et sert plus bas, donc doit -être initialisé une seule fois !!
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
List_io<TypeQuelconque>& tpg = (tabnoeud_TypeQuelconque(imail)); // pour simplifier
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_GrandParticuliere__SM_sur_refN")
{ 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_TypeQuelconque on essaie au niveau des
// vecteur globaux
if (il == tpg.end())
{il = find(listeVecGlobbal.begin(),listeVecGlobbal.end(),a);
if (il != listeVecGlobbal.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) listeVecGlobbal_retenu.push_back(*il);
}
};
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
// --- les references des régions en éléments + num du pti où sont calculés les SMs
if (strstr(entreePrinc.tablcarCVisu,"debut_list_SM_sur_refE")!=NULL)
{ // lecture de la liste de références de elements
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface les listes actuelles
List_io <BlocScal>& lis_nomref_E = tab_nomDeRef_E_SM(imail);
lis_nomref_E.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_list__SM_sur_refE")
{ if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 2))
{ cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference d'element correcte "
<< " on passe ! ";
}
else
{ int numinteg; *entreePrinc.entCVisu >> numinteg; // lecture du num d'integ
lis_nomref_E.push_back(BlocScal(nom,numinteg)); }
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
// --- les references des regions en ref de pti d'éléments où sont calculés les SMs
if (strstr(entreePrinc.tablcarCVisu,"debut_list_SM_sur_refpti")!=NULL)
{ // lecture de la liste de références de points d'intégration d'élements
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface les listes actuelles
List_io <string>& lis_nomref_ptinteg = tab_nomDeRef_ptinteg_SM(imail);
lis_nomref_ptinteg.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_list__SM_sur_refpti")
{ if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 6))
{ cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference de point "
<< " d'integration correcte, on passe ! ";
}
else
{ lis_nomref_ptinteg.push_back(nom); }
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
//---- les grandeurs à considérer aux pti des éléments ----
// ** les ddl
if (strstr(entreePrinc.tablcarCVisu,"deb_list_ddl__SM_sur_refEpti")!=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_pourSM(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_list_ddl__SM_sur_refEpti")
{ lis_sor.push_back(Ddl_enum_etendu(nom));}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
// ** les grandeurs particulières
if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandParticuliere__SM_sur_refEpti")!=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_pourSM(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__SM_sur_refEpti")
{ 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
// 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
};
// ** les grandeurs évoluées aux éléments a visualiser
if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandEvoluee__SM_sur_refEpti")!=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 = (tabelement_evoluee_retenu_pourSM(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__SM_sur_refEpti")
{ 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
// 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 references des régions en faces d'élément + num du pti où sont calculés les SMs
if (strstr(entreePrinc.tablcarCVisu,"debut_list_SM_sur_refFE")!=NULL)
{ // lecture de la liste de références de faces d'elements
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface les listes actuelles
List_io <BlocScal>& lis_nomref_F_E = tab_nomDeRef_F_E_SM(imail);
lis_nomref_F_E.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_list__SM_sur_refFE")
{ if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 2))
{ cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference de faces d'element correcte "
<< " on passe ! ";
}
else
{ int numinteg; *entreePrinc.entCVisu >> numinteg; // lecture du num d'integ
lis_nomref_F_E.push_back(BlocScal(nom,numinteg)); }
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
// --- les references des regions en ref de pti de faces d'éléments où sont calculés les SMs
if (strstr(entreePrinc.tablcarCVisu,"debut_list_SM_sur_refFpti")!=NULL)
{ // lecture de la liste de références de points d'intégration de faces d'élements
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface les listes actuelles
List_io <string>& lis_nomref_ptinteg = tab_nomDeRef_F_ptinteg_SM(imail);
lis_nomref_ptinteg.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_list__SM_sur_refFpti")
{ if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 7))
{ cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference de point "
<< " d'integration de face correcte, on passe ! ";
}
else
{ lis_nomref_ptinteg.push_back(nom); }
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
//---- les grandeurs à considérer aux pti de faces d'éléments ----
// ** les grandeurs
if (strstr(entreePrinc.tablcarCVisu,"deb_list_Grandeur_SM_sur_refFEpti")!=NULL)
{ // lecture de la liste des grandeurs
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface la liste actuelle
List_io<TypeQuelconque>& tpg_ret = (tab_F_element_TypeQuelconque_retenu_pourSM(imail)); // pour simplifier
tpg_ret.clear();
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
List_io<TypeQuelconque>& tpg = (tab_F_element_TypeQuelconque(imail)); // pour simplifier
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_Grandeur_SM_sur_refFEpti")
{ 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
// 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
};
// --- les references des régions en arêtes d'élément + num du pti où sont calculés les SMs
if (strstr(entreePrinc.tablcarCVisu,"debut_list_SM_sur_refAE")!=NULL)
{ // lecture de la liste de références d'arêtes d'elements
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface les listes actuelles
List_io <BlocScal>& lis_nomref_A_E = tab_nomDeRef_A_E_SM(imail);
lis_nomref_A_E.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_list__SM_sur_refAE")
{ if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 2))
{ cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference d'aretes d'element correcte "
<< " on passe ! ";
}
else
{ int numinteg; *entreePrinc.entCVisu >> numinteg; // lecture du num d'integ
lis_nomref_A_E.push_back(BlocScal(nom,numinteg)); }
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
// --- les references des regions en ref de pti d'arêtes d'éléments où sont calculés les SMs
if (strstr(entreePrinc.tablcarCVisu,"debut_list_SM_sur_refApti")!=NULL)
{ // lecture de la liste de références de points d'intégration d'arêtes d'élements
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface les listes actuelles
List_io <string>& lis_nomref_ptinteg = tab_nomDeRef_A_ptinteg_SM(imail);
lis_nomref_ptinteg.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_list__SM_sur_refApti")
{ if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 8))
{ cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference de point "
<< " d'integration d'arete correcte, on passe ! ";
}
else
{ lis_nomref_ptinteg.push_back(nom); }
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
//---- les grandeurs à considérer aux pti d'arêtes d'éléments ----
// ** les grandeurs
if (strstr(entreePrinc.tablcarCVisu,"deb_list_Grandeur_SM_sur_refAEpti")!=NULL)
{ // lecture de la liste des grandeurs
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface la liste actuelle
List_io<TypeQuelconque>& tpg_ret = (tab_A_element_TypeQuelconque_retenu_pourSM(imail)); // pour simplifier
tpg_ret.clear();
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
List_io<TypeQuelconque>& tpg = (tab_A_element_TypeQuelconque(imail)); // pour simplifier
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_Grandeur_SM_sur_refAEpti")
{ 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
// 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
};
//---- lecture des grandeurs aux noeuds individuellement ----
if (strstr(entreePrinc.tablcarCVisu,"debut_liste_ddl_et_noeud")!=NULL)
{ entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
// ** liste de noeuds
if (strstr(entreePrinc.tablcarCVisu,"deb_list_noeud")!=NULL)
{ // lecture de la liste de noeuds
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface la liste actuelle
List_io <int>& lis_sor = tab_num_noeud(imail);
lis_sor.erase(lis_sor.begin(),lis_sor.end());
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_noeud")
{ lis_sor.push_back(ChangeEntier(nom));}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
}
// ** les references de liste de noeuds
if (strstr(entreePrinc.tablcarCVisu,"deb_list_ref_noeud")!=NULL)
{ // lecture de la liste de références de noeuds
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface la liste actuelle
List_io <string>& lis_nomref = nomDeRef(imail);
lis_nomref.erase(lis_nomref.begin(),lis_nomref.end());
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_ref_noeud")
{ if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 1))
{ cout << "\n erreur de nom: " << nom << ": ne correspond pas a une reference de noeud correcte "
<< " on passe ! ";
}
else
{lis_nomref.push_back(nom);}
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
}
// ** les ddl principaux aux noeuds
if (strstr(entreePrinc.tablcarCVisu,"deb_list_ddl_noeud")!=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.erase(lis_sor.begin(),lis_sor.end());
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_ddl_noeud")
{ lis_sor.push_back(Ddl_enum_etendu(nom));}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
// ** le type de sortie: type_sortie_ddl_retenue
if (strstr(entreePrinc.tablcarCVisu,"type_sortie_ddl_retenue")!=NULL)
{ // lecture du type de sortie
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
(*entreePrinc.entCVisu) >> type_sortie_ddl_retenue;
if ((type_sortie_ddl_retenue<0)||(type_sortie_ddl_retenue>2))
{cout << "\n *** erreur en lecture du type_sortie_ddl_retenue (valeur a 0 ou a t ou delta ou...)"
<< " la valeur doit-etre soit 0 soit 1 soit 2 et on a lue " << type_sortie_ddl_retenue
<< " on essaie de continuer mais la sortie sera sans doute erronee ..."
<< "\n Choix_grandeurs_maple::Lecture_parametres_OrdreVisu(...";
};
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
}
else {type_sortie_ddl_retenue=0;}; // sinon mise en place de la valeur par défaut
// ** lecture des ddl etendus aux noeuds
if (strstr(entreePrinc.tablcarCVisu,"deb_list_ddl_etendu_noeud")!=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.erase(lis_sor.begin(),lis_sor.end());
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_ddl_etendu_noeud")
{ lis_sor.push_back(Ddl_enum_etendu(nom));}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
// ** les grandeurs particulières aux noeuds
if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandParticuliere_noeud")!=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 = (tabnoeud_TypeQuelconque_retenu(imail)); // pour simplifier
tpg_ret.clear(); // on vide les listes
listeVecGlobbal_retenu.clear(); // idem
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
List_io<TypeQuelconque>& tpg = (tabnoeud_TypeQuelconque(imail)); // pour simplifier
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_GrandParticuliere_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_TypeQuelconque on essaie au niveau des
// vecteur globaux
if (il == tpg.end())
{il = find(listeVecGlobbal.begin(),listeVecGlobbal.end(),a);
if (il != listeVecGlobbal.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) listeVecGlobbal_retenu.push_back(*il);
}
};
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
};
// puis un autre pour "fin_liste_ddl_et_noeud"
entreePrinc.NouvelleDonneeCVisu();
};
// ----- lecture des grandeurs aux points d'intégrations d'éléments ------
if (strstr(entreePrinc.tablcarCVisu,"debut_liste_ddl_ptinteg")!=NULL)
{ entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
// ** les éléments et points d'intégration
if (strstr(entreePrinc.tablcarCVisu,"deb_list_NbElement_NbPtInteg")!=NULL)
{ // lecture de la liste des éléments et points d'intégration
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface les listes actuelles
List_io <int>& lis_sor = tab_num_element(imail);
List_io <int>& lis_sor2 = tab_num_integ(imail);
lis_sor.erase(lis_sor.begin(),lis_sor.end());
lis_sor2.erase(lis_sor2.begin(),lis_sor2.end());
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom ; compteur++;
if (nom != "fin_list_NbElement_NbPtInteg")
{(*entreePrinc.entCVisu) >> nom2 ;
lis_sor.push_back(ChangeEntier(nom));
lis_sor2.push_back(ChangeEntier(nom2));
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
}
// ** les references de liste d'éléments
if (strstr(entreePrinc.tablcarCVisu,"deb_list_ref_element")!=NULL)
{ // lecture de la liste de références de elements
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface les listes actuelles
List_io <BlocScal>& lis_nomref_E = nomDeRef_E(imail);
lis_nomref_E.erase(lis_nomref_E.begin(),lis_nomref_E.end());
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_ref_element")
{ if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 2))
{ cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference d'element correcte "
<< " on passe ! ";
}
else
{ int numinteg; *entreePrinc.entCVisu >> numinteg; // lecture du num d'integ
lis_nomref_E.push_back(BlocScal(nom,numinteg)); }
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
}
// *** les references de liste de points d'intégration d'éléments
if (strstr(entreePrinc.tablcarCVisu,"deb_list_ref_ptinteg_element")!=NULL)
{ // lecture de la liste de références de points d'intégration d'élements
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface les listes actuelles
List_io <string>& lis_nomref_ptinteg = nomDeRef_ptinteg(imail);
lis_nomref_ptinteg.erase(lis_nomref_ptinteg.begin(),lis_nomref_ptinteg.end());
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_ref_ptinteg_element")
{ if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 6))
{ cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference de point "
<< " d'integration correcte, on passe ! ";
}
else
{ lis_nomref_ptinteg.push_back(nom); }
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
}
// ** les ddl
if (strstr(entreePrinc.tablcarCVisu,"deb_list_ddl_element")!=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.erase(lis_sor.begin(),lis_sor.end());
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_ddl_element")
{ lis_sor.push_back(Ddl_enum_etendu(nom));}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
}
// ** les grandeurs particulières
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
//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
// 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
}
// ** les grandeurs évoluées aux éléments a visualiser
if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandEvoluee_element")!=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 = (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
// 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
};
// puis un autre pour "fin_liste_ddl_ptinteg"
entreePrinc.NouvelleDonneeCVisu();
}
// ----- lecture des grandeurs aux points d'intégrations de faces d'éléments ------
if (strstr(entreePrinc.tablcarCVisu,"debut_liste_grandeurs_ptinteg_F_E")!=NULL)
{ entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
// ** les faces d'éléments et points d'intégration
if (strstr(entreePrinc.tablcarCVisu,"deb_list_NbFaceElement_NbPtInteg")!=NULL)
{ // lecture de la liste des faces d'éléments et points d'intégration
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface les listes actuelles
List_io <int>& lis_sor = tab_num_F_element(imail);
List_io <int>& lis_sor2 = tab_num_F_integ(imail);
List_io <int>& lis_sor3 = tab_num_F(imail);
string nom3;
lis_sor.erase(lis_sor.begin(),lis_sor.end());
lis_sor2.erase(lis_sor2.begin(),lis_sor2.end());
lis_sor3.erase(lis_sor3.begin(),lis_sor3.end());
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom ; compteur++;
if (nom != "fin_list_NbFaceElement_NbPtInteg")
{(*entreePrinc.entCVisu) >> nom3 >> nom2 ;
lis_sor.push_back(ChangeEntier(nom));
lis_sor3.push_back(ChangeEntier(nom3));
lis_sor2.push_back(ChangeEntier(nom2));
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
}
// ** les references de liste de faces d'éléments
if (strstr(entreePrinc.tablcarCVisu,"deb_list_ref_F_element")!=NULL)
{ // lecture de la liste de références de faces d'élement
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface les listes actuelles
List_io <BlocScal>& lis_nomref_F_E = nomDeRef_F_E(imail);
lis_nomref_F_E.erase(lis_nomref_F_E.begin(),lis_nomref_F_E.end());
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_ref_F_element")
{ if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 3))
{ cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference de faces d'element correcte "
<< " on passe ! ";
}
else
{ int numinteg; *entreePrinc.entCVisu >> numinteg; // lecture du num d'integ
lis_nomref_F_E.push_back(BlocScal(nom,numinteg)); }
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
}
// *** les references de liste de points d'intégration de faces d'élément
if (strstr(entreePrinc.tablcarCVisu,"deb_list_ref_ptinteg_F_element")!=NULL)
{ // lecture de la liste de références de points d'intégration de faces d'élement
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface les listes actuelles
List_io <string>& lis_nomref_ptinteg = nomDeRef_F_ptinteg(imail);
lis_nomref_ptinteg.erase(lis_nomref_ptinteg.begin(),lis_nomref_ptinteg.end());
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_ref_ptinteg_F_element")
{ if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 7))
{ cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference de point "
<< " d'integration correcte pour une face d'element, on passe ! ";
}
else
{ lis_nomref_ptinteg.push_back(nom); }
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
}
// ** les grandeurs
if (strstr(entreePrinc.tablcarCVisu,"deb_list_Grandeur_F_element")!=NULL)
{ // lecture de la liste des grandeurs
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface la liste actuelle
List_io<TypeQuelconque>& tpg_ret = (tab_F_element_TypeQuelconque_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 = (tab_F_element_TypeQuelconque(imail)); // pour simplifier
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_Grandeur_F_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
//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
// 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
}
// puis un autre pour "fin_liste_grandeurs_ptinteg_F_E"
entreePrinc.NouvelleDonneeCVisu();
}
// ----- lecture des grandeurs aux points d'intégrations d'arêtes d'éléments ------
if (strstr(entreePrinc.tablcarCVisu,"debut_liste_grandeurs_ptinteg_A_E")!=NULL)
{ entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
// ** les arêtes d'éléments et points d'intégration
if (strstr(entreePrinc.tablcarCVisu,"deb_list_NbAreteElement_NbPtInteg")!=NULL)
{ // lecture de la liste des faces d'éléments et points d'intégration
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface les listes actuelles
List_io <int>& lis_sor = tab_num_A_element(imail);
List_io <int>& lis_sor2 = tab_num_A_integ(imail);
List_io <int>& lis_sor3 = tab_num_A(imail);
string nom3;
lis_sor.erase(lis_sor.begin(),lis_sor.end());
lis_sor2.erase(lis_sor2.begin(),lis_sor2.end());
lis_sor3.erase(lis_sor3.begin(),lis_sor3.end());
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom ; compteur++;
if (nom != "fin_list_NbAreteElement_NbPtInteg")
{(*entreePrinc.entCVisu) >> nom3 >> nom2 ;
lis_sor.push_back(ChangeEntier(nom));
lis_sor3.push_back(ChangeEntier(nom3));
lis_sor2.push_back(ChangeEntier(nom2));
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
}
// ** les references de liste d'arêtes d'éléments
if (strstr(entreePrinc.tablcarCVisu,"deb_list_ref_A_element")!=NULL)
{ // lecture de la liste de références d'arêtes d'élement
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface les listes actuelles
List_io <BlocScal>& lis_nomref_A_E = nomDeRef_A_E(imail);
lis_nomref_A_E.erase(lis_nomref_A_E.begin(),lis_nomref_A_E.end());
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_ref_A_element")
{ if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 4))
{ cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference d'arete d'element correcte "
<< " on passe ! ";
}
else
{ int numinteg; *entreePrinc.entCVisu >> numinteg; // lecture du num d'integ
lis_nomref_A_E.push_back(BlocScal(nom,numinteg)); }
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
}
// *** les references de liste de points d'intégration d'arêtes d'élément
if (strstr(entreePrinc.tablcarCVisu,"deb_list_ref_ptinteg_A_element")!=NULL)
{ // lecture de la liste de références de points d'intégration d'arêtes d'élement
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface les listes actuelles
List_io <string>& lis_nomref_ptinteg = nomDeRef_A_ptinteg(imail);
lis_nomref_ptinteg.erase(lis_nomref_ptinteg.begin(),lis_nomref_ptinteg.end());
// lecture de la liste demandée
int compteur=0; // pour éviter une boucle infinie
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_ref_ptinteg_A_element")
{ if ((!(lesRef->Existe(nom,imail))) || ((lesRef->Trouve(nom,imail)).Indic() != 8))
{ cout << "\n erreur de nom (** "<< nom << " **) donne ne correspond pas a une reference de point "
<< " d'integration correcte pour une arete d'element, on passe ! ";
}
else
{ lis_nomref_ptinteg.push_back(nom); }
}
else break;
}
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
}
// ** les grandeurs
if (strstr(entreePrinc.tablcarCVisu,"deb_list_Grandeur_A_element")!=NULL)
{ // lecture de la liste des grandeurs
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
// on efface la liste actuelle
List_io<TypeQuelconque>& tpg_ret = (tab_A_element_TypeQuelconque_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 = (tab_A_element_TypeQuelconque(imail)); // pour simplifier
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;
if (nom != "fin_list_Grandeur_A_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
//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
// 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
}
// puis un autre pour "fin_liste_grandeurs_ptinteg_A_E"
entreePrinc.NouvelleDonneeCVisu();
}
// informations particulières pour le cas où il y a une animation
if (strstr(entreePrinc.tablcarCVisu,"debut_info_particulier")!=NULL)
{ // lecture de la liste des grandeurs
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
if (strstr(entreePrinc.tablcarCVisu,"grandeur_au_noeud?")!=NULL)
(*entreePrinc.entCVisu) >> nom >> type_xi;
if (strstr(entreePrinc.tablcarCVisu,"x1=")!=NULL)
(*entreePrinc.entCVisu) >> nom >> x1;
if (strstr(entreePrinc.tablcarCVisu,"x2=")!=NULL)
(*entreePrinc.entCVisu) >> nom >> x2;
if (strstr(entreePrinc.tablcarCVisu,"accroi_x1=")!=NULL)
(*entreePrinc.entCVisu) >> nom >> accroi_x1;
if (strstr(entreePrinc.tablcarCVisu,"accroi_x2=")!=NULL)
(*entreePrinc.entCVisu) >> nom >> accroi_x2;
// on ne lit pas le mot clé fin_info_particulier
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement pour la suite
}
// lecture du paramètre de pilotage du style de sortie
if (strstr(entreePrinc.tablcarCVisu,"parametre_style_de_sortie")!=NULL)
{ // lecture du style
(*entreePrinc.entCVisu) >> nom >> style_de_sortie;
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement pour la suite
};
// 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 Choix_grandeurs_maple::Lecture_parametres_OrdreVisu(... ";
UtilLecture::ErrNouvelEnregCVisu sortie(-1) ; throw (sortie);
}
else // sinon c'est ok
{entreePrinc.NouvelleDonneeCVisu();}; // on passe un enregistrement
};
} // -- fin du while sur les maillages
} // -- fin du if then else sur "debut_grandeurs_maple"
// vérification des listes de pt d'integ et d'éléments relativement au grandeur à sortir
VerifListes();
} // -- 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 pour les grandeurs a visualiser au format maple a partir d'un fichier .CVisu,"
<< " on ne tiens pas compte de la liste fournie !! ";
// récup des listes sauvées
tabnoeud_type_ddl_retenu=tabnoeud_type_ddl_retenu_sauve; // ddl principaux aux noeuds à visualiser
tabelement_type_ddl_retenu=tabelement_type_ddl_retenu_sauve; // ddl aux elements à visualiser
tabnoeud_type_ddlEtendu_retenu=tabnoeud_type_ddlEtendu_retenu_sauve; // ddl étendu aux noeuds
tabnoeud_TypeQuelconque_retenu=tabnoeud_TypeQuelconque_retenu_sauve; // les grandeurs quelconques
tabelement_evoluee_retenu = tabelement_evoluee_retenu_s;
// -> face d'éléments
tab_F_element_TypeQuelconque_retenu = tab_F_element_TypeQuelconque_retenu_sauve;
tab_F_element_TypeQuelconque_retenu_pourSM = tab_F_element_TypeQuelconque_retenu_pourSM_sauve;
// -> arête d'éléments
tab_A_element_TypeQuelconque_retenu = tab_A_element_TypeQuelconque_retenu_sauve;
tab_A_element_TypeQuelconque_retenu_pourSM = tab_A_element_TypeQuelconque_retenu_pourSM_sauve;
tab_num_noeud=tab_num_noeud_sauve; // liste des noeuds à visualiser
tab_num_element=tab_num_element_sauve; // liste des éléments à visualiser
tab_num_integ=tab_num_integ_sauve; // liste des numéros de point d'integration à visualiser
type_sortie_ddl_retenue=type_sortie_ddl_retenue_sauve;
nomDeRef = nomDeRef_sauve; // list de nom de références de noeuds
nomDeRef_E = nomDeRef_E_sauve; // list de nom de références d'éléments et de point d'intégration associé
nomDeRef_ptinteg = nomDeRef_ptinteg_sauve; // list de nom de références de pt d'integ
listeVecGlobbal_retenu = listeVecGlobbal_retenu_sauve; // les vecteurs globaux
// -> les pti de face d'éléments
tab_num_F_element = tab_num_F_element_sauve; // liste des éléments à visualiser
tab_num_F = tab_num_F_sauve; // liste des num de face ou arêtes d'éléments à visualiser
tab_num_F_integ = tab_num_F_integ_sauve; // liste des numéros de point d'integration à visualiser associé à tab_num_F_element
nomDeRef_F_E = nomDeRef_F_E_sauve; // list de nom de références face d'éléments associés
nomDeRef_F_ptinteg = nomDeRef_F_ptinteg_sauve; // list de nom de références de pt d'integ de face d'éléments
// -> les pti d'arête d'éléments
tab_num_A_element = tab_num_A_element_sauve; // liste des éléments à visualiser
tab_num_A = tab_num_A_sauve; // liste des num d'arêtes d'éléments à visualiser
tab_num_A_integ = tab_num_A_integ_sauve; // liste des numéros de point d'integration à visualiser associé à tab_num_A_element
nomDeRef_A_E = nomDeRef_A_E_sauve; // list de nom de références d'arête d'éléments associé
nomDeRef_A_ptinteg = nomDeRef_A_ptinteg_sauve; // list de nom de références de pt d'integ d'arête d'éléments
// ------parties moyennes et sommes
tab_nomDeRef_SM = tab_nomDeRef_SM_sauve;
tab_nomDeRef_E_SM = tab_nomDeRef_E_SM_sauve;
tab_nomDeRef_ptinteg_SM = tab_nomDeRef_ptinteg_SM_sauve;
tabnoeud_type_ddl_retenu_pourSM = tabnoeud_type_ddl_retenu_pourSM_sauve;
tabnoeud_type_ddlEtendu_retenu_pourSM = tabnoeud_type_ddlEtendu_retenu_pourSM_sauve;
tabnoeud_TypeQuelconque_retenu_pourSM = tabnoeud_TypeQuelconque_retenu_pourSM_sauve;
tabelement_type_ddl_retenu_pourSM = tabelement_type_ddl_retenu_pourSM_sauve;
tabelement_typeParti_retenu_pourSM = tabelement_typeParti_retenu_pourSM_sauve;
tabelement_evoluee_retenu_pourSM = tabelement_evoluee_retenu_pourSM_sauve;
// concernant les faces et arêtes
tab_nomDeRef_F_E_SM = tab_nomDeRef_F_E_SM_sauve;
tab_nomDeRef_F_ptinteg_SM = tab_nomDeRef_F_ptinteg_SM_sauve;
tab_nomDeRef_A_E_SM = tab_nomDeRef_A_E_SM_sauve;
tab_nomDeRef_A_ptinteg_SM = tab_nomDeRef_A_ptinteg_SM_sauve;
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n Choix_grandeurs_maple::Lecture_parametres_OrdreVisu(..";
}
// on passe à un nouvel enregistrement
entreePrinc.NouvelleDonneeCVisu();
};
// 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 (listeVecGlobbal_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)= &listeVecGlobbal_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_TypeQuelconque_retenu);
};
// écriture des paramètres de l'ordre dans un flux
void Choix_grandeurs_maple::Ecriture_parametres_OrdreVisu(UtilLecture & entreePrinc)
{ // récup du flot
ostream & sort = (*(entreePrinc.Sort_CommandeVisu()));
// on commente le fonctionnement
bool fr = ParaGlob::Francais(); // pour simplifier
if (fr)
{sort << "\n # ----------------------------- definition des grandeurs a visualiser (maple): ---------------- "
<< "\n debut_grandeurs_maple # un mot cle de debut (debut_grandeurs_maple),";
}
else
{sort << "\n # ----------------------------- definition of the quantities which are to be visualised (maple): ---------------- "
<< "\n debut_grandeurs_maple # a key word that indicates the beginning for .maple output (debut_grandeurs_maple),";
};
// appel de l'ordre de la classe mère
OrdreVisu::Ecrit_para_OrdreVisu_general(entreePrinc);
// on sort les grandeurs globales éventuelles
if (fr)
{sort << "\n # les grandeurs globales (energie, puissance ....) un mot cle de debut, le nom des grandeurs puis un mot de fin";}
else
{sort << "\n # global quantities (energie, power ....) a keyword for the beginning, the name of the quantities, then a keyword for the end ";};
sort <<"\n debut_grandeurs_globales ";
List_io <string>::iterator jaint,jaintfin = list_grand_global_retenu.end();
for (jaint=list_grand_global_retenu.begin();jaint!=jaintfin;jaint++)
sort << *jaint << " ";
sort << " fin_grandeurs_globales ";
// puis les paramètres propres
if (fr)
{sort << "\n # ensuite pour chaque maillage:,"
<< "\n # le numero du maillage <un entier>, "
<< "\n # les infos pour la visualisation eventuelle des torseurs de reaction,"
<< "\n # les infos pour la visualisation eventuelle de sommes, moyennes etc. sur des références "
<< "\n # - de noeuds "
<< "\n # - d'elements "
<< "\n # - de face d'element "
<< "\n # - d'arete d'element "
<< "\n # les infos pour la visualisation eventuelle aux noeud,"
<< "\n # - tout d'abord les ddl principaux (position, deplacements, temperature etc.)"
<< "\n # - puis les ddl etendus et particulieres qui peuvent representer des grandeurs diverses "
<< "\n # les infos pour la visualisation eventuelle aux elements,"
<< "\n # - tout d'abord les grandeurs generiques (deformations, contraintes etc.)"
<< "\n # - puis les grandeurs particulieres, par exemple specifique a une loi de comp ou une mesure de def "
<< "\n # les infos pour la visualisation eventuelle aux faces d'element de grandeurs quelconques,"
<< "\n # les infos pour la visualisation eventuelle aux aretes d'element de grandeurs quelconques,"
<< "\n # enfin un mot cle de fin ( fin_grandeurs_maple)";
}
else
{sort << "\n # then for each mesh:,"
<< "\n # the numer of the mesh <an integer>, "
<< "\n # the informations for a possible visualisation of the reaction wrenches,"
<< "\n # the informations for a possible visualisation of summ, average ... on references "
<< "\n # - for nodes "
<< "\n # - for elements "
<< "\n # - for element facets "
<< "\n # - for element edges "
<< "\n # the informations for a possible visualisation at nodes,"
<< "\n # - firstly, the direct dof (position, displacement, temperature etc.)"
<< "\n # - secondly the extend and specific dof which can represent other entities "
<< "\n # the informations for a possible visualisation at elements,"
<< "\n # - firstly, the generic quantities (deformations, stress, etc.)"
<< "\n # - secondly the particular quantities, for instance, specific for a behaviour, or a measure of deformation "
<< "\n # the informations for a possible visualisation at element facet,"
<< "\n # the informations for a possible visualisation at element edge,"
<< "\n # and finally a keyword for the end ( fin_grandeurs_maple)";
};
// préparation pour la sortie des listes
list<int>::const_iterator ili,ilifin,ili2,ilifin2,iti,itifin;
list<Ddl_enum_etendu>::const_iterator ild,ildfin;
list<TypeQuelconque>::const_iterator iGP,iGPfin;
List_io < bool >::const_iterator ivinit,ivinitfin;
int nb_mail = tabnoeud_type_ddl_retenu.Taille();
// -- le détail des grandeurs par maillage
for (int imail=1;imail<=nb_mail;imail++)
{ // ** le numero de maillage
sort << "\n " << imail;
if (fr) {sort << " # le numero de maillage";} else {sort << " # the number of the mesh";};
// ** les torseurs de reaction
{if (fr)
{sort << "\n # les torseurs de reaction: un mot cle de debut: debut_list_torseur_reaction";
sort << "\n # une liste de nom <chaine de caracteres >, puis <fin_list_torseur_reaction>";
}
else
{sort << "\n # the wrenches of reaction: a keyword for the beginning: debut_list_torseur_reaction";
sort << "\n # a list of name <string >, then <fin_list_torseur_reaction>";
};
sort <<"\n debut_list_torseur_reaction " ;
// --- les references des regions ou sont calculé le torseur de reaction
{List_io <String_et_entier >& list_torseur_condLim_retenu = tab_list_torseur_condLim_retenu(imail);
List_io <String_et_entier>::iterator keint,keintfin = list_torseur_condLim_retenu.end();
for (keint=list_torseur_condLim_retenu.begin();keint!=keintfin;keint++)
sort << (*keint).nom << " ";
sort << " fin_list_torseur_reaction ";
};
};
// <-><-><-><-><-><-> les sommes, moyennes etc. sur des références <-><-><-><-><-><->
// ====== sur les ref de noeuds =======
{if (fr)
{sort << "\n # les sommes, moyennes etc. sur ref de noeuds: un mot cle de debut: debut_list_SM_sur_refN";
sort << "\n # une liste de nom de ref <chaine de caracteres >, puis <fin_list__SM_sur_refN>";
}
else
{sort << "\n # the sum on a ref of nodes: a keyword for the beginning: debut_list_SM_sur_refN";
sort << "\n # a list of name <string >, then <fin_list__SM_sur_refN>";
};
sort <<"\n debut_list_SM_sur_refN " ;
// --- les références des régions en noeuds
{List_io <string >& nomDeRef_SM = tab_nomDeRef_SM(imail);
List_io <string>::iterator keint,keintfin = nomDeRef_SM.end();
for (keint=nomDeRef_SM.begin();keint!=keintfin;keint++)
sort << (*keint) << " ";
sort << " fin_list__SM_sur_refN ";
};
//---- les grandeurs à considérer aux noeuds ----
{// ** les ddl principaux aux noeuds
{if (fr) {sort << "\n # debut de la liste des ddl a considerer <deb_list_ddl_SM_sur_refN>, (une liste de ddl),"
<< " puis <fin_list_ddl_SM_sur_refN>";}
else {sort << "\n # beginning of the list of the dof <deb_list_ddl_SM_sur_refN> , (the list), then <fin_list_ddl_SM_sur_refN>";};
sort << "\n deb_list_ddl_SM_sur_refN ";
ildfin = tabnoeud_type_ddl_retenu_pourSM(imail).end();
for (ild=tabnoeud_type_ddl_retenu_pourSM(imail).begin();ild!=ildfin;ild++)
sort << (*ild);
sort << " fin_list_ddl_SM_sur_refN ";
};
// ** les ddl étendus des noeuds
{// on encapsule pour une gestion visuelle plus facile
// ---- les ddl étendus
if (fr) {sort << "\n # debut de la liste des ddl etendus a considerer, (une liste de ddl),"
<< " puis <fin_list_ddl_etendu__SM_sur_refN>";}
else {sort << "\n # beginning of the list of the extended dof <deb_list_ddl__SM_sur_refN> , (the list), then <fin_list_ddl__SM_sur_refN>";};
sort << "\n deb_list_ddl_etendu__SM_sur_refN ";
ildfin = tabnoeud_type_ddlEtendu_retenu_pourSM(imail).end();
for (ild=tabnoeud_type_ddlEtendu_retenu_pourSM(imail).begin();ild!=ildfin;ild++)
sort << (*ild);
sort << " fin_list_ddl_etendu__SM_sur_refN ";
if (fr) { sort << " # fin des ddl etendu pour _SM_sur_refNs";}
else { sort << " # end of the extended dof for _SM_sur_refNs";};
};
// ** les grandeurs quelconques aux noeuds
{// on encapsule pour une gestion visuelle plus facile
// ---- les grandeurs quelconques ---
if (fr) {sort << "\n # debut de la liste des grandeurs particulieres a considerer, (une liste de string),"
<< " puis <fin_list_GrandParticuliere__SM_sur_refN>";}
else {sort << "\n # beginning of the list of particular values at node (a string list) <deb_list_GrandParticuliere__SM_sur_refN> , (the list), then <fin_list_GrandParticuliere__SM_sur_refN>";};
sort << "\n deb_list_GrandParticuliere__SM_sur_refN ";
iGPfin = tabnoeud_TypeQuelconque_retenu_pourSM(imail).end();
for (iGP=tabnoeud_TypeQuelconque_retenu_pourSM(imail).begin();iGP!=iGPfin;iGP++)
sort << ((*iGP).EnuTypeQuelconque().NomPlein()) << " ";
sort << " fin_list_GrandParticuliere__SM_sur_refN ";
if (fr) { sort << " # fin des grandeurs particulieres aux _SM_sur_refNs";}else { sort << " # end of the particular values for _SM_sur_refN";};
};
};
};
// ====== sur les ref de d'éléments =======
{ if (fr)
{sort << "\n # les SM sur ref d'elements: un mot cle de debut: debut_list_SM_sur_refE";
sort << "\n # une liste de nom de ref d'elements <chaine de caracteres >, le pti associe "
<< "\n # puis <fin_list__SM_sur_refE>";
}
else
{sort << "\n # the sum on a ref of element: a keyword for the beginning: debut_list_SM_sur_refE";
sort << "\n # a list of name <string > + 1 pti, then <fin_list__SM_sur_refE>";
};
sort <<"\n debut_list_SM_sur_refE " ;
// --- les references des régions en éléments + num du pti où sont calculés les SMs
{List_io <BlocScal >& nomDeRef_E_SM = tab_nomDeRef_E_SM(imail);
List_io <BlocScal>::iterator keint,keintfin = nomDeRef_E_SM.end();
for (keint=nomDeRef_E_SM.begin();keint!=keintfin;keint++)
{sort << " " << (*keint).NomRef(); sort << " " << (int)((*keint).Val()); }
sort << " fin_list__SM_sur_refE ";
};
// -- idem sur les pti
if (fr)
{sort << "\n # les SMs sur ref de pti: un mot cle de debut: debut_list_SM_sur_refpti";
sort << "\n # une liste de nom de ref <chaine de caracteres >, puis <fin_list__SM_sur_refpti>";
}
else
{sort << "\n # the sum on a ref of element: a keyword for the beginning: debut_list_SM_sur_refpti";
sort << "\n # a list of name <string >, then <fin_list__SM_sur_refpti>";
};
sort <<"\n debut_list_SM_sur_refpti " ;
// --- les references des regions en ref de pti où sont calculés les SMs
{List_io <string >& nomDeRef_ptinteg_SM = tab_nomDeRef_ptinteg_SM(imail);
List_io <string>::iterator keint,keintfin = nomDeRef_ptinteg_SM.end();
for (keint=nomDeRef_ptinteg_SM.begin();keint!=keintfin;keint++)
sort << (*keint) << " ";
sort << " fin_list__SM_sur_refpti ";
};
//---- les grandeurs à considérer aux pti des éléments ----
{// ** les ddl
{sort << "\n # debut de la liste des ddl a considerer , (une liste de ddl), "
<< " puis <fin_list_ddl__SM_sur_refEpti>";
sort << "\n deb_list_ddl__SM_sur_refEpti ";
ildfin = tabelement_type_ddl_retenu_pourSM(imail).end();
for (ild=tabelement_type_ddl_retenu_pourSM(imail).begin();ild!=ildfin;ild++)
sort << (*ild) << " ";
sort << " fin_list_ddl__SM_sur_refEpti # fin de la liste de ddl a considerer pour les elements";
};
// ** les grandeurs particulières
{if (fr) {sort << "\n # debut de la liste des grandeurs particulieres a considerer pour les _SM_sur_refEptis, (une liste de string),"
<< " puis <fin_list_GrandParticuliere__SM_sur_refEpti>";}
else {sort << "\n # beginning of the list of particular values at the _SM_sur_refEpti (a string list) <deb_list_GrandParticuliere__SM_sur_refEpti> , (the list), then <fin_list_GrandParticuliere__SM_sur_refEpti>";};
sort << "\n deb_list_GrandParticuliere__SM_sur_refEpti ";
iGPfin = tabelement_typeParti_retenu_pourSM(imail).end();
for (iGP=tabelement_typeParti_retenu_pourSM(imail).begin();iGP!=iGPfin;iGP++)
sort << ((*iGP).EnuTypeQuelconque().NomPlein()) << " ";
sort << " fin_list_GrandParticuliere__SM_sur_refEpti ";
if (fr) { sort << " # fin des grandeurs particulieres aux _SM_sur_refEptis";}else { sort << " # end of the particular values at the _SM_sur_refEpti";};
};
// ** les grandeurs évoluées aux éléments a visualiser
{ if (fr) {sort << "\n # tableau de grandeurs evoluees aux _SM_sur_refEptis a visualiser, un par maillage";
sort << "\n deb_list_GrandEvoluee__SM_sur_refEpti " ;
}
else {sort << "\n # beginning of the list of tensorial values at _SM_sur_refEpti, one for a mesh ";
sort << "\n deb_list_GrandEvoluee__SM_sur_refEpti " ;
};
List_io < TypeQuelconque >::iterator ilq,ilqfin=tabelement_evoluee_retenu_pourSM(imail).end();
for (ilq=tabelement_evoluee_retenu_pourSM(imail).begin();ilq!=ilqfin;ilq++)
{ sort << ((*ilq).EnuTypeQuelconque().NomPlein()) << " " ;};
if (fr) {sort << " fin_list_GrandEvoluee__SM_sur_refEpti " ;}
else {sort << " fin_list_GrandEvoluee__SM_sur_refEpti " ;};
};
};
};
// ====== sur les ref de faces d'élément =======
{ // 1) les ref de faces d'élément
if (fr)
{sort << "\n # les SM sur ref de faces d'element: un mot cle de debut: debut_list_SM_sur_refFE";
sort << "\n # une liste de nom de ref de faces d'element <chaine de caracteres >, le pti associe "
<< "\n # puis <fin_list__SM_sur_refFE>";
}
else
{sort << "\n # the sum on a ref of element facet: a keyword for the beginning: debut_list_SM_sur_refFE";
sort << "\n # a list of name <string > + 1 pti, then <fin_list__SM_sur_refFE>";
};
// ... écriture des references de faces d'élément + num du pti où sont calculés les SMs
{sort <<"\n debut_list_SM_sur_refFE " ;
List_io <BlocScal >& nomDeRef_F_E_SM = tab_nomDeRef_F_E_SM(imail);
List_io <BlocScal>::iterator keint,keintfin = nomDeRef_F_E_SM.end();
for (keint=nomDeRef_F_E_SM.begin();keint!=keintfin;keint++)
{sort << " " << (*keint).NomRef(); sort << " " << (int)((*keint).Val()); }
sort << " fin_list__SM_sur_refFE ";
};
// 2) idem sur les ref de pti de face
if (fr)
{sort << "\n # les SMs sur ref de pti de face: un mot cle de debut: debut_list_SM_sur_refFpti";
sort << "\n # une liste de nom de ref <chaine de caracteres >, puis <fin_list__SM_sur_refFpti>";
}
else
{sort << "\n # the sum on a ref of element facet: a keyword for the beginning: debut_list_SM_sur_refFpti";
sort << "\n # a list of name <string >, then <fin_list__SM_sur_refFpti>";
};
// ... écriture des references des regions en ref de pti où sont calculés les SMs
{sort <<"\n debut_list_SM_sur_refFpti " ;
List_io <string >& nomDeRef_ptinteg_SM = tab_nomDeRef_F_ptinteg_SM(imail);
List_io <string>::iterator keint,keintfin = nomDeRef_ptinteg_SM.end();
for (keint=nomDeRef_ptinteg_SM.begin();keint!=keintfin;keint++)
sort << (*keint) << " ";
sort << " fin_list__SM_sur_refFpti ";
};
// 3) écriture de la liste des grandeurs à considérer aux pti des faces d'élément ----
{if (fr) {sort << "\n # debut de la liste des grandeurs a considerer pour les SM sur face, (une liste de string),"
<< " <deb_list_Grandeur_SM_sur_refFEpti> , (la liste), puis <fin_list_Grandeur_SM_sur_refFEpti>";}
else {sort << "\n # beginning of the list of values at the SM on facet (a string list),"
<< " <deb_list_Grandeur_SM_sur_refFEpti> , (the list), then <fin_list_Grandeur_SM_sur_refFEpti>";};
sort << "\n deb_list_Grandeur_SM_sur_refFEpti ";
iGPfin = tab_F_element_TypeQuelconque_retenu_pourSM(imail).end();
for (iGP=tab_F_element_TypeQuelconque_retenu_pourSM(imail).begin();iGP!=iGPfin;iGP++)
sort << ((*iGP).EnuTypeQuelconque().NomPlein()) << " ";
sort << " fin_list_Grandeur_SM_sur_refFEpti ";
if (fr) { sort << " # fin des grandeurs aux _SM_sur_refFEptis";}else { sort << " # end of the values at the _SM_sur_refFEpti";};
};
};
// ====== sur les ref d'arêtes d'élément =======
{ // 1) les ref d'arêtes d'élément
if (fr)
{sort << "\n # les SM sur ref d'aretes d'element: un mot cle de debut: debut_list_SM_sur_refAE";
sort << "\n # une liste de nom de ref d'aretes d'element <chaine de caracteres >, le pti associe "
<< "\n # puis <fin_list__SM_sur_refAE>";
}
else
{sort << "\n # the sum on a ref of element edge: a keyword for the beginning: debut_list_SM_sur_refAE";
sort << "\n # a list of name <string > + 1 pti, then <fin_list__SM_sur_refAE>";
};
// ... écriture des references d'arêtes d'élément + num du pti où sont calculés les SMs
{sort <<"\n debut_list_SM_sur_refAE " ;
List_io <BlocScal >& nomDeRef_A_E_SM = tab_nomDeRef_A_E_SM(imail);
List_io <BlocScal>::iterator keint,keintfin = nomDeRef_A_E_SM.end();
for (keint=nomDeRef_A_E_SM.begin();keint!=keintfin;keint++)
{sort << " " << (*keint).NomRef(); sort << " " << (int)((*keint).Val()); }
sort << " fin_list__SM_sur_refAE ";
};
// 2) idem sur les ref de pti d'arêtes
if (fr)
{sort << "\n # les SMs sur ref de pti d'aretes: un mot cle de debut: debut_list_SM_sur_refApti";
sort << "\n # une liste de nom de ref <chaine de caracteres >, puis <fin_list__SM_sur_refApti>";
}
else
{sort << "\n # the sum on a ref of element edges: a keyword for the beginning: debut_list_SM_sur_refApti";
sort << "\n # a list of name <string >, then <fin_list__SM_sur_refApti>";
};
// ... écriture des references des ref de pti d'arêtes où sont calculés les SMs
{sort <<"\n debut_list_SM_sur_refApti " ;
List_io <string >& nomDeRef_ptinteg_SM = tab_nomDeRef_A_ptinteg_SM(imail);
List_io <string>::iterator keint,keintfin = nomDeRef_ptinteg_SM.end();
for (keint=nomDeRef_ptinteg_SM.begin();keint!=keintfin;keint++)
sort << (*keint) << " ";
sort << " fin_list__SM_sur_refApti ";
};
// 3) écriture de la liste des grandeurs à considérer aux pti des arêtes d'élément ----
{if (fr) {sort << "\n # debut de la liste des grandeurs a considerer pour les SM sur aretes, (une liste de string),"
<< " <deb_list_Grandeur_SM_sur_refAEpti> , (la liste), puis <fin_list_Grandeur_SM_sur_refAEpti>";}
else {sort << "\n # beginning of the list of values at the SM on edge (a string list),"
<< " <deb_list_Grandeur_SM_sur_refAEpti> , (the list), then <fin_list_Grandeur_SM_sur_refAEpti>";};
sort << "\n deb_list_Grandeur_SM_sur_refAEpti ";
iGPfin = tab_A_element_TypeQuelconque_retenu_pourSM(imail).end();
for (iGP=tab_A_element_TypeQuelconque_retenu_pourSM(imail).begin();iGP!=iGPfin;iGP++)
sort << ((*iGP).EnuTypeQuelconque().NomPlein()) << " ";
sort << " fin_list_Grandeur_SM_sur_refAEpti ";
if (fr) { sort << " # fin des grandeurs aux _SM_sur_refAEptis";}else { sort << " # end of the values at the _SM_sur_refAEpti";};
};
};
// <-><-><-><-><-><-> les grandeurs individuelles <-><-><-><-><-><->
//---- les grandeurs aux noeuds ----
{ sort <<"\n debut_liste_ddl_et_noeud ";
if (fr) {sort << " # ** debut des ddl principaux aux noeuds " ;}
else {sort << " # ** beginning of the dof at nodes " ;}
// ** liste de noeuds
{// on encapsule pour une gestion visuelle plus facile
if (fr)
{sort << "\n # debut de la liste de noeuds, puis une liste de numero de noeud <entier>, puis <fin_list_noeud>";}
else
{sort << "\n # beginning of the list at nodes, then a list of number of node <integer>, then <fin_list_noeud>";};
sort << "\n deb_list_noeud ";
ilifin = tab_num_noeud(imail).end();
for (ili=tab_num_noeud(imail).begin();ili!=ilifin;ili++)
sort << " " << (*ili);
sort << " fin_list_noeud ";
};
// ** les references de liste de noeuds
{if (fr) {sort << "\n # debut de la liste des ref de noeuds, puis une liste de nom <chaine de caracteres >, "
<< "puis <fin_list_ref_noeud>";}
else {sort << "\n # beginning of the list of reference of nodes, then a liste of name <string >, then <fin_list_ref_noeud>";};
sort << "\n deb_list_ref_noeud ";
List_io <string >::iterator ilnom,ilnomfin = nomDeRef(imail).end();
for (ilnom=nomDeRef(imail).begin();ilnom!=ilnomfin;ilnom++)
sort << " " << (*ilnom);
sort << " fin_list_ref_noeud ";
};
// ** les ddl principaux aux noeuds
{if (fr) {sort << "\n # debut de la liste des ddl a considerer aux noeuds, (une liste de ddl),"
<< " puis <fin_list_ddl_noeud>";}
else {sort << "\n # beginning of the list of the dof at node <deb_list_ddl_noeud> , (the list), then <fin_list_ddl_noeud>";};
sort << "\n deb_list_ddl_noeud ";
ildfin = tabnoeud_type_ddl_retenu(imail).end();
for (ild=tabnoeud_type_ddl_retenu(imail).begin();ild!=ildfin;ild++)
sort << (*ild);
/* { sort << " ";
if ((*ild).Nom_vide()) sort << Nom_ddl((*ild).Enum()); else sort << (*ild).Nom();
}*/
sort << " fin_list_ddl_noeud ";
};
// ** le type de sortie: type_sortie_ddl_retenue
{ sort << "\n type_sortie_ddl_retenue= " << type_sortie_ddl_retenue;
};
// ** les ddl étendus des noeuds
{ // on encapsule pour une gestion visuelle plus facile
// ---- les ddl étendus
if (fr) {sort << "\n # debut de la liste des ddl etendus a considerer aux noeuds, (une liste de ddl),"
<< " puis <fin_list_ddl_etendu_noeud>";}
else {sort << "\n # beginning of the list of the extended dof at node <deb_list_ddl_noeud> , (the list), then <fin_list_ddl_noeud>";};
sort << "\n deb_list_ddl_etendu_noeud ";
ildfin = tabnoeud_type_ddlEtendu_retenu(imail).end();
for (ild=tabnoeud_type_ddlEtendu_retenu(imail).begin();ild!=ildfin;ild++)
sort << (*ild);
sort << " fin_list_ddl_etendu_noeud ";
if (fr) { sort << " # fin des ddl etendu aux noeuds";}else { sort << " # end of the extended dof at nodes";};
};
// ** les grandeurs quelconques aux noeuds
{ // on encapsule pour une gestion visuelle plus facile
// ---- les grandeurs quelconques ---
if (fr) {sort << "\n # debut de la liste des grandeurs particulieres a considerer aux noeuds, (une liste de string),"
<< " puis <fin_list_GrandParticuliere_noeud>";}
else {sort << "\n # beginning of the list of particular values at node (a string list) <deb_list_GrandParticuliere_noeud> , (the list), then <fin_list_GrandParticuliere_noeud>";};
sort << "\n deb_list_GrandParticuliere_noeud ";
iGPfin = tabnoeud_TypeQuelconque_retenu(imail).end();
for (iGP=tabnoeud_TypeQuelconque_retenu(imail).begin();iGP!=iGPfin;iGP++)
sort << ((*iGP).EnuTypeQuelconque().NomPlein()) << " ";
sort << " fin_list_GrandParticuliere_noeud ";
if (fr) { sort << " # fin des grandeurs particulieres aux noeuds";}else { sort << " # end of the particular values at nodes";};
};
// ---- fin des grandeurs aux noeuds ----
sort <<"\n fin_liste_ddl_et_noeud ";
if (fr) { sort << " # fin des grandeurs aux noeuds";}else { sort << " # end of the quantities at nodes";};
};
// ---- les grandeurs aux points d'intégrations d'éléments ----
{ sort <<"\n debut_liste_ddl_ptinteg ";
if (fr) { sort << "# ** debut des grandeurs aux elements " ;}else { sort << " # ** beginning of the quantities at elements";};
// ** les éléments et points d'intégration
{if (fr)
{ sort << "\n # debut de la liste des elements et points d'integration, une liste de "
<< " (un element, un numero de pt d'integ), puis <fin_list_NbElement_NbPtInteg>";
}
else
{ sort << "\n # beginning of the lists of elements+integration points, a list of "
<< " (one element, an number of a integration point), then <fin_list_NbElement_NbPtInteg>";
};
sort << "\n deb_list_NbElement_NbPtInteg ";
ilifin = tab_num_element(imail).end();
ilifin2 = tab_num_integ(imail).end();
ili2=tab_num_integ(imail).begin();
for (ili=tab_num_element(imail).begin();ili!=ilifin;ili++,ili2++)
sort << " " << (*ili) << " " << (*ili2);
sort << " fin_list_NbElement_NbPtInteg ";
}
// ** les references de liste d'éléments
{if (fr)// encapsulage
{ sort << "\n # debut de la liste des ref d'elements, puis une liste de: nom <chaine de caracteres > + numero d'integ, "
<< "puis <fin_list_ref_element>";}
else
{ sort << "\n # beginning of the list of elements, then a list of : name <string > + number of integration, "
<< "then <fin_list_ref_element>";}
sort << "\n deb_list_ref_element ";
List_io <BlocScal >::iterator ilnomel,ilnomelfin = nomDeRef_E(imail).end();
for (ilnomel=nomDeRef_E(imail).begin();ilnomel!=ilnomelfin;ilnomel++)
{sort << " " << (*ilnomel).NomRef(); sort << " " << (int)((*ilnomel).Val()); }
sort << " fin_list_ref_element ";
};
// *** les references de liste de points d'intégration d'éléments
{if (fr)
{ sort << "\n # debut de la liste des ref de ptinteg d'elements, puis une liste de: nom <chaine de caracteres > "
<< "puis <fin_list_ref_ptinteg_element>";}
else
{ sort << "\n # beginning of the list of ref of integ point for element, then a list of name <string > "
<< "then <fin_list_ref_ptinteg_element>";}
sort << "\n deb_list_ref_ptinteg_element ";
List_io <string >::iterator ilnomel,ilnomelfin = nomDeRef_ptinteg(imail).end();
for (ilnomel=nomDeRef_ptinteg(imail).begin();ilnomel!=ilnomelfin;ilnomel++)
{sort << " " << (*ilnomel) << " " ; }
sort << " fin_list_ref_ptinteg_element ";
};
// ** les ddl
{sort << "\n # debut de la liste des ddl a considerer pour les elements, (une liste de ddl), "
<< " puis <fin_list_ddl_element>";
sort << "\n deb_list_ddl_element ";
ildfin = tabelement_type_ddl_retenu(imail).end();
for (ild=tabelement_type_ddl_retenu(imail).begin();ild!=ildfin;ild++)
sort << (*ild) << " ";
sort << " fin_list_ddl_element # fin de la liste de ddl a considerer pour les elements";
};
// ** les grandeurs particulières
{if (fr) {sort << "\n # debut de la liste des grandeurs particulieres a considerer pour les elements, (une liste de string),"
<< " puis <fin_list_GrandParticuliere_element>";}
else {sort << "\n # beginning of the list of particular values at the element (a string list) <deb_list_GrandParticuliere_element> , (the list), then <fin_list_GrandParticuliere_element>";};
sort << "\n deb_list_GrandParticuliere_element ";
iGPfin = tabelement_typeParti_retenu(imail).end();
for (iGP=tabelement_typeParti_retenu(imail).begin();iGP!=iGPfin;iGP++)
sort << ((*iGP).EnuTypeQuelconque().NomPlein()) << " ";
sort << " fin_list_GrandParticuliere_element ";
if (fr) { sort << " # fin des grandeurs particulieres aux elements";}else { sort << " # end of the particular values at the element";};
};
// ** les grandeurs évoluées aux éléments a visualiser
{ if (fr) {sort << "\n # tableau de grandeurs evoluees aux elements a visualiser, un par maillage";
sort << "\n deb_list_GrandEvoluee_element " ;
}
else {sort << "\n # beginning of the list of tensorial values at element, one for a mesh ";
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()) << " " ;};
if (fr) {sort << " fin_list_GrandEvoluee_element " ;}
else {sort << " fin_list_GrandEvoluee_element " ;};
};
// ---- fin des grandeurs aux points d'intégrations ----
sort <<"\n fin_liste_ddl_ptinteg # fin des grandeurs aux elements ";
};
// ---- les grandeurs aux points d'intégrations de faces d'élément ----
{ sort <<"\n debut_liste_grandeurs_ptinteg_F_E ";
if (fr) { sort << "# ** debut des grandeurs aux faces d'elements " ;}else { sort << " # ** beginning of the quantities at element facet";};
// ** les éléments, faces et points d'intégration
{if (fr)
{ sort << "\n # debut de la liste des faces d'element et points d'integration, une liste de "
<< " (un element, une face, un numero de pt d'integ), puis <fin_list_NbFaceElement_NbPtInteg>";
}
else
{ sort << "\n # beginning of the lists of facet elements + integration points, a list of "
<< " (one element, face, an number of a integration point), then <fin_list_NbFaceElement_NbPtInteg>";
};
sort << "\n deb_list_NbFaceElement_NbPtInteg ";
ilifin = tab_num_F_element(imail).end();
ilifin2 = tab_num_F_integ(imail).end();
ili2=tab_num_F_integ(imail).begin();
iti = tab_num_F(imail).begin();
for (ili=tab_num_F_element(imail).begin();ili!=ilifin;ili++,ili2++,iti++)
sort << " " << (*ili) <<" " << (*iti)<< " " << (*ili2);
sort << " fin_list_NbFaceElement_NbPtInteg ";
}
// ** les references de liste de faces d'élément
{if (fr)// encapsulage
{ sort << "\n # debut de la liste des ref de faces d'element, puis une liste de: nom <chaine de caracteres > + numero d'integ, "
<< "puis <fin_list_ref_F_element>";}
else
{ sort << "\n # beginning of the list of element facet, then a list of : name <string > + number of integration, "
<< "then <fin_list_ref_F_element>";}
sort << "\n deb_list_ref_F_element ";
List_io <BlocScal >::iterator ilnomel,ilnomelfin = nomDeRef_F_E(imail).end();
for (ilnomel=nomDeRef_F_E(imail).begin();ilnomel!=ilnomelfin;ilnomel++)
{sort << " " << (*ilnomel).NomRef(); sort << " " << (int)((*ilnomel).Val()); }
sort << " fin_list_ref_F_element ";
};
// *** les references de liste de points d'intégration de faces d'élément
{if (fr)
{ sort << "\n # debut de la liste des ref de ptinteg de faces d'element, puis une liste de: nom <chaine de caracteres > "
<< "puis <fin_list_ref_ptinteg_F_element>";}
else
{ sort << "\n # beginning of the list of ref of integ point for element facet, then a list of name <string > "
<< "then <fin_list_ref_ptinteg_F_element>";}
sort << "\n deb_list_ref_ptinteg_F_element ";
List_io <string >::iterator ilnomel,ilnomelfin = nomDeRef_F_ptinteg(imail).end();
for (ilnomel=nomDeRef_F_ptinteg(imail).begin();ilnomel!=ilnomelfin;ilnomel++)
{sort << " " << (*ilnomel) << " " ; }
sort << " fin_list_ref_ptinteg_F_element ";
};
// ** les grandeurs
{if (fr) {sort << "\n # debut de la liste des grandeurs a considerer pour les faces d'elements, (une liste de string),"
<< " puis <fin_list_Grandeur_F_element>";}
else {sort << "\n # beginning of the list of particular values at the element facet (a string list) <deb_list_Grandeur_F_element> , (the list), then <fin_list_Grandeur_F_element>";};
sort << "\n deb_list_Grandeur_F_element ";
iGPfin = tab_F_element_TypeQuelconque_retenu(imail).end();
for (iGP=tab_F_element_TypeQuelconque_retenu(imail).begin();iGP!=iGPfin;iGP++)
sort << ((*iGP).EnuTypeQuelconque().NomPlein()) << " ";
sort << " fin_list_Grandeur_F_element ";
};
// ---- fin des grandeurs aux points d'intégrations des faces d'éléments ----
sort <<"\n fin_liste_grandeurs_ptinteg_F_E # fin des grandeurs aux faces d'elements ";
};
// ---- les grandeurs aux points d'intégrations des arêtes d'élément ----
{ sort <<"\n debut_liste_grandeurs_ptinteg_A_E ";
if (fr) { sort << "# ** debut des grandeurs aux aretes d'elements " ;}else { sort << " # ** beginning of the quantities at element edges";};
// ** les éléments, arete et points d'intégration
{if (fr)
{ sort << "\n # debut de la liste des aretes d'element et points d'integration, une liste de "
<< " (un element, une arete, un numero de pt d'integ), puis <fin_list_NbAreteElement_NbPtInteg>";
}
else
{ sort << "\n # beginning of the lists of edge elements + integration points, a list of "
<< " (one element, facet, an number of a integration point), then <fin_list_NbAreteElement_NbPtInteg>";
};
sort << "\n deb_list_NbAreteElement_NbPtInteg ";
ilifin = tab_num_A_element(imail).end();
ilifin2 = tab_num_A_integ(imail).end();
ili2=tab_num_A_integ(imail).begin();
iti = tab_num_A(imail).begin();
for (ili=tab_num_A_element(imail).begin();ili!=ilifin;ili++,ili2++,iti++)
sort << " " << (*ili) <<" " << (*iti)<< " " << (*ili2);
sort << " fin_list_NbAreteElement_NbPtInteg ";
}
// ** les references de liste d'arêtes d'élément
{if (fr)// encapsulage
{ sort << "\n # debut de la liste des ref d'arete d'element, puis une liste de: nom <chaine de caracteres > + numero d'integ, "
<< "puis <fin_list_ref_A_element>";}
else
{ sort << "\n # beginning of the list of elements edge, then a list of : name <string > + number of integration, "
<< "then <fin_list_ref_A_element>";}
sort << "\n deb_list_ref_A_element ";
List_io <BlocScal >::iterator ilnomel,ilnomelfin = nomDeRef_A_E(imail).end();
for (ilnomel=nomDeRef_A_E(imail).begin();ilnomel!=ilnomelfin;ilnomel++)
{sort << " " << (*ilnomel).NomRef(); sort << " " << (int)((*ilnomel).Val()); }
sort << " fin_list_ref_A_element ";
};
// *** les references de liste de points d'intégration d'arêtes d'élément
{if (fr)
{ sort << "\n # debut de la liste des ref de ptinteg d'aretes d'element, puis une liste de: nom <chaine de caracteres > "
<< "puis <fin_list_ref_ptinteg_A_element>";}
else
{ sort << "\n # beginning of the list of ref of integ point for element edge, then a list of name <string > "
<< "then <fin_list_ref_ptinteg_A_element>";}
sort << "\n deb_list_ref_ptinteg_A_element ";
List_io <string >::iterator ilnomel,ilnomelfin = nomDeRef_A_ptinteg(imail).end();
for (ilnomel=nomDeRef_A_ptinteg(imail).begin();ilnomel!=ilnomelfin;ilnomel++)
{sort << " " << (*ilnomel) << " " ; }
sort << " fin_list_ref_ptinteg_A_element ";
};
// ** les grandeurs
{if (fr) {sort << "\n # debut de la liste des grandeurs a considerer pour les aretes d'elements, (une liste de string),"
<< " puis <fin_list_Grandeur_A_element>";}
else {sort << "\n # beginning of the list of particular values at the element edge (a string list) <deb_list_Grandeur_A_element> , (the list), then <fin_list_Grandeur_A_element>";};
sort << "\n deb_list_Grandeur_A_element ";
iGPfin = tab_A_element_TypeQuelconque_retenu(imail).end();
for (iGP=tab_A_element_TypeQuelconque_retenu(imail).begin();iGP!=iGPfin;iGP++)
sort << ((*iGP).EnuTypeQuelconque().NomPlein()) << " ";
sort << " fin_list_Grandeur_A_element ";
};
// ---- fin des grandeurs aux points d'intégrations des arêtes d'éléments ----
sort <<"\n fin_liste_grandeurs_ptinteg_A_E # fin des grandeurs aux aretes d'elements ";
};
};
// --- informations particulière pour le cas où il y a une animation
sort << "\n# informations particuliere dans le cas ou il y a une animation";
sort << "\n# type_xi indique si oui ou non les grandeurs a tracer sont aux noeuds (sinon c'est au elements)";
sort << "\n# x1 et x2 indiquent les noms des ddls des grandeurs en x et y. accroi_x1 et accroi_x2 indiquent ";
sort << "\n# si oui ou non x1 et x2 represente l'accroissement entre 0 et t de la grandeur ou bien la grandeur elle meme.";
sort << "\n debut_info_particulier ";
sort << " grandeur_au_noeud? " << type_xi << " x1= " << x1 << " x2= " << x2
<< " accroi_x1= " << accroi_x1 << " accroi_x2= " << accroi_x2
<< " fin_info_particulier ";
// un paramètre de pilotage du style de sortie
sort << "\n# un parametre de pilotage du style de sortie";
sort << "\n parametre_style_de_sortie " << style_de_sortie;
// 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;
// fin
sort << "\n fin_grandeurs_maple # fin des grandeurs a visualiser au format maple \n";
};
Reference in a new issue Copy permalink