rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Resultats/Gmsh/Isovaleurs_Gmsh2.cc

2230 lines
129 KiB
C++
Raw Normal View History

ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Isovaleurs_Gmsh.h"
#include <iomanip>
#include <algorithm>
#include "CharUtil.h"
#include "Coordonnee2.h"
#include "ConstMath.h"
#include "MathUtil.h"
#include "Banniere.h"
#include "TypeQuelconqueParticulier.h"
#include "Visualisation_Gmsh.h"
// choix de l'isovaleur à visualiser calculée à partir des grandeurs évoluées aux points d'intégrations
void Isovaleurs_Gmsh::ChoixIsovaleur_tensorielle_ptinteg(const string& choix)
{ // tout d'abord on traite le cas de tous les isovaleurs
if (choix=="to")
{ tabelement_evoluee_retenu = tabelement_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 = tabelement_evoluee.Taille();
for (int imail = 1;imail<=nbmail;imail++)
{List_io < TypeQuelconque >& element_evoluee = tabelement_evoluee(imail); // pour simplifier
List_io < TypeQuelconque >& element_evoluee_retenu = tabelement_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 la contrainte et la déformation courante
// tout d'abord les grandeurs communes:
// a) on sort les contraintes
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
{if ((*iq).EnuTypeQuelconque()== CONTRAINTE_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()== CONTRAINTE_COURANTE) break;};
if (iqev == iqevfin)element_evoluee_retenu.push_back(*iq);
};
// b) et les déformations
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
{if ((*iq).EnuTypeQuelconque()== 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()== DEFORMATION_COURANTE) 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: break; // sinon pour l'instant on ne fait rien
};
break;
} //-- fin du cas MECA_SOLIDE_DEFORMABLE
default:
cout << "\n pour l'instant pas de parametre par defaut pour les pt integ !! "
<< "\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) venant des pts d'integ a visualiser ";
int nbmail = tabelement_evoluee.Taille();
// update du tableau evolues à visualiser si nécessaire
if (tabelement_evoluee_retenu.Taille() != nbmail)
tabelement_evoluee_retenu.Change_taille(nbmail);
for (int imail = 1;imail<=nbmail;imail++)
{// on ne traite que s'il y a des grandeurs disponibles
if (tabelement_evoluee(imail).size() != 0 )
{choix_valide=false;
while (!choix_valide) // premier while
{try
{ cout << "\n (0 ou f ou fin) fin choix grandeurs tensorielles ";
cout << "\n listes de type de grandeur tensorielles a visualiser ";
// affichage des grandeurs retenues si la liste n'est pas vide
if ((tabelement_evoluee_retenu(imail)).size())
{ cout << "\n Maillage nb: " << imail << "\n liste des types de grandeurs enregistres: ";
List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_evoluee_retenu(imail)).end();
for (iet=(tabelement_evoluee_retenu(imail)).begin();iet!=ietfin;iet++)
cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
cout << endl;
};
cout << "\n Maillage nb: " << imail << " liste des types de grandeurs tensorielles disponibles ";
List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_evoluee(imail)).end();
for (iet=(tabelement_evoluee(imail)).begin();iet!=ietfin;iet++)
cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
// le menu
cout << "\n donner la grandeur a visulaliser "
<< "\n (to) toutes les grandeurs "
<< "\n (de) les grandeurs par defaut"
<< "\n (une liste de grandeurs tensorielles) "
<< "\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
tabelement_evoluee_retenu(imail) = tabelement_evoluee(imail);
choix_valide=false;
};
// sinon
if ((rep == "0") || (rep == "f") || (rep == "fin"))
{choix_valide=true;}
else if (rep=="ef")
{ tabelement_evoluee_retenu(imail).erase(tabelement_evoluee_retenu(imail).begin(),
tabelement_evoluee_retenu(imail).end());
}
else if (rep=="de")
{List_io < TypeQuelconque >& element_evoluee = tabelement_evoluee(imail); // pour simplifier
List_io < TypeQuelconque >& element_evoluee_retenu = tabelement_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 la contrainte et la déformation courante
// tout d'abord les grandeurs communes:
// a) on sort les contraintes
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
{if ((*iq).EnuTypeQuelconque()== CONTRAINTE_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()== CONTRAINTE_COURANTE) break;};
if (iqev == iqevfin)element_evoluee_retenu.push_back(*iq);
};
// b) et les déformations
for (iq=element_evoluee.begin();iq!=iqfin;iq++)
{if ((*iq).EnuTypeQuelconque()== 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()== DEFORMATION_COURANTE) 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: break; // sinon pour l'instant on ne fait rien
};
break;
} //-- fin du cas MECA_SOLIDE_DEFORMABLE
default:
cout << "\n pour l'instant pas de parametre par defaut pour les pt integ !! "
<< "\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
List_io<TypeQuelconque>& tpg_ret = (tabelement_evoluee_retenu(imail)); // pour simplifier
List_io<TypeQuelconque>& tpg = (tabelement_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);
}
else
{ cout << "\n erreur, grandeur non disponible !, recommencez ";};
};
}
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
tabelement_evoluee_retenu(imail).sort(); // on ordonne
tabelement_evoluee_retenu(imail).unique();// on supprime les doublons
}; //-- fin de if (tabelement_typeParti(imail).size() != 0 )
};//-- fin de la boucle sur les maillages
};
// choix de l'isovaleur à visualiser calculée à partir des grandeurs quelconques aux points d'intégrations
void Isovaleurs_Gmsh::ChoixIsovaleur_quelc_ptinteg(const string& choix)
{ // tout d'abord on traite le cas de tous les isovaleurs
if (choix=="to")
{ tabelement_typeParti_retenu = tabelement_typeParti;
return;
}
else if (choix=="de")
{ // pour l'instant aucun éléments par défaut
return;
};
// maintenant on traite le cas interactif
bool choix_valide = false;
string rep;
cout << "\n choix d'isovaleur venant des pts d'integ a visualiser (de type grandeurs particulieres) ";
int nbmail = tabelement_typeParti.Taille();
// update du tableau de ddl à visualiser si nécessaire
if (tabelement_typeParti_retenu.Taille() != nbmail)
tabelement_typeParti_retenu.Change_taille(nbmail);
for (int imail = 1;imail<=nbmail;imail++)
{// on ne traite que s'il y a des grandeurs disponibles
if (tabelement_typeParti(imail).size() != 0 )
{choix_valide=false;
while (!choix_valide) // premier while
{try
{ cout << "\n (0 ou f ou fin) fin choix grandeurs particulieres ";
cout << "\n listes de type de grandeur particuliere a visualiser ";
// affichage des ddl retenues si la liste n'est pas vide
if ((tabelement_typeParti_retenu(imail)).size())
{ cout << "\n Maillage nb: " << imail << "\n liste des types de grandeurs enregistres: ";
List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_typeParti_retenu(imail)).end();
for (iet=(tabelement_typeParti_retenu(imail)).begin();iet!=ietfin;iet++)
{cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
};
cout << endl;
};
cout << "\n Maillage nb: " << imail << " liste des types de grandeur particuliere disponibles ";
List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_typeParti(imail)).end();
for (iet=(tabelement_typeParti(imail)).begin();iet!=ietfin;iet++)
cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
cout << "\n donner la grandeur particuliere a visualiser "
<< "\n (to) tous les grandeurs particulieres "
<< "\n ou une liste de grandeurs particulieres "
<< "\n (0 ou f ou fin) fin choix de grandeurs particulieres "
<< "\n reponse ? ";
rep = lect_return_defaut(false,"f");
if (rep == "fin_prog") Sortie(1);
if (rep == "to")
{// cas de tous les ddl
tabelement_typeParti_retenu(imail) = tabelement_typeParti(imail);
choix_valide=false;
};
// sinon
if ((rep == "0") || (rep == "f") || (rep == "fin"))
{choix_valide=true;}
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
List_io<TypeQuelconque>& tpg_ret = (tabelement_typeParti_retenu(imail)); // pour simplifier
List_io<TypeQuelconque>& tpg = (tabelement_typeParti(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);
}
else
{ cout << "\n erreur, grandeur non disponible !, recommencez ";};
}
}
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 grandeur particuliere !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper fin_prog pour arreter le programme";
choix_valide=false;
}
} //-- fin du premier while
tabelement_typeParti_retenu(imail).sort(); // on ordonne
tabelement_typeParti_retenu(imail).unique();// on supprime les doublons
}; //-- fin de if (tabelement_typeParti(imail).size() != 0 )
}//-- fin de la boucle sur les maillages
};
// initialisation de l'exécution du transferts
void Isovaleurs_Gmsh::InitPremierIncrExecutionTransfertAuxNoeuds()
{ // cas du premier incrément et que l'on veut un transfert
// l'objectif est d'initialiser de manière a doc les noeuds (introduire les grandeurs)
// on boucle sur les maillages
int nb_mail=lesMail->NbMaillage();
for (int imail=1;imail<=nb_mail;imail++)
{ lesMail->AjoutConteneurAuNoeud(imail,glob_elem_ddl_retenu,tab_quelconque);
};
};
// définition interactives des paramètres généraux des isovaleurs
void Isovaleurs_Gmsh::ParametresGeneraux(const string& )
{ bool choix_val = false;
bool fr = ParaGlob::Francais();
if (fr)
{cout << "\n -- parametres generaux pour la sortie des isovaleurs ";}
else
{cout << "\n -- definition of the main parameters for the isovalues ";}
string rep;
while (!choix_val)
{try
{if (fr)
{cout << "\n (0 ou f ou fin) fin modif"
<< "\n (1) sortie des tenseurs dans le repere absolu (par defaut) "
<< "\n (2) sortie des tenseurs dans un repere ad hoc, qui depend du type d'element ";
cout << "\n \n reponse ? ";
}
else
{cout << "\n (0 or f or end) end of modif"
<< "\n (1) output of the tensor componants in the global frame (default) "
<< "\n (2) output of the tensor componants in a specific local frame, depending of the element ";
cout << "\n \n answers ? ";
};
rep = lect_return_defaut(false,"f");
// sinon
int num = ChangeEntier(rep);
if ((rep == "0")||(rep == "f")||(rep == "end"))
{ choix_val=true; }
else
{ // def du type de sortie
if (num == 1) { absolue = true;}
else if (num == 2) { absolue = false;}
else
{ if (fr)
{cout << "\n Erreur on attendait un entier entre 0 et 1 ou 2!!, "
<< "\n redonnez une bonne valeur";
}
else
{cout << "\n Error the answers is an int in the range of 0..2 !!, "
<< "\n try again ";
};
choix_val=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
{if (fr)
{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";
}
else
{cout << "\n error, we expect one of the proposed keywords !!, "
<< "\n try again to give a right answer "
<< "\n or write 'f' in order to stop this menu ";
};
choix_val=false;
};
}; //-- fin du while
return;
};
// ---- cas de l'ancien format ---------
// sortie d'une view pour un type quelconque simple !!, c'est-à-dire pas un tableau par exemple
// en fait ne concerne que les types scalaires, vectoriels, ou tensoriels
// dans le cas où le type simple provient d'un tableau
// numero donne un numéro de l'élément à sortir dans l'entête de la view si diff de 0
void Isovaleurs_Gmsh::SortirUneViewTypeQuelconque_old_format(ostream & sort,TypeQuelconque_enum_etendu enu
,EnumType2Niveau enuStructure, int numero
,Tableau <List_io < bool >::iterator >& t_indic_sortie,int nbmail
,const Tableau <int>& tab_mail,EnumTypeGrandeur enugrandeur,LesMaillages * lesMail,const int& incre)
{ // def de l'entete
string nom((enu.NomPlein()));
EnteteView(sort,incre,nom,numero);
// ramène le tableau t_Egmsh
// t_Egmsh(im)(ie): donne pour le maillage im, et pour l'élément ie, le numéro gmsh de l'élément
const Tableau < Tableau < int > >& t_Egmsh = mailInitial->TabEgmsh();
// récup de la connection herezh->gmsh
// t_GmshHer(i)(j) : donne pour le noeud j de l'élément i de gmsh, le numéro d'herezh
const Tableau < Tableau < int > >& tGmshHer = Visualisation_Gmsh::Tab_GmshHer();
// on définit un cas du type de celui géré par gmsh
int castype = 0;
switch (enugrandeur)
{ case SCALAIRE: case SCALAIRE_ENTIER: case SCALAIRE_DOUBLE:
{castype=1;break;}
case COORDONNEE: case COORDONNEEB: case COORDONNEEH:
{castype=2;break;}
case TENSEURBB: case TENSEURHH:
{castype=3;break;}
// case CHAINE_CAR: // pour l'instant on n'a pas de type quelconque pour le type caractère donc on ne met rien
// {castype=4;break;}
default:
cout << "\n ***** erreur en sortie de la grandeur quelconque " << (enu.NomPlein())
<< " le type " << NomType2Niveau(enuStructure) << "n'est pas gere par gmsh, le fichier resultat "
<< " ne sera donc pas exploitable !! on continue quand meme !!";
return;
};
for (int im =1; im <= nbmail; im++)
{// on ne continue que si la grandeur quelconque est à sortir
if (*(t_indic_sortie(im)))
{int numMail = tab_mail(im);
int nbmaxelem = lesMail->Nombre_element(numMail);
int dcaN = mailInitial->DecalNumNoeud(numMail);
for (int numElem = 1; numElem <= nbmaxelem; numElem++)
{Element& elem = lesMail->Element_LesMaille(numMail,numElem); // récup de l'élément
Tableau<Noeud *>& t_n = elem.Tab_noeud();
int num_elem_gmsh = t_Egmsh(im)(numElem); // numéro de classement du type d'élément gmsh
// -- sortie du type de valeur: scalaire, vecteur ou tenseur
// ***** a complèter pour les éléments quadratiques incomplet et les autres non possibles *****
switch (castype)
{ case 1: {sort << "\n" << tabScalVecTensGmsh.scalar_pourView(num_elem_gmsh)<< "(";break;}
case 2: {sort << "\n" << tabScalVecTensGmsh.vector_pourView(num_elem_gmsh)<< "(";break;}
case 3: {sort << "\n" << tabScalVecTensGmsh.tensor_pourView(num_elem_gmsh)<< "(";break;}
case 4: {sort << "\n" << tabScalVecTensGmsh.text_pourView(num_elem_gmsh)<< "(";break;}
};
// -- sortie des coordonnées
// on considère le nombre de noeuds de la sortie gmsh, et non celui de l'élément (qui peut-être
// plus grand dans le cas d'un sfe, ou plus petit dans le cas d'un quadratique incomplet !)
int nbNmax = tGmshHer(num_elem_gmsh).Taille(); //t_n.Taille();
for (int ino=1;ino<=nbNmax;ino++) // ino = numéro gmsh
{ int num_her = tGmshHer(num_elem_gmsh)(ino); // --> num HZpp
int num_N = t_n(num_her)->Num_noeud()+dcaN; // num global
SortieUseUneCoordonnee(incre,sort,(ino == nbNmax),num_N);
};
// -- sortie des grandeurs
for (int ino=1;ino<=nbNmax;ino++)
{int num_her = tGmshHer(num_elem_gmsh)(ino); // --> num HZpp
const TypeQuelconque& tyret = t_n(num_her)->Grandeur_quelconque(enu); // récup de la grandeur
switch (castype)
{ case 1: // cas d'une grandeur scalaire (mais qui peut venir d'un tableau)
{ switch (enuStructure)
{case TYPE_SIMPLE:{tyret.Const_Grandeur_pointee()->Grandeur_brut(sort,ParaGlob::NbdigdoGR());
break;};
case TABLEAU_T: {Tab_Grandeur_scalaire_double* t_grandeur =
((Tab_Grandeur_scalaire_double*) tyret.Const_Grandeur_pointee());
Grandeur_scalaire_double& grandeur =t_grandeur->Grandeur_scalaire_associee(numero);
grandeur.Grandeur_brut(sort,ParaGlob::NbdigdoGR());
break;};
default:
cout << "\n -1- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
<< NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
<< " la sortie gmsh le fichier resultat ne sera donc pas exploitable !! on continue quand meme !!"
<< "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque_old_format(...";
};
break;
}
case 2: // cas d'une grandeur vectorielle à trois coordonnées, si il y en a moins, il y a des 0 à la place
{ const TypeQuelconque::Grandeur& grandeur=*(tyret.Const_Grandeur_pointee()); // pour simplifier
switch (enuStructure)
{case TYPE_SIMPLE:{sort << setprecision(ParaGlob::NbdigdoGR())
<< grandeur.GrandeurNumOrdre(1)
<<", "<<grandeur.GrandeurNumOrdre(2) <<","
<< grandeur.GrandeurNumOrdre(3) ;
break;};
case TABLEAU_T:
{Tab_Grandeur_Coordonnee* tab_coor = ((Tab_Grandeur_Coordonnee*) tyret.Const_Grandeur_pointee());
int taille = tab_coor->Taille();
// on boucle, et on sort chaque coordonnée
for (int i=1;i<=taille;i++)
{ const Grandeur_coordonnee& coor = tab_coor->Grandeur_Coordonnee_associee(i);
sort << setprecision(ParaGlob::NbdigdoGR())
<< coor.GrandeurNumOrdre(1) <<", "<<coor.GrandeurNumOrdre(2) <<","
<< coor.GrandeurNumOrdre(3) ;
};
break;
}
// pour l'instant il n'y a pas de tableau de coordonnée qui existe donc on ne met rien d'autre
default:
cout << "\n -2- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
<< NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
<< " la sortie gmsh le fichier resultat ne sera donc pas exploitable !! on continue quand meme !!"
<< "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque_old_format(...";
};
break;
}
case 3: // cas d'une grandeur tensorielle: forcément de dimension 9 (mais qui appartenir à un tableau
{ const TypeQuelconque::Grandeur& grandeur=*(tyret.Const_Grandeur_pointee()); // pour simplifier
switch (enuStructure)
{case TYPE_SIMPLE:
{ switch (grandeur.Type_grandeurAssocie())
{ case TENSEURBB:
{ const TenseurBB& t_BB = ((Grandeur_TenseurBB*) &grandeur)->RefConteneurTenseur();
Isovaleurs_Gmsh::SortieTenseurBB_ancien_format(sort,t_BB);
break;
}
case TENSEURHH:
{ const TenseurHH& t_HH = ((Grandeur_TenseurHH*) &grandeur)->RefConteneurTenseur();
Isovaleurs_Gmsh::SortieTenseurHH_ancien_format(sort,t_HH);
break;
}
default:
cout << "\n -3- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
<< NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
<< " la sortie gmsh le fichier resultat ne sera donc pas exploitable !! on continue quand meme !!"
<< "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque_old_format(...";
};
break;
}
case TABLEAU_T:
{switch (grandeur.Type_grandeurAssocie())
{case TENSEURHH:
{ const Tab_Grandeur_TenseurHH* g_t_t_HH = ((Tab_Grandeur_TenseurHH*) &grandeur);
const Grandeur_TenseurHH& g_t_HH = g_t_t_HH->Grandeur_TenseurHH_associee(numero);
const TenseurHH& t_HH = g_t_HH.RefConteneurTenseur();
Isovaleurs_Gmsh::SortieTenseurHH_ancien_format(sort,t_HH);
break;
}
// pour l'instant il n'y a que les tableaux de tenseurHH qui existent
default:
cout << "\n -4- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
<< NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
<< " la sortie gmsh le fichier resultat ne sera donc pas exploitable !! on continue quand meme !!"
<< "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque_old_format(...";
};
break;
}
// pour l'instant il n'y a que les types simples et les tableaux qui sont pris en compte pour les tenseurs
default:
cout << "\n -5- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
<< NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
<< " la sortie gmsh le fichier resultat ne sera donc pas exploitable !! on continue quand meme !!"
<< "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque_old_format(...";
}; // fin du switch (enuStructure) pour les tenseurs
break;
} //-- fin du cas castype = 3 c-a-d des cas relatifs aux tenseurs
}; //-- fin du switch (castype)
// gestion des fins de ligne
if (ino != nbNmax) {sort <<", ";}
else {sort <<"};";};
}; //-- fin de la boucle sur les noeuds de l'éléments
}; //-- fin de la boucle sur les éléments
}; //-- fin du test if (*(t_indic_sortie(im)))
}; //-- fin de la boucle sur les maillage
// fin de la view
sort << "\n }; ";
};
// sortie d'une view pour un type quelconque simple !!, c'est-à-dire pas un tableau par exemple
// en fait ne concerne que les types scalaires, vectoriels, ou tensoriels
// dans le cas où le type simple provient d'un tableau
// numero donne un numéro de l'élément à sortir dans l'entête de la view si diff de 0
void Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(ostream & sort,TypeQuelconque& typ
,EnumType2Niveau enuStructure, int numero
,Tableau <List_io < bool >::iterator >& t_indic_sortie,int nbmail
,const Tableau <int>& tab_mail,EnumTypeGrandeur enugrandeur,LesMaillages * lesMail,const int& incre)
{
// récup du temps actuel
double temps_actuel = ParaGlob::Variables_de_temps().TempsCourant();
TypeQuelconque_enum_etendu enu = typ.EnuTypeQuelconque();
EnuTypeQuelParticulier enu_particulier
= typ.Const_Grandeur_pointee()->Type_enumGrandeurParticuliere();
// on définit un cas du type de celui géré par gmsh
int castype = 0;int NB_val = 0;
switch (enugrandeur)
{case SCALAIRE: case SCALAIRE_ENTIER: case SCALAIRE_DOUBLE:
{castype=1;NB_val=1;break;}
case COORDONNEE: case COORDONNEEB: case COORDONNEEH:
{castype=2;NB_val=3; break;}
case BASE__H: // en fait une base est traite comme un ensemble de une grandeur
// COORDONNEE par axe de la base
// donc arrivée ici on sort une grandeur COORDONNEE de numéro i
{castype=5;NB_val=3;
break;
}
case TENSEURBB: case TENSEURHH:
{castype=3;NB_val=9;break;}
case VECTEUR: // pas géré par gmsh directement
{int nb_double = 0;
switch (enuStructure)
{ case TYPE_SIMPLE:
{
if (enu_particulier == PARTICULIER_VECTEUR_NOMMER)
{Grandeur_Vecteur_Nommer* t_grandeur =
((Grandeur_Vecteur_Nommer*) typ.Const_Grandeur_pointee());
nb_double = t_grandeur->ConteneurVecteur().Taille();
castype=4;
}
else if (enu_particulier == PARTICULIER_VECTEUR)
{Grandeur_Vecteur* t_grandeur =
((Grandeur_Vecteur*) typ.Const_Grandeur_pointee());
nb_double = t_grandeur->ConteneurVecteur()->Taille();
castype=6;
}
break;
};
case TABLEAU_T:
{
if (enu_particulier == PARTICULIER_TABLEAU_VECTEUR_NOMMER)
{Tab_Grandeur_Vecteur_Nommer* t_grandeur =
((Tab_Grandeur_Vecteur_Nommer*) typ.Const_Grandeur_pointee());
Grandeur_Vecteur_Nommer& grn = (*t_grandeur)(numero);
nb_double = grn.ConteneurVecteur().Taille();
castype=4;
}
else if (enu_particulier == PARTICULIER_TABLEAU_VECTEUR)
{Tab_Grandeur_Vecteur* t_grandeur =
((Tab_Grandeur_Vecteur*) typ.Const_Grandeur_pointee());
const Grandeur_Vecteur& grn = (*t_grandeur)(numero);
nb_double = grn.ConteneurVecteur_const().Taille();
castype=6;
}
break;
}
default:
cout << "\n ***** erreur en sortie de la grandeur quelconque " << (enu.NomPlein() )
<< " le type " << NomType2Niveau(enuStructure) << "n'est pas gere par gmsh, le fichier resultat "
<< " ne sera donc pas exploitable !! on continue quand meme !!";
return;
};
switch (nb_double)
{ case 1: NB_val=1; break;
case 2: case 3: NB_val=3; break;
case 4: case 5: case 6: NB_val=6; break;
default: // cas non prévu pour l'instant dans gmsh
cout << "\n ***** erreur en sortie de la grandeur quelconque " << enu.NomPlein()
<< " le type " << NomType2Niveau(enuStructure) << "n'est pas gere par gmsh, le fichier resultat "
<< " ne sera donc pas exploitable !! on continue quand meme !!";
return;
};
break;
}
// case CHAINE_CAR: // pour l'instant on n'a pas de type quelconque pour le type caractère donc on ne met rien
// {castype=4;break;}
default:
cout << "\n ***** erreur en sortie de la grandeur quelconque " << enu.NomPlein()
<< " le type " << NomType2Niveau(enuStructure) << "n'est pas gere par gmsh, le fichier resultat "
<< " ne sera donc pas exploitable !! on continue quand meme !!";
return;
};
// def de l'entete
string nom(enu.NomPlein());
if (numero != 0)
nom = nom + "_" + ChangeEntierSTring(numero);
EnteteNodeData(sort,incre,temps_actuel,nom,NB_val);
// s'il faut sortir une grandeur nulle on la définie: a priori c'est une opération
// qui est faite uniquement une fois pour chaque
// type donc pas couteuse
TypeQuelconque type_null(typ);
// on initialise la grandeur par défaut
type_null.Grandeur_pointee()->InitParDefaut();
// -- sortie des grandeurs
// on balaie les maillages
for (int im =1; im <= nbmail; im++)
{ // on ne continue que si le maillage est à sortir
// !!! en fait avec gmsh, et le nouveau format, il faut que l'on sorte toujours quelque chose, car le nombre de noeuds
// est celui de l'ensemble des maillages présents, à moins que le maillage ne soit pas actif, là il n'y a pas de pb, mais
// dans les autres cas, il faut que le nombre de valeurs = le nombre de noeuds, quelque soit les grandeurs. Donc l'idée
// est de sortir une grandeur nulle, lorsque la grandeur n'est pas prévue pour ce maillage
bool grandeur_prevu_en_sortie = (*(t_indic_sortie(im))); // drapeau utilisé en sortie
// if (*(t_indic_sortie(im))) // première version
{int numMail = tab_mail(im);
int decal_noe = mailInitial->DecalNumNoeud(numMail);
Tableau<Noeud *>& t_n = lesMail->Tab_noeud(numMail);
int nbmaxinoeud = t_n.Taille();
for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++)
{ // recup du noeud
Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
sort << "\n" << noe.Num_noeud()+decal_noe << " " ;
//-- les grandeurs
// ici on va choisir entre le cas normal et le cas d'une grandeur nulle
TypeQuelconque const * typ_en_sortie = &type_null; // init à la valeur par défaut
if (grandeur_prevu_en_sortie)
typ_en_sortie = &(noe.Grandeur_quelconque(enu));
// puis on sort la grandeur
switch (castype)
{ case 1: // cas d'une grandeur scalaire (mais qui peut venir d'un tableau)
{ switch (enuStructure)
{ case TYPE_SIMPLE:{typ_en_sortie->Const_Grandeur_pointee()->Grandeur_brut(sort,ParaGlob::NbdigdoGR());
break;};
case TABLEAU_T: {Tab_Grandeur_scalaire_double* t_grandeur =
((Tab_Grandeur_scalaire_double*) typ_en_sortie->Const_Grandeur_pointee());
Grandeur_scalaire_double& grandeur =t_grandeur->Grandeur_scalaire_associee(numero);
grandeur.Grandeur_brut(sort,ParaGlob::NbdigdoGR());
break;};
default:
cout << "\n -1- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
<< NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
<< " la sortie gmsh le fichier resultat ne sera donc pas exploitable !! on continue quand meme !!"
<< "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(...";
};
break;
}
case 2: // cas d'une grandeur vectorielle à trois coordonnées, si il y en a moins, il y a des 0 à la place
{ const TypeQuelconque::Grandeur& grandeur=*(typ_en_sortie->Const_Grandeur_pointee()); // pour simplifier
switch (enuStructure)
{case TYPE_SIMPLE:{sort << setprecision(ParaGlob::NbdigdoGR())
<< grandeur.GrandeurNumOrdre(1) <<" "<<grandeur.GrandeurNumOrdre(2) <<" "
<< grandeur.GrandeurNumOrdre(3) ;
break;};
case TABLEAU_T:
{Tab_Grandeur_Coordonnee* tab_coor = ((Tab_Grandeur_Coordonnee*) typ_en_sortie->Const_Grandeur_pointee());
// on sort les coordonnées pour numéro
const Grandeur_coordonnee& coor = tab_coor->Grandeur_Coordonnee_associee(numero);
sort << setprecision(ParaGlob::NbdigdoGR())
<< coor.GrandeurNumOrdre(1) <<" "<<coor.GrandeurNumOrdre(2) <<" "
<< coor.GrandeurNumOrdre(3) ;
break;
}
// pour l'instant il n'y a pas de tableau de coordonnée qui existe donc on ne met rien d'autre
default:
cout << "\n -2- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
<< NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
<< " la sortie gmsh le fichier resultat ne sera donc pas exploitable !! on continue quand meme !!"
<< "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(...";
};
break;
}
case 3: // cas d'une grandeur tensorielle: forcément de dimension 9 (mais qui appartenir à un tableau
{ const TypeQuelconque::Grandeur& grandeur=*(typ_en_sortie->Const_Grandeur_pointee()); // pour simplifier
switch (enuStructure)
{case TYPE_SIMPLE:
{ switch (grandeur.Type_grandeurAssocie())
{ case TENSEURBB:
{ const TenseurBB& t_BB = ((Grandeur_TenseurBB*) &grandeur)->RefConteneurTenseur();
Isovaleurs_Gmsh::SortieTenseurBB(sort,t_BB);
break;
}
case TENSEURHH:
{ const TenseurHH& t_HH = ((Grandeur_TenseurHH*) &grandeur)->RefConteneurTenseur();
Isovaleurs_Gmsh::SortieTenseurHH(sort,t_HH);
break;
}
default:
cout << "\n -3- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
<< NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
<< " la sortie gmsh le fichier resultat ne sera donc pas exploitable !! on continue quand meme !!"
<< "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(...";
};
break;
}
case TABLEAU_T:
{switch (grandeur.Type_grandeurAssocie())
{case TENSEURHH:
{ const Tab_Grandeur_TenseurHH* g_t_t_HH = ((Tab_Grandeur_TenseurHH*) &grandeur);
const Grandeur_TenseurHH& g_t_HH = g_t_t_HH->Grandeur_TenseurHH_associee(numero);
const TenseurHH& t_HH = g_t_HH.RefConteneurTenseur();
Isovaleurs_Gmsh::SortieTenseurHH(sort,t_HH);
break;
}
case TENSEURBB:
{ const Tab_Grandeur_TenseurBB* g_t_t_BB = ((Tab_Grandeur_TenseurBB*) &grandeur);
const Grandeur_TenseurBB& g_t_BB = g_t_t_BB->Grandeur_TenseurBB_associee(numero);
const TenseurBB& t_BB = g_t_BB.RefConteneurTenseur();
Isovaleurs_Gmsh::SortieTenseurBB(sort,t_BB);
break;
}
// pour l'instant il n'y a que les tableaux de tenseurHH qui existent
default:
cout << "\n -4- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
<< NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
<< " la sortie gmsh le fichier resultat ne sera donc pas exploitable !! on continue quand meme !!"
<< "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(...";
};
break;
}
// pour l'instant il n'y a que les types simples et les tableaux qui sont pris en compte pour les tenseurs
default:
cout << "\n -5- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
<< NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
<< " la sortie gmsh le fichier resultat ne sera donc pas exploitable !! on continue quand meme !!"
<< "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(...";
}; // fin du switch (enuStructure) pour les tenseurs
break;
} //-- fin du cas castype = 3 c-a-d des cas relatifs aux tenseurs
case 4: // cas d'une grandeur VECTEUR nommé que l'on gère comme un tableau de scalaires
{ switch (enuStructure)
{ case TYPE_SIMPLE:
{Grandeur_Vecteur_Nommer* t_grandeur =
((Grandeur_Vecteur_Nommer*) typ_en_sortie->Const_Grandeur_pointee());
Vecteur& vec = *((Vecteur*) &t_grandeur->ConteneurVecteur());
Isovaleurs_Gmsh::SortieVecteur(sort,vec);
break;
};
case TABLEAU_T:
{Tab_Grandeur_Vecteur_Nommer* t_grandeur =
((Tab_Grandeur_Vecteur_Nommer*) typ_en_sortie->Const_Grandeur_pointee());
Grandeur_Vecteur_Nommer& grn = (*t_grandeur)(numero);
const Vecteur& vec = *((const Vecteur*) &(grn.ConteneurVecteur()));
Isovaleurs_Gmsh::SortieVecteur(sort,vec);
break;
}
default:
cout << "\n -1- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
<< NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
<< " la sortie gmsh le fichier resultat ne sera donc pas exploitable !! on continue quand meme !!"
<< "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(...";
};
break;
}
case 5: // cas d'une grandeur de type BaseH
// c'est géré comme une succession de vecteur à trois coordonnées, si il y en a moins, il y a des 0 à la place
{ const TypeQuelconque::Grandeur& grandeur=*(typ_en_sortie->Const_Grandeur_pointee()); // pour simplifier
switch (enuStructure)
{case TYPE_SIMPLE:
{ Grandeur_BaseH* base
= ((Grandeur_BaseH*) typ_en_sortie->Const_Grandeur_pointee());
// le numéro de sortie correspond au numéro de vecteur de base
const BaseH& baH1 = base->RefConteneurBaseH();
const Coordonnee& V = baH1.Coordo(numero);
V.Affiche(sort,ParaGlob::NbdigdoGR());
// sur gmsh, il faut des vecteurs à 3 composantes
switch (3 - V.Dimension())
{case 0: // on ne fait rien
break;
case 1: // cas où il manque une composante
sort << " 0 "; break;
case 2: // il manque 2 composantes
sort << " 0 0 "; break;
case 3: // il manque 3 composantes... un peu étrange !!
sort << " 0 0 0 "; break;
default:
cout << "\n *** erreur en sortie d'une grandeur Grandeur_BaseH "
<< " la dimension du vecteur de la base = " << V.Dimension()
<< " le resultat ne sera pas exploitable par gmsh !";
break;
};
break;
};
case TABLEAU_T:
{Tab_Grandeur_BaseH* tab_base
= ((Tab_Grandeur_BaseH*) typ_en_sortie->Const_Grandeur_pointee());
// on va considérer que toutes les bases ont le même nombre de vecteur
// correspondant à la dimension de l'espace de travail
int nb_vect = ParaGlob::Dimension();
// récup du numéro de l'axe
int N_a = ((numero-1) % nb_vect) + 1 ;
// récup du numéro dans le tableau de la base
int n_dans_tab = ((numero-1) / nb_vect) + 1 ;
// récup de la base
Grandeur_BaseH& gr = (*tab_base)(n_dans_tab);
const BaseH& baH1 = gr.RefConteneurBaseH();
// récup des coordonnées du vecteur N_a
const Coordonnee& V = baH1.Coordo(N_a);
V.Affiche(sort,ParaGlob::NbdigdoGR());
// sur gmsh, il faut des vecteurs à 3 composantes
switch (3 - V.Dimension())
{case 0: // on ne fait rien
break;
case 1: // cas où il manque une composante
sort << " 0 "; break;
case 2: // il manque 2 composantes
sort << " 0 0 "; break;
case 3: // il manque 3 composantes... un peu étrange !!
sort << " 0 0 0 "; break;
default:
cout << "\n *** erreur en sortie d'une grandeur Grandeur_BaseH "
<< " provenant d'un element de tableau: "<<n_dans_tab
<< " la dimension du vecteur de la base = " << V.Dimension()
<< " le resultat ne sera pas exploitable par gmsh !";
break;
};
break;
}
// pour l'instant rien d'autre
default:
cout << "\n -2- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
<< NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
<< " la sortie gmsh le fichier resultat ne sera donc pas exploitable !! on continue quand meme !!"
<< "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(...";
};
break;
}
case 6: // cas d'une grandeur VECTEUR que l'on gère comme un tableau de scalaires
{ switch (enuStructure)
{ case TYPE_SIMPLE:
{Grandeur_Vecteur* t_grandeur =
((Grandeur_Vecteur*) typ_en_sortie->Const_Grandeur_pointee());
const Vecteur& vec = *((Vecteur*) t_grandeur->ConteneurVecteur());
Isovaleurs_Gmsh::SortieVecteur(sort,vec);
break;
};
case TABLEAU_T:
{Tab_Grandeur_Vecteur* t_grandeur =
((Tab_Grandeur_Vecteur*) typ_en_sortie->Const_Grandeur_pointee());
Vecteur& vec = *((Vecteur*) &(*t_grandeur)(numero));
Isovaleurs_Gmsh::SortieVecteur(sort,vec);
break;
}
default:
cout << "\n -1- *** attention la structure " << NomType2Niveau(enuStructure) << " pour le type "
<< NomTypeGrandeur(enugrandeur) << " n'est pas encore gere pour "
<< " la sortie gmsh le fichier resultat ne sera donc pas exploitable !! on continue quand meme !!"
<< "\n Isovaleurs_Gmsh::SortirUneViewTypeQuelconque(...";
};
break;
}
}; //-- fin du switch (castype)
};
};
};
// fin de la view
sort << "\n$EndNodeData \n";
};
//--ancien format --// utilitaire pour la sortie d'un tenseur HH
// bool: indique s'il faut une virgule ou non après le dernier enreg
void Isovaleurs_Gmsh::SortieTenseurHH_ancien_format(ostream & sort,const TenseurHH& t_HH)
{ switch (Abs(t_HH.Dimension()))
{case 1: { sort << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,1) << ", ";
for (int i=2;i<=9;i++) sort << " 0., "; // le reste en 0
break;
}
case 2: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,1) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,2) << ", 0., ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,2) << ", " ;
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(2,2) << ", ";
sort << " 0., 0., 0., 0. ";
break;
};
case 3: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,1) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,2) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,3) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(2,1) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(2,2) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(2,3) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(3,1) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(3,2) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(3,3) ;
break;
};
default: cout << "\n erreur !! Isovaleurs_Gmsh::SortieTenseurHH(.."; Sortie(1);
};
};
//-- ancien format // utilitaire pour la sortie d'un tenseur BB
// bool: indique s'il faut une virgule ou non après le dernier enreg
void Isovaleurs_Gmsh::SortieTenseurBB_ancien_format(ostream & sort,const TenseurBB& t_BB)
{ switch (Abs(t_BB.Dimension()))
{case 1: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,1) << ", ";
for (int i=2;i<=9;i++) sort << " 0., "; // le reste en 0
break;
}
case 2: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,1) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,2) << ", 0., ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,2) << ", " ;
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(2,2) << ", ";
sort << " 0., 0., 0., 0. ";
break;
};
case 3: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,1) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,2) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,3) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(2,1) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(2,2) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(2,3) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(3,1) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(3,2) << ", ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(3,3) ;
break;
};
default: cout << "\n erreur !! Isovaleurs_Gmsh::SortieTenseurBB(.."; Sortie(1);
};
};
// utilitaire pour la sortie d'un tenseur HH
// bool: indique s'il faut une virgule ou non après le dernier enreg
void Isovaleurs_Gmsh::SortieTenseurHH(ostream & sort,const TenseurHH& t_HH)
{ switch (Abs(t_HH.Dimension()))
{case 1: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,1) << " ";
for (int i=2;i<=9;i++) sort << " 0. "; // le reste en 0
break;
}
case 2: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,1) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,2) << " 0. ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,2) << " " ;
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(2,2) << " ";
sort << " 0. 0. 0. 0. ";
break;
};
case 3: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,1) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,2) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(1,3) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(2,1) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(2,2) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(2,3) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(3,1) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(3,2) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_HH(3,3) ;
break;
};
default: cout << "\n erreur !! Isovaleurs_Gmsh::SortieTenseurHH(.."; Sortie(1);
};
};
// utilitaire pour la sortie d'un tenseur BB
// bool: indique s'il faut une virgule ou non après le dernier enreg
void Isovaleurs_Gmsh::SortieTenseurBB(ostream & sort,const TenseurBB& t_BB)
{ switch (Abs(t_BB.Dimension()))
{case 1: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,1) << " ";
for (int i=2;i<=9;i++) sort << " 0. "; // le reste en 0
break;
}
case 2: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,1) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,2) << " 0. ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,2) << " " ;
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(2,2) << " ";
sort << " 0. 0. 0. 0. ";
break;
};
case 3: { sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,1) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,2) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(1,3) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(2,1) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(2,2) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(2,3) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(3,1) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(3,2) << " ";
sort << setw(ParaGlob::NbdigdoGR()) << setprecision(ParaGlob::NbdigdoGR()) << t_BB(3,3) ;
break;
};
default: cout << "\n erreur !! Isovaleurs_Gmsh::SortieTenseurBB(.."; Sortie(1);
};
};
// utilitaire pour une sortie de type Vecteur
void Isovaleurs_Gmsh::SortieVecteur(ostream & sort,const Vecteur& vec)
{
switch (vec.Taille())
{case 1: // cas d'un équivalent scalaire
sort << setprecision(ParaGlob::NbdigdoGR()) << vec(1) << " ";break;
case 2: // là on fait un équivalent Coordonnees
sort << setprecision(ParaGlob::NbdigdoGR())
<< vec(1) << " "<< vec(2) << " 0. ";break;
case 3: // là on fait un équivalent Coordonnees
sort << setprecision(ParaGlob::NbdigdoGR())
<< vec(1) << " "<< vec(2) << " "<< vec(3)<< " ";break;
case 4: // là on fait un équivalent tenseur
sort << setprecision(ParaGlob::NbdigdoGR())
<< vec(1) << " "<< vec(2) << " "<< vec(3)<< " "<< vec(4)
<< " 0 0 ";break;
case 5: // là on fait un équivalent tenseur
sort << setprecision(ParaGlob::NbdigdoGR())
<< vec(1) << " "<< vec(2) << " "<< vec(3)<< " "<< vec(4)
<< vec(5) << " 0 ";break;
case 6: // là on fait un équivalent tenseur
sort << setprecision(ParaGlob::NbdigdoGR())
<< vec(1) << " "<< vec(2) << " "<< vec(3)<< " "<< vec(4)
<< vec(5) << " "<< vec(6) << " ";break;
default:
cout << "\n nombre de composante du vecteur superieur a 6 "
<< " aucune sortie possible avec gmsh " ;
};
};
// initialisation les différentes listes internes qui globalisent tous les maillages
void Isovaleurs_Gmsh::GlobalisationListSurTousLesMaillagesPourLesNoeuds()
{ // on initialise toutes les listes globales
glob_noe_ddl_retenu.clear();
glob_noeud_ddl_etendu_retenu.clear();
glob_noeud_evol_retenu.clear();
glob_elem_ddl_retenu.clear();
glob_elem_evol_retenu.clear();
glob_elem_Parti_retenu.clear();
// on passe en revue tous les maillages pour crées les listes globales des grandeurs
int nb_mail = tabnoeud_type_ddl_retenu.Taille(); // dim des maillages, via un tableau arbitraire
for (int imail=1;imail<= nb_mail;imail++)
{ // on merge les listes (il faut qu'avant chaque merge, les listes soient ordonnées)
// comme l'ordre merge ajoute les listes mais en détruisant la liste initiale, on crée une liste intermédiaire
tabnoeud_type_ddl_retenu(imail).sort();
List_io < Ddl_enum_etendu > interDddlenumetendu(tabnoeud_type_ddl_retenu(imail));
glob_noe_ddl_retenu.merge(interDddlenumetendu);
tabnoeud_type_ddlEtendu_retenu(imail).sort();
List_io < Ddl_enum_etendu > inter2Dddlenumetendu(tabnoeud_type_ddlEtendu_retenu(imail));
glob_noeud_ddl_etendu_retenu.merge(inter2Dddlenumetendu);
tabnoeud_evoluee_retenu(imail).sort();
List_io < TypeQuelconque > internoeudevolretenu(tabnoeud_evoluee_retenu(imail));
//debug
//cout << "\n debug: Isovaleurs_Gmsh::GlobalisationListSurTousLesMaillagesPourLesNoeuds() ";
//cout << "\n list tabnoeud_evoluee_retenu("<<imail<<") "<< tabnoeud_evoluee_retenu(imail) << endl;
// fin debug
glob_noeud_evol_retenu.merge(internoeudevolretenu);
tabelement_type_ddl_retenu(imail).sort();
List_io < Ddl_enum_etendu > interelemDddlenumetendu(tabelement_type_ddl_retenu(imail));
glob_elem_ddl_retenu.merge(interelemDddlenumetendu);
tabelement_evoluee_retenu(imail).sort();
List_io < TypeQuelconque > interelemevolretenu(tabelement_evoluee_retenu(imail));
glob_elem_evol_retenu.merge(interelemevolretenu);
tabelement_typeParti_retenu(imail).sort();
List_io < TypeQuelconque > interelempartiretenu(tabelement_typeParti_retenu(imail));
glob_elem_Parti_retenu.merge(interelempartiretenu);
// on ordonne
glob_noe_ddl_retenu.sort();
glob_noeud_ddl_etendu_retenu.sort();
glob_noeud_evol_retenu.sort();
glob_elem_ddl_retenu.sort();
glob_elem_evol_retenu.sort();
glob_elem_Parti_retenu.sort();
// on supprime les doublons
glob_noe_ddl_retenu.unique();
glob_noeud_ddl_etendu_retenu.unique();
glob_noeud_evol_retenu.unique();
glob_elem_ddl_retenu.unique();
glob_elem_evol_retenu.unique();
glob_elem_Parti_retenu.unique();
};
// pour le transfert des points d'intégration aux noeuds, on met à jour le tableau de pointeur global
// ne concerne donc que les grandeurs quelconques définis aux noeuds
if (glob_elem_evol_retenu.size()!=0) {tab_quelconque(1)= &glob_elem_evol_retenu;}
else {tab_quelconque(1)= NULL;};
if (glob_elem_Parti_retenu.size()!=0){tab_quelconque(2)= &glob_elem_Parti_retenu;}
else {tab_quelconque(2)= NULL;};
// on définit les tableaux d'indicateurs de sortie de grandeurs
for (int imai=1;imai<= nb_mail;imai++)
{ // initialisation des tableaux d'indicateurs
List_io < bool >& g_noeud_type_ddl_asortir = t_g_noeud_ddl_asortir(imai); // pour simplifier
g_noeud_type_ddl_asortir.clear();
List_io < bool >& g_noeud_ddl_etendu_asortir = t_g_noeud_ddl_etendu_asortir(imai); // pour simplifier
g_noeud_ddl_etendu_asortir.clear();
List_io < bool >& g_noeud_evoluee_asortir = t_g_noeud_evoluee_asortir(imai); // pour simplifier
g_noeud_evoluee_asortir.clear();
List_io < bool >& g_element_ddl_asortir = t_g_elem_ddl_asortir(imai); // pour simplifier
g_element_ddl_asortir.clear();
List_io < bool >& g_element_evoluee_asortir = t_g_elem_evoluee_asortir(imai); // pour simplifier
g_element_evoluee_asortir.clear();
List_io < bool >& g_element_typeParti_asortir = t_g_elem_typeParti_asortir(imai); // pour simplifier
g_element_typeParti_asortir.clear();
// on passe en revue les grandeurs à sortir et on met à jour les indicateurs en conséquence
// .. pour les ddl aux noeuds
{List_io < Ddl_enum_etendu >& noeud_type_ddl_retenu = tabnoeud_type_ddl_retenu(imai); // pour simplifier
List_io < Ddl_enum_etendu >::iterator i1,i1fin=glob_noe_ddl_retenu.end();
for (i1=glob_noe_ddl_retenu.begin();i1!=i1fin;i1++)
if (find(noeud_type_ddl_retenu.begin(),noeud_type_ddl_retenu.end(),(*i1)) == noeud_type_ddl_retenu.end())
{g_noeud_type_ddl_asortir.push_back(false);} // cas où le ddl initial n'existe pas pour le maillage considéré
else {g_noeud_type_ddl_asortir.push_back(true);}; // cas où le ddl initial existe également pour le maillage considéré
};
{// .. pour les ddl étendues définis aux noeuds
List_io < Ddl_enum_etendu >& noeud_type_ddlEtendu_retenu = tabnoeud_type_ddlEtendu_retenu(imai); // pour simplifier
List_io < Ddl_enum_etendu >::iterator i1,i1fin=glob_noeud_ddl_etendu_retenu.end();
for (i1=glob_noeud_ddl_etendu_retenu.begin();i1!=i1fin;i1++)
if (find(noeud_type_ddlEtendu_retenu.begin(),noeud_type_ddlEtendu_retenu.end(),(*i1)) == noeud_type_ddlEtendu_retenu.end())
{g_noeud_ddl_etendu_asortir.push_back(false);} // cas où le ddl étendu n'existe pas pour le maillage considéré
else {g_noeud_ddl_etendu_asortir.push_back(true);}; // cas où le ddl étendu existe également pour le maillage considéré
};
{// .. pour les types évoluées définis aux noeuds
List_io < TypeQuelconque >& noeud_evoluee_retenu = tabnoeud_evoluee_retenu(imai); // pour simplifier
List_io < TypeQuelconque >::iterator i1,i1fin=glob_noeud_evol_retenu.end();
for (i1=glob_noeud_evol_retenu.begin();i1!=i1fin;i1++)
if (find(noeud_evoluee_retenu.begin(),noeud_evoluee_retenu.end(),(*i1)) == noeud_evoluee_retenu.end())
{g_noeud_evoluee_asortir.push_back(false);} // cas où le type évolué n'existe pas pour le maillage considéré
else {g_noeud_evoluee_asortir.push_back(true);}; // cas où le type évolué existe également pour le maillage considéré
};
// .. pour les ddl venant d'un transfert aux noeuds des grandeurs aux pt d'integ
List_io < Ddl_enum_etendu >& element_type_ddl_retenu = tabelement_type_ddl_retenu(imai); // pour simplifier
List_io < Ddl_enum_etendu >::iterator j1,j1fin=glob_elem_ddl_retenu.end();
for (j1=glob_elem_ddl_retenu.begin();j1!=j1fin;j1++)
if (find(element_type_ddl_retenu.begin(),element_type_ddl_retenu.end(),(*j1))== element_type_ddl_retenu.end())
{g_element_ddl_asortir.push_back(false);} // cas où le ddl global n'existe pas pour le maillage considéré
else {g_element_ddl_asortir.push_back(true);}; // cas où le ddl global existe également pour le maillage considéré
// .. pour les types évolulées venant d'un transfert aux noeuds des grandeurs aux pt d'integ
List_io < TypeQuelconque >& element_evoluee_retenu = tabelement_evoluee_retenu(imai); // pour simplifier
List_io < TypeQuelconque >::iterator k1,k1fin=glob_elem_evol_retenu.end();
for (k1=glob_elem_evol_retenu.begin();k1!=k1fin;k1++)
if (find(element_evoluee_retenu.begin(),element_evoluee_retenu.end(),(*k1))== element_evoluee_retenu.end())
{g_element_evoluee_asortir.push_back(false);} // cas où le ddl évolué global n'existe pas pour le maillage considéré
else {g_element_evoluee_asortir.push_back(true);}; // cas où le ddl évolué global existe également pour le maillage considéré
// .. pour les types particuliers aux elements venant d'un transfert aux noeuds
List_io < TypeQuelconque >& element_typeParti_retenu = tabelement_typeParti_retenu(imai); // pour simplifier
List_io < TypeQuelconque >::iterator m1,m1fin=glob_elem_Parti_retenu.end();
for (m1=glob_elem_Parti_retenu.begin();m1!=m1fin;m1++)
if (find(element_typeParti_retenu.begin(),element_typeParti_retenu.end(),(*m1))== element_typeParti_retenu.end())
{g_element_typeParti_asortir.push_back(false);} // cas où le ddl évolué global n'existe pas pour le maillage considéré
else {g_element_typeParti_asortir.push_back(true);}; // cas où le ddl évolué global existe également pour le maillage considéré
};
};
// vérification que le transfert peut se faire (pas de doublon de grandeurs)
void Isovaleurs_Gmsh::VerificationTransfertPossible_et_doublon()
{ // l'objectif est de vérifier qu'il n'y a pas deux grandeurs identiques au niveau des types quelconques et évoluées
// (ce qui posera des pb au niveau des moyennes aux noeuds)
int nb_mail = tabnoeud_type_ddl_retenu.Taille(); // dim des maillages, via un tableau arbitraire
for (int imail=1;imail<= nb_mail;imail++)
{ List_io < TypeQuelconque >& element_evoluee_retenu = tabelement_evoluee_retenu(imail);
List_io < TypeQuelconque >& element_typeParti_retenu = tabelement_typeParti_retenu(imail);
List_io < TypeQuelconque >& noe_typeParti_retenu = tabnoeud_evoluee_retenu(imail);
// on ordonne
element_evoluee_retenu.sort();
element_typeParti_retenu.sort();
noe_typeParti_retenu.sort();
// a priori il y a peut d'éléments donc on compare
List_io < TypeQuelconque >::iterator i1,i1end = element_evoluee_retenu.end();
i1=element_evoluee_retenu.begin();
List_io < TypeQuelconque >::iterator j1,j1end = element_typeParti_retenu.end();
j1=element_typeParti_retenu.begin();
List_io < TypeQuelconque >::iterator k1,k1end = noe_typeParti_retenu.end();
k1=noe_typeParti_retenu.begin();
for (i1=element_evoluee_retenu.begin(); i1 != i1end; i1++)
for (j1=element_typeParti_retenu.begin();j1 != j1end; j1++)
for (k1=noe_typeParti_retenu.begin();k1 != k1end; k1++)
{ if ((*i1)==(*j1))
{cout << "\n attention *** probleme concernant le transfert aux noeuds il ne faut pas avoir deux grandeurs identiques, or ici "
<< "\n on a la grandeurs : " << ((*i1).EnuTypeQuelconque().NomPlein()) << " en double !! "
<< "\n on supprime l'un d'eux ";
element_typeParti_retenu.erase(j1);
};
if ((*i1)==(*k1))
{cout << "\n attention *** probleme concernant le transfert aux noeuds il ne faut pas avoir deux grandeurs identiques, or ici "
<< "\n on a la grandeurs : " << ((*i1).EnuTypeQuelconque().NomPlein()) << " en double !! "
<< "\n on supprime l'un d'eux ";
noe_typeParti_retenu.erase(k1);
};
if ((*j1)==(*k1))
{cout << "\n attention *** probleme concernant le transfert aux noeuds il ne faut pas avoir deux grandeurs identiques, or ici "
<< "\n on a la grandeurs : " << ((*j1).EnuTypeQuelconque().NomPlein()) << " en double !! "
<< "\n on supprime l'un d'eux ";
noe_typeParti_retenu.erase(k1);
};
};
};
// de plus, il ne faut pas qu'il y ait la même grandeur de type évoluées définis aux noeuds, qui soit également définit pour le transfert
// des pti aux noeud, ou en ddl pur
// (cela posera des pb au niveau des moyennes aux noeuds, et de nom de fichier de sortie)
for (int imail=1;imail<= nb_mail;imail++)
{ List_io < Ddl_enum_etendu >& noe_ddl_retenu = tabnoeud_type_ddl_retenu(imail);
List_io < Ddl_enum_etendu >& noe_ddlEtendu_retenu = tabnoeud_type_ddlEtendu_retenu(imail);
List_io < Ddl_enum_etendu >& element_type_ddl_retenu = tabelement_type_ddl_retenu(imail);
// on ordonne
noe_ddl_retenu.sort();
noe_ddlEtendu_retenu.sort();
element_type_ddl_retenu.sort();
// a priori il y a peu d'éléments donc on compare
List_io < Ddl_enum_etendu >::iterator i1,i1end = noe_ddl_retenu.end();
i1=noe_ddl_retenu.begin();
List_io < Ddl_enum_etendu >::iterator j1,j1end = noe_ddlEtendu_retenu.end();
j1=noe_ddlEtendu_retenu.begin();
List_io < Ddl_enum_etendu >::iterator k1,k1end = element_type_ddl_retenu.end();
k1=element_type_ddl_retenu.begin();
for (i1=noe_ddl_retenu.begin(); i1 != i1end; i1++)
for (j1=noe_ddlEtendu_retenu.begin();j1 != j1end; j1++)
for (k1=element_type_ddl_retenu.begin();k1 != k1end; k1++)
{ if ((*i1)==(*j1))
{cout << "\n attention *** probleme concernant le transfert aux noeuds il ne faut pas avoir deux grandeurs identiques, or ici "
<< "\n on a la grandeurs : " << (((*i1).Nom_vide()) ? Nom_ddl((*i1).Enum()) : (*i1).Nom() )
<< " en double !! "
<< "\n on supprime l'un d'eux ";
noe_ddlEtendu_retenu.erase(j1);
};
if ((*i1)==(*k1))
{cout << "\n attention *** probleme concernant le transfert aux noeuds il ne faut pas avoir deux grandeurs identiques, or ici "
<< "\n on a la grandeurs : " << (((*i1).Nom_vide()) ? Nom_ddl((*i1).Enum()) : (*i1).Nom() )
<< " en double !! "
<< "\n on supprime l'un d'eux ";
element_type_ddl_retenu.erase(k1);
};
if ((*j1)==(*k1))
{cout << "\n attention *** probleme concernant le transfert aux noeuds il ne faut pas avoir deux grandeurs identiques, or ici "
<< "\n on a la grandeurs : " << (((*j1).Nom_vide()) ? Nom_ddl((*j1).Enum()) : (*j1).Nom() )
<< " en double !! "
<< "\n on supprime l'un d'eux ";
element_type_ddl_retenu.erase(k1);
};
};
};
};
//------------ méthodes utilitaires qui sont également utilisées par d'autres classes----
// numero: dans le cas où c'est une view pour un élément de tableau, donc de numéro numero
void Isovaleurs_Gmsh::EnteteView(ostream & sort,const int & incre, const string& nom,const int & numero ) const
{ // def de l'entete
sort << "\n\n View \""<< nom << " incre= " << incre ;
if (numero != 0)
sort << ", NB tab " << numero;
sort <<"\" { ";
};
// utilitaire pour la sortie de l'entête d'un bloc NodeData utilisé avec le nouveau format gmsh
// numero: dans le cas où c'est une view pour un élément de tableau, donc de numéro numero
void Isovaleurs_Gmsh::EnteteNodeData(ostream & sort,const int & incre, const double& temps
,const string& nom,const int & nb_composante ) const
{ // dans le cas où l'incrément est supérieur à 1000000, on est dans un cas spécial de mode débug, pour lequel
// le temps ne veut rien dire donc on a un traitement spécial
if (incre < 1000000) // cas normal
{sort << "\n\n$NodeData \n1 \n\""<< nom
<< "\"\n1 \n"<< temps << "\n3 \n"<< incre <<"\n"<< nb_composante <<"\n"
<< mailInitial->Nb_total_noeud();
}
else // cas particulier début
{int compteur = incre % 1000000;
sort << "\n\n$NodeData \n1 \n\""<< nom
<< "\"\n1 \n"<< compteur << "\n3 \n"<< compteur <<"\n"<< nb_composante <<"\n"
<< mailInitial->Nb_total_noeud();
};
};
// sortie de la def des coordonnées pour une view
void Isovaleurs_Gmsh::SortieDefCoordonnees_old_format(ostream & sort,const int & incre
,int nbmail, const Tableau <int>& tab_mail,LesMaillages * lesMail) const
{ int dim = ParaGlob::Dimension();
for (int im =1; im <= nbmail; im++)
{int numMail = tab_mail(im);
int nbmaxnoeud = lesMail->Nombre_noeud(numMail);
int decalnoeud = mailInitial->DecalNumNoeud(numMail);
// deux cas soit on applique une pseudo-homothetie ou non
if (!((mailInitial->Considerer_homothetie()) && ((mailInitial->T_homothetie())(numMail))))
{// cas sans homothetie : cas classique
for (int ino = 1; ino <= nbmaxnoeud; ino++)
{Noeud& noe = lesMail->Noeud_LesMaille(numMail, ino); // pour simplifier
int num_noeud = ino + decalnoeud;
const Coordonnee& co = noe.Coord2();
sort << "\n";
switch (dim)
{ case 3: sort << "Z" << num_noeud <<"i"<<incre << " = " << co(3) << " ; ";
case 2: sort << "Y" << num_noeud <<"i"<<incre << " = " << co(2) << " ; ";
case 1: sort << "X" << num_noeud <<"i"<<incre << " = " << co(1) << " ; ";
};
// on remplie de 0, au cas où la dimension n'est pas 3
switch (dim)
{ case 1: sort << "Y" << num_noeud <<"i"<<incre << " = 0 ; " ;
case 2: sort << "Z" << num_noeud <<"i"<<incre << " = 0 ; " ;
};
};
}
else // cas avec Homothetie
{Coordonnee& orig = (mailInitial->T_orig())(numMail); // pour simplifier
Coordonnee& fact_mult = (mailInitial->T_fact_mult())(numMail); // pour simplifier
for (int ino = 1; ino <= nbmaxnoeud; ino++)
{ Noeud& noe = lesMail->Noeud_LesMaille(numMail, ino); // pour simplifier
int num_noeud = ino + decalnoeud;
const Coordonnee& co = noe.Coord2();
const Coordonnee& co_0 = noe.Coord0();
Coordonnee delta_co = co-co_0; // calcul du déplacement
// on calcul les coordonnées initiale avec homothetie
Coordonnee A(co_0-orig); int dim = A.Dimension();
switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
{ case 3: A(3) *= fact_mult(3);
case 2: A(2) *= fact_mult(2);
case 1: A(1) *= fact_mult(1);
};
A +=orig;
// on rajoute le déplacement
A += delta_co;
sort << "\n";
switch (dim)
{ case 3: sort << "Z" << num_noeud <<"i"<<incre << " = " << A(3) << " ; ";
case 2: sort << "Y" << num_noeud <<"i"<<incre << " = " << A(2) << " ; ";
case 1: sort << "X" << num_noeud <<"i"<<incre << " = " << A(1) << " ; ";
};
// on remplie de 0, au cas où la dimension n'est pas 3
switch (dim)
{ case 1: sort << "Y" << num_noeud <<"i"<<incre << " = 0 ; " ;
case 2: sort << "Z" << num_noeud <<"i"<<incre << " = 0 ; " ;
};
};
}
}; // fin de la boucle sur les maillage
};
// sortie de l'utilisation d'une coordonnée
void Isovaleurs_Gmsh::SortieUseUneCoordonnee(int incre, ostream & sort,bool fin,int num_N) const
{ sort << "X"<<num_N<<"i"<<incre << ",Y"<<num_N<<"i"<<incre << ",Z"<<num_N<<"i"<<incre;
if(fin) {sort << "){";}
else {sort << ", ";};
};
// création de la liste des noms correspondants à tous les grandeurs à sortir
void Isovaleurs_Gmsh::CreatListNomsTousLesGrandeurs()
{ // --cette création s'appuie sur les listes globales, qui doivent donc être construite
// on efface la liste existante
nomsGrandeursSortie.clear();
// !! normalement tous les noms sont différents, cela a été vérifié dans :
// Isovaleurs_Gmsh::VerificationTransfertPossible_et_doublon()
// on passe en revue la liste des ddl aux noeuds
{List_io < Ddl_enum_etendu >::iterator ili,ilifin= glob_noe_ddl_retenu.end();
for (ili=glob_noe_ddl_retenu.begin();ili != ilifin; ili++)
nomsGrandeursSortie.push_back(((*ili).Nom_plein()+"_ddl_noe"));
};
// .. pour les ddl étendues définis aux noeuds
{List_io < Ddl_enum_etendu >::iterator ili,ilifin= glob_noeud_ddl_etendu_retenu.end();
for (ili=glob_noeud_ddl_etendu_retenu.begin();ili != ilifin; ili++)
nomsGrandeursSortie.push_back(((*ili).Nom_plein()+"_ddl_etendu_noe"));
};
// .. pour les types évoluées définis aux noeuds
{List_io < TypeQuelconque >::iterator ili,ilifin= glob_noeud_evol_retenu.end();
for (ili=glob_noeud_evol_retenu.begin();ili != ilifin; ili++)
nomsGrandeursSortie.push_back( string(((*ili).EnuTypeQuelconque().NomPlein())+"_evolue_noe" ));
};
// .. pour les ddl venant d'un transfert aux noeuds des grandeurs aux pt d'integ
{List_io < Ddl_enum_etendu >::iterator ili,ilifin = glob_elem_ddl_retenu.end();
for (ili=glob_elem_ddl_retenu.begin();ili != ilifin; ili++)
nomsGrandeursSortie.push_back(((*ili).Nom_plein()+"_pti"));
};
// .. pour les types évoluées venant d'un transfert aux noeuds des grandeurs aux pt d'integ
{List_io < TypeQuelconque >::iterator ipi,ipifin=glob_elem_evol_retenu.end();
for (ipi=glob_elem_evol_retenu.begin();ipi != ipifin; ipi++)
nomsGrandeursSortie.push_back( string(((*ipi).EnuTypeQuelconque().NomPlein())+"_evolue_pti" ));
// .. pour les types particuliers aux elements venant d'un transfert aux noeuds
ipifin= glob_elem_Parti_retenu.end();
for (ipi=glob_elem_Parti_retenu.begin();ipi != ipifin; ipi++)
{ // on traite le cas VECTEUR nommé d'une manière particulière
TypeQuelconque& typ = (*ipi); // pour simplifier
EnumTypeGrandeur enugrandeur = typ.EnuTypeGrandeur();
EnumType2Niveau enuStructure = typ.Const_Grandeur_pointee()->Type_structure_grandeurAssocie();
// string sup="";// un string vide
// if ((enuStructure == TYPE_SIMPLE) && (enugrandeur == VECTEUR))
// {Grandeur_Vecteur_Nommer& t_grandeur =
// *((Grandeur_Vecteur_Nommer*) typ.Const_Grandeur_pointee());
// sup += *(t_grandeur.Nom_ref());
// };
// string nom_s(typ.EnuTypeQuelconque().NomPlein());
//
nomsGrandeursSortie.push_back( string(((*ipi).EnuTypeQuelconque().NomPlein())+"_particulier_pti" )); };
};
//----- debug
//list <string>::iterator iti,itifin=nomsGrandeursSortie.end();
//cout << "\n la liste des noms ";
//for (iti=nomsGrandeursSortie.begin();iti != itifin;iti++)
// cout << (*iti) << " ";
//cout << endl;
//
//----- fin debug
};
// écriture des grandeurs aux noeuds au nouveau format
void Isovaleurs_Gmsh::EcritureAuxNoeuds(const Tableau <int>& tab_mail,LesMaillages * lesMail
,int incre,UtilLecture & entreePrinc)
{ // pour simplifier
int nbmail = tab_mail.Taille();
// ici l'objectif est de tout mettre dans un seul groupe de résultat de manière à pouvoir tout
// visualiser en même temps
// on ne traite que s'il y a des ddl
bool atraiter = false;
{if ( (glob_noe_ddl_retenu.size() != 0)
|| (glob_noeud_ddl_etendu_retenu.size() != 0)
|| (glob_noeud_evol_retenu.size() != 0)
|| (glob_elem_ddl_retenu.size() != 0)
|| (glob_elem_evol_retenu.size() != 0)
|| (glob_elem_Parti_retenu.size() != 0)
)
atraiter = true;
};
if (atraiter)
{
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
double temps_actuel = ParaGlob::Variables_de_temps().TempsCourant();
// 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 utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
// maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
List_io < Ddl_enum_etendu >::iterator il,ilfin=glob_noe_ddl_retenu.end();
Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
Tableau <List_io < bool >::iterator > t_choix_var_ddl(nbmail);
for (int im =1; im <= nbmail; im++)
{t_indic_sortie(im)=t_g_noeud_ddl_asortir(im).begin();
t_choix_var_ddl(im)=choix_var_ddl(im).begin();
};
for (il=glob_noe_ddl_retenu.begin();il != ilfin;il++)
{ Enum_ddl ddl = (*il).Enum(); // récup du ddl de base
Ddl_enum_etendu ddl_etendu = (*il); // le ddl étendue associé
bool ddl_basique = (*il).Nom_vide();
ostream &sort = entreePrinc.Sort_resultat_Gmsh(ddl_etendu.Nom_plein()+"_ddl_noe");
// def de l'entete
EnteteNodeData(sort,incre,temps_actuel,ddl_etendu.Nom_plein(),1);
// -- sortie des grandeurs
// on balaie les maillages
for (int im =1; im <= nbmail; im++)
{// on ne continue que si le maillage est à sortir
// !!! en fait avec gmsh, et le nouveau format, il faut que l'on sorte toujours quelque chose, car le nombre de noeuds
// est celui de l'ensemble des maillages présents,
bool grandeur_prevu_en_sortie = (*(t_indic_sortie(im))); // drapeau utilisé en sortie
//if (*(t_indic_sortie(im)))
{int numMail = tab_mail(im);
int decal_noe = mailInitial->DecalNumNoeud(numMail);
Tableau<Noeud *>& t_n = lesMail->Tab_noeud(im);
int nbmaxinoeud = t_n.Taille();
for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++)
{ // recup du noeud
Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
sort << "\n" << noe.Num_noeud()+decal_noe << " " ;
//-- les grandeurs
if (grandeur_prevu_en_sortie)
{bool varddl = *(t_choix_var_ddl(im)); // variation ou pas
// il y a un choix suivant que c'est un ddl de base ou un ddl étendu
if (ddl_basique)
{ if (noe.Existe_ici(ddl))
{ if (varddl) // cas de la variation
{sort << setprecision(ParaGlob::NbdigdoGR())
<< (noe.Valeur_tdt(ddl)-noe.Valeur_0(ddl));}
else
{ sort << setprecision(ParaGlob::NbdigdoGR()) << noe.Valeur_tdt(ddl) ;};
}
else // si la valeur n'existe pas on sort 0
{sort << 0. ;};
}
else // sinon c'est un ddl étendue
{ if (noe.Existe_ici_ddlEtendu(ddl_etendu))
{ sort << setprecision(ParaGlob::NbdigdoGR())
<< (noe.DdlEtendue(ddl_etendu).ConstValeur()) ;}
else // si la valeur n'existe pas on sort 0
{sort << 0 ;};
};
}
else // cas d'une sortie non prévue, on sort quand même 0.
{sort << 0 ;};
};
};
};
// fin de la view
sort << "\n$EndNodeData \n";
// mise à jour des pointeurs de choix
for (int im =1; im <= nbmail; im++)
{t_indic_sortie(im)++;t_choix_var_ddl(im)++;}
}; //-- fin de la boucle sur les enum aux noeud
}; //--// fin du test s'il y a des enum à sortir ou nom
// 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 utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
// maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
List_io < Ddl_enum_etendu >::iterator il,ilfin=glob_noeud_ddl_etendu_retenu.end();
Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
for (int im =1; im <= nbmail; im++)
{t_indic_sortie(im)=t_g_noeud_ddl_etendu_asortir(im).begin();
};
for (il=glob_noeud_ddl_etendu_retenu.begin();il != ilfin;il++)
{ Enum_ddl ddl = (*il).Enum(); // récup du ddl de base
Ddl_enum_etendu ddl_etendu = (*il); // le ddl étendue associé
bool ddl_basique = (*il).Nom_vide();
ostream &sort = entreePrinc.Sort_resultat_Gmsh((*il).Nom_plein()+"_ddl_etendu_noe");
// def de l'entete
EnteteNodeData(sort,incre,temps_actuel,(*il).Nom_plein(),1);
// -- sortie des grandeurs
// on balaie les maillages
for (int im =1; im <= nbmail; im++)
{// on ne continue que si le maillage est à sortir
// !!! en fait avec gmsh, et le nouveau format, il faut que l'on sorte toujours quelque chose, car le nombre de noeuds
// est celui de l'ensemble des maillages présents,
bool grandeur_prevu_en_sortie = (*(t_indic_sortie(im))); // drapeau utilisé en sortie
//if (*(t_indic_sortie(im)))
{int numMail = tab_mail(im);
int decal_noe = mailInitial->DecalNumNoeud(numMail);
Tableau<Noeud *>& t_n = lesMail->Tab_noeud(im);
int nbmaxinoeud = t_n.Taille();
for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++)
{ // recup du noeud
Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
sort << "\n" << noe.Num_noeud()+decal_noe << " " ;
//-- les grandeurs
if (grandeur_prevu_en_sortie)
{// il y a un choix suivant que c'est un ddl de base ou un ddl étendu
if (ddl_basique)
{ if (noe.Existe_ici(ddl))
{ sort << setprecision(ParaGlob::NbdigdoGR()) << noe.Valeur_tdt(ddl) ;}
else // si la valeur n'existe pas on sort 0
{sort << 0. ;};
}
else // sinon c'est un ddl étendue
{ if (noe.Existe_ici_ddlEtendu(ddl_etendu))
{ sort << setprecision(ParaGlob::NbdigdoGR())
<< (noe.DdlEtendue(ddl_etendu).ConstValeur()) ;}
else // si la valeur n'existe pas on sort 0
{sort << 0 ;};
};
}
else // cas d'une sortie non prévue, on sort quand même 0.
{sort << 0 ;};
};
};
};
// fin de la view
sort << "\n$EndNodeData \n";
// mise à jour des pointeurs de choix
for (int im =1; im <= nbmail; im++)
{t_indic_sortie(im)++;}
}; //-- fin de la boucle sur les enum aux noeud
}; //--// fin du test s'il y a des enum à sortir ou nom
// 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
if ((glob_noeud_evol_retenu.size() != 0) && (incre != 0))
{// on utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
// maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
List_io < TypeQuelconque >::iterator il,ilfin=glob_noeud_evol_retenu.end();
Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
for (int im =1; im <= nbmail; im++)
{t_indic_sortie(im)=t_g_noeud_evoluee_asortir(im).begin();
};
//debug
//cout << "\n debug Isovaleurs_Gmsh::EcritureAuxNoeuds "
// << "\n glob_noeud_evol_retenu "<< glob_noeud_evol_retenu << endl;
//fin debug
for (il=glob_noeud_evol_retenu.begin();il != ilfin;il++)
{TypeQuelconque& typ = (*il); // pour simplifier
ostream &sort = entreePrinc.Sort_resultat_Gmsh((typ.EnuTypeQuelconque().NomPlein())+"_evolue_noe");
// -- choix entre grandeur simple ou complexe
EnumTypeGrandeur enugrandeur = typ.EnuTypeGrandeur();
EnumType2Niveau enuStructure = typ.Const_Grandeur_pointee()->Type_structure_grandeurAssocie();
switch (enuStructure)
{ case TYPE_SIMPLE:
{ // appel directe de la routine adoc
int numero = 0;
SortirUneViewTypeQuelconque(sort,typ,enuStructure,numero
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case TABLEAU_T:
{ // dans le cas d'un tableau on boucle sur les éléments du tableau
switch (enugrandeur)
{ case TENSEURHH:
{Tab_Grandeur_TenseurHH& tab_tensHH = *((Tab_Grandeur_TenseurHH*) typ.Const_Grandeur_pointee());
int taille = tab_tensHH.Taille();
// on boucle, et on sort chaque tenseur
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case TENSEURBB:
{Tab_Grandeur_TenseurBB& tab_tensBB = *((Tab_Grandeur_TenseurBB*) typ.Const_Grandeur_pointee());
int taille = tab_tensBB.Taille();
// on boucle, et on sort chaque tenseur
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case SCALAIRE: case SCALAIRE_ENTIER: case SCALAIRE_DOUBLE:
{Tab_Grandeur_scalaire_double& tab_Gdouble = *((Tab_Grandeur_scalaire_double*) typ.Const_Grandeur_pointee());
int taille = tab_Gdouble.Taille();
// on boucle, et on sort chaque scalaire
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case COORDONNEE:
{Tab_Grandeur_Coordonnee& tab_coordonnee = *((Tab_Grandeur_Coordonnee*) typ.Const_Grandeur_pointee());
int taille = tab_coordonnee.Taille();
// on boucle, et on sort chaque coordonnée
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case VECTEUR:
{Tab_Grandeur_Vecteur& tab_vecteur = *((Tab_Grandeur_Vecteur*) typ.Const_Grandeur_pointee());
int taille = tab_vecteur.Taille();
// on boucle, et on sort chaque vecteur
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
default:
cout << "\n attention : cas de sortie de grandeur tableau non implantee (mais il suffit de le demander !!) ";
typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
cout << "\n Isovaleurs_Gmsh::EcritureAuxNoeuds(... 4 ";
};//-- fin du switch (enugrandeur)
break;
}
default:
cout << "\n attention : cas de sortie de grandeur de type secondaire " << NomType2Niveau(enuStructure)
<< " non implantee (mais il suffit de le demander !!) ";
typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
cout << "\n Isovaleurs_Gmsh::EcritureAuxNoeuds(... 3 ";
};
// mise à jour des pointeurs de choix
for (int im =1; im <= nbmail; im++)
t_indic_sortie(im)++;
}; //--// fin de la boucle sur les enum
}; //--// fin du test s'il y a des enum à sortir ou nom
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
// b) cas des ddl de base (simple) venant d'un transfert aux noeuds des grandeurs aux pt d'integ
// on ne sort que les incréments différents de 0, car pour l'incrément 0 pas de grandeurs licites aux pt integ
//debug
//cout << "\n debug Isovaleurs_Gmsh::EcritureAuxNoeuds "
// << "\n glob_elem_ddl_retenu "<< glob_elem_ddl_retenu << endl;
//fin debug
if ((glob_elem_ddl_retenu.size() != 0) && (incre != 0))
{// on utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
// maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
List_io < Ddl_enum_etendu >::iterator il,ilfin=glob_elem_ddl_retenu.end();
Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
for (int im =1; im <= nbmail; im++)
t_indic_sortie(im)=t_g_elem_ddl_asortir(im).begin();
for (il=glob_elem_ddl_retenu.begin();il != ilfin;il++)
{Ddl_enum_etendu& ddlEtendu = (*il); // pour simplifier
ostream *sorti;
// def de l'entete
sorti = &(entreePrinc.Sort_resultat_Gmsh(ddlEtendu.Nom_plein()+"_pti"));
EnteteNodeData(*sorti,incre,temps_actuel,ddlEtendu.Nom_plein(),1);
ostream& sort = *sorti;
// -- sortie des grandeurs
// on balaie les maillages
for (int im =1; im <= nbmail; im++)
{// on ne continue que si le ddl est à sortir
// !!! en fait avec gmsh, et le nouveau format, il faut que l'on sorte toujours quelque chose, car le nombre de noeuds
// est celui de l'ensemble des maillages présents,
bool grandeur_prevu_en_sortie = (*(t_indic_sortie(im))); // drapeau utilisé en sortie
//if (*(t_indic_sortie(im)))
{int numMail = tab_mail(im);
int decal_noe = mailInitial->DecalNumNoeud(numMail);
Tableau<Noeud *>& t_n = lesMail->Tab_noeud(numMail);
int nbmaxinoeud = t_n.Taille();
for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++)
{ // recup du noeud
Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
sort << "\n" << noe.Num_noeud()+decal_noe << " " ;
//-- les grandeurs
if (grandeur_prevu_en_sortie)
{if (noe.Existe_ici_ddlEtendu(ddlEtendu))
{ sort << setprecision(ParaGlob::NbdigdoGR()) << (noe.DdlEtendue(ddlEtendu).ConstValeur());}
else // si la valeur n'existe pas on sort 0
{sort << 0. ;};
}
else // cas d'une sortie non prévue, on sort quand même 0.
{sort << 0 ;};
};
};
};
// fin de la view
sort << "\n$EndNodeData \n";
// mise à jour des pointeurs de choix
for (int im =1; im <= nbmail; im++)
t_indic_sortie(im)++;
}; //--// fin de la boucle sur les enum
}; //--// fin du test d'existance d'énum à sortir venant d'un transfert aux noeuds des grandeurs aux pt d'integ
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
// c) cas des types évoluées venant d'un transfert aux noeuds des grandeurs aux pt d'integ
// on ne sort que les incréments différents de 0, car pour l'incrément 0 pas de grandeurs licites aux pt integ
if ((glob_elem_evol_retenu.size() != 0) && (incre != 0))
{// on utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
// maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
List_io < TypeQuelconque >::iterator il,ilfin=glob_elem_evol_retenu.end();
Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
for (int im =1; im <= nbmail; im++)
t_indic_sortie(im)=t_g_elem_evoluee_asortir(im).begin();
for (il=glob_elem_evol_retenu.begin();il != ilfin;il++)
{TypeQuelconque& typ = (*il); // pour simplifier
ostream &sort = entreePrinc.Sort_resultat_Gmsh((typ.EnuTypeQuelconque().NomPlein())+"_evolue_pti");
// -- choix entre grandeur simple ou complexe
EnumTypeGrandeur enugrandeur = typ.EnuTypeGrandeur();
EnumType2Niveau enuStructure = typ.Const_Grandeur_pointee()->Type_structure_grandeurAssocie();
switch (enuStructure)
{ case TYPE_SIMPLE:
{ // appel directe de la routine adoc
int numero = 0;
SortirUneViewTypeQuelconque(sort,typ,enuStructure,numero
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case TABLEAU_T:
{ // dans le cas d'un tableau on boucle sur les éléments du tableau
switch (enugrandeur)
{ case TENSEURHH:
{Tab_Grandeur_TenseurHH& tab_tensHH = *((Tab_Grandeur_TenseurHH*) typ.Const_Grandeur_pointee());
int taille = tab_tensHH.Taille();
// on boucle, et on sort chaque tenseur
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case TENSEURBB:
{Tab_Grandeur_TenseurBB& tab_tensBB = *((Tab_Grandeur_TenseurBB*) typ.Const_Grandeur_pointee());
int taille = tab_tensBB.Taille();
// on boucle, et on sort chaque tenseur
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case SCALAIRE: case SCALAIRE_ENTIER: case SCALAIRE_DOUBLE:
{Tab_Grandeur_scalaire_double& tab_Gdouble = *((Tab_Grandeur_scalaire_double*) typ.Const_Grandeur_pointee());
int taille = tab_Gdouble.Taille();
// on boucle, et on sort chaque scalaire
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case COORDONNEE:
{Tab_Grandeur_Coordonnee& tab_coordonnee = *((Tab_Grandeur_Coordonnee*) typ.Const_Grandeur_pointee());
int taille = tab_coordonnee.Taille();
// on boucle, et on sort chaque scalaire
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case VECTEUR:
{Tab_Grandeur_Vecteur& tab_vecteur = *((Tab_Grandeur_Vecteur*) typ.Const_Grandeur_pointee());
int taille = tab_vecteur.Taille();
// on boucle, et on sort chaque scalaire
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
default:
cout << "\n attention : cas de sortie de grandeur tableau non implantee (mais il suffit de le demander !!) ";
typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
cout << "\n Isovaleurs_Gmsh::EcritureAuxNoeuds(... 4 ";
};//-- fin du switch (enugrandeur)
break;
}
default:
cout << "\n attention : cas de sortie de grandeur de type secondaire " << NomType2Niveau(enuStructure)
<< " non implantee (mais il suffit de le demander !!) ";
typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
cout << "\n Isovaleurs_Gmsh::EcritureAuxNoeuds(... 3 ";
};
// mise à jour des pointeurs de choix
for (int im =1; im <= nbmail; im++)
t_indic_sortie(im)++;
}; //--// fin de la boucle sur les enum
}; //--// fin du test d'existance de type évolué venant d'un transfert aux noeuds des grandeurs aux pt d'integ
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
// d) cas des types particuliers aux elements venant d'un transfert aux noeuds
// on ne sort que les incréments différents de 0, car pour l'incrément 0 pas de grandeurs licites aux pt integ
if ((glob_elem_Parti_retenu.size() != 0) && (incre != 0))
{// on utilise la liste globale car la boucle la plus grande est sur les ddl et non sur les
// maillage, ceci de manière à avoir (éventuellement) une seule view qui rassemble plusieurs maillages
List_io < TypeQuelconque >::iterator il,ilfin=glob_elem_Parti_retenu.end();
Tableau <List_io < bool >::iterator > t_indic_sortie(nbmail);
for (int im =1; im <= nbmail; im++)
t_indic_sortie(im)=t_g_elem_typeParti_asortir(im).begin();
for (il=glob_elem_Parti_retenu.begin();il != ilfin;il++)
{TypeQuelconque& typ = (*il); // pour simplifier
// -- choix entre grandeur simple ou complexe
EnumTypeGrandeur enugrandeur = typ.EnuTypeGrandeur();
EnumType2Niveau enuStructure = typ.Const_Grandeur_pointee()->Type_structure_grandeurAssocie();
// // traitement particulier pour VECTEUR
// string sup="";// un string vide
// if ((enuStructure == TYPE_SIMPLE) && (enugrandeur == VECTEUR))
// {Grandeur_Vecteur_Nommer& t_grandeur =
// *((Grandeur_Vecteur_Nommer*) typ.Const_Grandeur_pointee());
// sup += *(t_grandeur.Nom_ref());
// };
// ostream &sort = entreePrinc.Sort_resultat_Gmsh((typ.EnuTypeQuelconque().NomPlein())+sup+"_particulier_pti");
ostream &sort = entreePrinc.Sort_resultat_Gmsh((typ.EnuTypeQuelconque().NomPlein())+"_particulier_pti");
// il faut combiner les deux types d'enu
// compte tenu du fait que VECTEUR et TABLEAU_T sont traité de la même manière
switch (enuStructure)
{ case TYPE_SIMPLE:
{ if (enugrandeur != VECTEUR)
{// appel directe de la routine adoc
int numero = 0;
SortirUneViewTypeQuelconque(sort,typ,enuStructure,numero
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
}
// sinon c'est un VECTEUR, on traite comme un tableau_T, donc on ne met pas de break;
else
{Grandeur_Vecteur_Nommer& t_grandeur =
*((Grandeur_Vecteur_Nommer*) typ.Const_Grandeur_pointee());
Vecteur& vi = t_grandeur.ConteneurVecteur();
int taille = vi.Taille();
// on boucle, et on sort chaque valeur
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
};
break;
}
case TABLEAU_T:
{ // dans le cas d'un tableau (ou d'un VECTEUR) on boucle sur les éléments du tableau
switch (enugrandeur)
{ case TENSEURHH:
{Tab_Grandeur_TenseurHH& tab_tensHH = *((Tab_Grandeur_TenseurHH*) typ.Const_Grandeur_pointee());
int taille = tab_tensHH.Taille();
// on boucle, et on sort chaque tenseur
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case TENSEURBB:
{Tab_Grandeur_TenseurBB& tab_tensBB = *((Tab_Grandeur_TenseurBB*) typ.Const_Grandeur_pointee());
int taille = tab_tensBB.Taille();
// on boucle, et on sort chaque tenseur
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case SCALAIRE: case SCALAIRE_ENTIER: case SCALAIRE_DOUBLE:
{Tab_Grandeur_scalaire_double& tab_Gdouble = *((Tab_Grandeur_scalaire_double*) typ.Const_Grandeur_pointee());
int taille = tab_Gdouble.Taille();
// on boucle, et on sort chaque scalaire
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case COORDONNEE:
{Tab_Grandeur_Coordonnee& tab_coordonnee = *((Tab_Grandeur_Coordonnee*) typ.Const_Grandeur_pointee());
int taille = tab_coordonnee.Taille();
// on boucle, et on sort chaque scalaire
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case VECTEUR:
{Tab_Grandeur_Vecteur& tab_vecteur = *((Tab_Grandeur_Vecteur*) typ.Const_Grandeur_pointee());
int taille = tab_vecteur.Taille();
// on boucle, et on sort chaque scalaire
for (int i=1;i<=taille;i++)
SortirUneViewTypeQuelconque(sort,typ,enuStructure,i
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
break;
}
case BASE__H:
{Tab_Grandeur_BaseH& tab_base = *((Tab_Grandeur_BaseH*) typ.Const_Grandeur_pointee());
int taille = tab_base.Taille();
if (taille > 0)
{// on va considérer que toutes les bases ont le même nombre de vecteur
Grandeur_BaseH& gr = tab_base(1);
const BaseH& baH1 = gr.RefConteneurBaseH();
int nb_vect = baH1.NbVecteur();
// on va traiter chaque vecteur de base comme une grandeur coordonnée
// on boucle, et on sort chaque base H
int indice_vecteur = 1; // le numéro du vecteur à sortir
// par exemple si la base comporte 3 vecteurs, et qu'il y a 2 bases
// a sortir cela fera au total 6 vecteurs : les 3 premiers pour la base1
// les 3 suivants pour la base 2
for (int i=1;i<=taille;i++) // le compteur de base
for (int num_vec = 1; num_vec <= nb_vect; num_vec++,indice_vecteur++)
SortirUneViewTypeQuelconque(sort,typ,enuStructure,indice_vecteur
,t_indic_sortie,nbmail,tab_mail,enugrandeur,lesMail,incre);
};
break;
}
default:
cout << "\n attention : cas de sortie de grandeur tableau non implantee (mais il suffit de le demander !!) ";
typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
cout << "\n Isovaleurs_Gmsh::EcritureAuxNoeuds(... 1 ";
};//-- fin du switch (enugrandeur)
break;
}
default:
cout << "\n attention : cas de sortie de grandeur de type secondaire " << NomType2Niveau(enuStructure)
<< " non implantee (mais il suffit de le demander !!) ";
typ.Const_Grandeur_pointee()->Ecriture_grandeur(sort);
cout << "\n Isovaleurs_Gmsh::EcritureAuxNoeuds(... 2 ";
};
// mise à jour des pointeurs de choix
for (int im =1; im <= nbmail; im++)
t_indic_sortie(im)++;
}; //--// fin de la boucle sur les enum
}; //--// fin du test d'existance de type évolué venant d'un transfert aux noeuds des grandeurs aux pt d'integ
}; //-- fin du cas if (atraiter)
};
// gestion de l'accumulation due au passage des grandeurs choisies venant des éléments, aux noeuds, lorsque ces grandeurs sont
// directement diponibles aux noeuds
void Isovaleurs_Gmsh::Passage_grandeursRetenuesAuxNoeuds_elementsVersNoeuds()
{ int nb_maillage = tabnoeud_type_ddl.Taille();// def du nombre de maillage avec un tableau quelconque
// dans le cas où les ddl récupérés des éléments sont visibles directement aux noeuds on les bascule
// sur les noeuds, car il ne faut pas faire de transfert particulier
for (int imail=1;imail<=nb_maillage;imail++)
{
// on fait l'optimisation et le rangement
tabnoeud_evoluee_retenu(imail).sort();tabnoeud_evoluee_retenu(imail).unique();
// on construit les tableaux a accumuler
{List_io<Ddl_enum_etendu>& aaccum_ret = a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail); // pour simplifier
List_io<Ddl_enum_etendu>& aaccum = a_accumuler_tabnoeud_type_ddlEtendu(imail); // pour simplifier
aaccum_ret.clear();
List_io<Ddl_enum_etendu>& tpg_ret = (tabnoeud_type_ddlEtendu_retenu(imail)); // pour simplifier
List_io < Ddl_enum_etendu >::iterator iq,iqfin=tpg_ret.end();
for (iq=tpg_ret.begin();iq!=iqfin;iq++)// on parcours la liste
// si l'élément doit-être accumulé, on l'indique
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();
};
{List_io<TypeQuelconque>& aaccum_ret = (a_accumuler_tabnoeud_evoluee_retenu(imail)); // pour simplifier
List_io<TypeQuelconque>& aaccum = (a_accumuler_tabnoeud_evoluee(imail)); // pour simplifier
aaccum_ret.clear();
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++)// on parcours la liste
// si l'élément doit-être accumulé, on l'indique
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();
};
////debug
//cout << "\n debug Isovaleurs_Gmsh::Passage_grandeursRetenuesAuxNoeuds_elementsVersNoeuds() "
// << "\n 2: tabnoeud_type_ddlEtendu_retenu(imail) " << tabnoeud_type_ddlEtendu_retenu(imail)
// << "\n 3: tabnoeud_evoluee_retenu(imail) "<<tabnoeud_evoluee_retenu(imail)<< endl;
////fin debug
// on ajoute éventuellement des conteneurs ad hoc aux noeuds
// une fois que ces conteneurs existent, ils sont remplit automatiquement par l'élément
List_io < TypeQuelconque > litq; // une autre pour les quelconques
Tableau <List_io < TypeQuelconque > * > tabQ(2);
tabQ(1)= &tabnoeud_evoluee_retenu(imail);tabQ(2)=&litq;
// on est obligé d'utiliser un tableau dont le second terme est nul,
// ceci pour pouvoir utiliser "AjoutConteneurAuNoeud" tel quel
lesMail->AjoutConteneurAuNoeud(imail,tabnoeud_type_ddlEtendu_retenu(imail),tabQ);
};
};
// passage des grandeurs disponibles venant des éléments, aux noeuds, lorsque ces grandeurs sont
// directement diponibles aux noeuds
void Isovaleurs_Gmsh::Passage_grandeursDisponiblesAuxNoeuds_elementsVersNoeuds()
{ int nb_maillage = tabnoeud_type_ddl.Taille();// def du nombre de maillage avec un tableau quelconque
// dans le cas où les ddl récupérés des éléments sont visibles directement aux noeuds on les bascule
// sur les noeuds, car il ne faut pas faire de transfert particulier
for (int imail=1;imail<=nb_maillage;imail++)
{
{List_io <Ddl_enum_etendu>& lis_sor = tabelement_type_ddl(imail); // pour simplifier
//debug
//cout << "\n debug Isovaleurs_Gmsh::Passage_grandeursDisponiblesAuxNoeuds_elementsVersNoeuds() "
// << "\n tabelement_type_ddl_retenu(imail) " << tabelement_type_ddl_retenu(imail) << endl;
//fin debug
List_io <Ddl_enum_etendu>::iterator ili,ilifin = lis_sor.end();
List_io <List_io <Ddl_enum_etendu>::iterator> inter; // pour stocker les grandeurs à déplacer
// on parcours d'abord la liste venant des éléments
for (ili=lis_sor.begin();ili != ilifin;ili++)
{
//debug
//if ((*ili).Nom() == "pression_ext")
// cout << "\n debug Isovaleurs_Gmsh::Passage_grandeursDisponiblesAuxNoeuds_elementsVersNoeuds() "
// << "\n tabelement_type_ddl_retenu(imail) " << tabelement_type_ddl_retenu(imail) << endl;
//fin debug
if ((Meme_famille((*ili).Enum(),X1)) // X1 est un ddl définit aux noeuds
|| ((*ili).Nom() == "pression_ext") // cas particuliers : def au pti, mais dispo tel quel au noeud
)
{inter.push_back(ili);tabnoeud_type_ddlEtendu(imail).push_back(*ili);
// les grandeurs qui viennent des éléments sont visible par moyenne aux noeuds
a_accumuler_tabnoeud_type_ddlEtendu(imail).push_back(*ili);
};
};
// on supprime
List_io <List_io <Ddl_enum_etendu>::iterator>::iterator ik,ikfin = inter.end();
for (ik = inter.begin();ik!=ikfin;ik++)
lis_sor.erase(*ik);
tabnoeud_type_ddlEtendu_retenu(imail).sort();tabnoeud_type_ddlEtendu(imail).unique();
a_accumuler_tabnoeud_type_ddlEtendu(imail).sort();
a_accumuler_tabnoeud_type_ddlEtendu(imail).unique();
};
//.. idem pour les grandeurs évoluées ...
{List_io <TypeQuelconque>& lis_sor = tabelement_evoluee(imail); // pour simplifier
List_io <TypeQuelconque>::iterator ili,ilifin = lis_sor.end();
List_io <List_io <TypeQuelconque>::iterator> inter; // pour stocker les grandeurs à déplacer
// on parcours d'abord la liste venant des éléments
for (ili=lis_sor.begin();ili != ilifin;ili++)
if (Meme_famille((*ili).Enum(),X1)) // X1 est un ddl définit aux noeuds
{inter.push_back(ili);tabnoeud_evoluee(imail).push_back(*ili);
// les grandeurs qui viennent des éléments sont visible par moyenne aux noeuds
a_accumuler_tabnoeud_evoluee(imail).push_back(*ili);
};
// on supprime
List_io <List_io <TypeQuelconque>::iterator>::iterator ik,ikfin = inter.end();
for (ik = inter.begin();ik!=ikfin;ik++)
lis_sor.erase(*ik);
};
//.. idem pour les grandeurs particulières ...
{List_io <TypeQuelconque>& lis_sor = tabelement_typeParti(imail); // pour simplifier
List_io <TypeQuelconque>::iterator ili,ilifin = lis_sor.end();
List_io <List_io <TypeQuelconque>::iterator> inter; // pour stocker les grandeurs à déplacer
// on parcours d'abord la liste venant des éléments
for (ili=lis_sor.begin();ili != ilifin;ili++)
if (Meme_famille((*ili).Enum(),X1)) // X1 est un ddl définit aux noeuds
{inter.push_back(ili);tabnoeud_evoluee(imail).push_back(*ili);
// les grandeurs qui viennent des éléments sont visible par moyenne aux noeuds
a_accumuler_tabnoeud_evoluee(imail).push_back(*ili);
};
// on supprime
List_io <List_io <TypeQuelconque>::iterator>::iterator ik,ikfin = inter.end();
for (ik = inter.begin();ik!=ikfin;ik++)
lis_sor.erase(*ik);
};
// comme tabnoeud_evoluee est utilisé pour les éléments par les grandeurs évoluées et particulières
// on fait l'optimisation et le rangement une seule fois à la fin
tabnoeud_evoluee(imail).sort();tabnoeud_evoluee(imail).unique();
a_accumuler_tabnoeud_evoluee(imail).sort();
a_accumuler_tabnoeud_evoluee(imail).unique();
//debug
//cout << "\n debug Isovaleurs_Gmsh::Passage_grandeursDisponiblesAuxNoeuds_elementsVersNoeuds() "
// << "\n 2: tabelement_type_ddl(imail) " << tabelement_type_ddl(imail)
// << "\n 3: a_accumuler_tabnoeud_evoluee(imail) "<<a_accumuler_tabnoeud_evoluee(imail)<< endl;
//fin debug
};
};
// calcul des grandeurs aux noeuds, directement accessible des éléments
void Isovaleurs_Gmsh::CalculAuxElemAuxNoeuds(const Tableau <int>& tab_mail,LesMaillages * lesMail)
{ // .. on initialise les conteneurs ..
int nbmail = tab_mail.Taille();
int cas=1; // par défaut on cumul et on moyenne simplement
// pour utiliser la méthode InitUpdateAuNoeud, on doit construire tabQ a deux dim
List_io < TypeQuelconque > litq; // une autre pour les quelconques
Tableau <List_io < TypeQuelconque > * > tabQ(2);
tabQ(2)=&litq;
////debug
//cout << "\n debug Isovaleurs_Gmsh::CalculAuxElemAuxNoeuds(...) "
// << "\n a_accumuler_tabnoeud_evoluee_retenu(1) " << a_accumuler_tabnoeud_evoluee_retenu(1)
// << "\n a_accumuler_tabnoeud_type_ddlEtendu_retenu(1) "<<a_accumuler_tabnoeud_type_ddlEtendu_retenu(1)<< endl;
////fin debug
for (int imail=1;imail<=nbmail;imail++)
{ tabQ(1) = &a_accumuler_tabnoeud_evoluee_retenu(imail);
lesMail->InitUpdateAuNoeud(imail,a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail),tabQ,cas);
};
// accumulation aux noeuds de grandeurs venant de l'éléments vers ses noeuds (exemple la pression appliquée)
// autres que celles aux pti classiques, mais directements disponibles
for (int imail=1;imail<=nbmail;imail++)
lesMail->Accumul_aux_noeuds(imail,a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail)
,a_accumuler_tabnoeud_evoluee_retenu(imail),cas);
// calcul des moyennes en chaque noeuds)
tabQ.Change_taille(1);
for (int imail=1;imail<=nbmail;imail++)
{ tabQ(1) = &a_accumuler_tabnoeud_evoluee_retenu(imail);
lesMail->FinTransfertPtIntegAuNoeud(imail,a_accumuler_tabnoeud_type_ddlEtendu_retenu(imail),tabQ,cas);
};
};
Reference in a new issue Copy permalink