2230 lines
129 KiB
C++
2230 lines
129 KiB
C++
|
|
||
|
|
// 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);
|
||
|
|
};
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
|