// 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) . // // 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 . // // For more information, please consult: . #include "Choix_grandeurs_maple.h" #include "CharUtil.h" #include "ReferenceNE.h" #include "ReferencePtiAF.h" #include "ParaGlob.h" #include #include "TypeQuelconqueParticulier.h" /* // -> face d'éléments Tableau > tab_F_element_TypeQuelconque; // TypeQuelconque aux faces d'elements possibles à visualiser Tableau > tab_F_element_TypeQuelconque_retenu; // TypeQuelconque aux faces d'elements à visualiser Tableau > tab_F_element_TypeQuelconque_retenu_pourSM; // idem pour somme, moy etc. sur une ref // -> arête d'éléments Tableau > tab_A_element_TypeQuelconque; // TypeQuelconque aux arêtes d'elements possibles à visualiser Tableau > tab_A_element_TypeQuelconque_retenu; // TypeQuelconque aux arête d'elements à visualiser Tableau > tab_A_element_TypeQuelconque_retenu_pourSM; // idem pour somme, moy etc. sur une ref Tableau > 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 > tab_nomDeRef_F_ptinteg_SM; // list de nom de références de pt d'integ de faces d'éléments Tableau > 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 > 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 > tab_num_F_element; // liste des éléments à visualiser Tableau > tab_num_F; // liste des num de face ou arêtes d'éléments à visualiser Tableau > tab_num_F_integ; // liste des numéros de point d'integration à visualiser associé à tab_num_F_element Tableau > nomDeRef_F_E; // list de nom de références face d'éléments associés Tableau > 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 > tab_num_A_element; // liste des éléments à visualiser Tableau > tab_num_A; // liste des num d'arêtes d'éléments à visualiser Tableau > tab_num_A_integ; // liste des numéros de point d'integration à visualiser associé à tab_num_A_element Tableau > nomDeRef_A_E; // list de nom de références d'arête d'éléments associé Tableau > 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 >& 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 >::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 & 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 >& 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 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 * > 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 ::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 >::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 & 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 ::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::iterator inoeud,inoeudfin=tab_num_noeud(n_mail).end(); // on crée une liste intermédiaire qui contient tous les noeuds à sortir, List_io 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 ::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::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::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::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::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 tab_total_elem = tab_num_element(n_mail); // tout d'abord récup de la liste des éléments List_io 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 ::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 ::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 ::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::iterator ienufin=tabelement_type_ddl_retenu(n_mail).end(); List_io::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 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::iterator iquefin=tabelement_typeParti_retenu(n_mail).end(); List_io::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::iterator jquefin=tabelement_evoluee_retenu(n_mail).end(); List_io::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::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 tab_total_elem = tab_num_F_element(n_mail); // tout d'abord récup de la liste des éléments List_io tab_total_face = tab_num_F(n_mail); // les numéros de face List_io 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 ::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 ::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 ::iterator iptinteg = tab_total_ptint.begin(); List_io ::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::iterator iquefin=tab_F_element_TypeQuelconque_retenu(n_mail).end(); List_io::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::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 tab_total_elem = tab_num_A_element(n_mail); // tout d'abord récup de la liste des éléments List_io tab_total_arete = tab_num_A(n_mail); // les numéros d'arêtes List_io 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 ::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 ::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 ::iterator iptinteg = tab_total_ptint.begin(); List_io ::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::iterator iquefin=tab_A_element_TypeQuelconque_retenu(n_mail).end(); List_io::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 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 * > 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& 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 ::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 << " ["<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 & 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 ::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 << " ["<::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 ::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::iterator iquefin=tabnoeud_TypeQuelconque_retenu(*imail).end(); List_io::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::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 ::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_"<::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 ::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 tab_elem = tab_num_element(*imail); // tout d'abord récup de la liste des éléments List_io 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 ::iterator i_elem = tab_elem.begin(); List_io ::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 ::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_"<::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_"<::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 ::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 tab_elem = tab_num_F_element(*imail); // tout d'abord récup de la liste des éléments List_io tab_face_elem = tab_num_F(*imail); // liste des faces d'élément List_io 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 ::iterator i_elem = tab_elem.begin(); List_io ::iterator i_F_elem = tab_face_elem.begin(); List_io ::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 ::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_"<::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_"<::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 ::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 tab_elem = tab_num_A_element(*imail); // tout d'abord récup de la liste des éléments List_io tab_face_elem = tab_num_A(*imail); // liste des arêtes d'élément List_io 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 ::iterator i_elem = tab_elem.begin(); List_io ::iterator i_A_elem = tab_face_elem.begin(); List_io ::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 ::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_"<::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_"< 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::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& tpg_ret = (tabnoeud_TypeQuelconque_retenu(num_mail)); // pour simplifier List_io::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& tpg_ret = (tabelement_typeParti_retenu(num_mail)); // pour simplifier List_io::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& tpg_ret = (tabelement_evoluee_retenu(num_mail)); // pour simplifier List_io::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& tpg_ret = (tabnoeud_TypeQuelconque_retenu(num_mail)); // pour simplifier List_io::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& tpg_ret = (tabelement_typeParti_retenu(num_mail)); // pour simplifier List_io::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& tpg_ret = (tabelement_evoluee_retenu(num_mail)); // pour simplifier List_io::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 > 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 > tabnoeud_type_ddlEtendu_retenu_sauve(tabnoeud_type_ddlEtendu_retenu); // ddl etendu aux noeuds à visualiser Tableau > tabnoeud_TypeQuelconque_retenu_sauve(tabnoeud_TypeQuelconque_retenu); // grandeurs particulières aux noeuds Tableau > tabelement_type_ddl_retenu_sauve(tabelement_type_ddl_retenu); // ddl aux elements à visualiser // -> face d'éléments Tableau > tab_F_element_TypeQuelconque_retenu_sauve(tab_F_element_TypeQuelconque_retenu); Tableau > tab_F_element_TypeQuelconque_retenu_pourSM_sauve(tab_F_element_TypeQuelconque_retenu_pourSM); // -> arête d'éléments Tableau > tab_A_element_TypeQuelconque_retenu_sauve(tab_A_element_TypeQuelconque_retenu); Tableau > tab_A_element_TypeQuelconque_retenu_pourSM_sauve(tab_A_element_TypeQuelconque_retenu_pourSM); Tableau > tab_num_noeud_sauve(tab_num_noeud); // liste des noeuds à visualiser Tableau > tab_num_element_sauve(tab_num_element); // liste des éléments à visualiser Tableau > tab_num_integ_sauve(tab_num_integ); // liste des numéros de point d'integration à visualiser // -> les pti de face d'éléments Tableau > tab_num_F_element_sauve(tab_num_F_element); // liste des éléments à visualiser Tableau > tab_num_F_sauve(tab_num_F); // liste des num de face ou arêtes d'éléments à visualiser Tableau > tab_num_F_integ_sauve(tab_num_F_integ); // liste des numéros de point d'integration à visualiser associé à tab_num_F_element Tableau > nomDeRef_F_E_sauve(nomDeRef_F_E); // list de nom de références face d'éléments associés Tableau > 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 > tab_num_A_element_sauve(tab_num_A_element); // liste des éléments à visualiser Tableau > tab_num_A_sauve(tab_num_A); // liste des num d'arêtes d'éléments à visualiser Tableau > tab_num_A_integ_sauve(tab_num_A_integ); // liste des numéros de point d'integration à visualiser associé à tab_num_A_element Tableau > nomDeRef_A_E_sauve(nomDeRef_A_E); // list de nom de références d'arête d'éléments associé Tableau > 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 > // les torseurs associées aux conditions limite, à visualiser tab_list_torseur_condLim_retenu_sauve(tab_list_torseur_condLim_retenu); Tableau > tabelement_evoluee_retenu_s(tabelement_evoluee_retenu); Tableau > nomDeRef_sauve(nomDeRef); // list de nom de références de noeuds Tableau > nomDeRef_E_sauve(nomDeRef_E); // list de nom de références d'éléments et de point d'intégration associé Tableau > nomDeRef_ptinteg_sauve(nomDeRef_ptinteg); // list de nom de références de pt d'integ d'éléments List_io listeVecGlobbal_retenu_sauve(listeVecGlobbal_retenu); // les vecteurs globaux à visualiser listeVecGlobbal_retenu.clear(); // initialisation // ------parties moyennes et sommes Tableau > tab_nomDeRef_SM_sauve(tab_nomDeRef_SM); Tableau > tab_nomDeRef_E_SM_sauve(tab_nomDeRef_E_SM); Tableau > tab_nomDeRef_ptinteg_SM_sauve(tab_nomDeRef_ptinteg_SM); Tableau > tabnoeud_type_ddl_retenu_pourSM_sauve(tabnoeud_type_ddl_retenu_pourSM); Tableau > tabnoeud_type_ddlEtendu_retenu_pourSM_sauve(tabnoeud_type_ddlEtendu_retenu_pourSM); Tableau > tabnoeud_TypeQuelconque_retenu_pourSM_sauve(tabnoeud_TypeQuelconque_retenu_pourSM); Tableau > tabelement_type_ddl_retenu_pourSM_sauve(tabelement_type_ddl_retenu_pourSM); Tableau > tabelement_typeParti_retenu_pourSM_sauve(tabelement_typeParti_retenu_pourSM); Tableau > tabelement_evoluee_retenu_pourSM_sauve(tabelement_evoluee_retenu_pourSM); // concernant les faces et arêtes Tableau > tab_nomDeRef_F_E_SM_sauve(tab_nomDeRef_F_E_SM); Tableau > tab_nomDeRef_F_ptinteg_SM_sauve(tab_nomDeRef_F_ptinteg_SM); Tableau > tab_nomDeRef_A_E_SM_sauve(tab_nomDeRef_A_E_SM); Tableau > 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 & list_torseur_condLim = tab_list_torseur_condLim(imail); List_io & list_torseur_condLim_retenu = tab_list_torseur_condLim_retenu(imail); List_io ::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 & 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 & 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 & 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& 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& 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::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 & 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 & 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 & 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& 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& 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::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& 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& 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::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 & 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 & 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& 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& 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::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 & 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 & 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& 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& 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::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 & 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 & 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 & 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 & 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& 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& 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::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 & lis_sor = tab_num_element(imail); List_io & 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 & 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 & 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 & 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& 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& 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::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& 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& 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::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 & lis_sor = tab_num_F_element(imail); List_io & lis_sor2 = tab_num_F_integ(imail); List_io & 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 & 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 & 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& 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& 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::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 & lis_sor = tab_num_A_element(imail); List_io & lis_sor2 = tab_num_A_integ(imail); List_io & 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 & 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 & 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& 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& 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::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 * > 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 ::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 , " << "\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 , " << "\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::const_iterator ili,ilifin,ili2,ilifin2,iti,itifin; list::const_iterator ild,ildfin; list::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 , puis "; } else {sort << "\n # the wrenches of reaction: a keyword for the beginning: debut_list_torseur_reaction"; sort << "\n # a list of name , then "; }; sort <<"\n debut_list_torseur_reaction " ; // --- les references des regions ou sont calculé le torseur de reaction {List_io & list_torseur_condLim_retenu = tab_list_torseur_condLim_retenu(imail); List_io ::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 , puis "; } 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 , then "; }; sort <<"\n debut_list_SM_sur_refN " ; // --- les références des régions en noeuds {List_io & nomDeRef_SM = tab_nomDeRef_SM(imail); List_io ::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 , (une liste de ddl)," << " puis ";} else {sort << "\n # beginning of the list of the dof , (the list), then ";}; 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 ";} else {sort << "\n # beginning of the list of the extended dof , (the list), then ";}; 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 ";} else {sort << "\n # beginning of the list of particular values at node (a string list) , (the list), then ";}; 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 , le pti associe " << "\n # puis "; } 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 + 1 pti, then "; }; 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 & nomDeRef_E_SM = tab_nomDeRef_E_SM(imail); List_io ::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 , puis "; } 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 , then "; }; sort <<"\n debut_list_SM_sur_refpti " ; // --- les references des regions en ref de pti où sont calculés les SMs {List_io & nomDeRef_ptinteg_SM = tab_nomDeRef_ptinteg_SM(imail); List_io ::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 "; 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 ";} else {sort << "\n # beginning of the list of particular values at the _SM_sur_refEpti (a string list) , (the list), then ";}; 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 , le pti associe " << "\n # puis "; } 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 + 1 pti, then "; }; // ... é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 & nomDeRef_F_E_SM = tab_nomDeRef_F_E_SM(imail); List_io ::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 , puis "; } 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 , then "; }; // ... écriture des references des regions en ref de pti où sont calculés les SMs {sort <<"\n debut_list_SM_sur_refFpti " ; List_io & nomDeRef_ptinteg_SM = tab_nomDeRef_F_ptinteg_SM(imail); List_io ::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)," << " , (la liste), puis ";} else {sort << "\n # beginning of the list of values at the SM on facet (a string list)," << " , (the list), then ";}; 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 , le pti associe " << "\n # puis "; } 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 + 1 pti, then "; }; // ... é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 & nomDeRef_A_E_SM = tab_nomDeRef_A_E_SM(imail); List_io ::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 , puis "; } 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 , then "; }; // ... é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 & nomDeRef_ptinteg_SM = tab_nomDeRef_A_ptinteg_SM(imail); List_io ::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)," << " , (la liste), puis ";} else {sort << "\n # beginning of the list of values at the SM on edge (a string list)," << " , (the list), then ";}; 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 , puis ";} else {sort << "\n # beginning of the list at nodes, then a list of number of node , then ";}; 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 , " << "puis ";} else {sort << "\n # beginning of the list of reference of nodes, then a liste of name , then ";}; sort << "\n deb_list_ref_noeud "; List_io ::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 ";} else {sort << "\n # beginning of the list of the dof at node , (the list), then ";}; 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 ";} else {sort << "\n # beginning of the list of the extended dof at node , (the list), then ";}; 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 ";} else {sort << "\n # beginning of the list of particular values at node (a string list) , (the list), then ";}; 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 "; } else { sort << "\n # beginning of the lists of elements+integration points, a list of " << " (one element, an number of a integration point), then "; }; 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 + numero d'integ, " << "puis ";} else { sort << "\n # beginning of the list of elements, then a list of : name + number of integration, " << "then ";} sort << "\n deb_list_ref_element "; List_io ::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 " << "puis ";} else { sort << "\n # beginning of the list of ref of integ point for element, then a list of name " << "then ";} sort << "\n deb_list_ref_ptinteg_element "; List_io ::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 "; 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 ";} else {sort << "\n # beginning of the list of particular values at the element (a string list) , (the list), then ";}; 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 "; } 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 "; }; 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 + numero d'integ, " << "puis ";} else { sort << "\n # beginning of the list of element facet, then a list of : name + number of integration, " << "then ";} sort << "\n deb_list_ref_F_element "; List_io ::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 " << "puis ";} else { sort << "\n # beginning of the list of ref of integ point for element facet, then a list of name " << "then ";} sort << "\n deb_list_ref_ptinteg_F_element "; List_io ::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 ";} else {sort << "\n # beginning of the list of particular values at the element facet (a string list) , (the list), then ";}; 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 "; } 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 "; }; 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 + numero d'integ, " << "puis ";} else { sort << "\n # beginning of the list of elements edge, then a list of : name + number of integration, " << "then ";} sort << "\n deb_list_ref_A_element "; List_io ::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 " << "puis ";} else { sort << "\n # beginning of the list of ref of integ point for element edge, then a list of name " << "then ";} sort << "\n deb_list_ref_ptinteg_A_element "; List_io ::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 ";} else {sort << "\n # beginning of the list of particular values at the element edge (a string list) , (the list), then ";}; 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"; };