rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Resultats/Gid/Isovaleurs_Gid.cc
Gérard Rio 0460624e94 mise à jour 7.010
2023-05-03 17:23:49 +02:00

2623 lines
152 KiB
C++
Raw Permalink Blame History

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