2021-09-28 14:10:44 +02:00
|
|
|
|
|
|
|
|
// This file is part of the Herezh++ application.
|
|
|
|
|
//
|
|
|
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
|
|
|
// of mechanics for large transformations of solid structures.
|
|
|
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
|
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
|
|
|
//
|
|
|
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
|
|
|
//
|
2023-05-03 17:23:49 +02:00
|
|
|
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
2021-09-28 14:10:44 +02:00
|
|
|
// AUTHOR : Gérard Rio
|
|
|
|
|
// E-MAIL : gerardrio56@free.fr
|
|
|
|
|
//
|
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
|
|
|
// it under the terms of the GNU General Public License as published by
|
|
|
|
|
// the Free Software Foundation, either version 3 of the License,
|
|
|
|
|
// or (at your option) any later version.
|
|
|
|
|
//
|
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
|
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
|
// See the GNU General Public License for more details.
|
|
|
|
|
//
|
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
|
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
|
//
|
|
|
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
|
|
|
|
|
|
|
|
|
#include "Isovaleurs_Gid.h"
|
|
|
|
|
|
|
|
|
|
using namespace std;
|
|
|
|
|
#include <iomanip>
|
|
|
|
|
#include <algorithm>
|
|
|
|
|
#include "CharUtil.h"
|
|
|
|
|
#include "Coordonnee2.h"
|
|
|
|
|
#include "ConstMath.h"
|
|
|
|
|
#include "MathUtil.h"
|
|
|
|
|
#include "Banniere.h"
|
|
|
|
|
#include "TypeQuelconqueParticulier.h"
|
|
|
|
|
|
|
|
|
|
// CONSTRUCTEURS :
|
|
|
|
|
// par defaut
|
|
|
|
|
Isovaleurs_Gid::Isovaleurs_Gid () :
|
|
|
|
|
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)
|
|
|
|
|
,ddlSurY_1D(true),transfert_au_noeud(false),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)
|
|
|
|
|
,absolue(true),li_glob_restreinte_TQ()
|
|
|
|
|
{ for (int i=1; i<=2; i++) tab_quelconque(i)=NULL;};
|
|
|
|
|
|
|
|
|
|
// constructeur de copie
|
|
|
|
|
Isovaleurs_Gid::Isovaleurs_Gid (const Isovaleurs_Gid& 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()
|
|
|
|
|
,ddlSurY_1D(ord.ddlSurY_1D)
|
|
|
|
|
,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(),tabelement_evoluee_retenu()
|
|
|
|
|
,tabelement_typeParti(),tabelement_typeParti_retenu()
|
|
|
|
|
,mailInitial(ord.mailInitial),lesMail(ord.lesMail)
|
|
|
|
|
,transfert_au_noeud(ord.transfert_au_noeud),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)
|
|
|
|
|
,absolue(ord.absolue)
|
|
|
|
|
,li_glob_restreinte_TQ(ord.li_glob_restreinte_TQ)
|
|
|
|
|
{ // il y a un pb avec les maps au niveau du constructeur de copie ??
|
|
|
|
|
// impossible de comprendre, mais comme d'une part on ne s'en sert pas souvent et d'autre part à terme on utilisera
|
|
|
|
|
// des tables de hashage, on implante une fonction ayant le même effet mais plus longue
|
|
|
|
|
// cas de map_gauss_base
|
|
|
|
|
map < string, List_io < Ddl_enum_etendu > , std::less <string> >::const_iterator im,imfin=ord.map_gauss_base.end();
|
|
|
|
|
for (im = ord.map_gauss_base.begin();im!=imfin;im++)
|
|
|
|
|
map_gauss_base[(*im).first]=(*im).second;
|
|
|
|
|
// cas de map_gauss_baseEVol
|
|
|
|
|
map < string, List_io < TypeQuelconque > , std::less <string> >::const_iterator im2,im2fin=ord.map_gauss_baseEVol.end();
|
|
|
|
|
for (im2 = ord.map_gauss_baseEVol.begin();im2!=im2fin;im2++)
|
|
|
|
|
map_gauss_baseEVol[(*im2).first]=(*im2).second;
|
|
|
|
|
// cas de map_gauss_basePQ
|
|
|
|
|
map < string, List_io < TypeQuelconque > , std::less <string> >::const_iterator im3,im3fin=ord.map_gauss_basePQ.end();
|
|
|
|
|
for (im3 = ord.map_gauss_basePQ.begin();im3!=im3fin;im3++)
|
|
|
|
|
map_gauss_basePQ[(*im3).first]=(*im3).second;
|
|
|
|
|
// mise à jour du tableau de pointeur
|
|
|
|
|
for (int i=1; i<=2; i++) tab_quelconque(i)=NULL;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// DESTRUCTEUR :
|
|
|
|
|
Isovaleurs_Gid::~Isovaleurs_Gid ()
|
|
|
|
|
{ };
|
|
|
|
|
|
|
|
|
|
// 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_Gid::ExeOrdre(ParaGlob * ,const Tableau <int>& tab_mail,LesMaillages * lesMail,bool ,LesReferences*
|
|
|
|
|
,LesLoisDeComp* ,DiversStockage*,Charge*,LesCondLim*
|
|
|
|
|
,LesContacts* lesContacts,Resultats*,UtilLecture & entreePrinc,OrdreVisu::EnumTypeIncre type_incre,int incre
|
|
|
|
|
,bool ,const map < string, const double * , std::less <string> >&
|
|
|
|
|
,const List_io < TypeQuelconque >& listeVecGlob)
|
|
|
|
|
{// pour simplifier
|
|
|
|
|
int nbdigit = ParaGlob::NbdigdoGR();
|
|
|
|
|
// visualisation du maillage pointé si actif
|
|
|
|
|
ostream &sort = entreePrinc.Sort_resultat_Gid();
|
|
|
|
|
int dim = ParaGlob::Dimension();
|
|
|
|
|
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,sort);
|
|
|
|
|
// %% cas des noeuds %% on initialise les différentes listes internes qui globalisent tous les maillages
|
|
|
|
|
GlobalisationListSurTousLesMaillagesPourLesNoeuds();
|
|
|
|
|
InitPremierIncrExecutionTransfertAuxNoeuds(); // init pour les transferts aux noeuds
|
|
|
|
|
// --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)
|
|
|
|
|
{ // dans le cas de contact on alimente des listes particulières
|
|
|
|
|
lesContacts->List_reduite_aux_contact(glob_noeud_evol_retenu
|
|
|
|
|
,li_glob_restreinte_TQ
|
|
|
|
|
);
|
|
|
|
|
// ajout des conteneurs de manière systématique
|
|
|
|
|
Tableau <List_io < TypeQuelconque > * > tabQ(2);
|
|
|
|
|
tabQ(1)= &li_glob_restreinte_TQ; tabQ(2)=NULL;
|
|
|
|
|
List_io < Ddl_enum_etendu > vide;
|
|
|
|
|
lesMail->AjoutConteneurAuNoeud(vide,tabQ);
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
// cas général
|
|
|
|
|
// -------------------------------------------------------------------------------------------------
|
|
|
|
|
// I - On commence par s'occuper des ddl aux pt d'integ
|
|
|
|
|
// ensuite les noeuds car pendant la sortie aux pt integ, on peut avoir du transfert aux noeuds
|
|
|
|
|
// qui ensuite sera traité pour la visualisation par les noeuds
|
|
|
|
|
// -------------------------------------------------------------------------------------------------
|
|
|
|
|
EcritureAuxPtInteg(tab_mail,lesMail,sort,incre);
|
|
|
|
|
// -------------------------------------------------------
|
|
|
|
|
// II - traitement des degrés de libertés aux noeuds
|
|
|
|
|
// -------------------------------------------------------
|
|
|
|
|
EcritureAuxNoeuds(tab_mail,lesMail,sort,incre);
|
|
|
|
|
}; //-- 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_Gid::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, pas de transferts aux noeuds "
|
|
|
|
|
<< "\n (3) parametres generaux "
|
|
|
|
|
<< "\n (4) choix grandeurs aux noeuds "
|
|
|
|
|
<< "\n (5) choix grandeurs scalaires aux pts integ "
|
|
|
|
|
<< "\n (6) choix grandeurs tensorielles aux pts integ "
|
|
|
|
|
<< "\n (7) choix grandeurs particulieres aux pts integ "
|
|
|
|
|
<< "\n (8) transferts aux noeuds de grandeurs existantes aux points d'integration "
|
|
|
|
|
<< "\n (9) annuler le transferts aux noeuds de grandeurs existantes aux points d'integration "
|
|
|
|
|
<< "\n (10) ddl etendu aux noeuds "
|
|
|
|
|
<< "\n (11) 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) transfer from integration points to nodes for defined values "
|
|
|
|
|
<< "\n (9) remove transfer (8) "
|
|
|
|
|
<< "\n (10) extended dof at nodes "
|
|
|
|
|
<< "\n (11) 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");
|
|
|
|
|
}
|
|
|
|
|
else if ((num >= 3)&&(num<=11))
|
|
|
|
|
{ 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 8: // "transferts aux noeuds de grandeurs existantes aux points d'integration"
|
|
|
|
|
{transfert_au_noeud = true;
|
|
|
|
|
VerificationTransfertPossible();
|
|
|
|
|
break;}
|
|
|
|
|
case 9: // "transferts aux noeuds de grandeurs existantes aux points d'integration"
|
|
|
|
|
{transfert_au_noeud = false;
|
|
|
|
|
break;}
|
|
|
|
|
case 3: //"definition des parametres generaux"
|
|
|
|
|
{ ParametresGeneraux(" "); break;}
|
|
|
|
|
case 10: // "choix des isovaleurs ddl étendus aux noeuds"
|
|
|
|
|
{ChoixIsovaleur_ddl_etendu_noeud(" ");
|
|
|
|
|
break;}
|
|
|
|
|
case 11: // "choix des isovaleurs quelconque aux noeuds"
|
|
|
|
|
{ChoixIsovaleur_evoluee_noeud(" ");
|
|
|
|
|
break;}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else { cout << "\n Erreur on attendait un entier entre 3 et 11 !!, "
|
|
|
|
|
<< "\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);
|
|
|
|
|
// vérification que le transfert peut se faire (pas de doublon de grandeurs)
|
|
|
|
|
VerificationTransfertPossible();
|
|
|
|
|
// on ajoute les conteneurs internes des maillages si besoin est en fonction
|
|
|
|
|
// des choix de l'utilisateurs
|
|
|
|
|
{Tableau <List_io < TypeQuelconque > * > tabQ(2);
|
|
|
|
|
tabQ(1) = &glob_noeud_evol_retenu; tabQ(2) = NULL;
|
|
|
|
|
lesMail->AjoutConteneurAuNoeud(glob_noeud_ddl_etendu_retenu,tabQ);
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// 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_Gid::Initialisation(ParaGlob * paraGlob,LesMaillages * lesmail,LesReferences* lesRef
|
|
|
|
|
,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage,Charge* charge
|
|
|
|
|
,LesCondLim* lesCondLim,LesContacts* lesContacts
|
|
|
|
|
,Resultats* resultats,EnumTypeIncre type_incre,int incre
|
|
|
|
|
,const map < string, const double * , std::less <string> >& listeVarGlob
|
|
|
|
|
,const List_io < TypeQuelconque >& listeVecGlob
|
|
|
|
|
,bool fil_calcul)
|
|
|
|
|
{ // initialisation de la liste des différentes isovaleurs possibles
|
|
|
|
|
// uniquement lors du premier et du dernier passage pour économiser
|
|
|
|
|
if ((type_incre == OrdreVisu::DERNIER_INCRE) || (type_incre == OrdreVisu::PREMIER_INCRE))
|
|
|
|
|
{Init_liste_isovaleur(lesmail,lesContacts,fil_calcul);}
|
|
|
|
|
//appel de l'ordre d'initialisation de la classe mère
|
|
|
|
|
OrdreVisu::Initialisation(paraGlob,lesmail,lesRef,lesLoisDeComp,diversStockage,charge
|
|
|
|
|
,lesCondLim,lesContacts,resultats,type_incre,incre
|
|
|
|
|
,listeVarGlob,listeVecGlob,fil_calcul);
|
|
|
|
|
choix_var_ddl.Change_taille(lesmail->NbMaillage());
|
|
|
|
|
// récup de l'adresse des maillages
|
|
|
|
|
lesMail = lesmail;
|
|
|
|
|
// récupération de la liste des vecteurs globaux
|
|
|
|
|
list_vect_globalPourNoeud = listeVecGlob;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// initialisation de la liste des différentes isovaleurs possibles
|
|
|
|
|
void Isovaleurs_Gid::Init_liste_isovaleur(LesMaillages * lesMail
|
|
|
|
|
,LesContacts* lesContacts,bool fil_calcul)
|
|
|
|
|
{
|
|
|
|
|
// cas des contacts: a priori il n'y a que des grandeurs définies aux noeuds
|
|
|
|
|
// on définit des conteneurs ad hoc aux noeud
|
|
|
|
|
int nb_maillage = lesMail->NbMaillage();
|
|
|
|
|
if (!fil_calcul)
|
|
|
|
|
{
|
|
|
|
|
{List_io<TypeQuelconque> liste_inter = lesContacts->ListeGrandeurs_particulieres(absolue);
|
|
|
|
|
// on abonde donc le tableau précédent et ceci pour chaque maillage
|
|
|
|
|
// de plus on définie éventuellement les conteneurs aux noeuds
|
|
|
|
|
List_io < Ddl_enum_etendu > li1; // liste vide pour l'appel de AjoutConteneurAuNoeud
|
|
|
|
|
Tableau <List_io < TypeQuelconque > * > tabQ(2); tabQ(1)=&liste_inter;tabQ(2)=NULL;
|
|
|
|
|
for (int i=1;i<=nb_maillage;i++)
|
|
|
|
|
lesMail->AjoutConteneurAuNoeud(li1,tabQ); // ajout éventuel de conteneur
|
|
|
|
|
};
|
|
|
|
|
// récupération des ddl présents dans les maillages aux noeuds
|
|
|
|
|
tabnoeud_type_ddl = lesMail->Les_type_de_ddl_par_noeud(absolue);
|
|
|
|
|
tabelement_type_ddl = lesMail->Les_type_de_ddl_par_element(absolue);
|
|
|
|
|
// idem mais sous forme de grandeurs évoluées
|
|
|
|
|
tabnoeud_type_ddlEtendu = lesMail->Les_type_de_ddl_etendu_par_noeud(absolue);
|
|
|
|
|
tabnoeud_evoluee.Change_taille(0);
|
|
|
|
|
tabnoeud_evoluee = lesMail->Les_type_de_TypeQuelconque_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
|
|
|
|
|
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
|
|
|
|
|
int nb_maillage = tabnoeud_type_ddl.Taille();
|
|
|
|
|
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
|
|
|
|
|
}
|
|
|
|
|
// 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_Gid::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_Gid")!=NULL)
|
|
|
|
|
{// sauvegarde des parametres actuels
|
|
|
|
|
Tableau < List_io < Ddl_enum_etendu> > tabnoeud_type_ddl_retenu_s(tabnoeud_type_ddl_retenu);
|
|
|
|
|
Tableau <List_io <bool> > choix_var_ddl_s=choix_var_ddl;
|
|
|
|
|
Tableau <List_io < Ddl_enum_etendu > > tabnoeud_type_ddlEtendu_retenu_sauve(tabnoeud_type_ddlEtendu_retenu); // ddl etendu aux noeuds à visualiser
|
|
|
|
|
Tableau <List_io < TypeQuelconque > > tabnoeud_evoluee_retenu_sauve(tabnoeud_evoluee_retenu); // grandeurs évoluées aux noeuds
|
|
|
|
|
Tableau <List_io < Ddl_enum_etendu > > tabelement_type_ddl_retenu_s(tabelement_type_ddl_retenu);
|
|
|
|
|
Tableau <List_io < TypeQuelconque > > tabelement_evoluee_retenu_s(tabelement_evoluee_retenu);
|
|
|
|
|
Tableau <List_io < TypeQuelconque > > tabelement_typeParti_retenu_s(tabelement_typeParti_retenu);
|
|
|
|
|
bool transfert_au_noeud_sav = transfert_au_noeud;
|
|
|
|
|
// essaie de lecture
|
|
|
|
|
try
|
|
|
|
|
{ string nom,nom1;
|
|
|
|
|
(*entreePrinc.entCVisu) >> nom ;
|
|
|
|
|
if (nom != "debut_isovaleur_Gid")
|
|
|
|
|
{ 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_Gid "
|
|
|
|
|
<< " on ne tiens pas compte des parametres fournis !! ";
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{ // appel de l'ordre de la classe mère
|
|
|
|
|
OrdreVisu::Lect_para_OrdreVisu_general(entreePrinc);
|
|
|
|
|
// puis lecture des parametres propres
|
|
|
|
|
// transfert aux noeuds
|
|
|
|
|
if (strstr(entreePrinc.tablcarCVisu,"transfert_aux_noeuds")!=NULL)
|
|
|
|
|
{ (*entreePrinc.entCVisu) >> nom >> transfert_au_noeud;
|
|
|
|
|
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
|
|
|
|
|
};
|
|
|
|
|
int nb_maillage = lesMail->NbMaillage(); int imail;
|
|
|
|
|
while (strstr(entreePrinc.tablcarCVisu,"fin_isovaleur_Gid")==NULL)
|
|
|
|
|
{ (*entreePrinc.entCVisu) >> imail; // lecture du numero de maillage
|
|
|
|
|
if (imail > nb_maillage) // vérif de la validité du numéro de maillage
|
|
|
|
|
// si nb maillage trop grand, erreur, on génère une erreur pour arrêter la lecture
|
|
|
|
|
{ cout << "\n erreur, le numero de maillage est trop grand !! nombre lu " << imail
|
|
|
|
|
<< " alors que nb_maillage enregistre: " << nb_maillage ;
|
|
|
|
|
cout << "\n Isovaleurs_Gid::Lecture_parametres_OrdreVisu(... ";
|
|
|
|
|
UtilLecture::ErrNouvelEnregCVisu sortie(-1) ; throw (sortie);
|
|
|
|
|
}
|
|
|
|
|
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
|
|
|
|
|
// ---- les ddl aux noeuds a visualiser
|
|
|
|
|
if (strstr(entreePrinc.tablcarCVisu,"debut_tableau_ddl_aux_noeuds")!=NULL)
|
|
|
|
|
{ // lecture de la liste des ddl
|
|
|
|
|
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
|
|
|
|
|
// on efface la liste actuelle
|
|
|
|
|
List_io <Ddl_enum_etendu>& lis_sor = tabnoeud_type_ddl_retenu(imail);
|
|
|
|
|
List_io <bool>& choix_v_dd = choix_var_ddl(imail);
|
|
|
|
|
List_io <bool>::iterator ichoixdd;
|
|
|
|
|
lis_sor.clear();choix_v_dd.clear();
|
|
|
|
|
string nom2;
|
|
|
|
|
// lecture de la liste demandée
|
|
|
|
|
int compteur=0; // pour éviter une boucle infinie
|
|
|
|
|
while (compteur < 1000000)
|
|
|
|
|
{ (*entreePrinc.entCVisu) >> nom >> nom2; compteur++;
|
|
|
|
|
if (nom != "fin_tableau_ddl_aux_noeuds")
|
|
|
|
|
{ lis_sor.push_back(Ddl_enum_etendu(nom));
|
|
|
|
|
choix_v_dd.push_back(ChangeEntier(nom2));
|
|
|
|
|
}
|
|
|
|
|
else break;
|
|
|
|
|
}
|
|
|
|
|
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
|
|
|
|
|
}
|
|
|
|
|
// ** lecture des ddl etendus aux noeuds
|
|
|
|
|
if (strstr(entreePrinc.tablcarCVisu,"debut_tableau_ddl_etendu_aux_noeuds")!=NULL)
|
|
|
|
|
{ // lecture de la liste des ddl
|
|
|
|
|
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
|
|
|
|
|
// on efface la liste actuelle
|
|
|
|
|
List_io <Ddl_enum_etendu>& lis_sor = tabnoeud_type_ddlEtendu_retenu(imail);
|
|
|
|
|
lis_sor.clear();
|
|
|
|
|
// lecture de la liste demandée
|
|
|
|
|
int compteur=0; // pour éviter une boucle infinie
|
|
|
|
|
while (compteur < 1000000)
|
|
|
|
|
{ (*entreePrinc.entCVisu) >> nom; compteur++;
|
|
|
|
|
if (nom != "fin_tableau_ddl_etendu_aux_noeuds")
|
|
|
|
|
{if (find(lis_sor.begin(),lis_sor.end(),Ddl_enum_etendu(nom))==lis_sor.end())
|
|
|
|
|
// il n'existe pas, on le rajoute
|
|
|
|
|
lis_sor.push_back(Ddl_enum_etendu(nom));
|
|
|
|
|
}
|
|
|
|
|
else break;
|
|
|
|
|
}
|
|
|
|
|
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
|
|
|
|
|
};
|
|
|
|
|
// ** les grandeurs évoluées aux noeuds
|
|
|
|
|
if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandEvoluee_noeud")!=NULL)
|
|
|
|
|
{ // lecture de la liste des grandeurs évoluées
|
|
|
|
|
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
|
|
|
|
|
// on efface la liste actuelle
|
|
|
|
|
List_io<TypeQuelconque>& tpg_ret = (tabnoeud_evoluee_retenu(imail)); // pour simplifier
|
|
|
|
|
tpg_ret.clear();
|
|
|
|
|
list_vect_globalPourNoeud_retenu.clear(); // idem
|
|
|
|
|
// lecture de la liste demandée
|
|
|
|
|
int compteur=0; // pour éviter une boucle infinie
|
|
|
|
|
List_io<TypeQuelconque>& tpg = (tabnoeud_evoluee(imail)); // pour simplifier
|
|
|
|
|
while (compteur < 1000000)
|
|
|
|
|
{ (*entreePrinc.entCVisu) >> nom; compteur++;
|
|
|
|
|
if (nom != "fin_list_GrandEvoluee_noeud")
|
|
|
|
|
{ TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom)); // création d'un type quelconque sans grandeur
|
|
|
|
|
List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
|
|
|
|
|
bool trouve = false;
|
|
|
|
|
bool dans_global=false; // pour savoir si c'est dans le vecteur global ou pas
|
|
|
|
|
// si la grandeur n'existe pas au niveau de tabnoeud_evoluee on essaie au niveau des
|
|
|
|
|
// vecteur globaux
|
|
|
|
|
if (il == tpg.end())
|
|
|
|
|
{il = find(list_vect_globalPourNoeud.begin(),list_vect_globalPourNoeud.end(),a);
|
|
|
|
|
if (il != list_vect_globalPourNoeud.end())
|
|
|
|
|
trouve = true;dans_global=true;
|
|
|
|
|
}
|
|
|
|
|
else // sinon c'est bon on a trouvé
|
|
|
|
|
{trouve = true;};
|
|
|
|
|
// si la grandeur existe on essaie de l'enregistrer sinon on passe
|
|
|
|
|
if (trouve)
|
|
|
|
|
{// s'il n'existe pas déjà on l'enregistre vraiment
|
|
|
|
|
if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
|
|
|
|
|
{ tpg_ret.push_back(*il);
|
|
|
|
|
if (dans_global) list_vect_globalPourNoeud_retenu.push_back(*il);
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
else break;
|
|
|
|
|
};
|
|
|
|
|
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// ---- les ddl aux éléments a visualiser
|
|
|
|
|
if (strstr(entreePrinc.tablcarCVisu,"debut_tableau_ddl_aux_elements")!=NULL)
|
|
|
|
|
{ // lecture de la liste des ddl
|
|
|
|
|
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
|
|
|
|
|
// on efface la liste actuelle
|
|
|
|
|
List_io <Ddl_enum_etendu>& lis_sor = tabelement_type_ddl_retenu(imail);
|
|
|
|
|
lis_sor.erase(lis_sor.begin(),lis_sor.end());
|
|
|
|
|
// lecture de la liste demandée
|
|
|
|
|
int compteur=0; // pour éviter une boucle infinie
|
|
|
|
|
while (compteur < 1000000)
|
|
|
|
|
{ (*entreePrinc.entCVisu) >> nom; compteur++;
|
|
|
|
|
if (nom != "fin_tableau_ddl_aux_elements")
|
|
|
|
|
{ lis_sor.push_back(Ddl_enum_etendu(nom));}
|
|
|
|
|
else break;
|
|
|
|
|
}
|
|
|
|
|
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
|
|
|
|
|
}
|
|
|
|
|
// ---- les grandeurs évoluées aux éléments a visualiser
|
|
|
|
|
if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandEvoluee_element")!=NULL)
|
|
|
|
|
{ // lecture de la liste des grandeurs particulières
|
|
|
|
|
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
|
|
|
|
|
// on efface la liste actuelle
|
|
|
|
|
List_io<TypeQuelconque>& tpg_ret = (tabelement_evoluee_retenu(imail)); // pour simplifier
|
|
|
|
|
tpg_ret.erase(tpg_ret.begin(),tpg_ret.end());
|
|
|
|
|
// lecture de la liste demandée
|
|
|
|
|
int compteur=0; // pour éviter une boucle infinie
|
|
|
|
|
List_io<TypeQuelconque>& tpg = (tabelement_evoluee(imail)); // pour simplifier
|
|
|
|
|
while (compteur < 1000000)
|
|
|
|
|
{ (*entreePrinc.entCVisu) >> nom; compteur++;
|
|
|
|
|
if (nom != "fin_list_GrandEvoluee_element")
|
|
|
|
|
{ TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom)); // création d'un type quelconque sans grandeur
|
|
|
|
|
List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
|
|
|
|
|
// s'il n'existe pas déjà on l'enregistre vraiment
|
|
|
|
|
if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
|
|
|
|
|
{ tpg_ret.push_back(*il);}
|
|
|
|
|
}
|
|
|
|
|
else break;
|
|
|
|
|
}
|
|
|
|
|
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
|
|
|
|
|
}
|
|
|
|
|
// ---- les grandeurs particulières aux éléments a visualiser
|
|
|
|
|
if (strstr(entreePrinc.tablcarCVisu,"deb_list_GrandParticuliere_element")!=NULL)
|
|
|
|
|
{ // lecture de la liste des grandeurs particulières
|
|
|
|
|
(*entreePrinc.entCVisu) >> nom; // on passe le mot clé
|
|
|
|
|
// on efface la liste actuelle
|
|
|
|
|
List_io<TypeQuelconque>& tpg_ret = (tabelement_typeParti_retenu(imail)); // pour simplifier
|
|
|
|
|
tpg_ret.erase(tpg_ret.begin(),tpg_ret.end());
|
|
|
|
|
// lecture de la liste demandée
|
|
|
|
|
int compteur=0; // pour éviter une boucle infinie
|
|
|
|
|
List_io<TypeQuelconque>& tpg = (tabelement_typeParti(imail)); // pour simplifier
|
|
|
|
|
while (compteur < 1000000)
|
|
|
|
|
{ (*entreePrinc.entCVisu) >> nom; compteur++;
|
|
|
|
|
if (nom != "fin_list_GrandParticuliere_element")
|
|
|
|
|
{ TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(nom)); // création d'un type quelconque sans grandeur
|
|
|
|
|
List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
|
|
|
|
|
// si la grandeur existe on essaie de l'enregistrer sinon on passe
|
|
|
|
|
if (il != tpg.end())
|
|
|
|
|
{// s'il n'existe pas déjà on l'enregistre vraiment
|
|
|
|
|
if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
|
|
|
|
|
{ tpg_ret.push_back(*il);}
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
else break;
|
|
|
|
|
}
|
|
|
|
|
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
|
|
|
|
|
}
|
|
|
|
|
}// -- fin du while sur les maillages
|
|
|
|
|
entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
|
|
|
|
|
} // -- fin du if then else sur "debut_isovaleur_Gid"
|
|
|
|
|
} // -- fin du try
|
|
|
|
|
catch (ErrSortieFinale)
|
|
|
|
|
// cas d'une direction voulue vers la sortie
|
|
|
|
|
// on relance l'interuption pour le niveau supérieur
|
|
|
|
|
{ ErrSortieFinale toto;
|
|
|
|
|
throw (toto);
|
|
|
|
|
}
|
|
|
|
|
catch (...)// erreur de lecture
|
|
|
|
|
{ cout << "\n Erreur en lecture des parametres pour les isovaleurs a partir d'un fichier .CVisu,"
|
|
|
|
|
<< " on ne tiens pas compte des parametres fournis !! ";
|
|
|
|
|
// récup des parametres sauvées
|
|
|
|
|
tabnoeud_type_ddl_retenu = tabnoeud_type_ddl_retenu_s;
|
|
|
|
|
choix_var_ddl=choix_var_ddl_s;
|
|
|
|
|
tabnoeud_type_ddlEtendu_retenu=tabnoeud_type_ddlEtendu_retenu_sauve;
|
|
|
|
|
tabnoeud_evoluee_retenu=tabnoeud_evoluee_retenu_sauve;
|
|
|
|
|
tabelement_type_ddl_retenu = tabelement_type_ddl_retenu_s;
|
|
|
|
|
tabelement_evoluee_retenu = tabelement_evoluee_retenu_s;
|
|
|
|
|
tabelement_typeParti_retenu = tabelement_typeParti_retenu_s;
|
|
|
|
|
transfert_au_noeud = transfert_au_noeud_sav;
|
|
|
|
|
if (ParaGlob::NiveauImpression() >= 4)
|
|
|
|
|
cout << "\n Isovaleurs_Gid::Lecture_parametres_OrdreVisu(..";
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// dans le cas où il y a des vecteurs globaux qui ont été retenus,
|
|
|
|
|
// il faut définir aux noeuds des conteneurs adéquates
|
|
|
|
|
if (list_vect_globalPourNoeud_retenu.size() != 0)
|
|
|
|
|
{ // def de conteneurs pour le passage d'infos
|
|
|
|
|
List_io < Ddl_enum_etendu > lienu; // une liste vide
|
|
|
|
|
List_io < TypeQuelconque > litq; // une autre pour les quelconques
|
|
|
|
|
Tableau <List_io < TypeQuelconque > * > tabQ(2);
|
|
|
|
|
tabQ(1)= &list_vect_globalPourNoeud_retenu;tabQ(2)=&litq;
|
|
|
|
|
// on est obligé d'utiliser un tableau dont le second terme est nul,
|
|
|
|
|
// ceci pour pouvoir utiliser "AjoutConteneurAuNoeud" tel quel
|
|
|
|
|
int nbmail_total = lesMail->NbMaillage();
|
|
|
|
|
for (int imail=1;imail <= nbmail_total;imail++)
|
|
|
|
|
lesMail->AjoutConteneurAuNoeud(imail,lienu,tabQ);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// on introduit certains conteneurs internes des maillages si besoin est en fonction
|
|
|
|
|
// des choix de l'utilisateurs: utiles uniquement pour certaines grandeurs
|
|
|
|
|
lesMail->Intro_Conteneurs_internes_noeud_relier_auto_autres_grandeur(tabnoeud_evoluee_retenu);
|
|
|
|
|
// vérification que le transfert peut se faire (pas de doublon de grandeurs)
|
|
|
|
|
VerificationTransfertPossible();
|
|
|
|
|
|
|
|
|
|
// on ajoute les conteneurs internes des maillages si besoin est en fonction
|
|
|
|
|
// des choix de l'utilisateurs
|
|
|
|
|
{Tableau <List_io < TypeQuelconque > * > tabQ(2);
|
|
|
|
|
tabQ(1) = &glob_noeud_evol_retenu; tabQ(2) = NULL;
|
|
|
|
|
lesMail->AjoutConteneurAuNoeud(glob_noeud_ddl_etendu_retenu,tabQ);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// écriture des paramètres de l'ordre dans un flux
|
|
|
|
|
void Isovaleurs_Gid::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_Gid # mot cle de debut des parametres pour les isovaleurs";
|
|
|
|
|
// appel de l'ordre de la classe mère
|
|
|
|
|
OrdreVisu::Ecrit_para_OrdreVisu_general(entreePrinc);
|
|
|
|
|
// puis les paramètres
|
|
|
|
|
// transfert aux noeuds
|
|
|
|
|
sort << "\n transfert_aux_noeuds " << transfert_au_noeud
|
|
|
|
|
<< " # =1 indique que toutes les valeurs definis aux pt d'integ sont transferees"
|
|
|
|
|
<< " \n # egalement aux noeuds, =0 pas de transfert aux noeuds";
|
|
|
|
|
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 ddl aux noeuds a visualiser
|
|
|
|
|
sort << "\n # tableau de (ddl + 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 ";
|
|
|
|
|
int nb_mail = tabnoeud_type_ddl_retenu.Taille();
|
|
|
|
|
sort << "\n debut_tableau_ddl_aux_noeuds " ;
|
|
|
|
|
List_io < Ddl_enum_etendu >::iterator ild,ildfin = tabnoeud_type_ddl_retenu(imail).end();
|
|
|
|
|
List_io <bool>::iterator ilbo=choix_var_ddl(imail).begin();
|
|
|
|
|
for (ild=tabnoeud_type_ddl_retenu(imail).begin();ild!=ildfin;ild++,ilbo++)
|
|
|
|
|
{ sort << (*ild) << " " << (*ilbo) << " ";};
|
|
|
|
|
sort << " fin_tableau_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
|
|
|
|
|
sort << "\n # tableau de ddl aux elements a visualiser, un par maillage";
|
|
|
|
|
sort << "\n debut_tableau_ddl_aux_elements " ;
|
|
|
|
|
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_Gid # mot cle de fin des parametres pour les isovaleurs \n";
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// ======================================== méthodes privées =====================================
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// choix de l'isovaleur à visualiser calculée à partir des noeuds
|
|
|
|
|
void Isovaleurs_Gid::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 à true par défaut
|
|
|
|
|
int nbmail = tabnoeud_type_ddl.Taille();
|
|
|
|
|
for (int imail = 1;imail<=nbmail;imail++)
|
|
|
|
|
{ List_io < Ddl_enum_etendu >& noeud_type_ddl_retenu = tabnoeud_type_ddl_retenu(imail);
|
|
|
|
|
List_io < Ddl_enum_etendu >::iterator ili,ilideb,ilifin=noeud_type_ddl_retenu.end();
|
|
|
|
|
ilideb = noeud_type_ddl_retenu.begin();
|
|
|
|
|
List_io <bool>& choix_v_ddl = choix_var_ddl(imail);
|
|
|
|
|
choix_v_ddl.erase(choix_v_ddl.begin(),choix_v_ddl.end()); // 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 visualiser "
|
|
|
|
|
<< "\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);
|
|
|
|
|
if (rep == "to")
|
|
|
|
|
// cas de toutes les grandeurs sans les réactions
|
|
|
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddl(imail).end();
|
|
|
|
|
// on nettoie les listes avant chargement
|
|
|
|
|
(tabnoeud_type_ddl_retenu(imail)).clear();
|
|
|
|
|
choix_var_ddl(imail).clear();
|
|
|
|
|
// puis on enregistre
|
|
|
|
|
for (ite = tabnoeud_type_ddl(imail).begin();ite != itefin; ite++)
|
|
|
|
|
if ( !Ddl_reaction((*ite).Enum()))
|
|
|
|
|
{tabnoeud_type_ddl_retenu(imail).push_back(*ite);
|
|
|
|
|
// -- choix var ou pas: on encapsule car on utilise des mêmes noms de variables
|
|
|
|
|
{ bool choix_var_valide=false;
|
|
|
|
|
while (!choix_var_valide)
|
|
|
|
|
{try
|
|
|
|
|
{ cout << "\n valeur du ddl " << (*ite).Nom_plein()
|
|
|
|
|
<< " ou variation entre t=0 et t (rep 1 ou 0 ) ? \n"
|
|
|
|
|
<< "\n reponse ? ";
|
|
|
|
|
string rap = lect_chaine();
|
|
|
|
|
if (rap == "1") {choix_var_ddl(imail).push_back(true);choix_var_valide=true;}
|
|
|
|
|
else if (rap == "0") {choix_var_ddl(imail).push_back(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 de la variation ou non des ddl !!, "
|
|
|
|
|
<< "\n redonnez une bonne valeur";
|
|
|
|
|
choix_var_valide=false;
|
|
|
|
|
}
|
|
|
|
|
}; //-- fin du while
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
tabnoeud_type_ddl_retenu(imail).sort(); // on ordonne
|
|
|
|
|
tabnoeud_type_ddl_retenu(imail).unique();// on supprime les doublons
|
|
|
|
|
choix_valide=false;
|
|
|
|
|
}
|
|
|
|
|
else if (rep == "tr")
|
|
|
|
|
// cas de toutes les grandeurs avec les réactions
|
|
|
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddl(imail).end();
|
|
|
|
|
// on nettoie les listes avant chargement
|
|
|
|
|
(tabnoeud_type_ddl_retenu(imail)).clear();
|
|
|
|
|
choix_var_ddl(imail).clear();
|
|
|
|
|
// puis on enregistre
|
|
|
|
|
for (ite = tabnoeud_type_ddl(imail).begin();ite != itefin; ite++)
|
|
|
|
|
{tabnoeud_type_ddl_retenu(imail).push_back(*ite);
|
|
|
|
|
// -- choix var ou pas: on encapsule car on utilise des mêmes noms de variables
|
|
|
|
|
{ bool choix_var_valide=false;
|
|
|
|
|
while (!choix_var_valide)
|
|
|
|
|
{try
|
|
|
|
|
{ cout << "\n valeur du ddl " << (*ite).Nom_plein()
|
|
|
|
|
<< " ou variation entre t=0 et t (rep 1 ou 0 ) ? \n"
|
|
|
|
|
<< "\n reponse ? ";
|
|
|
|
|
string rap = lect_chaine();
|
|
|
|
|
if (rap == "1") {choix_var_ddl(imail).push_back(true);choix_var_valide=true;}
|
|
|
|
|
else if (rap == "0") {choix_var_ddl(imail).push_back(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 de la variation ou non des ddl !!, "
|
|
|
|
|
<< "\n redonnez une bonne valeur";
|
|
|
|
|
choix_var_valide=false;
|
|
|
|
|
}
|
|
|
|
|
}; //-- fin du while
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
tabnoeud_type_ddl_retenu(imail).sort(); // on ordonne
|
|
|
|
|
tabnoeud_type_ddl_retenu(imail).unique();// on supprime les doublons
|
|
|
|
|
choix_valide=false;
|
|
|
|
|
}
|
|
|
|
|
else if (rep == "ef")
|
|
|
|
|
{// on efface la liste
|
|
|
|
|
(tabnoeud_type_ddl_retenu(imail)).clear();
|
|
|
|
|
choix_var_ddl(imail).clear();
|
|
|
|
|
choix_valide=false;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
bool deplace_ou_valeur_a_demander = false; // pour la gestion
|
|
|
|
|
// 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
|
|
|
|
|
{ Enum_ddl enum_d = Id_nom_ddl(rep.c_str());
|
|
|
|
|
Ddl_enum_etendu ddl_enu_etendue(enum_d);
|
|
|
|
|
// 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))
|
|
|
|
|
{// 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 ((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)));
|
|
|
|
|
case 2: tabnoeud_type_ddl_retenu(imail).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)));
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
else // cas d'une grandeur scalaire simple
|
|
|
|
|
{ tabnoeud_type_ddl_retenu(imail).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)
|
|
|
|
|
{ bool choix_var_valide=false;
|
|
|
|
|
while (!choix_var_valide)
|
|
|
|
|
{try
|
|
|
|
|
{ cout << "\n valeur du ddl 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(true);choix_var_valide=true;}
|
|
|
|
|
else if (rep == "0") {choix_var_ddl(imail).push_back(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 de la variation ou non des ddl !!, "
|
|
|
|
|
<< "\n redonnez une bonne valeur";
|
|
|
|
|
choix_var_valide=false;
|
|
|
|
|
}
|
|
|
|
|
}; //-- fin du second while
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
|
tabnoeud_type_ddl_retenu(imail).sort(); // on ordonne
|
|
|
|
|
tabnoeud_type_ddl_retenu(imail).unique();// on supprime les doublons
|
|
|
|
|
}//-- fin de la boucle sur les maillages
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// choix de l'isovaleur à visualiser calculée à partir des ddl etendu aux noeuds
|
|
|
|
|
void Isovaleurs_Gid::ChoixIsovaleur_ddl_etendu_noeud(const string& choix)
|
|
|
|
|
{ // tout d'abord on traite le cas de tous les isovaleurs ou para par défaut
|
|
|
|
|
// ici idem pour les noeuds
|
|
|
|
|
if ((choix=="to")||(choix=="de"))
|
|
|
|
|
{ tabnoeud_type_ddlEtendu_retenu = tabnoeud_type_ddlEtendu;
|
|
|
|
|
a_accumuler_tabnoeud_type_ddlEtendu_retenu=a_accumuler_tabnoeud_type_ddlEtendu;
|
|
|
|
|
return;
|
|
|
|
|
};
|
|
|
|
|
// maintenant on traite le cas interactif
|
|
|
|
|
int dim = ParaGlob::Dimension();
|
|
|
|
|
bool choix_valide = false;
|
|
|
|
|
string rep;
|
|
|
|
|
cout << "\n choix d'isovaleur a visualiser ";
|
|
|
|
|
int nbmail = tabnoeud_type_ddlEtendu.Taille();
|
|
|
|
|
// update du tableau de ddl à visualiser si nécessaire
|
|
|
|
|
if (tabnoeud_type_ddlEtendu_retenu.Taille() != nbmail)
|
|
|
|
|
{tabnoeud_type_ddlEtendu_retenu.Change_taille(nbmail);
|
|
|
|
|
a_accumuler_tabnoeud_type_ddlEtendu_retenu.Change_taille(nbmail);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
for (int imail = 1;imail<=nbmail;imail++)
|
|
|
|
|
{choix_valide=false;
|
|
|
|
|
// dans le cas où il n'y a rien n'a visualiser on passe
|
|
|
|
|
if (tabnoeud_type_ddlEtendu(imail).size() == 0)
|
|
|
|
|
{cout << "\n *** aucune grandeur a visualiser pour le maillage "<< imail << endl;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
while (!choix_valide) // premier while
|
|
|
|
|
{try
|
|
|
|
|
{ cout << "\n listes de type de ddl a visualiser ";
|
|
|
|
|
cout << "\n Maillage nb: " << imail << " liste des types de ddl disponibles "
|
|
|
|
|
<< "\n" << tabnoeud_type_ddlEtendu(imail);
|
|
|
|
|
// affichage des ddl retenues si la liste n'est pas vide
|
|
|
|
|
if (tabnoeud_type_ddlEtendu_retenu(imail).size() != 0)
|
|
|
|
|
cout << "\n Maillage nb: " << imail << " liste des types de ddl enregistres "
|
|
|
|
|
<< "\n" << tabnoeud_type_ddlEtendu_retenu(imail);
|
|
|
|
|
|
|
|
|
|
cout << "\n donnez la ou les grandeurs que vous voulez visualiser (rep grandeurs?) "
|
|
|
|
|
<< "\n ou toutes les grandeurs (rep : to) "
|
|
|
|
|
<< "\n effacer la liste actuelle (rep : ef) "
|
|
|
|
|
<< "\n fin (pour terminer tapez : fin (ou f ou 0)) "
|
|
|
|
|
<< "\n reponse ? ";
|
|
|
|
|
|
|
|
|
|
rep = lect_return_defaut(false,"f");
|
|
|
|
|
if (rep == "fin_prog") Sortie(1);
|
|
|
|
|
List_io<Ddl_enum_etendu> nouveau_ddl_a_demander;
|
|
|
|
|
if (rep == "to")
|
|
|
|
|
// cas de toutes les grandeurs
|
|
|
|
|
{// on prévient que si on veut une grandeur sous forme de vecteur il faut la demander spécifiquement
|
|
|
|
|
cout << "\n attention, si vous voulez une grandeur vectorielle ou tensorielle "
|
|
|
|
|
<< "\n il faut refaire un passage en demandant cette grandeur specifiquement ";
|
|
|
|
|
// on vide les listes
|
|
|
|
|
(tabnoeud_type_ddlEtendu_retenu(imail)).clear();
|
|
|
|
|
// maintenant on ajoute les ddl
|
|
|
|
|
List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddlEtendu(imail).end();
|
|
|
|
|
for (ite = tabnoeud_type_ddlEtendu(imail).begin();ite != itefin; ite++)
|
|
|
|
|
{tabnoeud_type_ddlEtendu_retenu(imail).push_back(*ite);
|
|
|
|
|
nouveau_ddl_a_demander.push_back(*ite);
|
|
|
|
|
// si c'est un ddl a accumuler directement aux noeuds, on enregistre
|
|
|
|
|
if (find(a_accumuler_tabnoeud_type_ddlEtendu(imail).begin(),a_accumuler_tabnoeud_type_ddlEtendu(imail).end()
|
|
|
|
|
,(*ite)) != a_accumuler_tabnoeud_type_ddlEtendu(imail).end())
|
|
|
|
|
a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail).push_back((*ite));
|
|
|
|
|
};
|
|
|
|
|
// on n'ordonne pas ni supprime les doublons car a priori tabnoeud_type_ddlEtendu(imail) ne comporte pas de doublon
|
|
|
|
|
// si car l'utilisateur peut faire deux appels consécutifs ...
|
|
|
|
|
nouveau_ddl_a_demander.sort();nouveau_ddl_a_demander.unique();
|
|
|
|
|
choix_valide=false;
|
|
|
|
|
}
|
|
|
|
|
else if (rep == "ef")
|
|
|
|
|
{// on efface la liste
|
|
|
|
|
(tabnoeud_type_ddlEtendu_retenu(imail)).clear();
|
|
|
|
|
(a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail)).clear();
|
|
|
|
|
choix_valide=false;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// sinon
|
|
|
|
|
if ((rep == "0") || (rep == "f") || (rep == "fin"))
|
|
|
|
|
{choix_valide=true;}
|
|
|
|
|
else if (Ddl_enum_etendu::VerifExistence(rep)) // test pour savoir si c'est vraiment un ddl
|
|
|
|
|
{ //Enum_ddl enum_d = Id_nom_ddl(rep.c_str());
|
|
|
|
|
//Ddl_enum_etendu ddl_enu_etendue(enum_d);
|
|
|
|
|
Ddl_enum_etendu ddl_enu_etendue(rep);
|
|
|
|
|
// on vérifie si le ddl existe dans la liste proposée
|
|
|
|
|
if (Ddl_enum_etendu::Existe_dans_la_liste(tabnoeud_type_ddlEtendu(imail),ddl_enu_etendue))
|
|
|
|
|
{ // on regarde si l'on veut uniquement la grandeur scalaire ou tout
|
|
|
|
|
bool choix_var_valide=false;
|
|
|
|
|
bool choixScalaireUniquement = true;
|
|
|
|
|
if (ddl_enu_etendue.TypeDeGrandeur() != SCALAIRE)
|
|
|
|
|
while (!choix_var_valide)
|
|
|
|
|
{try
|
|
|
|
|
{ cout << "\n voulez vous uniquement la grandeur scalaire (rep 1) ou toutes les composantes de la grandeur (rep 2) ? \n"
|
|
|
|
|
<< "\n reponse ? ";
|
|
|
|
|
rep = lect_chaine();
|
|
|
|
|
if (rep == "1") {choixScalaireUniquement=true;choix_var_valide=true;}
|
|
|
|
|
else if (rep == "2") {choixScalaireUniquement=false;choix_var_valide=true;}
|
|
|
|
|
else {cout << "\n mauvais choix, recommencez";choix_var_valide=false;}
|
|
|
|
|
}
|
|
|
|
|
catch (ErrSortieFinale)
|
|
|
|
|
// cas d'une direction voulue vers la sortie
|
|
|
|
|
// on relance l'interuption pour le niveau supérieur
|
|
|
|
|
{ ErrSortieFinale toto;
|
|
|
|
|
throw (toto);
|
|
|
|
|
}
|
|
|
|
|
catch (...)// erreur en lecture
|
|
|
|
|
{ cout << "\n Erreur dans le choix scalaire ou non !!, "
|
|
|
|
|
<< "\n redonnez une bonne valeur";
|
|
|
|
|
choix_var_valide=false;
|
|
|
|
|
};
|
|
|
|
|
}; //-- fin du second while
|
|
|
|
|
// dans le cas où le ddl est de type vecteur, on ajoute toutes les composantes
|
|
|
|
|
EnumTypeGrandeur type_grandeur = ddl_enu_etendue.TypeDeGrandeur(); // le premier type de grandeur
|
|
|
|
|
List_io<Ddl_enum_etendu>& aaccumuler_inter_retenu = a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail); // pour simplifier
|
|
|
|
|
List_io<Ddl_enum_etendu>& aaccumuler_inter = a_accumuler_tabnoeud_type_ddlEtendu(imail); // pour simplifier
|
|
|
|
|
if ((!choixScalaireUniquement) && ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE)
|
|
|
|
|
|| (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH)))
|
|
|
|
|
{ // cas d'un type vecteur
|
|
|
|
|
Enum_ddl enu_type_famille = PremierDdlFamille(ddl_enu_etendue.Enum());
|
|
|
|
|
// pour l'instant ***** on ne sort que des iso de ddl non étendue donc on peut constituer les
|
|
|
|
|
// ddl du vecteur qui est forcément de dim 3
|
|
|
|
|
switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
|
|
|
|
|
{ case 3:{Ddl_enum_etendu ddl_enum(Enum_ddl(enu_type_famille+dim-3));
|
|
|
|
|
tabnoeud_type_ddlEtendu_retenu(imail).push_back(ddl_enum);
|
|
|
|
|
nouveau_ddl_a_demander.push_back(ddl_enum);
|
|
|
|
|
if (find(aaccumuler_inter.begin(),aaccumuler_inter.end(),ddl_enum) != aaccumuler_inter.end())
|
|
|
|
|
aaccumuler_inter_retenu.push_back(ddl_enum);
|
|
|
|
|
}
|
|
|
|
|
case 2:{Ddl_enum_etendu ddl_enum(Enum_ddl(enu_type_famille+dim-2));
|
|
|
|
|
tabnoeud_type_ddlEtendu_retenu(imail).push_back(ddl_enum);
|
|
|
|
|
nouveau_ddl_a_demander.push_back(ddl_enum);
|
|
|
|
|
if (find(aaccumuler_inter.begin(),aaccumuler_inter.end(),ddl_enum) != aaccumuler_inter.end())
|
|
|
|
|
aaccumuler_inter_retenu.push_back(ddl_enum);
|
|
|
|
|
}
|
|
|
|
|
case 1:{Ddl_enum_etendu ddl_enum(Enum_ddl(enu_type_famille+dim-1));
|
|
|
|
|
tabnoeud_type_ddlEtendu_retenu(imail).push_back(ddl_enum);
|
|
|
|
|
nouveau_ddl_a_demander.push_back(ddl_enum);
|
|
|
|
|
if (find(aaccumuler_inter.begin(),aaccumuler_inter.end(),ddl_enum) != aaccumuler_inter.end())
|
|
|
|
|
aaccumuler_inter_retenu.push_back(ddl_enum);
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
else // cas d'une grandeur scalaire simple
|
|
|
|
|
{ tabnoeud_type_ddlEtendu_retenu(imail).push_back(ddl_enu_etendue);
|
|
|
|
|
nouveau_ddl_a_demander.push_back(ddl_enu_etendue);
|
|
|
|
|
if (find(aaccumuler_inter.begin(),aaccumuler_inter.end(),ddl_enu_etendue) != aaccumuler_inter.end())
|
|
|
|
|
aaccumuler_inter_retenu.push_back(ddl_enu_etendue);
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
/* else if ( Existe_typeQuelconque(rep)) // cas où c'est un type quelconque
|
|
|
|
|
{ //Enum_ddl enum_d = Id_nom_ddl(rep.c_str());
|
|
|
|
|
//Ddl_enum_etendu ddl_enu_etendue(enum_d);
|
|
|
|
|
Ddl_enum_etendu ddl_enu_etendue(rep);
|
|
|
|
|
// on vérifie si le ddl existe dans la liste proposée
|
|
|
|
|
if ( (Ddl_enum_etendu::Existe_dans_la_liste(tabnoeud_type_ddlEtendu(imail),ddl_enu_etendue))
|
|
|
|
|
|| (Ddl_enum_etendu::Existe_dans_la_liste(list_vect_globalPourNoeud,ddl_enu_etendue))
|
|
|
|
|
)
|
|
|
|
|
{ // on regarde si l'on veut uniquement la grandeur scalaire ou tout
|
|
|
|
|
bool choix_var_valide=false;
|
|
|
|
|
bool choixScalaireUniquement = true;
|
|
|
|
|
while (!choix_var_valide)
|
|
|
|
|
{try
|
|
|
|
|
{ cout << "\n voulez vous uniquement la grandeur scalaire (rep 1) ou toutes les composantes de la grandeur (rep 2) ? \n"
|
|
|
|
|
<< "\n reponse ? ";
|
|
|
|
|
cin >> rep;
|
|
|
|
|
if (rep == "1") {choixScalaireUniquement=true;choix_var_valide=true;}
|
|
|
|
|
else if (rep == "2") {choixScalaireUniquement=false;choix_var_valide=true;}
|
|
|
|
|
else {cout << "\n mauvais choix, recommencez";choix_var_valide=false;}
|
|
|
|
|
}
|
|
|
|
|
catch (...)// erreur en lecture
|
|
|
|
|
{ cout << "\n Erreur dans le choix scalaire ou non !!, "
|
|
|
|
|
<< "\n redonnez une bonne valeur";
|
|
|
|
|
choix_var_valide=false;
|
|
|
|
|
};
|
|
|
|
|
}; //-- fin du second while
|
|
|
|
|
// dans le cas où le ddl est de type vecteur, on ajoute toutes les composantes
|
|
|
|
|
EnumTypeGrandeur type_grandeur = ddl_enu_etendue.TypeDeGrandeur(); // le premier type de grandeur
|
|
|
|
|
if ((!choixScalaireUniquement) && ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE)
|
|
|
|
|
|| (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH)))
|
|
|
|
|
{ // cas d'un type vecteur
|
|
|
|
|
Enum_ddl enu_type_famille = PremierDdlFamille(ddl_enu_etendue.Enum());
|
|
|
|
|
// pour l'instant ***** on ne sort que des iso de ddl non étendue donc on peut constituer les
|
|
|
|
|
// ddl du vecteur qui est forcément de dim 3
|
|
|
|
|
switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
|
|
|
|
|
{ case 3: tabnoeud_type_ddlEtendu_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-3)));
|
|
|
|
|
nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-3)));
|
|
|
|
|
case 2: tabnoeud_type_ddlEtendu_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-2)));
|
|
|
|
|
nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-2)));
|
|
|
|
|
case 1: tabnoeud_type_ddlEtendu_retenu(imail).push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-1)));
|
|
|
|
|
nouveau_ddl_a_demander.push_back(Ddl_enum_etendu(Enum_ddl(enu_type_famille+dim-1)));
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
else // cas d'une grandeur scalaire simple
|
|
|
|
|
{ tabnoeud_type_ddlEtendu_retenu(imail).push_back(ddl_enu_etendue);
|
|
|
|
|
nouveau_ddl_a_demander.push_back(ddl_enu_etendue);
|
|
|
|
|
};
|
|
|
|
|
deplace_ou_valeur_a_demander=true;
|
|
|
|
|
} */
|
|
|
|
|
else
|
|
|
|
|
{cout << "\n ddl inexistant dans la liste proposee, recommencez";
|
|
|
|
|
choix_valide=false;
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
catch (...)// 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_Gid::ChoixIsovaleur_evoluee_noeud(const string& choix)
|
|
|
|
|
{ // tout d'abord on traite le cas de tous les isovaleurs
|
|
|
|
|
if (choix=="to")
|
|
|
|
|
{ tabnoeud_evoluee_retenu = tabnoeud_evoluee;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
else if (choix=="de")
|
|
|
|
|
{ // on prend le premier élément de chaque maillage et on statut en fonction de son type
|
|
|
|
|
int nbmail = tabnoeud_evoluee.Taille();
|
|
|
|
|
for (int imail = 1;imail<=nbmail;imail++)
|
|
|
|
|
{List_io < TypeQuelconque >& element_evoluee = tabnoeud_evoluee(imail); // pour simplifier
|
|
|
|
|
List_io < TypeQuelconque >& element_evoluee_retenu = tabnoeud_evoluee_retenu(imail); // pour simplifier
|
|
|
|
|
List_io < TypeQuelconque >::iterator iq,iqfin=element_evoluee.end();
|
|
|
|
|
List_io < TypeQuelconque >::iterator iqev,iqevfin;
|
|
|
|
|
Element& ele = lesMail->Element_LesMaille(imail,1);
|
|
|
|
|
Element::Signature signa = ele.Signature_element();
|
|
|
|
|
switch (signa.id_problem)
|
|
|
|
|
{case MECA_SOLIDE_DEFORMABLE:
|
|
|
|
|
{// c'est avec les types évoluées que l'on travaille, on sort les forces internes et externes globales // tout d'abord les grandeurs communes:
|
|
|
|
|
// a) on sort les forces externes
|
|
|
|
|
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
|
|
|
|
|
{if ((*iq).EnuTypeQuelconque()== FORCE_GENE_EXT) break;};
|
|
|
|
|
if (iq != iqfin)
|
|
|
|
|
{ // on enregistre s'il n'existe pas déjà
|
|
|
|
|
iqevfin=element_evoluee_retenu.end();
|
|
|
|
|
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
|
|
|
|
|
{if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_EXT) break;};
|
|
|
|
|
if (iqev == iqevfin)element_evoluee_retenu.push_back(*iq);
|
|
|
|
|
};
|
|
|
|
|
// b) et les forces internes
|
|
|
|
|
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
|
|
|
|
|
{if ((*iq).EnuTypeQuelconque()== FORCE_GENE_INT) break;};
|
|
|
|
|
if (iq != iqfin)
|
|
|
|
|
{ // on enregistre s'il n'existe pas déjà
|
|
|
|
|
iqevfin=element_evoluee_retenu.end();
|
|
|
|
|
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
|
|
|
|
|
{if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_INT) break;};
|
|
|
|
|
if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
|
|
|
|
|
};
|
|
|
|
|
// c) les forces internes + externes
|
|
|
|
|
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
|
|
|
|
|
{if ((*iq).EnuTypeQuelconque()== FORCE_GENE_TOT) break;};
|
|
|
|
|
if (iq != iqfin)
|
|
|
|
|
{ // on enregistre s'il n'existe pas déjà
|
|
|
|
|
iqevfin=element_evoluee_retenu.end();
|
|
|
|
|
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
|
|
|
|
|
{if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_TOT) break;};
|
|
|
|
|
if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
|
|
|
|
|
};
|
|
|
|
|
// d) les forces résidues d'équilibre
|
|
|
|
|
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
|
|
|
|
|
{if ((*iq).EnuTypeQuelconque()== RESIDU_GLOBAL) break;};
|
|
|
|
|
if (iq != iqfin)
|
|
|
|
|
{ // on enregistre s'il n'existe pas déjà
|
|
|
|
|
iqevfin=element_evoluee_retenu.end();
|
|
|
|
|
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
|
|
|
|
|
{if ((*iqev).EnuTypeQuelconque()== RESIDU_GLOBAL) break;};
|
|
|
|
|
if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
|
|
|
|
|
};
|
|
|
|
|
// puis choix en fonction de l'évolution temporelle
|
|
|
|
|
switch (Evolution_temporelle_du_calcul(ParaGlob::param->TypeCalcul_maitre()))
|
|
|
|
|
{ case DYNAMIQUE:
|
|
|
|
|
{ // on sort les vitesses de déformation
|
|
|
|
|
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
|
|
|
|
|
{if ((*iq).EnuTypeQuelconque()== VITESSE_DEFORMATION_COURANTE) break;};
|
|
|
|
|
if (iq != iqfin)
|
|
|
|
|
{ // on enregistre s'il n'existe pas déjà
|
|
|
|
|
iqevfin=element_evoluee_retenu.end();
|
|
|
|
|
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
|
|
|
|
|
{if ((*iqev).EnuTypeQuelconque()== VITESSE_DEFORMATION_COURANTE) break;};
|
|
|
|
|
if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
|
|
|
|
|
};
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
// on ne fait rien
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
break;
|
|
|
|
|
} //-- fin du cas MECA_SOLIDE_DEFORMABLE
|
|
|
|
|
default:
|
|
|
|
|
cout << "\n pour l'instant pas de parametre par defaut pour les noeuds !! "
|
|
|
|
|
<< "\n pour le type de problem : " << NomElemTypeProblem(signa.id_problem)
|
|
|
|
|
<< "\n on continue sur le cas general ";
|
|
|
|
|
};
|
|
|
|
|
}; //-- fin de la boucle sur les maillages
|
|
|
|
|
return;
|
|
|
|
|
};
|
|
|
|
|
// maintenant on traite le cas interactif
|
|
|
|
|
string rep;
|
|
|
|
|
bool choix_valide = false;
|
|
|
|
|
cout << "\n choix d'isovaleur (grandeurs evoluees) defini aux noeuds, a visualiser ";
|
|
|
|
|
int nbmail = tabnoeud_evoluee.Taille();
|
|
|
|
|
// update du tableau evolues à visualiser si nécessaire
|
|
|
|
|
if (tabnoeud_evoluee_retenu.Taille() != nbmail)
|
|
|
|
|
tabnoeud_evoluee_retenu.Change_taille(nbmail);
|
|
|
|
|
for (int imail = 1;imail<=nbmail;imail++)
|
|
|
|
|
{// on ne traite que s'il y a des grandeurs disponibles
|
|
|
|
|
if ( (tabnoeud_evoluee(imail).size() == 0 )
|
|
|
|
|
&& (list_vect_globalPourNoeud.size() == 0))
|
|
|
|
|
{ cout << "\n aucune grandeur n'est definit, donc aucune proposition ";}
|
|
|
|
|
else
|
|
|
|
|
{choix_valide=false;
|
|
|
|
|
while (!choix_valide) // premier while
|
|
|
|
|
{try
|
|
|
|
|
{ cout << "\n (0 ou f ou fin) fin choix grandeurs evoluees ";
|
|
|
|
|
cout << "\n listes de type de grandeur evoluees a visualiser ";
|
|
|
|
|
// affichage des grandeurs retenues si la liste n'est pas vide
|
|
|
|
|
if ((tabnoeud_evoluee_retenu(imail)).size())
|
|
|
|
|
{ cout << "\n Maillage nb: " << imail << "\n liste des types de grandeurs enregistres: ";
|
|
|
|
|
List_io < TypeQuelconque >::iterator iet,ietfin = (tabnoeud_evoluee_retenu(imail)).end();
|
|
|
|
|
for (iet=(tabnoeud_evoluee_retenu(imail)).begin();iet!=ietfin;iet++)
|
|
|
|
|
cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
|
|
|
|
|
cout << endl;
|
|
|
|
|
};
|
|
|
|
|
cout << "\n Maillage nb: " << imail << " liste des types de grandeurs evoluees disponibles ";
|
|
|
|
|
// tout d'abord celles venant du maillage
|
|
|
|
|
List_io < TypeQuelconque >::iterator iet,ietfin = (tabnoeud_evoluee(imail)).end();
|
|
|
|
|
for (iet=(tabnoeud_evoluee(imail)).begin();iet!=ietfin;iet++)
|
|
|
|
|
cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
|
|
|
|
|
// puis celles venant de l'algorithme
|
|
|
|
|
{List_io < TypeQuelconque >::iterator iet,ietfin = list_vect_globalPourNoeud.end();
|
|
|
|
|
List_io<TypeQuelconque>& tpg = (tabnoeud_evoluee(imail));
|
|
|
|
|
for (iet=list_vect_globalPourNoeud.begin();iet!=ietfin;iet++)
|
|
|
|
|
{ if ( find(tpg.begin(),tpg.end(),(*iet)) == tpg.end()) // on ne sort que si ça n'a pas déjà été sorti
|
|
|
|
|
cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
// le menu
|
|
|
|
|
cout << "\n donner la grandeur a visualiser "
|
|
|
|
|
<< "\n (to) toutes les grandeurs "
|
|
|
|
|
<< "\n (de) les grandeurs par defaut"
|
|
|
|
|
<< "\n (une liste de grandeurs evoluees) "
|
|
|
|
|
<< "\n (ef) pour effacer la liste "
|
|
|
|
|
<< "\n (0 ou f ou fin) fin choix grandeur tensorielle "
|
|
|
|
|
<< "\n reponse ? ";
|
|
|
|
|
rep = lect_return_defaut(false,"f");
|
|
|
|
|
if (rep == "fin_prog") Sortie(1);
|
|
|
|
|
if (rep == "to")
|
|
|
|
|
{// cas de toutes les grandeurs
|
|
|
|
|
// tout d'abord venant des maillages
|
|
|
|
|
tabnoeud_evoluee_retenu(imail).clear(); // avec les types évolués il vaut vider avant la recopie
|
|
|
|
|
tabnoeud_evoluee_retenu(imail) = tabnoeud_evoluee(imail);
|
|
|
|
|
// puis celles venant de l'algorithme
|
|
|
|
|
{List_io<TypeQuelconque>& tpg_ret = (tabnoeud_evoluee_retenu(imail)); // pour simplifier
|
|
|
|
|
List_io<TypeQuelconque>& tpg = list_vect_globalPourNoeud; // pour simplifier
|
|
|
|
|
List_io<TypeQuelconque>::iterator il,ilfin = list_vect_globalPourNoeud.end();
|
|
|
|
|
for (il=list_vect_globalPourNoeud.begin();il != ilfin;il++)
|
|
|
|
|
{ tpg_ret.push_back(*il);
|
|
|
|
|
list_vect_globalPourNoeud_retenu.push_back(*il); // sert pour ajouter les conteneurs aux noeuds
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
choix_valide=false;
|
|
|
|
|
};
|
|
|
|
|
// sinon
|
|
|
|
|
if ((rep == "0") || (rep == "f") || (rep == "fin"))
|
|
|
|
|
{choix_valide=true;}
|
|
|
|
|
else if (rep=="ef")
|
|
|
|
|
{ tabnoeud_evoluee_retenu(imail).clear();
|
|
|
|
|
list_vect_globalPourNoeud_retenu.clear();
|
|
|
|
|
}
|
|
|
|
|
else if (rep=="de")
|
|
|
|
|
{List_io < TypeQuelconque >& element_evoluee = tabnoeud_evoluee(imail); // pour simplifier
|
|
|
|
|
List_io < TypeQuelconque >& element_evoluee_retenu = tabnoeud_evoluee_retenu(imail); // pour simplifier
|
|
|
|
|
List_io < TypeQuelconque >::iterator iq,iqfin=element_evoluee.end();
|
|
|
|
|
List_io < TypeQuelconque >::iterator iqev,iqevfin;
|
|
|
|
|
Element& ele = lesMail->Element_LesMaille(imail,1);
|
|
|
|
|
Element::Signature signa = ele.Signature_element();
|
|
|
|
|
switch (signa.id_problem)
|
|
|
|
|
{case MECA_SOLIDE_DEFORMABLE:
|
|
|
|
|
{// c'est avec les types évoluées que l'on travaille, on sort les forces internes et externes globales // tout d'abord les grandeurs communes:
|
|
|
|
|
// a) on sort les forces externes
|
|
|
|
|
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
|
|
|
|
|
{if ((*iq).EnuTypeQuelconque()== FORCE_GENE_EXT) break;};
|
|
|
|
|
if (iq != iqfin)
|
|
|
|
|
{ // on enregistre s'il n'existe pas déjà
|
|
|
|
|
iqevfin=element_evoluee_retenu.end();
|
|
|
|
|
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
|
|
|
|
|
{if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_EXT) break;};
|
|
|
|
|
if (iqev == iqevfin)element_evoluee_retenu.push_back(*iq);
|
|
|
|
|
};
|
|
|
|
|
// b) et les forces internes
|
|
|
|
|
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
|
|
|
|
|
{if ((*iq).EnuTypeQuelconque()== FORCE_GENE_INT) break;};
|
|
|
|
|
if (iq != iqfin)
|
|
|
|
|
{ // on enregistre s'il n'existe pas déjà
|
|
|
|
|
iqevfin=element_evoluee_retenu.end();
|
|
|
|
|
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
|
|
|
|
|
{if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_INT) break;};
|
|
|
|
|
if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
|
|
|
|
|
};
|
|
|
|
|
// c) les forces internes + externes
|
|
|
|
|
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
|
|
|
|
|
{if ((*iq).EnuTypeQuelconque()== FORCE_GENE_TOT) break;};
|
|
|
|
|
if (iq != iqfin)
|
|
|
|
|
{ // on enregistre s'il n'existe pas déjà
|
|
|
|
|
iqevfin=element_evoluee_retenu.end();
|
|
|
|
|
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
|
|
|
|
|
{if ((*iqev).EnuTypeQuelconque()== FORCE_GENE_TOT) break;};
|
|
|
|
|
if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
|
|
|
|
|
};
|
|
|
|
|
// d) les forces résidues d'équilibre
|
|
|
|
|
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
|
|
|
|
|
{if ((*iq).EnuTypeQuelconque()== RESIDU_GLOBAL) break;};
|
|
|
|
|
if (iq != iqfin)
|
|
|
|
|
{ // on enregistre s'il n'existe pas déjà
|
|
|
|
|
iqevfin=element_evoluee_retenu.end();
|
|
|
|
|
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
|
|
|
|
|
{if ((*iqev).EnuTypeQuelconque()== RESIDU_GLOBAL) break;};
|
|
|
|
|
if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
|
|
|
|
|
};
|
|
|
|
|
// puis choix en fonction de l'évolution temporelle
|
|
|
|
|
switch (Evolution_temporelle_du_calcul(ParaGlob::param->TypeCalcul_maitre()))
|
|
|
|
|
{ case DYNAMIQUE:
|
|
|
|
|
{ // on sort les vitesses de déformation
|
|
|
|
|
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
|
|
|
|
|
{if ((*iq).EnuTypeQuelconque()== VITESSE_DEFORMATION_COURANTE) break;};
|
|
|
|
|
if (iq != iqfin)
|
|
|
|
|
{ // on enregistre s'il n'existe pas déjà
|
|
|
|
|
iqevfin=element_evoluee_retenu.end();
|
|
|
|
|
for (iqev=element_evoluee_retenu.begin();iqev!=iqevfin;iqev++)
|
|
|
|
|
{if ((*iqev).EnuTypeQuelconque()== VITESSE_DEFORMATION_COURANTE) break;};
|
|
|
|
|
if (iqev == iqevfin) element_evoluee_retenu.push_back(*iq);
|
|
|
|
|
};
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
// on ne fait rien
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
break;
|
|
|
|
|
} //-- fin du cas MECA_SOLIDE_DEFORMABLE
|
|
|
|
|
default:
|
|
|
|
|
cout << "\n pour l'instant pas de parametre par defaut pour les noeuds !! "
|
|
|
|
|
<< "\n pour le type de problem : " << NomElemTypeProblem(signa.id_problem)
|
|
|
|
|
<< "\n on continue sur le cas general ";
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
else if (TypeQuelconque_enum_etendu::VerifExistence(rep) ) // vérif que c'est une grandeur possible
|
|
|
|
|
{ // maintenant on vérifie qu'elle appartient à la liste des grandeurs disponibles
|
|
|
|
|
TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
|
|
|
|
|
bool trouve=false; // init pour le message d'erreur
|
|
|
|
|
// tout d'abord vérif pour celles venant du maillage
|
|
|
|
|
{List_io<TypeQuelconque>& tpg_ret = (tabnoeud_evoluee_retenu(imail)); // pour simplifier
|
|
|
|
|
List_io<TypeQuelconque>& tpg = (tabnoeud_evoluee(imail)); // pour simplifier
|
|
|
|
|
if (find(tpg.begin(),tpg.end(),a) != tpg.end())
|
|
|
|
|
{ // il existe -> enregistrement
|
|
|
|
|
List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
|
|
|
|
|
// s'il n'existe pas déjà on l'enregistre vraiment
|
|
|
|
|
if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
|
|
|
|
|
tpg_ret.push_back(*il);
|
|
|
|
|
trouve = true; // on a bien trouvé une grandeur
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
// puis vérif pour celles venant de l'algorithme
|
|
|
|
|
{List_io<TypeQuelconque>& tpg_ret = (tabnoeud_evoluee_retenu(imail)); // pour simplifier
|
|
|
|
|
List_io<TypeQuelconque>& tpg = list_vect_globalPourNoeud; // pour simplifier
|
|
|
|
|
if (find(tpg.begin(),tpg.end(),a) != tpg.end())
|
|
|
|
|
{ // il existe -> enregistrement
|
|
|
|
|
List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
|
|
|
|
|
// s'il n'existe pas déjà on l'enregistre vraiment
|
|
|
|
|
if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
|
|
|
|
|
{ tpg_ret.push_back(*il);
|
|
|
|
|
list_vect_globalPourNoeud_retenu.push_back(*il); // sert pour ajouter les conteneurs aux noeuds
|
|
|
|
|
};
|
|
|
|
|
trouve = true; // on a bien trouvé une grandeur
|
|
|
|
|
// on sort un message pour indiquer que la grandeur globale ne sera
|
|
|
|
|
// disponible qu'au fil du calcul
|
|
|
|
|
{cout << "\n ---- attention, la grandeur suivante ne sera disponible qu'au fil du calcul ----";
|
|
|
|
|
cout << "\n " << ((*il).EnuTypeQuelconque().NomPlein()) ;
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
if (!trouve)
|
|
|
|
|
{ cout << "\n erreur, grandeur non disponible !, recommencez ";};
|
|
|
|
|
};
|
|
|
|
|
// on supprime les doublons dans la liste retenue
|
|
|
|
|
(tabnoeud_evoluee_retenu(imail)).sort();
|
|
|
|
|
(tabnoeud_evoluee_retenu(imail)).unique();
|
|
|
|
|
list_vect_globalPourNoeud.sort();
|
|
|
|
|
list_vect_globalPourNoeud.unique();
|
|
|
|
|
}
|
|
|
|
|
catch (ErrSortieFinale)
|
|
|
|
|
// cas d'une direction voulue vers la sortie
|
|
|
|
|
// on relance l'interuption pour le niveau supérieur
|
|
|
|
|
{ ErrSortieFinale toto;
|
|
|
|
|
throw (toto);
|
|
|
|
|
}
|
|
|
|
|
catch (...)// erreur en lecture
|
|
|
|
|
{ cout << "\n Erreur dans la lecture evolues !!, "
|
|
|
|
|
<< "\n redonnez une bonne valeur"
|
|
|
|
|
<< "\n ou taper fin_prog pour arreter le programme";
|
|
|
|
|
choix_valide=false;
|
|
|
|
|
};
|
|
|
|
|
}; //-- fin du premier while
|
|
|
|
|
tabnoeud_evoluee_retenu(imail).sort(); // on ordonne
|
|
|
|
|
tabnoeud_evoluee_retenu(imail).unique();// on supprime les doublons
|
|
|
|
|
// on parcours la liste a_accumuler_tabnoeud_evoluee pour savoir le type d'accumulation à mettre en place
|
|
|
|
|
|
|
|
|
|
{List_io<TypeQuelconque>& aaccum_ret = (a_accumuler_tabnoeud_evoluee_retenu(imail)); // pour simplifier
|
|
|
|
|
List_io<TypeQuelconque>& aaccum = (a_accumuler_tabnoeud_evoluee(imail)); // pour simplifier
|
|
|
|
|
List_io<TypeQuelconque>& tpg_ret = (tabnoeud_evoluee_retenu(imail)); // pour simplifier
|
|
|
|
|
List_io < TypeQuelconque >::iterator iq,iqfin=tpg_ret.end();
|
|
|
|
|
for (iq=tpg_ret.begin();iq!=iqfin;iq++)
|
|
|
|
|
if (find(aaccum.begin(),aaccum.end(),(*iq)) != aaccum.end())
|
|
|
|
|
aaccum_ret.push_back(*iq);// accumulation simple
|
|
|
|
|
//on ordonne et supprime les doublons
|
|
|
|
|
aaccum_ret.sort();aaccum_ret.unique();
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
}; //-- fin de if (tabelement_typeParti(imail).size() != 0 )
|
|
|
|
|
};//-- fin de la boucle sur les maillages
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// choix de l'isovaleur à visualiser calculée à partir des ddl aux points d'intégrations
|
|
|
|
|
void Isovaleurs_Gid::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) aux pt 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).erase(tabelement_type_ddl_retenu(imail).begin(),
|
|
|
|
|
tabelement_type_ddl_retenu(imail).end());
|
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
|
void Isovaleurs_Gid::ExeOrdrePremierIncrement(const Tableau <int>& tab_mail,LesMaillages * lesMail,ostream &sort)
|
|
|
|
|
{ // pour simplifier
|
|
|
|
|
int nbdigit = ParaGlob::NbdigdoGR();
|
|
|
|
|
int dim = ParaGlob::Dimension();
|
|
|
|
|
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.erase(li_P_gauss_total.begin(),li_P_gauss_total.end());
|
|
|
|
|
// idem pour map_gauss_base
|
|
|
|
|
map_gauss_base.erase(map_gauss_base.begin(),map_gauss_base.end());
|
|
|
|
|
map_gauss_basePQ.erase(map_gauss_basePQ.begin(),map_gauss_basePQ.end());
|
|
|
|
|
map_gauss_baseEVol.erase(map_gauss_baseEVol.begin(),map_gauss_baseEVol.end());
|
|
|
|
|
|
|
|
|
|
// --- boucle sur les maillages ---
|
|
|
|
|
for (int im=1;im<=nbmail;im++)
|
|
|
|
|
{int numMail=tab_mail(im);
|
|
|
|
|
Tableau < Tableau < P_gauss > >& tp_tp_gauss_base = tp_tp_tp_gauss_base(im); // pour simplifier
|
|
|
|
|
// 1) on récupère tout d'abord le nombre d'éléments différents dans le maillage
|
|
|
|
|
const List_io <Element::Signature>& li_sig_elem = (mailInitial->Tab_liste_type_element())(numMail);
|
|
|
|
|
// 2) on cherche la liste des types de ddl différents associés à des pt de gauss
|
|
|
|
|
List_io < Enum_ddl > lisEnumDdl; // liste de tous les premiers ddl différents
|
|
|
|
|
// 2-A) cas des ddl étendue
|
|
|
|
|
List_io < Ddl_enum_etendu >& element_type_ddl_retenu=tabelement_type_ddl_retenu(numMail); // pour simplifier
|
|
|
|
|
List_io < Ddl_enum_etendu >::iterator iel,ielfin=element_type_ddl_retenu.end();
|
|
|
|
|
for (iel=element_type_ddl_retenu.begin();iel!=ielfin;iel++)
|
|
|
|
|
{ Enum_ddl pr_ddl = PremierDdlFamille((*iel).Enum()); // récup du premier ddl
|
|
|
|
|
if (find(lisEnumDdl.begin(),lisEnumDdl.end(),pr_ddl)== lisEnumDdl.end())
|
|
|
|
|
lisEnumDdl.push_back(pr_ddl);
|
|
|
|
|
};
|
|
|
|
|
// 2-B) cas des grandeurs quelconques pour les grandeurs évoluées: tensorielles
|
|
|
|
|
List_io < TypeQuelconque >& element_evoluee_retenu=tabelement_evoluee_retenu(numMail); // pour simplifier
|
|
|
|
|
List_io < TypeQuelconque >::iterator ielEV,ielfinEV=element_evoluee_retenu.end();
|
|
|
|
|
for (ielEV=element_evoluee_retenu.begin();ielEV!=ielfinEV;ielEV++)
|
|
|
|
|
{ Enum_ddl pr_ddl = PremierDdlFamille((*ielEV).Enum()); // récup du premier ddl
|
|
|
|
|
if (find(lisEnumDdl.begin(),lisEnumDdl.end(),pr_ddl)== lisEnumDdl.end())
|
|
|
|
|
lisEnumDdl.push_back(pr_ddl);
|
|
|
|
|
};
|
|
|
|
|
// 2-C) cas des grandeurs quelconques pour les grandeurs particulières
|
|
|
|
|
List_io < TypeQuelconque >& element_typeParti_retenu=tabelement_typeParti_retenu(numMail); // pour simplifier
|
|
|
|
|
List_io < TypeQuelconque >::iterator ielPQ,ielfinPQ=element_typeParti_retenu.end();
|
|
|
|
|
for (ielPQ=element_typeParti_retenu.begin();ielPQ!=ielfinPQ;ielPQ++)
|
|
|
|
|
{ Enum_ddl pr_ddl = PremierDdlFamille((*ielPQ).Enum()); // récup du premier ddl
|
|
|
|
|
if (find(lisEnumDdl.begin(),lisEnumDdl.end(),pr_ddl)== lisEnumDdl.end())
|
|
|
|
|
lisEnumDdl.push_back(pr_ddl);
|
|
|
|
|
};
|
|
|
|
|
// 3) maintenant on boucle sur les types de ddl différents et sur les types d'éléments pour construire
|
|
|
|
|
// la définition des pt d'integ associés aux infos à sortir
|
|
|
|
|
List_io <Element::Signature>::const_iterator ifin=li_sig_elem.end();
|
|
|
|
|
List_io < Enum_ddl >::iterator iddle,iddlefin= lisEnumDdl.end();
|
|
|
|
|
List_io <Element::Signature>::const_iterator ipos;
|
|
|
|
|
// récup du tableau de sous maillages
|
|
|
|
|
const Tableau < List_io < Element* > > & tab_sous_mesh
|
|
|
|
|
= (mailInitial->Tableau_de_sous_maillage())(numMail);
|
|
|
|
|
int nbsmax = tab_sous_mesh.Taille(); // récup du nombre de sous maillage
|
|
|
|
|
// définition d'un tableau intermédiaire permettant de retrouver le P_gauss dans la liste li_P_gauss_total
|
|
|
|
|
Tableau < Tableau < P_gauss *> > tab_point_enum(nbsmax);
|
|
|
|
|
|
|
|
|
|
// récup de la liste de noms de sous maillage
|
|
|
|
|
const List_io <string>& li_nom_sous_mesh
|
|
|
|
|
= (mailInitial->Tab_listes_nom_sousMaillage())(numMail);
|
|
|
|
|
|
|
|
|
|
// important: *** on boucle d'abord sur les types d'éléments c'est-à-dire les sous maillages
|
|
|
|
|
// et à l'intérieur on boucle sur les ddl, because, c'est dans cet ordre que l'on sort les résultats
|
|
|
|
|
// --> l'enjeux c'est l'ordre des éléments de tp_gauss_base
|
|
|
|
|
tp_tp_gauss_base.Change_taille(li_sig_elem.size());
|
|
|
|
|
int ism = 1; // init numéro de sous maillage
|
|
|
|
|
// init nom de sous maillage
|
|
|
|
|
List_io <string>::const_iterator inom=li_nom_sous_mesh.begin();
|
|
|
|
|
for (ipos= li_sig_elem.begin();ipos!=ifin;ipos++,ism++,inom++)
|
|
|
|
|
{List_io < P_gauss > lip_gauss_base ; // intermédiaire pour construire le tableau tp_gauss_base
|
|
|
|
|
int numero_ddl = 1;
|
|
|
|
|
for (iddle=lisEnumDdl.begin();iddle!=iddlefin;iddle++,numero_ddl++)
|
|
|
|
|
{ // récup du premier élément qui sert d'élément courant
|
|
|
|
|
const Element & ele = (*(*(tab_sous_mesh(ism).begin())));
|
|
|
|
|
tab_point_enum(ism).Change_taille(nombre_maxi_de_type_de_ddl); // dimensionnement du tableau indirecte
|
|
|
|
|
// on commence par regarder s'il n'y a pas déjà un groupe de pt_integ qui convient
|
|
|
|
|
// le nombre de pt d'integ est contenu dans l'élément géométrique associé
|
|
|
|
|
Isovaleurs_Gid::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_Gid::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_Gid::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_Gid::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
|
|
|
|
|
// écriture de l'entête
|
|
|
|
|
sort << "\n \n # definition des positions de points de gauss : maillage: "
|
|
|
|
|
<< lesMail->NomMaillage(numMail) << "\n";
|
|
|
|
|
// 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_Gid::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
|
|
|
|
|
|
|
|
|
|
// écriture des infos
|
|
|
|
|
sort << "\n GaussPoints \""<< nom_pt_integ_sous_maillage << "\" ";
|
|
|
|
|
//cout << "\n GaussPoints \""<< nom_pt_integ_sous_maillage << "\" " << endl; /// pour debug
|
|
|
|
|
// définition du type d'élément
|
|
|
|
|
sort << "Elemtype " ;
|
|
|
|
|
bool naturel=true; // indique si oui ou non les pt de gauss sont idem gid
|
|
|
|
|
int nb_integ=ele.NbPtInteg(*iddle); // récup du nombre de pt d'integ
|
|
|
|
|
// cas particulier des plaques et coques
|
|
|
|
|
Enum_PiPoCo typeele = ele.PoutrePlaqueCoque() ;
|
|
|
|
|
if ((typeele == COQUE) || (typeele == PLAQUE))
|
|
|
|
|
nb_integ = ele.NbPtIntegSurface(*iddle); // on récupère les pt d'integ de surface
|
|
|
|
|
|
|
|
|
|
switch ((*ipos).id_geom)
|
|
|
|
|
{// def du type d'élément et du sous_maillage Gid associé
|
|
|
|
|
case TRIANGLE :{sort << "Triangle \"";
|
|
|
|
|
if ((nb_integ!=1)&&(nb_integ!=3)&&(nb_integ!=6)) naturel = false;
|
|
|
|
|
break;}
|
|
|
|
|
case TRIA_AXI :{sort << "Triangle \"";
|
|
|
|
|
if ((nb_integ!=1)&&(nb_integ!=3)&&(nb_integ!=6)) naturel = false;
|
|
|
|
|
break;}
|
|
|
|
|
case QUADRANGLE : {sort << "Quadrilateral \"";
|
|
|
|
|
if ((nb_integ!=1)&&(nb_integ!=4)&&(nb_integ!=9)) naturel = false;
|
|
|
|
|
break;}
|
|
|
|
|
case QUAD_AXI :{sort << "Quadrilateral \"";
|
|
|
|
|
if ((nb_integ!=1)&&(nb_integ!=4)&&(nb_integ!=9)) naturel = false;
|
|
|
|
|
break;}
|
|
|
|
|
case TETRAEDRE : {sort << "Tetrahedra \"";
|
|
|
|
|
if (nb_integ!=4) naturel = false;
|
|
|
|
|
break;}
|
|
|
|
|
case HEXAEDRE :{sort << "Hexahedra \"";
|
|
|
|
|
if ((nb_integ!=8)&&(nb_integ!=27)) naturel = false;
|
|
|
|
|
break;}
|
|
|
|
|
case POUT :{sort << "Linear \""; break;}
|
|
|
|
|
case POINT : {sort << "Point \""; break;}
|
|
|
|
|
case PENTAEDRE : // gid ne gère pas les pentaèdres, on sort donc des hexaèdres avec deux lignes confondues
|
|
|
|
|
{ sort << "Hexahedra \"";
|
|
|
|
|
// ici dans tous les cas, la position des points d'intégration n'est pas naturelle
|
|
|
|
|
naturel = false;
|
|
|
|
|
cout << "\n warning : la sortie GID aux pt d'integ pour les pentaedres n'est pas correcte pour l'instant, mais la valeur"
|
|
|
|
|
<< " aux noeuds est correcte\n";
|
|
|
|
|
break;}
|
|
|
|
|
default :
|
|
|
|
|
cout << "\nErreur : cas d'element non traite par Gid !" << Nom_geom((*ipos).id_geom)
|
|
|
|
|
<< " ********** attention, le fichier de sortie isovaleur ne sera pas exploitable !!!\n";
|
|
|
|
|
};
|
|
|
|
|
sort << lesMail->NomMaillage(numMail) << "_" << ism << "\" ";
|
|
|
|
|
if ((*ipos).id_geom == POUT) sort << "\n Nodes not included "; // cas particulier des éléments barres
|
|
|
|
|
sort << "\n Number Of Gauss Points: " << nb_integ ; //ele.NbPtInteg(*iddle);
|
|
|
|
|
// test si on peut utiliser ou non les pts de gauss de Gid
|
|
|
|
|
if (naturel)
|
|
|
|
|
// cas simple
|
|
|
|
|
{sort << "\n Natural Coordinates: Internal ";}
|
|
|
|
|
else
|
|
|
|
|
// cas où l'on donne les pt d'integ
|
|
|
|
|
{sort << "\n Natural Coordinates: Given ";
|
|
|
|
|
// écriture des points d'integration
|
|
|
|
|
Enum_PiPoCo typeele = ele.PoutrePlaqueCoque() ;
|
|
|
|
|
if ( typeele == NON_PoutrePlaqueCoque)
|
|
|
|
|
{ // cas d'éléments classique
|
|
|
|
|
int nb_pt_gauss = ele.NbPtInteg(*iddle);
|
|
|
|
|
for (int ipg=1;ipg<=nb_pt_gauss;ipg++)
|
|
|
|
|
{sort << "\n ";
|
|
|
|
|
ele.ElementGeometrie(*iddle).CoorPtInteg(ipg).Affiche(sort,ParaGlob::NbdigdoGR());
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
else // cas de poutre plaque ou coque
|
|
|
|
|
{ switch (typeele)
|
|
|
|
|
{ case COQUE :
|
|
|
|
|
{ int nb_pt_gauss = ele.NbPtIntegSurface(*iddle); // on récupère les pt d'integ de surface
|
|
|
|
|
for (int ipg=1;ipg<=nb_pt_gauss;ipg++)
|
|
|
|
|
{sort << "\n ";
|
|
|
|
|
ele.ElementGeometrieSurface(*iddle)->CoorPtInteg(ipg).Affiche(sort,ParaGlob::NbdigdoGR());
|
|
|
|
|
};
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
default:
|
|
|
|
|
cout << " \n cas non pris en compte : element " << Nom_Enum_PiPoCo(typeele);
|
|
|
|
|
ele.Affiche(1);
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
// fin
|
|
|
|
|
sort << "\n End gausspoints \n";
|
|
|
|
|
}; //-- 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
|
|
|
|
|
/* list < P_gauss >::iterator lip,lipfin=li_P_gauss_total.end();
|
|
|
|
|
tab_point_enum.Change_taille(nombre_maxi_de_type_de_ddl); // utile uniquement au premier maillage
|
|
|
|
|
for (lip= li_P_gauss_total.begin();lip!=lipfin;lip++)
|
|
|
|
|
tab_point_enum((*lip).enu)=&(*lip); */
|
|
|
|
|
// 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 isoGid " << (*((*ielPQ).Grandeur_pointee())) << endl; // débug
|
|
|
|
|
Enum_ddl pr_ddl = PremierDdlFamille((*ielPQ).Enum()); // récup du premier ddl
|
|
|
|
|
for (int jsm =1; jsm <= nbsmax; jsm++)
|
|
|
|
|
map_gauss_basePQ[tab_point_enum(jsm)(pr_ddl)->nom_groupe_pt_integ].push_back((*ielPQ));
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// débug
|
|
|
|
|
//{
|
|
|
|
|
//cout << "\n " << tp_tp_gauss_base << endl; //// débug
|
|
|
|
|
//int nbsmax = tab_sous_mesh.Taille(); // récup du nombre de sous maillage
|
|
|
|
|
//for (int ism=1;ism<=nbsmax;ism++)
|
|
|
|
|
// { // récup du premier élément qui sert d'élément courant
|
|
|
|
|
// const Element & ele = (*(*(tab_sous_mesh(ism).begin())));
|
|
|
|
|
// ElemGeomC0& elegeom = (ele.ElementGeometrie(SIG11));
|
|
|
|
|
// cout << "\n" <<elegeom.TypeGeometrie() << elegeom.TypeInterpolation() << elegeom.Nbi() << endl;
|
|
|
|
|
// };
|
|
|
|
|
//}
|
|
|
|
|
// fin débug
|
|
|
|
|
|
|
|
|
|
}; //-- fin de la boucle sur les maillages
|
|
|
|
|
// ----- maintenant pour les types évoluées et quelconques on construit les map de tableaux de listes ---
|
|
|
|
|
map_gauss_tab_baseEVol.erase(map_gauss_tab_baseEVol.begin(),map_gauss_tab_baseEVol.end());
|
|
|
|
|
map_gauss_tab_basePQ.erase(map_gauss_tab_basePQ.begin(),map_gauss_tab_basePQ.end());
|
|
|
|
|
// on boucle sur les maillages puis les sous_maillages puis sur les groupes de pt de gauss
|
|
|
|
|
for (int im=1;im<=nbmail;im++)
|
|
|
|
|
{Tableau < Tableau < P_gauss > > & tp_tp_gauss_base = tp_tp_tp_gauss_base(im);
|
|
|
|
|
int nbsmax = tp_tp_gauss_base.Taille(); // récup en fait du nombre de sous maillage
|
|
|
|
|
for (int ism = 1; ism<= nbsmax; ism++)
|
|
|
|
|
{Tableau < P_gauss >& tp_gauss_base = tp_tp_gauss_base(ism);
|
|
|
|
|
int tp_taille=tp_gauss_base.Taille();
|
|
|
|
|
for (int ing=1;ing<=tp_taille;ing++)
|
|
|
|
|
{P_gauss& gauss_enCours = (tp_gauss_base(ing)); // pour simplifier
|
|
|
|
|
string& nom = gauss_enCours.nom_groupe_pt_integ; // pour simplifier
|
|
|
|
|
int nb_ptinteg = gauss_enCours.elemgeom->Nbi();
|
|
|
|
|
// // on regarde s'il s'agit d'une poutre plaque ou coque, si oui on change le nb de pt d'integ
|
|
|
|
|
// Enum_PiPoCo enu_pipoco = ele.PoutrePlaqueCoque();
|
|
|
|
|
// if ((enu_pipoco == PLAQUE)||(enu_pipoco == COQUE))
|
|
|
|
|
// {// dans ce cas il faut tenir compte des différentes couches de pt d'integ
|
|
|
|
|
// // comme il s'agit de pt d'integ classique, on prend SIG11 qui est le ddl banal
|
|
|
|
|
// nb_ptinteg = ele.NbPtIntegSurface(SIG11) * ele.NbPtIntegEpaiss(SIG11);
|
|
|
|
|
// };
|
|
|
|
|
// 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 isoGid " << (*((*map_gauss_basePQ[nom].begin()).Grandeur_pointee())) << endl; // débug
|
|
|
|
|
// cout << "\n debug de isoGid " << (*((*map_gauss_tab_basePQ[nom](1).begin()).Grandeur_pointee())) << endl; // débug
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// écriture des grandeurs aux points d'intégration
|
|
|
|
|
void Isovaleurs_Gid::EcritureAuxPtInteg(const Tableau <int>& tab_mail,LesMaillages * lesMail
|
|
|
|
|
,ostream &sort,int incre)
|
|
|
|
|
{ // dans le cas où l'on transfert aux noeuds, on initialise les compteurs
|
|
|
|
|
if (transfert_au_noeud)
|
|
|
|
|
lesMail->InitUpdateAuNoeud(glob_elem_ddl_retenu,tab_quelconque,cas_transfert);
|
|
|
|
|
int nbmail = tab_mail.Taille();
|
|
|
|
|
int dim = ParaGlob::Dimension();
|
|
|
|
|
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
|
|
|
|
|
// récup de la liste de noms de sous maillage
|
|
|
|
|
const List_io <string>& li_nom_sous_mesh
|
|
|
|
|
= (mailInitial->Tab_listes_nom_sousMaillage())(numMail);
|
|
|
|
|
// on récupère le décalage de numéros d'éléments
|
|
|
|
|
int decal_ele=mailInitial->DecalNumElement(numMail); // pour simplifier
|
|
|
|
|
// 1- on boucle sur les différents sous maillages
|
|
|
|
|
for (int ism=1;ism<=nbsmax;ism++)
|
|
|
|
|
{ // on boucle sur les groupes de pt de gauss relatifs à ce sous-maillage
|
|
|
|
|
Tableau < P_gauss >& tp_gauss_base = tp_tp_gauss_base(ism);
|
|
|
|
|
int tp_taille=tp_gauss_base.Taille();
|
|
|
|
|
Tableau <Tableau <double> > tab_val; // tableau de travail
|
|
|
|
|
for (int ing=1;ing<=tp_taille;ing++)
|
|
|
|
|
{P_gauss& gauss_enCours = (tp_gauss_base(ing)); // pour simplifier
|
|
|
|
|
// on recherche les liste de ddl étendue et/ou de type quelconque à sortir
|
|
|
|
|
// a) cas des ddl étendue
|
|
|
|
|
List_io < Ddl_enum_etendu >* lidsor = NULL;
|
|
|
|
|
if (map_gauss_base.find(gauss_enCours.nom_groupe_pt_integ)!=map_gauss_base.end())
|
|
|
|
|
lidsor=&(map_gauss_base[gauss_enCours.nom_groupe_pt_integ]);
|
|
|
|
|
|
|
|
|
|
// b) cas des types évoluées tensorielles
|
|
|
|
|
List_io < TypeQuelconque > * lidsorEV = NULL;
|
|
|
|
|
Tableau < List_io < TypeQuelconque > >* tablidsorEV = NULL;
|
|
|
|
|
if (map_gauss_tab_baseEVol.find(gauss_enCours.nom_groupe_pt_integ)!=map_gauss_tab_baseEVol.end())
|
|
|
|
|
{tablidsorEV=&(map_gauss_tab_baseEVol[gauss_enCours.nom_groupe_pt_integ]);
|
|
|
|
|
// pour la liste on pointe via la map de liste simple, la liste servira d'une part
|
|
|
|
|
// pour les identificateurs (enum), et d'autre part de liste de travail pour le passage au noeud
|
|
|
|
|
lidsorEV = &(map_gauss_baseEVol[gauss_enCours.nom_groupe_pt_integ]);
|
|
|
|
|
};
|
|
|
|
|
// c) cas des types quelconques pour les grandeurs particulières
|
|
|
|
|
List_io < TypeQuelconque >* lidsorPQ = NULL;
|
|
|
|
|
Tableau < List_io < TypeQuelconque > >* tablidsorPQ = NULL;
|
|
|
|
|
if (map_gauss_basePQ.find(gauss_enCours.nom_groupe_pt_integ)!=map_gauss_basePQ.end())
|
|
|
|
|
{tablidsorPQ=&(map_gauss_tab_basePQ[gauss_enCours.nom_groupe_pt_integ]);
|
|
|
|
|
// pour la liste on pointe via la map de liste simple, la liste servira d'une part
|
|
|
|
|
// pour les identificateurs (enum), et d'autre part de liste de travail pour le passage au noeud
|
|
|
|
|
lidsorPQ = &(map_gauss_basePQ[gauss_enCours.nom_groupe_pt_integ]);
|
|
|
|
|
// cout << "\n debug de isoGid " << (*((*map_gauss_tab_basePQ[gauss_enCours.nom_groupe_pt_integ](1).begin()).Grandeur_pointee())) << endl; // débug
|
|
|
|
|
// cout << "\n debug de isoGid " << (*( (*(lidsorPQ->begin())).Grandeur_pointee())) << endl; // débug
|
|
|
|
|
// cout << "\n debug de isoGid " << (*((*map_gauss_basePQ[nom].begin()).Grandeur_pointee())) << endl; // débug
|
|
|
|
|
};
|
|
|
|
|
// écriture de l'entête de groupe
|
|
|
|
|
sort << "\n ResultGroup \"calcul_mecanique\" " << incre << " OnGaussPoints \""
|
|
|
|
|
<< gauss_enCours.nom_groupe_pt_integ << "\" ";
|
|
|
|
|
// maintenant on décrit les différentes entitées définis aux points d'intégrations
|
|
|
|
|
// c-1 ----- tout d'abord les ddl étendues donc des grandeurs scalaires ------
|
|
|
|
|
// on définie les iterators pour balaier tous les types quelconques pour les grandeurs scalaires
|
|
|
|
|
List_io < Ddl_enum_etendu >::iterator li,li_end,li_deb;
|
|
|
|
|
|
|
|
|
|
if (lidsor!=NULL)
|
|
|
|
|
{li_end = (*lidsor).end();li_deb = (*lidsor).begin();
|
|
|
|
|
for (li=li_deb;li!=li_end;li++)
|
|
|
|
|
{ // on sauvegarde en scalaire
|
|
|
|
|
sort << "\n ResultDescription \"";
|
|
|
|
|
if (!((*li).Nom_vide())) {sort << (*li).Nom() <<"_"<< numMail << "\" Scalar ";}
|
|
|
|
|
else {sort << Nom_ddl((*li).Enum()) <<"_"<< numMail << "\" Scalar "; };
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
// c-2 ----- les types tensorielles c-a-d évoluées ------
|
|
|
|
|
bool drap_noeud = false; // drapeau pour indiquer que l'on sort des grandeurs aux pt integ
|
|
|
|
|
// on définie les iterators pour balaier tous les types quelconques pour les grandeurs tensorielles
|
|
|
|
|
List_io < TypeQuelconque >::iterator ieve,ieve_end,ieve_deb;
|
|
|
|
|
if (lidsorEV!=NULL)
|
|
|
|
|
{ieve_end = lidsorEV->end();ieve_deb = lidsorEV->begin();
|
|
|
|
|
for(ieve=ieve_deb;ieve!=ieve_end;ieve++)
|
|
|
|
|
{ // on sauvegarde en fonction du type et de la dimension des grandeurs
|
|
|
|
|
this->EnteteSortieIsovaleurs_G_Quelconque(sort,(*ieve),drap_noeud);
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
// c-3 ----- les types quelconques : idem types évolués ------
|
|
|
|
|
// on définie les iterators pour balaier tous les types quelconques pour les grandeurs particulières
|
|
|
|
|
List_io < TypeQuelconque >::iterator ique,ique_end,ique_deb;
|
|
|
|
|
if (lidsorPQ!=NULL)
|
|
|
|
|
{ique_end = lidsorPQ->end();ique_deb = lidsorPQ->begin();
|
|
|
|
|
for(ique=ique_deb;ique!=ique_end;ique++)
|
|
|
|
|
{ // on sauvegarde en fonction du type et de la dimension des grandeurs
|
|
|
|
|
this->EnteteSortieIsovaleurs_G_Quelconque(sort,(*ique),drap_noeud);
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
// maintenant on écrit les grandeurs associés
|
|
|
|
|
sort << "\n \n Values ";
|
|
|
|
|
// on balaie tous les éléments du sous_maillage
|
|
|
|
|
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);
|
|
|
|
|
sort << "\n" << ele.Num_elt_const() + decal_ele << " " ; // le numéro d'élément
|
|
|
|
|
// définition de la numérotation indirecte des numéros de points d'intégration naturels
|
|
|
|
|
// lorsque la numérotation de Gid est différente de celle d'Herezh++
|
|
|
|
|
int nb_pt_gauss = gauss_enCours.elemgeom->Nbi(); // récup du nombre de pt d'integ
|
|
|
|
|
|
|
|
|
|
Tableau <int> ind(nb_pt_gauss); bool indirecte=false; // ind(i) = le nb de HZ du i de Gid
|
|
|
|
|
// dimensionnement des tableaux de sortie
|
|
|
|
|
tab_val.Change_taille(nb_pt_gauss);
|
|
|
|
|
|
|
|
|
|
switch (ele.Id_geometrie())
|
|
|
|
|
{ case TRIANGLE : case TRIA_AXI:
|
|
|
|
|
{if (nb_pt_gauss==3) {indirecte=true; ind(2)= 1; ind(3)=2; ind(1)=3;}
|
|
|
|
|
else if (nb_pt_gauss==6) {indirecte=true; ind(5)= 1; ind(6)=2; ind(4)=3;
|
|
|
|
|
ind(1)= 4; ind(2)=5; ind(3)=6;};
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case QUADRANGLE : case QUAD_AXI:
|
|
|
|
|
{if (nb_pt_gauss==4) {indirecte=true; ind(1)= 1; ind(2)=2; ind(3)=4; ind(4)=3;}
|
|
|
|
|
else if (nb_pt_gauss==9) {indirecte=true; ind(1)= 1; ind(5)=2; ind(2)=3; ind(8)=4;
|
|
|
|
|
ind(9)= 5; ind(6)=6; ind(4)=7; ind(7)=8; ind(3)=9;};
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case TETRAEDRE :
|
|
|
|
|
{if (nb_pt_gauss==4) {indirecte=true; ind(1)= 1; ind(4)=2; ind(3)=3; ind(2)=4;};
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case HEXAEDRE :
|
|
|
|
|
{if (nb_pt_gauss==8) {indirecte=true; ind(7)= 1; ind(3)=2; ind(6)=3; ind(2)=4;
|
|
|
|
|
ind(8)= 5; ind(4)=6; ind(5)=7; ind(1)=8;}
|
|
|
|
|
else if (nb_pt_gauss==27) {indirecte=true; ind(1)= 1; ind(9)=2; ind(2)=3; ind(12)=4;
|
|
|
|
|
ind(21)= 5; ind(10)=6; ind(4)=7; ind(11)=8; ind(3)= 9; ind(13)=10; ind(22)=11; ind(14)=12;
|
|
|
|
|
ind(25)= 13; ind(27)=14; ind(23)=15; ind(16)=16; ind(24)= 17; ind(15)=18; ind(5)=19; ind(17)=20;
|
|
|
|
|
ind(6)= 21; ind(20)=22; ind(26)=23; ind(18)=24; ind(8)= 25; ind(19)=26; ind(7)=27; }
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case PENTAEDRE : // on le passe pour éviter un affichage d'erreur,
|
|
|
|
|
// mais ici la sortie au point d'integ n'est pas bonne, il faut utiliser uniquement les valeurs
|
|
|
|
|
// transferrées aux noeuds (il y a avant un affichage d'un warning !!)
|
|
|
|
|
{break;}
|
|
|
|
|
default :
|
|
|
|
|
// a priori il n'y a pas d'erreur si on passe ici, cela veut simplement dire que la numérotation des pti est identique
|
|
|
|
|
// entre herezh et gid...
|
|
|
|
|
// cout << "\nErreur : cas d'element non traite par Gid !" << Nom_geom(ele.Id_geometrie())
|
|
|
|
|
// << " ********** attention, le fichier de sortie ne sera pas exploitable !!!\n";
|
|
|
|
|
break;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// on balaie le nombre de pt d'integ
|
|
|
|
|
for (int nb_pt=1;nb_pt<=nb_pt_gauss;nb_pt++)
|
|
|
|
|
{ int iptinteg;bool sortie_retour_a_la_ligne=false;
|
|
|
|
|
if (indirecte) {iptinteg=ind(nb_pt);} else {iptinteg=nb_pt;};
|
|
|
|
|
Tableau <double > & tab = tab_val(iptinteg); // pour simplifier
|
|
|
|
|
// on récupère les infos correspondant aux ddl
|
|
|
|
|
// si les grandeurs n'existent pas, elles sont initialisées dans la méthode
|
|
|
|
|
if (lidsor != NULL)
|
|
|
|
|
{tab = ele.Valeur_a_diff_temps(absolue,TEMPS_tdt,*lidsor,iptinteg);
|
|
|
|
|
int tabtaille = tab.Taille();
|
|
|
|
|
for (int k=1;k<= tabtaille;k++)
|
|
|
|
|
sort << setprecision(ParaGlob::NbdigdoGR()) << tab(k) << " ";
|
|
|
|
|
if (nb_pt < nb_pt_gauss) sortie_retour_a_la_ligne=true;
|
|
|
|
|
};
|
|
|
|
|
// 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
|
|
|
|
|
if (lidsorEV != NULL)
|
|
|
|
|
{List_io < TypeQuelconque > & listsorEVduPtInteg = (*tablidsorEV)(iptinteg);
|
|
|
|
|
ele.ValTensorielle_a_diff_temps(absolue,TEMPS_tdt,listsorEVduPtInteg,iptinteg);
|
|
|
|
|
// sortie
|
|
|
|
|
ieve_end = listsorEVduPtInteg.end();
|
|
|
|
|
for (ieve=listsorEVduPtInteg.begin();ieve!=ieve_end;ieve++)
|
|
|
|
|
this->SortieGrandeursQuelconque(sort,(*ieve));
|
|
|
|
|
if (nb_pt < nb_pt_gauss) sortie_retour_a_la_ligne=true;
|
|
|
|
|
};
|
|
|
|
|
// 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);
|
|
|
|
|
// sortie
|
|
|
|
|
ique_end = listsorPQduPtInteg.end();
|
|
|
|
|
for (ique=listsorPQduPtInteg.begin();ique!=ique_end;ique++)
|
|
|
|
|
this->SortieGrandeursQuelconque(sort,(*ique));
|
|
|
|
|
if (nb_pt < nb_pt_gauss) sortie_retour_a_la_ligne=true;
|
|
|
|
|
};
|
|
|
|
|
// passage à la ligne si nécessaire
|
|
|
|
|
if (sortie_retour_a_la_ligne) sort << "\n ";
|
|
|
|
|
}; //-- fin de boucle sur les pt de gauss
|
|
|
|
|
// dans le cas où il y a un transert aux noeuds
|
|
|
|
|
if (transfert_au_noeud)
|
|
|
|
|
{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_Gid::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
|
|
|
|
|
sort << "\n End Values \n";
|
|
|
|
|
}; //-- 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
|
|
|
|
|
// dans le cas où l'on a fait un transfert aux noeuds on effectue la dernière étape
|
|
|
|
|
if (transfert_au_noeud)
|
|
|
|
|
lesMail->FinTransfertPtIntegAuNoeud(glob_elem_ddl_retenu,tab_quelconque,cas_transfert);
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// écriture des grandeurs aux noeuds
|
|
|
|
|
void Isovaleurs_Gid::EcritureAuxNoeuds(const Tableau <int>& tab_mail,LesMaillages * lesMail
|
|
|
|
|
,ostream &sort,int incre)
|
|
|
|
|
{ // pour simplifier
|
|
|
|
|
int nbmail = tab_mail.Taille();
|
|
|
|
|
int dim = ParaGlob::Dimension();
|
|
|
|
|
// 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 ou un transfert aux noeuds
|
|
|
|
|
bool atraiter = false;
|
|
|
|
|
if (transfert_au_noeud)
|
|
|
|
|
{if (glob_noe_ddl_retenu.size() != 0) atraiter = true;
|
|
|
|
|
if (glob_noeud_ddl_etendu_retenu.size() != 0) atraiter = true;
|
|
|
|
|
if (glob_noeud_evol_retenu.size() != 0) atraiter = true;
|
|
|
|
|
if (glob_elem_ddl_retenu.size() != 0) atraiter = true;
|
|
|
|
|
if (glob_elem_evol_retenu.size() != 0) atraiter = true;
|
|
|
|
|
if (glob_elem_Parti_retenu.size() != 0) atraiter = true;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{if (glob_noe_ddl_retenu.size() != 0) atraiter = true;
|
|
|
|
|
if (glob_noeud_ddl_etendu_retenu.size() != 0) atraiter = true;
|
|
|
|
|
if (glob_noeud_evol_retenu.size() != 0) atraiter = true;
|
|
|
|
|
};
|
|
|
|
|
//---------- traitement de l'entête -----------------
|
|
|
|
|
if (atraiter)
|
|
|
|
|
{// écriture de l'entête de groupe dans un premier passage
|
|
|
|
|
sort << "\n ResultGroup \"calcul_mecanique\" " << incre << " OnNodes ";
|
|
|
|
|
// les grandeurs a sortir sont globalisées sur tous les maillage
|
|
|
|
|
// maintenant on décrit les différentes entitées définis aux noeuds
|
|
|
|
|
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
|
|
|
// a) cas des ddl initiaux définis aux noeuds
|
|
|
|
|
// **(3mars2016) je retire l'incrément 0 qui est bancal, car ne représente pas l'état initial de la structure
|
|
|
|
|
if ((glob_noe_ddl_retenu.size() != 0)&& (incre != 0))
|
|
|
|
|
{//--// on fait un bloc d'isolement
|
|
|
|
|
List_io < Ddl_enum_etendu >::iterator ili,ilideb,ilifin=glob_noe_ddl_retenu.end();
|
|
|
|
|
List_io < Ddl_enum_etendu >::iterator yly;
|
|
|
|
|
ilideb = glob_noe_ddl_retenu.begin();
|
|
|
|
|
int sortie_de_vecteur_en_cours = 0;
|
|
|
|
|
for(ili=ilideb;ili!=ilifin;ili++)
|
|
|
|
|
{ // on regarde si le ddl est de type vecteur ou coordonnées car Gid peut en faire un traitement particulier
|
|
|
|
|
EnumTypeGrandeur type_grandeur = (*ili).TypeDeGrandeur();
|
|
|
|
|
// on regarde si l'on est en train de sortir un vecteur (ne marche pas au premier passage)
|
|
|
|
|
if ((sortie_de_vecteur_en_cours < dim) && (sortie_de_vecteur_en_cours >= 1))
|
|
|
|
|
{if (!((*ili).Nom_vide())) {sort << " \"" << (*ili).Nom() << "\" "; }
|
|
|
|
|
// !!!!! il faut gérer les différentes composantes comme pour les ddl purs
|
|
|
|
|
else
|
|
|
|
|
{Enum_ddl ddl = (*ili).Enum(); // récup du ddl
|
|
|
|
|
sort << " \"" << Nom_ddl(Enum_ddl(ddl)) << "\" ";
|
|
|
|
|
if ((dim == 2)&&(sortie_de_vecteur_en_cours==1)) // cas où il faut ajouter des ddl vides
|
|
|
|
|
sort << " \"" << Nom_ddl(Enum_ddl(ddl+1)) << "\" " ;
|
|
|
|
|
};
|
|
|
|
|
sortie_de_vecteur_en_cours++;
|
|
|
|
|
}
|
|
|
|
|
// sinon on regarde s'il s'agit d'un premier passage de vecteur
|
|
|
|
|
else if ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE)
|
|
|
|
|
|| (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH))
|
|
|
|
|
{ // c'est un vecteur ou coordonnées, on vérifie que toutes les grandeurs fonctions de la dimension
|
|
|
|
|
// sont présentes
|
|
|
|
|
sortie_de_vecteur_en_cours = 0; // réinitialisation au cas où l'on suit un précédent vecteur
|
|
|
|
|
// comme les ddl sont ordonnées, cela signifie que l'on est en train de tester le premier si
|
|
|
|
|
// toutes les composantes sont présentes
|
|
|
|
|
Enum_ddl pr_ddl = PremierDdlFamille((*ili).Enum()); // récup du premier ddl
|
|
|
|
|
bool present=true; // a priori tous les ddl sont présents
|
|
|
|
|
// on considère que tous les ddl sont ordonnées
|
|
|
|
|
yly = ili; // récup de la position du premier ddl
|
|
|
|
|
for (int i=1;i<=dim;i++,yly++)
|
|
|
|
|
{if ((Enum_ddl(pr_ddl+i-1) != (*yly).Enum())||((yly==ilifin)&&(i!=dim)))
|
|
|
|
|
{present=false;break;};};
|
|
|
|
|
if (present)
|
|
|
|
|
{// cas d'un type vecteur avec dim coordonnees, on sauvegarde en coordonnées
|
|
|
|
|
sort << "\n ResultDescription \"" << (*ili).NomGenerique() << "\" Vector "
|
|
|
|
|
<< "\n ComponentNames ";
|
|
|
|
|
// on sort la première composante
|
|
|
|
|
if (!((*ili).Nom_vide())) {sort << " \"" << (*ili).Nom() << "\" "; }
|
|
|
|
|
else
|
|
|
|
|
{ Enum_ddl ddl = (*ili).Enum(); // récup du ddl
|
|
|
|
|
sort << " \"" << Nom_ddl(ddl) << "\" ";
|
|
|
|
|
if (dim == 1) // cas où il faut ajouter des ddl vides
|
|
|
|
|
sort << " \"" << Nom_ddl(Enum_ddl(ddl+1)) << "\" \""
|
|
|
|
|
<< Nom_ddl(Enum_ddl(ddl+2)) << "\" ";
|
|
|
|
|
};
|
|
|
|
|
if (dim != 1) {sortie_de_vecteur_en_cours++;}
|
|
|
|
|
else {sortie_de_vecteur_en_cours=0;}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{// cas d'un vecteur incomplet, on sauvegarde en scalaire
|
|
|
|
|
sort << "\n ResultDescription \"";
|
|
|
|
|
if (!((*ili).Nom_vide())) {sort << (*ili).Nom() << "\" Scalar ";}
|
|
|
|
|
else {sort << Nom_ddl((*ili).Enum()) << "\" Scalar "; };
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
// cas où on est sûr que ce n'est pas un vecteur, on traite tout comme des scalaires typés
|
|
|
|
|
else
|
|
|
|
|
{// on sauvegarde en scalaire
|
|
|
|
|
sort << "\n ResultDescription \"";
|
|
|
|
|
if (!((*ili).Nom_vide())) {sort << (*ili).Nom() << "\" Scalar ";}
|
|
|
|
|
else {sort << Nom_ddl((*ili).Enum()) << "\" Scalar "; };
|
|
|
|
|
};
|
|
|
|
|
}; // fin de la boucle sur les ddl
|
|
|
|
|
}; //--// fin du bloc d'isolement
|
|
|
|
|
|
|
|
|
|
// a-1) cas des ddl étendues définis aux noeuds
|
|
|
|
|
// **(3mars2016) je retire l'incrément 0 qui est bancal, car ne représente pas l'état initial de la structure
|
|
|
|
|
if ((glob_noeud_ddl_etendu_retenu.size() != 0) && (incre != 0))
|
|
|
|
|
{//--// on fait un bloc d'isolement
|
|
|
|
|
List_io < Ddl_enum_etendu >::iterator ili,ilideb,ilifin=glob_noeud_ddl_etendu_retenu.end();
|
|
|
|
|
List_io < Ddl_enum_etendu >::iterator yly;
|
|
|
|
|
ilideb = glob_noeud_ddl_etendu_retenu.begin();
|
|
|
|
|
int sortie_de_vecteur_en_cours = 0;
|
|
|
|
|
for(ili=ilideb;ili!=ilifin;ili++)
|
|
|
|
|
{ // on regarde si le ddl est de type vecteur ou coordonnées car Gid peut en faire un traitement particulier
|
|
|
|
|
EnumTypeGrandeur type_grandeur = (*ili).TypeDeGrandeur();
|
|
|
|
|
// on regarde si l'on est en train de sortir un vecteur (ne marche pas au premier passage)
|
|
|
|
|
if ((sortie_de_vecteur_en_cours < dim) && (sortie_de_vecteur_en_cours >= 1))
|
|
|
|
|
{if (!((*ili).Nom_vide())) {sort << " \"" << (*ili).Nom() << "\" "; }
|
|
|
|
|
// !!!!! il faut gérer les différentes composantes comme pour les ddl purs
|
|
|
|
|
else
|
|
|
|
|
{Enum_ddl ddl = (*ili).Enum(); // récup du ddl
|
|
|
|
|
sort << " \"" << Nom_ddl(Enum_ddl(ddl)) << "\" ";
|
|
|
|
|
if ((dim == 2)&&(sortie_de_vecteur_en_cours==1)) // cas où il faut ajouter des ddl vides
|
|
|
|
|
sort << " \"" << Nom_ddl(Enum_ddl(ddl+1)) << "\" " ;
|
|
|
|
|
};
|
|
|
|
|
sortie_de_vecteur_en_cours++;
|
|
|
|
|
}
|
|
|
|
|
// sinon on regarde s'il s'agit d'un premier passage de vecteur
|
|
|
|
|
else if ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE)
|
|
|
|
|
|| (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH))
|
|
|
|
|
{ // c'est un vecteur ou coordonnées, on vérifie que toutes les grandeurs fonctions de la dimension
|
|
|
|
|
// sont présentes
|
|
|
|
|
sortie_de_vecteur_en_cours = 0; // réinitialisation au cas où l'on suit un précédent vecteur
|
|
|
|
|
// comme les ddl sont ordonnées, cela signifie que l'on est en train de tester le premier si
|
|
|
|
|
// toutes les composantes sont présentes
|
|
|
|
|
Enum_ddl pr_ddl = PremierDdlFamille((*ili).Enum()); // récup du premier ddl
|
|
|
|
|
bool present=true; // a priori tous les ddl sont présents
|
|
|
|
|
// on considère que tous les ddl sont ordonnées
|
|
|
|
|
yly = ili; // récup de la position du premier ddl
|
|
|
|
|
for (int i=1;i<=dim;i++,yly++)
|
|
|
|
|
{if ((Enum_ddl(pr_ddl+i-1) != (*yly).Enum())||((yly==ilifin)&&(i!=dim)))
|
|
|
|
|
{present=false;break;};};
|
|
|
|
|
if (present)
|
|
|
|
|
{// cas d'un type vecteur avec dim coordonnees, on sauvegarde en coordonnées
|
|
|
|
|
sort << "\n ResultDescription \"" << (*ili).NomGenerique() << "\" Vector "
|
|
|
|
|
<< "\n ComponentNames ";
|
|
|
|
|
// on sort la première composante
|
|
|
|
|
if (!((*ili).Nom_vide())) {sort << " \"" << (*ili).Nom() << "\" "; }
|
|
|
|
|
else
|
|
|
|
|
{ Enum_ddl ddl = (*ili).Enum(); // récup du ddl
|
|
|
|
|
sort << " \"" << Nom_ddl(ddl) << "\" ";
|
|
|
|
|
if (dim == 1) // cas où il faut ajouter des ddl vides
|
|
|
|
|
sort << " \"" << Nom_ddl(Enum_ddl(ddl+1)) << "\" \""
|
|
|
|
|
<< Nom_ddl(Enum_ddl(ddl+2)) << "\" ";
|
|
|
|
|
};
|
|
|
|
|
if (dim != 1) {sortie_de_vecteur_en_cours++;}
|
|
|
|
|
else {sortie_de_vecteur_en_cours=0;}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{// cas d'un vecteur incomplet, on sauvegarde en scalaire
|
|
|
|
|
sort << "\n ResultDescription \"";
|
|
|
|
|
if (!((*ili).Nom_vide())) {sort << (*ili).Nom() << "\" Scalar ";}
|
|
|
|
|
else {sort << Nom_ddl((*ili).Enum()) << "\" Scalar "; };
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
// cas où on est sûr que ce n'est pas un vecteur, on traite tout comme des scalaires typés
|
|
|
|
|
else
|
|
|
|
|
{// on sauvegarde en scalaire
|
|
|
|
|
sort << "\n ResultDescription \"";
|
|
|
|
|
if (!((*ili).Nom_vide())) {sort << (*ili).Nom() << "\" Scalar ";}
|
|
|
|
|
else {sort << Nom_ddl((*ili).Enum()) << "\" Scalar "; };
|
|
|
|
|
};
|
|
|
|
|
}; // fin de la boucle sur les ddl
|
|
|
|
|
}; //--// fin du bloc d'isolement
|
|
|
|
|
|
|
|
|
|
// a-2) cas des types évoluées définis aux noeuds
|
|
|
|
|
// **(3mars2016) je retire l'incrément 0 qui est bancal, car ne représente pas l'état initial de la structure
|
|
|
|
|
bool drap_noeud = true; // drapeau pour indiquer que l'on sort des grandeurs aux noeuds
|
|
|
|
|
if ((glob_noeud_evol_retenu.size() != 0) && (incre != 0))
|
|
|
|
|
{//--// on fait un bloc d'isolement
|
|
|
|
|
List_io < TypeQuelconque >::iterator ili,ilideb,ilifin=glob_noeud_evol_retenu.end();
|
|
|
|
|
List_io < TypeQuelconque >::iterator yly;
|
|
|
|
|
ilideb = glob_noeud_evol_retenu.begin();
|
|
|
|
|
int sortie_de_vecteur_en_cours = 0;
|
|
|
|
|
for(ili=ilideb;ili!=ilifin;ili++)
|
|
|
|
|
{ // on sauvegarde en fonction du type et de la dimension des grandeurs
|
|
|
|
|
this->EnteteSortieIsovaleurs_G_Quelconque(sort,(*ili),drap_noeud);
|
|
|
|
|
}; // fin de la boucle sur les grandeurs quelconques
|
|
|
|
|
}; //--// fin du bloc d'isolement
|
|
|
|
|
|
|
|
|
|
// ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
|
|
|
// b) cas des ddl venant d'un transfert aux noeuds des grandeurs aux pt d'integ
|
|
|
|
|
if ((glob_elem_ddl_retenu.size() != 0) && (incre != 0))
|
|
|
|
|
{ //--// on fait un bloc d'isolement
|
|
|
|
|
List_io < Ddl_enum_etendu >::iterator ili,ilideb,ilifin=glob_elem_ddl_retenu.end();
|
|
|
|
|
List_io < Ddl_enum_etendu >::iterator yly;
|
|
|
|
|
ilideb = glob_elem_ddl_retenu.begin();
|
|
|
|
|
int sortie_de_vecteur_en_cours = 0;
|
|
|
|
|
for(ili=ilideb;ili!=ilifin;ili++)
|
|
|
|
|
{ // on traite tout comme des scalaires typés
|
|
|
|
|
sort << "\n ResultDescription \"";
|
|
|
|
|
if (!((*ili).Nom_vide())) {sort << (*ili).Nom() << "\" Scalar ";}
|
|
|
|
|
else {sort << Nom_ddl((*ili).Enum()) << "\" Scalar "; };
|
|
|
|
|
}; // fin de la boucle sur les ddl
|
|
|
|
|
}; //--// fin du bloc d'isolement
|
|
|
|
|
|
|
|
|
|
// ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
|
|
|
// c) cas des types évoluées venant d'un transfert aux noeuds des grandeurs aux pt d'integ
|
|
|
|
|
if ((glob_elem_evol_retenu.size() != 0) && (incre != 0))
|
|
|
|
|
{ //--// on fait un bloc d'isolement
|
|
|
|
|
List_io < TypeQuelconque >::iterator ili,ilideb,ilifin=glob_elem_evol_retenu.end();
|
|
|
|
|
ilideb = glob_elem_evol_retenu.begin();
|
|
|
|
|
for(ili=ilideb;ili!=ilifin;ili++)
|
|
|
|
|
{ // on sauvegarde en fonction du type et de la dimension des grandeurs
|
|
|
|
|
this->EnteteSortieIsovaleurs_G_Quelconque(sort,(*ili),drap_noeud);
|
|
|
|
|
};
|
|
|
|
|
/* { // on considère que c'est systématique une suite de scalaires
|
|
|
|
|
int nb_scalaire = (*ili).NbMaxiNumeroOrdre();
|
|
|
|
|
// def du nom générique de la grandeur à sortir
|
|
|
|
|
string nom(NomTypeQuelconque((*ili).EnuTypeQuelconque()));
|
|
|
|
|
// on va sortir le nom générique suivie d'un numéro
|
|
|
|
|
for (int insca=1;insca<=nb_scalaire;insca++)
|
|
|
|
|
{// on sauvegarde en scalaire
|
|
|
|
|
sort << "\n ResultDescription \"";
|
|
|
|
|
sort << nom <<insca << "\" Scalar ";
|
|
|
|
|
};
|
|
|
|
|
}; // fin de la boucle sur les ddl */
|
|
|
|
|
}; //--// fin du bloc d'isolement
|
|
|
|
|
// ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
|
|
|
// d) cas des types particuliers aux elements venant d'un transfert aux noeuds
|
|
|
|
|
if ((glob_elem_Parti_retenu.size() != 0) && (incre != 0))
|
|
|
|
|
{ //--// on fait un bloc d'isolement
|
|
|
|
|
List_io < TypeQuelconque >::iterator ili,ilideb,ilifin=glob_elem_Parti_retenu.end();
|
|
|
|
|
ilideb = glob_elem_Parti_retenu.begin();
|
|
|
|
|
for(ili=ilideb;ili!=ilifin;ili++)
|
|
|
|
|
{ // on sauvegarde en fonction du type et de la dimension des grandeurs
|
|
|
|
|
this->EnteteSortieIsovaleurs_G_Quelconque(sort,(*ili),drap_noeud);
|
|
|
|
|
};
|
|
|
|
|
/* { // on considère que c'est systématique une suite de scalaires
|
|
|
|
|
int nb_scalaire = (*ili).NbMaxiNumeroOrdre();
|
|
|
|
|
// def du nom générique de la grandeur à sortir
|
|
|
|
|
string nom(NomTypeQuelconque_court((*ili).EnuTypeQuelconque()));
|
|
|
|
|
// on va sortir le nom générique suivie d'un numéro
|
|
|
|
|
for (int insca=1;insca<=nb_scalaire;insca++)
|
|
|
|
|
{// on sauvegarde en scalaire
|
|
|
|
|
sort << "\n ResultDescription \"";
|
|
|
|
|
sort << nom <<insca << "\" Scalar ";
|
|
|
|
|
};
|
|
|
|
|
}; // fin de la boucle sur les ddl */
|
|
|
|
|
}; //--// fin du bloc d'isolement
|
|
|
|
|
//---------- fin du traitement de l'entête -----------------
|
|
|
|
|
|
|
|
|
|
// maintenant on écrit les grandeurs associés
|
|
|
|
|
sort << "\n \n Values ";
|
|
|
|
|
for (int im=1;im<=nbmail;im++) // on boucle sur les maillages
|
|
|
|
|
{int numMail=tab_mail(im);
|
|
|
|
|
// ....... pour simplifier ...........
|
|
|
|
|
// .. pour les ddl aux noeuds
|
|
|
|
|
List_io < bool >& g_noeud_ddl_asortir = t_g_noeud_ddl_asortir(numMail);
|
|
|
|
|
// .. les ddl étendu aux noeuds
|
|
|
|
|
List_io < bool >& g_noeud_ddl_etendu_asortir = t_g_noeud_ddl_etendu_asortir(numMail);
|
|
|
|
|
// .. les grandeurs quelconques aux noeuds
|
|
|
|
|
List_io < bool >& g_noeud_evoluee_asortir = t_g_noeud_evoluee_asortir(numMail);
|
|
|
|
|
// .. pour les ddl venant d'un transfert aux noeuds des grandeurs aux pt d'integ
|
|
|
|
|
List_io < bool >& g_elem_ddl_asortir = t_g_elem_ddl_asortir(numMail);
|
|
|
|
|
// .. pour les types évoluées venant d'un transfert aux noeuds des grandeurs aux pt d'integ
|
|
|
|
|
List_io < bool >& g_elem_evoluee_asortir = t_g_elem_evoluee_asortir(numMail);
|
|
|
|
|
// .. pour les types particuliers aux elements venant d'un transfert aux noeuds
|
|
|
|
|
List_io < bool >& g_elem_typeParti_asortir = t_g_elem_typeParti_asortir(numMail);
|
|
|
|
|
|
|
|
|
|
// on balaie tous les noeuds du maillage
|
|
|
|
|
// on récupère le décalage de numéros
|
|
|
|
|
int decal_noe=mailInitial->DecalNumNoeud(numMail); // pour simplifier
|
|
|
|
|
List_io <bool>& choix_var_ddl_unMail = choix_var_ddl(numMail);
|
|
|
|
|
List_io <bool>::iterator itb,itest;
|
|
|
|
|
// cas des ddl étendu
|
|
|
|
|
List_io < Ddl_enum_etendu >::iterator ili,ilideb,ilifin;
|
|
|
|
|
List_io < Ddl_enum_etendu >::iterator yly;
|
|
|
|
|
// cas des grandeurs quelconques
|
|
|
|
|
List_io < TypeQuelconque >::iterator ibi,ibideb,ibifin;
|
|
|
|
|
|
|
|
|
|
int nbmaxinoeud = lesMail->Nombre_noeud(numMail);
|
|
|
|
|
for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++)
|
|
|
|
|
{ // recup du noeud
|
|
|
|
|
Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
|
|
|
|
|
sort << "\n" << noe.Num_noeud() + decal_noe << " " ;
|
|
|
|
|
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
|
|
|
// a) cas des ddl initiaux définis aux noeuds
|
|
|
|
|
if ((glob_noe_ddl_retenu.size() != 0) && (incre != 0))
|
|
|
|
|
{//--// on fait un bloc d'isolement
|
|
|
|
|
ilifin=glob_noe_ddl_retenu.end();
|
|
|
|
|
ilideb = glob_noe_ddl_retenu.begin();
|
|
|
|
|
// recup des valeur de ddl
|
|
|
|
|
itb=choix_var_ddl_unMail.begin(); // init de la liste d'indicateur de var
|
|
|
|
|
Enum_ddl enu_type_famille = PremierDdlFamille((*ilideb).Enum()); // la première famille
|
|
|
|
|
EnumTypeGrandeur type_grandeur = (*ilideb).TypeDeGrandeur(); // le premier type de grandeur
|
|
|
|
|
bool cas_vecteur=false;
|
|
|
|
|
if ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE)
|
|
|
|
|
|| (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH))
|
|
|
|
|
cas_vecteur=true; // signale que l'on sort un vecteur qui est "le" cas particulier
|
|
|
|
|
|
|
|
|
|
itest=g_noeud_ddl_asortir.begin(); // pour le test de sortie pour le maillage en question
|
|
|
|
|
for(ili=ilideb;ili!=ilifin;ili++,itb++,itest++)
|
|
|
|
|
{Enum_ddl enu = (*ili).Enum();
|
|
|
|
|
// on regarde si l'on a changé de famille
|
|
|
|
|
if (!Meme_famille(enu_type_famille,enu))
|
|
|
|
|
{if (cas_vecteur)
|
|
|
|
|
// on a changé de famille, on complète avec des zéros si c'est un vecteur
|
|
|
|
|
{switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
|
|
|
|
|
{ case 1: { sort << " 0. "; if (ddlSurY_1D) {break;};}
|
|
|
|
|
case 2: sort << " 0. ";
|
|
|
|
|
};
|
|
|
|
|
}; // sinon on ne fait rien
|
|
|
|
|
// on initialise pour la suite
|
|
|
|
|
enu_type_famille = PremierDdlFamille(enu);
|
|
|
|
|
type_grandeur = (*ili).TypeDeGrandeur();
|
|
|
|
|
if ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE)
|
|
|
|
|
|| (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH))
|
|
|
|
|
cas_vecteur=true; // signale que l'on sort un vecteur qui est "le" cas particulier
|
|
|
|
|
};
|
|
|
|
|
// si la grandeur existe et que l'on doit la sortir pour ce maillage (cf. itest) on la sort sinon on sort 0.
|
|
|
|
|
double val_ddl=0.;
|
|
|
|
|
if ((noe.Existe_ici(enu)) && (*itest) )
|
|
|
|
|
{val_ddl = noe.Valeur_tdt(enu); // la valeur actuelle
|
|
|
|
|
if ((*itb))
|
|
|
|
|
val_ddl -= noe.Valeur_0(enu);
|
|
|
|
|
};
|
|
|
|
|
if ((dim == 1) && ddlSurY_1D)
|
|
|
|
|
sort << " 0. ";// cas où on veut sortir sur y et non sur x les ddl
|
|
|
|
|
// enregistrement de la valeur
|
|
|
|
|
sort << setw (ParaGlob::NbdigdoGR()) << val_ddl << " ";
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// traitement pour la dernière série de ddl, dans le cas d'un vecteur
|
|
|
|
|
if (cas_vecteur)
|
|
|
|
|
switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
|
|
|
|
|
{ case 1: { sort << " 0. "; if (ddlSurY_1D) {break;};}
|
|
|
|
|
case 2: sort << " 0. ";
|
|
|
|
|
};
|
|
|
|
|
}; //--// fin du bloc d'isolement pour les ddl initiaux définis aux noeuds
|
|
|
|
|
// a-1) cas des ddl étendues définis aux noeuds
|
|
|
|
|
if ((glob_noeud_ddl_etendu_retenu.size() != 0) && (incre != 0))
|
|
|
|
|
{//--// on fait un bloc d'isolement
|
|
|
|
|
ilifin=glob_noeud_ddl_etendu_retenu.end();
|
|
|
|
|
ilideb = glob_noeud_ddl_etendu_retenu.begin();
|
|
|
|
|
// recup des valeur de ddl
|
|
|
|
|
itb=choix_var_ddl_unMail.begin(); // init de la liste d'indicateur de var
|
|
|
|
|
Enum_ddl enu_type_famille = PremierDdlFamille((*ilideb).Enum()); // la première famille
|
|
|
|
|
EnumTypeGrandeur type_grandeur = (*ilideb).TypeDeGrandeur(); // le premier type de grandeur
|
|
|
|
|
bool cas_vecteur=false;
|
|
|
|
|
if ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE)
|
|
|
|
|
|| (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH))
|
|
|
|
|
cas_vecteur=true; // signale que l'on sort un vecteur qui est "le" cas particulier
|
|
|
|
|
|
|
|
|
|
itest=g_noeud_ddl_asortir.begin(); // pour le test de sortie pour le maillage en question
|
|
|
|
|
for(ili=ilideb;ili!=ilifin;ili++,itb++,itest++)
|
|
|
|
|
{Enum_ddl enu = (*ili).Enum();
|
|
|
|
|
// on regarde si l'on a changé de famille
|
|
|
|
|
if (!Meme_famille(enu_type_famille,enu))
|
|
|
|
|
{if (cas_vecteur)
|
|
|
|
|
// on a changé de famille, on complète avec des zéros si c'est un vecteur
|
|
|
|
|
{switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
|
|
|
|
|
{ case 1: { sort << " 0. "; if (ddlSurY_1D) {break;};}
|
|
|
|
|
case 2: sort << " 0. ";
|
|
|
|
|
};
|
|
|
|
|
}; // sinon on ne fait rien
|
|
|
|
|
// on initialise pour la suite
|
|
|
|
|
enu_type_famille = PremierDdlFamille(enu);
|
|
|
|
|
type_grandeur = (*ili).TypeDeGrandeur();
|
|
|
|
|
if ((type_grandeur == VECTEUR) || (type_grandeur == COORDONNEE)
|
|
|
|
|
|| (type_grandeur == COORDONNEEB) || (type_grandeur == COORDONNEEH))
|
|
|
|
|
cas_vecteur=true; // signale que l'on sort un vecteur qui est "le" cas particulier
|
|
|
|
|
};
|
|
|
|
|
// si la grandeur existe et que l'on doit la sortir pour ce maillage (cf. itest) on la sort sinon on sort 0.
|
|
|
|
|
double val_ddl=0.;
|
|
|
|
|
if ((noe.Existe_ici(enu)) && (*itest) )
|
|
|
|
|
{val_ddl = noe.Valeur_tdt(enu); // la valeur actuelle
|
|
|
|
|
if ((*itb))
|
|
|
|
|
val_ddl -= noe.Valeur_0(enu);
|
|
|
|
|
};
|
|
|
|
|
if ((dim == 1) && ddlSurY_1D)
|
|
|
|
|
sort << " 0. ";// cas où on veut sortir sur y et non sur x les ddl
|
|
|
|
|
// enregistrement de la valeur
|
|
|
|
|
sort << setw (ParaGlob::NbdigdoGR()) << val_ddl << " ";
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// traitement pour la dernière série de ddl, dans le cas d'un vecteur
|
|
|
|
|
if (cas_vecteur)
|
|
|
|
|
switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
|
|
|
|
|
{ case 1: { sort << " 0. "; if (ddlSurY_1D) {break;};}
|
|
|
|
|
case 2: sort << " 0. ";
|
|
|
|
|
};
|
|
|
|
|
}; //--// fin du bloc d'isolement pour les ddl étendus définis aux noeuds
|
|
|
|
|
// a-2) cas des types évoluées définis aux noeuds
|
|
|
|
|
if ((glob_noeud_evol_retenu.size() != 0) && (incre != 0))
|
|
|
|
|
{ //--// on fait un bloc d'isolement
|
|
|
|
|
ibifin=glob_noeud_evol_retenu.end();
|
|
|
|
|
ibideb = glob_noeud_evol_retenu.begin();
|
|
|
|
|
// recup des valeur de ddl
|
|
|
|
|
itest=g_noeud_evoluee_asortir.begin(); // pour le test de sortie pour le maillage en question
|
|
|
|
|
for(ibi=ibideb;ibi!=ibifin;ibi++,itest++)
|
|
|
|
|
{// si la grandeur existe et que l'on doit la sortir pour ce maillage (cf. itest) on la sort sinon on sort 0.
|
|
|
|
|
TypeQuelconque_enum_etendu enu = (*ibi).EnuTypeQuelconque();
|
|
|
|
|
const TypeQuelconque* tq = NULL;
|
|
|
|
|
bool existe = noe.Existe_ici(enu);
|
|
|
|
|
if (existe) {tq = &(noe.Grandeur_quelconque(enu));};
|
|
|
|
|
// on sort les grandeurs
|
|
|
|
|
if ((*itest) * existe)
|
|
|
|
|
{ this->SortieGrandeursQuelconque(sort,(*tq));}
|
|
|
|
|
else // si ça n'existe pas au noeud on sort des 0, normalement (*ibi) ne sert que pour le type
|
|
|
|
|
// donc est initialisée à 0, on s'en sert comme conteneur nul
|
|
|
|
|
{ this->SortieGrandeursQuelconque(sort,(*ibi));};
|
|
|
|
|
};
|
|
|
|
|
}; //--// fin du bloc d'isolement pour les types évoluées
|
|
|
|
|
|
|
|
|
|
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
|
|
|
// b) cas des ddl venant d'un transfert aux noeuds des grandeurs aux pt d'integ
|
|
|
|
|
if ((glob_elem_ddl_retenu.size() != 0) && (incre != 0))
|
|
|
|
|
{ //--// on fait un bloc d'isolement
|
|
|
|
|
ilifin=glob_elem_ddl_retenu.end();
|
|
|
|
|
ilideb = glob_elem_ddl_retenu.begin();
|
|
|
|
|
// recup des valeur de ddl
|
|
|
|
|
itest=g_elem_ddl_asortir.begin(); // pour le test de sortie pour le maillage en question
|
|
|
|
|
for(ili=ilideb;ili!=ilifin;ili++,itest++)
|
|
|
|
|
{// si la grandeur existe et que l'on doit la sortir pour ce maillage (cf. itest) on la sort sinon on sort 0.
|
|
|
|
|
if ((dim == 1) && ddlSurY_1D)
|
|
|
|
|
sort << " 0. ";// cas où on veut sortir sur y et non sur x les ddl
|
|
|
|
|
// enregistrement de la valeur
|
|
|
|
|
if ((noe.Existe_ici_ddlEtendu(*ili)) && (*itest) )
|
|
|
|
|
{sort << setw (ParaGlob::NbdigdoGR()) << noe.DdlEtendue(*ili).ConstValeur() << " "; }
|
|
|
|
|
else {sort << " 0. "; };
|
|
|
|
|
};
|
|
|
|
|
}; //--// fin du bloc d'isolement pour les ddl
|
|
|
|
|
//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
|
|
|
|
|
if ((glob_elem_evol_retenu.size() != 0) && (incre != 0))
|
|
|
|
|
{ //--// on fait un bloc d'isolement
|
|
|
|
|
ibifin=glob_elem_evol_retenu.end();
|
|
|
|
|
ibideb = glob_elem_evol_retenu.begin();
|
|
|
|
|
// recup des valeur de ddl
|
|
|
|
|
itest=g_elem_evoluee_asortir.begin(); // pour le test de sortie pour le maillage en question
|
|
|
|
|
for(ibi=ibideb;ibi!=ibifin;ibi++,itest++)
|
|
|
|
|
{// si la grandeur existe et que l'on doit la sortir pour ce maillage (cf. itest) on la sort sinon on sort 0.
|
|
|
|
|
TypeQuelconque_enum_etendu enu = (*ibi).EnuTypeQuelconque();
|
|
|
|
|
const TypeQuelconque* tq = NULL;
|
|
|
|
|
bool existe = noe.Existe_ici(enu);
|
|
|
|
|
if (existe) {tq = &(noe.Grandeur_quelconque(enu));};
|
|
|
|
|
// on sort les grandeurs
|
|
|
|
|
if ((*itest) * existe)
|
|
|
|
|
{ this->SortieGrandeursQuelconque(sort,(*tq));}
|
|
|
|
|
else // si ça n'existe pas au noeud on sort des 0, normalement (*ibi) ne sert que pour le type
|
|
|
|
|
// donc est initialisée à 0, on s'en sert comme conteneur nul
|
|
|
|
|
{ this->SortieGrandeursQuelconque(sort,(*ibi));};
|
|
|
|
|
};
|
|
|
|
|
/* {// si la grandeur existe et que l'on doit la sortir pour ce maillage (cf. itest) on la sort sinon on sort 0.
|
|
|
|
|
// on considère que c'est systématique une suite de scalaires
|
|
|
|
|
int nb_scalaire = (*ibi).NbMaxiNumeroOrdre();
|
|
|
|
|
TypeQuelconque_enum_etendu enu = (*ibi).EnuTypeQuelconque();
|
|
|
|
|
const TypeQuelconque* tq = NULL;
|
|
|
|
|
bool existe = noe.Existe_ici(enu);
|
|
|
|
|
if (existe) {tq = &(noe.Grandeur_quelconque(enu));};
|
|
|
|
|
// on boucle sur tous les scalaires
|
|
|
|
|
if ((*itest) * existe)
|
|
|
|
|
{for (int insca=1;insca<=nb_scalaire;insca++)
|
|
|
|
|
{ sort << setw (ParaGlob::NbdigdoGR()) << tq->GrandeurNumOrdre(insca) << " ";}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{ for (int insca=1;insca<=nb_scalaire;insca++) sort << " 0. ";};
|
|
|
|
|
}; */
|
|
|
|
|
}; //--// fin du bloc d'isolement pour les types évoluées
|
|
|
|
|
// 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
|
|
|
|
|
if ((glob_elem_Parti_retenu.size() != 0) && (incre != 0))
|
|
|
|
|
{ //--// on fait un bloc d'isolement
|
|
|
|
|
ibifin=glob_elem_Parti_retenu.end();
|
|
|
|
|
ibideb = glob_elem_Parti_retenu.begin();
|
|
|
|
|
itest=g_elem_typeParti_asortir.begin(); // pour le test de sortie pour le maillage en question
|
|
|
|
|
for(ibi=ibideb;ibi!=ibifin;ibi++,itest++)
|
|
|
|
|
{TypeQuelconque_enum_etendu enu = (*ibi).EnuTypeQuelconque();
|
|
|
|
|
const TypeQuelconque* tq = NULL;
|
|
|
|
|
bool existe = noe.Existe_ici(enu);
|
|
|
|
|
if (existe) {tq = &(noe.Grandeur_quelconque(enu));};
|
|
|
|
|
// on sort les grandeurs
|
|
|
|
|
if ((*itest) * existe)
|
|
|
|
|
{ this->SortieGrandeursQuelconque(sort,(*tq));}
|
|
|
|
|
else // si ça n'existe pas au noeud on sort des 0, normalement (*ibi) ne sert que pour le type
|
|
|
|
|
// donc est initialisée à 0, on s'en sert comme conteneur nul
|
|
|
|
|
{ this->SortieGrandeursQuelconque(sort,(*ibi));};
|
|
|
|
|
};
|
|
|
|
|
/* {// on considère que c'est systématique une suite de scalaires
|
|
|
|
|
int nb_scalaire = (*ibi).NbMaxiNumeroOrdre();
|
|
|
|
|
TypeQuelconque_enum_etendu enu = (*ibi).EnuTypeQuelconque();
|
|
|
|
|
const TypeQuelconque* tq = NULL;
|
|
|
|
|
bool existe = noe.Existe_ici(enu);
|
|
|
|
|
if (existe) {tq = &(noe.Grandeur_quelconque(enu));};
|
|
|
|
|
// on sort les grandeurs
|
|
|
|
|
if ((*itest) * existe)
|
|
|
|
|
{for (int insca=1;insca<=nb_scalaire;insca++)
|
|
|
|
|
{ sort << setw (ParaGlob::NbdigdoGR()) << tq->GrandeurNumOrdre(insca) << " ";}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{ for (int insca=1;insca<=nb_scalaire;insca++) sort << " 0. ";};
|
|
|
|
|
};*/
|
|
|
|
|
}; //--// fin du bloc d'isolement pour les types particuliers
|
|
|
|
|
// aux elements venant d'un transfert aux noeuds
|
|
|
|
|
}; //fin boucle sur noeud
|
|
|
|
|
}; //-- fin de la boucle sur les maillages
|
|
|
|
|
sort << "\n End Values \n";
|
|
|
|
|
}; //-- fin du cas if (atraiter)
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
