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