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