3971 lines
256 KiB
C++
3971 lines
256 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 "Choix_grandeurs_maple.h"
|
||
|
|
#include "CharUtil.h"
|
||
|
|
#include "ReferenceNE.h"
|
||
|
|
#include "ReferencePtiAF.h"
|
||
|
|
#include "Enum_chargement.h"
|
||
|
|
|
||
|
|
#include <iomanip>
|
||
|
|
|
||
|
|
|
||
|
|
// entrée du choix pour les moyennes sommes etc. sur ref E
|
||
|
|
void Choix_grandeurs_maple::Entree_somme_moy_E(string& rep)
|
||
|
|
{ // cas de grandeurs aux éléments, on boucle sur les maillages
|
||
|
|
int dim = ParaGlob::Dimension();
|
||
|
|
cout << "\n --- somme, moyenne, max, min etc. sur des references d'elements et de pti ---";
|
||
|
|
// on récupère la liste des maillages à visualiser
|
||
|
|
const list <int>& list_mail = choix_mail->List_choisit();
|
||
|
|
list<int>::const_iterator ilm,ilmfin=list_mail.end();
|
||
|
|
int taille_list_maille = list_mail.size();
|
||
|
|
if (list_mail.size() == 0)
|
||
|
|
{ cout << "\n aucun maillage n'est definit ! , il faut commencer par definir les maillages pour"
|
||
|
|
<< " lesquels on veut une sortie ";
|
||
|
|
return;
|
||
|
|
};
|
||
|
|
// on balaie les différents maillages
|
||
|
|
for (ilm = list_mail.begin();ilm!=ilmfin;ilm++)
|
||
|
|
{ int n_mail = abs(*ilm); // numéro du maillage
|
||
|
|
|
||
|
|
// -- boucle sur les maillages
|
||
|
|
// affichage du nom du maillages s'il y en a plusieurs
|
||
|
|
if (taille_list_maille > 1)
|
||
|
|
cout << "\n ======>>>>> maillage : " << lesMail->NomMaillage(n_mail);
|
||
|
|
|
||
|
|
// -------------- cas des ddl principaux définis aux éléments -----------------
|
||
|
|
{cout << "\n -------- cas des ddl principaux definis aux elements ---------";
|
||
|
|
// on affiche la liste actuelle
|
||
|
|
if ((tabelement_type_ddl_retenu_pourSM(n_mail)).size())
|
||
|
|
{ cout << "\n liste actuelle des element a sortir en info: ";
|
||
|
|
List_io <int>::iterator ieint,ieintfin = tab_num_element(n_mail).end();
|
||
|
|
for (ieint=tab_num_element(n_mail).begin();ieint!=ieintfin;ieint++)
|
||
|
|
cout << *ieint << " ";
|
||
|
|
cout << "\n liste des grandeurs actuellement a sortir: ";
|
||
|
|
List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabelement_type_ddl_retenu_pourSM(n_mail)).end();
|
||
|
|
for (iet=(tabelement_type_ddl_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
|
||
|
|
cout << (*iet) << " " ;
|
||
|
|
cout << endl;
|
||
|
|
};
|
||
|
|
// on affiche les différentes grandeurs possibles
|
||
|
|
cout << "\n maillage nb : " << n_mail ;
|
||
|
|
cout << "\n la liste des grandeurs disponibles est la suivante : ";
|
||
|
|
List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabelement_type_ddl(n_mail)).end();
|
||
|
|
for (iet=(tabelement_type_ddl(n_mail)).begin();iet!=ietfin;iet++)
|
||
|
|
cout << (*iet) << " " ;
|
||
|
|
cout << "\n grandeurs que vous voulez visualiser ( rep : grandeurs?)"
|
||
|
|
<< "\n REMARQUE : il faut donner uniquement un jeux de ddl "
|
||
|
|
<< "\n def au meme point d'integration (contraintes/def "
|
||
|
|
<< "\n ou (exclusif) erreur ou ...) "
|
||
|
|
<< "\n effacer la liste actuelle (rep : ef) "
|
||
|
|
<< "\n (pour terminer tapez : fin (ou f))";
|
||
|
|
rep = "";
|
||
|
|
while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
{ cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
|
||
|
|
if (rep == "to")
|
||
|
|
// cas de toutes les grandeurs
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = tabelement_type_ddl(n_mail).end();
|
||
|
|
for (ite = tabelement_type_ddl(n_mail).begin();ite != itefin; ite++)
|
||
|
|
tabelement_type_ddl_retenu_pourSM(n_mail).push_back(*ite);
|
||
|
|
}
|
||
|
|
else if (Ddl_enum_etendu::VerifExistence(rep))
|
||
|
|
// on vérifie que cette grandeur existe
|
||
|
|
// enregistrement
|
||
|
|
{ Ddl_enum_etendu a = Ddl_enum_etendu::RecupDdl_enum_etendu(rep);
|
||
|
|
(tabelement_type_ddl_retenu_pourSM(n_mail)).push_back(a);
|
||
|
|
(tabelement_type_ddl_retenu_pourSM(n_mail)).unique(); // supprime le doublon si nécessaire
|
||
|
|
}
|
||
|
|
else if (rep == "ef")
|
||
|
|
{ // on efface la liste
|
||
|
|
(tabelement_type_ddl_retenu_pourSM(n_mail)).clear();
|
||
|
|
}
|
||
|
|
else if (((Minuscules(rep) == "fin") || (Minuscules(rep) == "f"))
|
||
|
|
&& ( (tabelement_type_ddl_retenu_pourSM(n_mail)).size()==0))
|
||
|
|
{ rep = "-"; cout << " \n *** ERREUR: vous devez definir au moins une grandeur a visualiser !!";}
|
||
|
|
else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
cout << " erreur de syntaxe dans le ddl! recommencez ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// -------------- cas des grandeurs particulières définis aux éléments -----------------
|
||
|
|
// def d'une liste de travail, pour vérifier que tous les grandeurs particuliers sont relatives
|
||
|
|
// à un même point d'intégration
|
||
|
|
List_io < Ddl_enum_etendu > li_ddl_particulieres;
|
||
|
|
{cout << "\n -------- cas des grandeurs particulières definies aux elements ---------";
|
||
|
|
// dans le cas où aucune grandeur particulière sont défini on passe
|
||
|
|
if ( (tabelement_typeParti(n_mail)).size() == 0)
|
||
|
|
{ cout << "\n aucune grandeur particuliere n'est definit, donc aucune proposition ";}
|
||
|
|
else
|
||
|
|
{ // on affiche la liste actuelle
|
||
|
|
if ((tabelement_typeParti_retenu_pourSM(n_mail)).size())
|
||
|
|
{ cout << "\n liste actuelle des element a sortir en info: ";
|
||
|
|
List_io <int>::iterator ieint,ieintfin = tab_num_element(n_mail).end();
|
||
|
|
for (ieint=tab_num_element(n_mail).begin();ieint!=ieintfin;ieint++)
|
||
|
|
cout << (*ieint) << " ";
|
||
|
|
cout << "\n liste des grandeurs particulieres actuellement a sortir: ";
|
||
|
|
List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_typeParti_retenu_pourSM(n_mail)).end();
|
||
|
|
for (iet=(tabelement_typeParti_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
|
||
|
|
cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
|
||
|
|
cout << endl;
|
||
|
|
};
|
||
|
|
// on affiche les différentes grandeurs possibles
|
||
|
|
cout << "\n maillage nb : " << n_mail ;
|
||
|
|
cout << "\n la liste des grandeurs particulieres disponibles est la suivante : ";
|
||
|
|
List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_typeParti(n_mail)).end();
|
||
|
|
for (iet=(tabelement_typeParti(n_mail)).begin();iet!=ietfin;iet++)
|
||
|
|
cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
|
||
|
|
cout << "\n";
|
||
|
|
cout << "\n grandeurs que vous voulez visualiser ( rep : grandeurs?)"
|
||
|
|
<< "\n REMARQUE : il faut donner uniquement un jeu de grandeurs "
|
||
|
|
<< "\n definies au meme point d'integration "
|
||
|
|
<< "\n effacer la liste actuelle (rep : ef) "
|
||
|
|
<< "\n toutes les grandeurs : (rep : to) "
|
||
|
|
<< "\n (pour terminer tapez : fin (ou f))";
|
||
|
|
rep = "";
|
||
|
|
while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
{ cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
|
||
|
|
if (rep == "to")
|
||
|
|
// cas de toutes les grandeurs
|
||
|
|
{List_io<TypeQuelconque>& tpg_ret = (tabelement_typeParti_retenu_pourSM(n_mail)); // pour simplifier
|
||
|
|
List_io<TypeQuelconque>& tpg = (tabelement_typeParti(n_mail)); // pour simplifier
|
||
|
|
List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
|
||
|
|
for (ite = tabelement_typeParti(n_mail).begin();ite != itefin; ite++)
|
||
|
|
if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
|
||
|
|
{ tpg_ret.push_back(*ite);
|
||
|
|
// on enregistre également le ddl associé qui définit le point d'integ où est calculé la grandeur
|
||
|
|
// particulière
|
||
|
|
li_ddl_particulieres.push_back(Ddl_enum_etendu((*ite).Enum()));
|
||
|
|
};
|
||
|
|
}
|
||
|
|
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_pourSM(n_mail)); // pour simplifier
|
||
|
|
List_io<TypeQuelconque>& tpg = (tabelement_typeParti(n_mail)); // 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);
|
||
|
|
// on enregistre également le ddl associé qui définit le point d'integ où est calculé la grandeur
|
||
|
|
// particulière
|
||
|
|
li_ddl_particulieres.push_back(Ddl_enum_etendu((*il).Enum()));
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ cout << "\n erreur, grandeur non disponible !, recommencez ";};
|
||
|
|
}
|
||
|
|
else if (rep == "ef")
|
||
|
|
{ // on efface la liste
|
||
|
|
(tabelement_typeParti_retenu_pourSM(n_mail)).clear();
|
||
|
|
}
|
||
|
|
else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
cout << " erreur de syntaxe recommencez ";
|
||
|
|
};
|
||
|
|
}; //-- fin du choix sur le fait qu'il existe ou non des grandeurs particulières pour le maillage
|
||
|
|
};
|
||
|
|
// -------------- cas des grandeurs évoluées définis aux éléments -----------------
|
||
|
|
// def d'une liste de travail, pour vérifier que tous les grandeurs évoluées sont relatives
|
||
|
|
// à un même point d'intégration
|
||
|
|
List_io < Ddl_enum_etendu > li_ddl_evoluees;
|
||
|
|
{cout << "\n -------- cas des grandeurs évoluees definies aux elements ---------";
|
||
|
|
// dans le cas où aucune grandeur particulière sont défini on passe
|
||
|
|
if ( (tabelement_evoluee(n_mail)).size() == 0)
|
||
|
|
{ cout << "\n aucune grandeur tensorielle n'est definit, donc aucune proposition ";}
|
||
|
|
else
|
||
|
|
{ // on affiche la liste actuelle
|
||
|
|
if ((tabelement_evoluee_retenu_pourSM(n_mail)).size())
|
||
|
|
{ cout << "\n liste actuelle des element a sortir en info: ";
|
||
|
|
List_io <int>::iterator ieint,ieintfin = tab_num_element(n_mail).end();
|
||
|
|
for (ieint=tab_num_element(n_mail).begin();ieint!=ieintfin;ieint++)
|
||
|
|
cout << (*ieint) << " ";
|
||
|
|
cout << "\n liste des grandeurs tensorielles actuellement a sortir: (attention: peuvent ne pas etre definies) ";
|
||
|
|
List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_evoluee_retenu_pourSM(n_mail)).end();
|
||
|
|
for (iet=(tabelement_evoluee_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
|
||
|
|
cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
|
||
|
|
cout << endl;
|
||
|
|
};
|
||
|
|
// on affiche les différentes grandeurs possibles
|
||
|
|
cout << "\n maillage nb : " << n_mail ;
|
||
|
|
cout << "\n la liste des grandeurs tensorielles disponibles est la suivante : (attention: peuvent ne pas etre definies)";
|
||
|
|
List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_evoluee(n_mail)).end();
|
||
|
|
for (iet=(tabelement_evoluee(n_mail)).begin();iet!=ietfin;iet++)
|
||
|
|
cout << "\n" << ((*iet).EnuTypeQuelconque().NomPlein()) ;
|
||
|
|
cout << "\n";
|
||
|
|
cout << "\n grandeurs que vous voulez visualiser ( rep : grandeurs?)"
|
||
|
|
<< "\n REMARQUE : il faut donner uniquement un jeu de grandeurs "
|
||
|
|
<< "\n defini au meme point d'integration "
|
||
|
|
<< "\n effacer la liste actuelle (rep : ef) "
|
||
|
|
<< "\n toutes les grandeurs : (rep : to) "
|
||
|
|
<< "\n (pour terminer tapez : fin (ou f))";
|
||
|
|
rep = "";
|
||
|
|
while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
{ cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
|
||
|
|
if (rep == "to")
|
||
|
|
// cas de toutes les grandeurs
|
||
|
|
{List_io<TypeQuelconque>& tpg_ret = (tabelement_evoluee_retenu_pourSM(n_mail)); // pour simplifier
|
||
|
|
List_io<TypeQuelconque>& tpg = (tabelement_evoluee(n_mail)); // pour simplifier
|
||
|
|
List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
|
||
|
|
for (ite = tabelement_evoluee(n_mail).begin();ite != itefin; ite++)
|
||
|
|
if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
|
||
|
|
{ tpg_ret.push_back(*ite);
|
||
|
|
// on enregistre également le ddl associé qui définit le point d'integ où est calculé la grandeur
|
||
|
|
// évoluées
|
||
|
|
li_ddl_particulieres.push_back(Ddl_enum_etendu((*ite).Enum()));
|
||
|
|
};
|
||
|
|
}
|
||
|
|
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_pourSM(n_mail)); // pour simplifier
|
||
|
|
List_io<TypeQuelconque>& tpg = (tabelement_evoluee(n_mail)); // 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);
|
||
|
|
// on enregistre également le ddl associé qui définit le point d'integ où est calculé la grandeur
|
||
|
|
// évoluées
|
||
|
|
li_ddl_particulieres.push_back(Ddl_enum_etendu((*il).Enum()));
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ cout << "\n erreur, grandeur non disponible !, recommencez ";};
|
||
|
|
}
|
||
|
|
else if (rep == "ef")
|
||
|
|
{ // on efface la liste
|
||
|
|
(tabelement_evoluee_retenu_pourSM(n_mail)).clear();
|
||
|
|
}
|
||
|
|
else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
cout << " erreur de syntaxe recommencez ";
|
||
|
|
};
|
||
|
|
}; //-- fin du choix sur le fait qu'il existe ou non des grandeurs évoluées pour le maillage
|
||
|
|
};
|
||
|
|
// -------------- on s'occupe maintenant des références associées -----------------
|
||
|
|
{cout << "\n -------- definition des references d'elements ---------";
|
||
|
|
// cas des références d'éléments
|
||
|
|
if ((tab_nomDeRef_E_SM(n_mail)).size() != 0)
|
||
|
|
{ cout << "\n liste actuelle de reference d'elements: (ref et num integ) ";
|
||
|
|
List_io <BlocScal >::iterator ieint1,ieintfin1 = (tab_nomDeRef_E_SM(n_mail)).end();
|
||
|
|
for (ieint1=(tab_nomDeRef_E_SM(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
|
||
|
|
cout << (*ieint1).NomRef() << " "<< (int) ((*ieint1).Val()) << " ";
|
||
|
|
cout << endl;
|
||
|
|
};
|
||
|
|
// cas des références de point d'intégration d'éléments
|
||
|
|
if ((tab_nomDeRef_ptinteg_SM(n_mail)).size() != 0)
|
||
|
|
{ cout << "\n liste actuelle de reference de pt d'integration d'elements: (ref) ";
|
||
|
|
List_io <string >::iterator ieint1,ieintfin1 = (tab_nomDeRef_ptinteg_SM(n_mail)).end();
|
||
|
|
for (ieint1=(tab_nomDeRef_ptinteg_SM(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
|
||
|
|
cout << (*ieint1) << " ";
|
||
|
|
cout << endl;
|
||
|
|
};
|
||
|
|
cout << "\n choix d'une reference de liste d'element (avec 1 ou tous les pti) -> (choix : refE)"
|
||
|
|
<< "\n (dans ce dernier cas il faut que tous les elements soient de meme type) "
|
||
|
|
<< "\n choix d'une reference de liste de point d'integration d'element -> (choix : refpti)"
|
||
|
|
<< "\n donnez le type de choix puis les infos correspondantes "
|
||
|
|
<< "\n choix de tous les ref d'elements -> (choix : torefE)"
|
||
|
|
<< "\n choix de tous les ref de pti -> (choix : torefpti)"
|
||
|
|
<< "\n effacer la liste actuelle des references d'elements -> (rep : efref) "
|
||
|
|
<< "\n afficher la liste des references d'elements existants -> (rep : affref) "
|
||
|
|
<< "\n effacer la liste actuelle des references de pt integ d'element -> (rep : efrefpti) "
|
||
|
|
<< "\n afficher la liste des references de pt integ d'elements existants -> (rep : affrefpti) "
|
||
|
|
<< "\n (tapez fin pour finir(ou f))";
|
||
|
|
string rep = "";
|
||
|
|
// -- début boucle choix position sur element
|
||
|
|
while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
{ cout << "\n choix ? ";rep = lect_return_defaut(false,"f");
|
||
|
|
if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f")) break;
|
||
|
|
// def du conteneur des numéros que l'on cherche
|
||
|
|
// comme on peut en définir plusieurs d'un coup (par exemple tous les pti d'un élément) on utilise une liste
|
||
|
|
list <Maillage::NBelemEtptInteg> list_nut; // à chaque passage elle est initialisée et donc vide au début
|
||
|
|
Maillage::NBelemEtptInteg nut; // idem, initialisé à chaque passage
|
||
|
|
if (rep == "refE")
|
||
|
|
{ string nom_ref;
|
||
|
|
cout << "\n nom de la reference ? ";
|
||
|
|
nom_ref= lect_chaine();
|
||
|
|
// vérif que la référence existe
|
||
|
|
if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 2))
|
||
|
|
{ cout << "\n erreur de nom (** "<< nom_ref << " **) donne ne correspond pas a une reference d'element correcte ";}
|
||
|
|
else
|
||
|
|
{ // choix du point d'intégration, ici on ne va pas utiliser la liste list_nut, mais une liste particulière
|
||
|
|
string repo;
|
||
|
|
cout << " numero d'un point d'integration ou: -1 pour tous les pti ? ";
|
||
|
|
repo= lect_chaine(); nut.nbPtInteg = ChangeEntier(repo);
|
||
|
|
if (nut.nbPtInteg != -1) // cas d'un seul pti
|
||
|
|
{// on vérifie que ce point d'intégration est valide pour tous les éléments de la référence
|
||
|
|
bool veriflocal = true;
|
||
|
|
List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_E_SM(n_mail).end();
|
||
|
|
|
||
|
|
// --- cas des ddl principaux
|
||
|
|
{List_io < Ddl_enum_etendu >& li_ddl = tabelement_type_ddl_retenu_pourSM(n_mail);
|
||
|
|
List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.Numero(ielem);
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
// --- cas des types particuliers aux éléments
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_particulieres.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl_particulieres.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.Numero(ielem);
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
// --- cas des types évolués aux éléments
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_evoluees.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl_evoluees.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.Numero(ielem);
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
// --- on enregistre si la vérification a été ok
|
||
|
|
if (veriflocal)
|
||
|
|
{ tab_nomDeRef_E_SM(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
|
||
|
|
tab_nomDeRef_E_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_E_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else // cas de tous les pti
|
||
|
|
{ // il faut d'abord que l'on vérifie que tous les pti pour tous les éléments sont valides
|
||
|
|
// .. on commence par tester si un premier élément existe vraiment et si oui, on récupère le nb de pti associé
|
||
|
|
bool veriflocal = true;
|
||
|
|
int nbpti = 0; // init
|
||
|
|
{ // on encapsule pour pas de redondance de nom
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
if (taillen < 1) {veriflocal = false;} // cas d'une ref vide, on ne peut pas aller plus loin
|
||
|
|
else
|
||
|
|
{nut.nbElem = reff.Numero(1);
|
||
|
|
if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
|
||
|
|
{if (nut.nbElem < 0)
|
||
|
|
{ cout << "\n le numero d'element doit etre superieur a 0 !!!";};
|
||
|
|
if (nut.nbElem > lesMail->Nombre_element(n_mail))
|
||
|
|
{ cout << "\n chois non valide, le numero d'element doit etre inferieur ou egal "
|
||
|
|
<< " au nombre total d'element du maillage !!!";
|
||
|
|
};
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else // sinon c'est ok, on continue au niveau des pti
|
||
|
|
{Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
|
||
|
|
|
||
|
|
List_io < Ddl_enum_etendu >& li_ddl = tabelement_type_ddl_retenu_pourSM(n_mail);
|
||
|
|
List_io<Ddl_enum_etendu>::iterator ite = li_ddl.end(); //une initialisation
|
||
|
|
// on cherche un élément valide
|
||
|
|
if (!(li_ddl.empty()))
|
||
|
|
{ ite = li_ddl.begin();} // la liste n'est pas vide, on prend le premier élément
|
||
|
|
else if (!(li_ddl_particulieres.empty()))
|
||
|
|
{ ite = li_ddl_particulieres.begin();}
|
||
|
|
else if (!(li_ddl_evoluees.empty()))
|
||
|
|
{ ite = li_ddl_evoluees.begin();}
|
||
|
|
else // toutes les listes sont vides on ne peut pas aller plus loin
|
||
|
|
{veriflocal = false;};
|
||
|
|
// si c'est ok:
|
||
|
|
if (veriflocal)
|
||
|
|
{nbpti = ele.NbPtInteg((*ite).Enum());};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// .. puis on balaie l'ensemble des éléments et l'ensemble des pti
|
||
|
|
if (veriflocal)
|
||
|
|
{List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_E_SM(n_mail).end();
|
||
|
|
|
||
|
|
// --- cas des ddl principaux
|
||
|
|
{List_io < Ddl_enum_etendu >& li_ddl = tabelement_type_ddl_retenu_pourSM(n_mail);
|
||
|
|
List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.Numero(ielem);
|
||
|
|
for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
break;
|
||
|
|
};
|
||
|
|
if (!veriflocal) break;
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
if (!veriflocal) break;
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
// --- cas des types particuliers aux éléments
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_particulieres.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl_particulieres.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.Numero(ielem);
|
||
|
|
for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
break;
|
||
|
|
};
|
||
|
|
if (!veriflocal) break;
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
if (!veriflocal) break;
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
// --- cas des types évolués aux éléments
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_evoluees.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl_evoluees.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.Numero(ielem);
|
||
|
|
for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
break;
|
||
|
|
};
|
||
|
|
if (!veriflocal) break;
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
if (!veriflocal) break;
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// arrivée ici, si tout est ok on enregistre
|
||
|
|
if (veriflocal)
|
||
|
|
// for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
|
||
|
|
// { tab_nomDeRef_E_SM(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
|
||
|
|
// tab_nomDeRef_E_SM(n_mail).sort(); // on ordonne
|
||
|
|
// tab_nomDeRef_E_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
// };
|
||
|
|
{ nut.nbPtInteg = -1;
|
||
|
|
tab_nomDeRef_E_SM(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
|
||
|
|
tab_nomDeRef_E_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_E_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}; // fin du choix du point d'intégration et de l'enregistrement
|
||
|
|
}
|
||
|
|
else if (rep == "refpti")
|
||
|
|
{ string nom_ref;
|
||
|
|
cout << "\n nom de la reference ? ";nom_ref= lect_chaine();
|
||
|
|
// vérif que la référence existe
|
||
|
|
if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 6))
|
||
|
|
{ cout << "\n erreur de nom (** "<< nom_ref << " **) donne ne correspond pas a une reference de point d'integration "
|
||
|
|
<< " d'element correcte ";}
|
||
|
|
else
|
||
|
|
{ // on vérifie que le choix est valide
|
||
|
|
bool veriflocal = true;
|
||
|
|
|
||
|
|
// --- cas des ddl principaux
|
||
|
|
{List_io < Ddl_enum_etendu >& li_ddl = tabelement_type_ddl_retenu_pourSM(n_mail);
|
||
|
|
List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbPtInteg = reff.NumeroFA(ielem);
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
// --- cas des types particuliers aux éléments
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_particulieres.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl_particulieres.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbPtInteg = reff.NumeroFA(ielem);
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
// --- cas des types évolués aux éléments
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_evoluees.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl_evoluees.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbPtInteg = reff.NumeroFA(ielem);
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
|
||
|
|
// on enregistre si la vérification a été ok
|
||
|
|
if (veriflocal)
|
||
|
|
{ tab_nomDeRef_ptinteg_SM(n_mail).push_back(nom_ref);
|
||
|
|
tab_nomDeRef_ptinteg_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_ptinteg_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
}; // fin de la vérification
|
||
|
|
}
|
||
|
|
else if (rep == "torefE")
|
||
|
|
{ // on va balayer tous les références
|
||
|
|
const Reference* refi = lesRef->Init_et_Premiere();
|
||
|
|
list <string> inter;
|
||
|
|
while (refi != NULL)
|
||
|
|
{ if (refi->Indic() == 2)
|
||
|
|
inter.push_back(refi->Nom());
|
||
|
|
refi = lesRef->Reference_suivante();
|
||
|
|
};
|
||
|
|
// maintenant on va indiquer les pti
|
||
|
|
// choix du point d'intégration, ici on ne va pas utiliser la liste list_nut, mais une liste particulière
|
||
|
|
string repo;
|
||
|
|
cout << " numero d'un point d'integration ou: -1 pour tous les pti ? ";
|
||
|
|
repo= lect_chaine(); nut.nbPtInteg = ChangeEntier(repo);
|
||
|
|
list <string>::iterator il,ilfin=inter.end();
|
||
|
|
if (nut.nbPtInteg != -1) // cas d'un seul pti
|
||
|
|
{ bool veriflocal = true;
|
||
|
|
for (il = inter.begin();il != ilfin; il++)
|
||
|
|
{// on vérifie que ce point d'intégration est valide pour tous les éléments de la référence
|
||
|
|
// --- cas des ddl principaux
|
||
|
|
{List_io < Ddl_enum_etendu >& li_ddl = tabelement_type_ddl_retenu_pourSM(n_mail);
|
||
|
|
List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference
|
||
|
|
const Reference& refi = lesRef->Trouve((*il),n_mail);
|
||
|
|
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.Numero(ielem);
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
// --- cas des types particuliers aux éléments
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_particulieres.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl_particulieres.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve((*il),n_mail);
|
||
|
|
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.Numero(ielem);
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
// --- cas des types évolués aux éléments
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_evoluees.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl_evoluees.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve((*il),n_mail);
|
||
|
|
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.Numero(ielem);
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// --- on enregistre si la vérification a été ok
|
||
|
|
if (veriflocal)
|
||
|
|
for (il = inter.begin();il != ilfin; il++)
|
||
|
|
{ tab_nomDeRef_E_SM(n_mail).push_back(BlocScal((*il),nut.nbPtInteg));
|
||
|
|
tab_nomDeRef_E_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_E_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else // cas de tous les pti
|
||
|
|
{ bool veriflocal = true;
|
||
|
|
for (il = inter.begin();il != ilfin; il++)
|
||
|
|
{ // il faut d'abord que l'on vérifie que tous les pti pour tous les éléments sont valides
|
||
|
|
// .. on commence par tester si un premier élément existe vraiment et si oui, on récupère le nb de pti associé
|
||
|
|
int nbpti = 0; // init
|
||
|
|
{ // on encapsule pour pas de redondance de nom
|
||
|
|
const Reference& refi = lesRef->Trouve((*il),n_mail);
|
||
|
|
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
if (taillen < 1) {veriflocal = false;} // cas d'une ref vide, on ne peut pas aller plus loin
|
||
|
|
else
|
||
|
|
{nut.nbElem = reff.Numero(1);
|
||
|
|
if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
|
||
|
|
{if (nut.nbElem < 0)
|
||
|
|
{ cout << "\n le numero d'element doit etre superieur a 0 !!!";};
|
||
|
|
if (nut.nbElem > lesMail->Nombre_element(n_mail))
|
||
|
|
{ cout << "\n chois non valide, le numero d'element doit etre inferieur ou egal "
|
||
|
|
<< " au nombre total d'element du maillage !!!";
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else // sinon c'est ok, on continue au niveau des pti
|
||
|
|
{Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
|
||
|
|
|
||
|
|
List_io < Ddl_enum_etendu >& li_ddl = tabelement_type_ddl_retenu_pourSM(n_mail);
|
||
|
|
List_io<Ddl_enum_etendu>::iterator ite = li_ddl.end(); //une initialisation
|
||
|
|
// on cherche un élément valide
|
||
|
|
if (!(li_ddl.empty()))
|
||
|
|
{ ite = li_ddl.begin();} // la liste n'est pas vide, on prend le premier élément
|
||
|
|
else if (!(li_ddl_particulieres.empty()))
|
||
|
|
{ ite = li_ddl_particulieres.begin();}
|
||
|
|
else if (!(li_ddl_evoluees.empty()))
|
||
|
|
{ ite = li_ddl_evoluees.begin();}
|
||
|
|
else // toutes les listes sont vides on ne peut pas aller plus loin
|
||
|
|
{veriflocal = false;};
|
||
|
|
// si c'est ok:
|
||
|
|
if (veriflocal)
|
||
|
|
{nbpti = ele.NbPtInteg((*ite).Enum());};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// .. puis on balaie l'ensemble des éléments et l'ensemble des pti
|
||
|
|
if (veriflocal)
|
||
|
|
{// --- cas des ddl principaux
|
||
|
|
{List_io < Ddl_enum_etendu >& li_ddl = tabelement_type_ddl_retenu_pourSM(n_mail);
|
||
|
|
List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve((*il),n_mail);
|
||
|
|
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.Numero(ielem);
|
||
|
|
for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
break;
|
||
|
|
};
|
||
|
|
if (!veriflocal) break;
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
if (!veriflocal) break;
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
// --- cas des types particuliers aux éléments
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_particulieres.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl_particulieres.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve((*il),n_mail);
|
||
|
|
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.Numero(ielem);
|
||
|
|
for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
break;
|
||
|
|
};
|
||
|
|
if (!veriflocal) break;
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
if (!veriflocal) break;
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
// --- cas des types évolués aux éléments
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_evoluees.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl_evoluees.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve((*il),n_mail);
|
||
|
|
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.Numero(ielem);
|
||
|
|
for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
break;
|
||
|
|
};
|
||
|
|
if (!veriflocal) break;
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
if (!veriflocal) break;
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// arrivée ici, si tout est ok on enregistre
|
||
|
|
if (veriflocal)
|
||
|
|
for (il = inter.begin();il != ilfin; il++)
|
||
|
|
{ nut.nbPtInteg = -1;
|
||
|
|
tab_nomDeRef_E_SM(n_mail).push_back(BlocScal((*il),nut.nbPtInteg));
|
||
|
|
tab_nomDeRef_E_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_E_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else if (rep == "torefpti")
|
||
|
|
{ // on va balayer tous les références
|
||
|
|
const Reference* refi = lesRef->Init_et_Premiere();
|
||
|
|
while (refi != NULL)
|
||
|
|
{ if (refi->Indic() == 6)
|
||
|
|
{ // on vérifie que le choix est valide
|
||
|
|
bool veriflocal = true;
|
||
|
|
|
||
|
|
// --- cas des ddl principaux
|
||
|
|
{List_io < Ddl_enum_etendu >& li_ddl = tabelement_type_ddl_retenu_pourSM(n_mail);
|
||
|
|
List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbPtInteg = reff.NumeroFA(ielem);
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
// --- cas des types particuliers aux éléments
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_particulieres.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl_particulieres.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbPtInteg = reff.NumeroFA(ielem);
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
// --- cas des types évolués aux éléments
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl_evoluees.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_ddl_evoluees.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbPtInteg = reff.NumeroFA(ielem);
|
||
|
|
// vérification de l'adéquation numéro de point d'intégration et énumération et élément
|
||
|
|
if (!(lesMail->Element_LesMaille(n_mail,nut.nbElem).Existe_pt_integ(nut.nbPtInteg,(*ite).Enum())))
|
||
|
|
{ cout << "\n le numero " << nut.nbPtInteg << " de numero d'ordre "
|
||
|
|
<< " pour le ddl " << Nom_ddl((*ite).Enum()) << " n'est pas valide pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
|
||
|
|
// on enregistre si la vérification a été ok
|
||
|
|
if (veriflocal)
|
||
|
|
{ tab_nomDeRef_ptinteg_SM(n_mail).push_back(refi->Nom());
|
||
|
|
tab_nomDeRef_ptinteg_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_ptinteg_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
}; // fin de la vérification
|
||
|
|
refi = lesRef->Reference_suivante();
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else if (rep == "efref")
|
||
|
|
{ // on efface la liste des références d'éléments et la liste de pt d'integ associée
|
||
|
|
(tab_nomDeRef_E_SM(n_mail)).clear();
|
||
|
|
}
|
||
|
|
else if (rep == "affref")
|
||
|
|
{ // affichage de la liste des références d'éléments enregistrées dans les maillages
|
||
|
|
cout << "\n liste des references d'elements ";
|
||
|
|
if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
|
||
|
|
const Reference* reff =NULL; bool prempass = true;
|
||
|
|
do {
|
||
|
|
if (prempass)
|
||
|
|
{ reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
|
||
|
|
else
|
||
|
|
{ reff = lesRef->Reference_suivante();} // récup de la ref courante
|
||
|
|
// sortie de la ref si c'est le bon maillage, et si c'est une ref d'élément
|
||
|
|
if (reff != NULL)
|
||
|
|
if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 2)) cout << reff->Nom() << " ";
|
||
|
|
prempass = false;
|
||
|
|
} while (reff != NULL);
|
||
|
|
}
|
||
|
|
else if (rep == "efrefpti")
|
||
|
|
{ // on efface la liste des références de pt d'integ d'éléments
|
||
|
|
(tab_nomDeRef_ptinteg_SM(n_mail)).clear();
|
||
|
|
}
|
||
|
|
else if (rep == "affrefpti")
|
||
|
|
{ // affichage de la liste des références de pti enregistrées dans les maillages
|
||
|
|
cout << "\n liste des references de pt integ d'elements ";
|
||
|
|
if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
|
||
|
|
const Reference* reff =NULL; bool prempass = true;
|
||
|
|
do {
|
||
|
|
if (prempass)
|
||
|
|
{ reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
|
||
|
|
else
|
||
|
|
{ reff = lesRef->Reference_suivante();} // récup de la ref courante
|
||
|
|
// sortie de la ref si c'est le bon maillage, et si c'est une ref d'élément
|
||
|
|
if (reff != NULL)
|
||
|
|
if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 6)) cout << reff->Nom() << " ";
|
||
|
|
prempass = false;
|
||
|
|
} while (reff != NULL);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ cout << "\n reponse non valide, recommencez " << endl;
|
||
|
|
};
|
||
|
|
}; // -- fin boucle choix
|
||
|
|
};
|
||
|
|
|
||
|
|
}; //-- fin de la boucle sur les maillages
|
||
|
|
};
|
||
|
|
// entrée du choix pour les moyennes sommes etc. sur ref de face d'E
|
||
|
|
void Choix_grandeurs_maple::Entree_somme_moy_F_E(string& rep)
|
||
|
|
{ // cas de grandeurs aux faces d'éléments, on boucle sur les maillages
|
||
|
|
int dim = ParaGlob::Dimension();
|
||
|
|
cout << "\n --- somme, moyenne, max, min etc. sur des references de faces d'element et de pti ---";
|
||
|
|
// on récupère la liste des maillages à visualiser
|
||
|
|
const list <int>& list_mail = choix_mail->List_choisit();
|
||
|
|
list<int>::const_iterator ilm,ilmfin=list_mail.end();
|
||
|
|
int taille_list_maille = list_mail.size();
|
||
|
|
if (list_mail.size() == 0)
|
||
|
|
{ cout << "\n aucun maillage n'est definit ! , il faut commencer par definir les maillages pour"
|
||
|
|
<< " lesquels on veut une sortie ";
|
||
|
|
return;
|
||
|
|
};
|
||
|
|
// on balaie les différents maillages
|
||
|
|
for (ilm = list_mail.begin();ilm!=ilmfin;ilm++)
|
||
|
|
{ int n_mail = abs(*ilm); // numéro du maillage
|
||
|
|
|
||
|
|
// -- boucle sur les maillages
|
||
|
|
// affichage du nom du maillages s'il y en a plusieurs
|
||
|
|
if (taille_list_maille > 1)
|
||
|
|
cout << "\n ======>>>>> maillage : " << lesMail->NomMaillage(n_mail);
|
||
|
|
|
||
|
|
// -------------- choix des grandeurs quelconques définis aux faces d'éléments -----------------
|
||
|
|
// def de la liste de travail qui contient les grandeurs à visualiser,
|
||
|
|
// sert également pour vérifier que tous les grandeurs quelconques sont relatives
|
||
|
|
// à un même point d'intégration
|
||
|
|
List_io < EnumTypeQuelconque > li_enu_quelconque;
|
||
|
|
{cout << "\n -------- cas des grandeurs quelconques definies aux faces d'elements ---------";
|
||
|
|
// dans le cas où aucune grandeur particulière sont défini on passe
|
||
|
|
if ( (tab_F_element_TypeQuelconque(n_mail)).size() == 0)
|
||
|
|
{ cout << "\n aucune grandeur particuliere n'est definit, donc aucune proposition ";}
|
||
|
|
else
|
||
|
|
{ // on affiche la liste actuelle
|
||
|
|
if ((tab_F_element_TypeQuelconque_retenu_pourSM(n_mail)).size())
|
||
|
|
{ cout << "\n liste actuelle des faces element a sortir en info: < (num_ele, num_face) > ";
|
||
|
|
List_io <int>::iterator ieint,ieintfin = tab_num_F_element(n_mail).end();
|
||
|
|
List_io <int>::iterator ifint = tab_num_F(n_mail).begin();
|
||
|
|
for (ieint=tab_num_F_element(n_mail).begin();ieint!=ieintfin;ieint++,ifint++)
|
||
|
|
cout << " (" << (*ieint) << ", "<<(*ifint)<<") ";
|
||
|
|
cout << "\n liste des grandeurs quelconques actuellement a sortir: ";
|
||
|
|
List_io < TypeQuelconque >::iterator iet,ietfin = (tab_F_element_TypeQuelconque_retenu_pourSM(n_mail)).end();
|
||
|
|
for (iet=(tab_F_element_TypeQuelconque_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
|
||
|
|
cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
|
||
|
|
cout << endl;
|
||
|
|
};
|
||
|
|
// on affiche les différentes grandeurs possibles
|
||
|
|
cout << "\n maillage nb : " << n_mail ;
|
||
|
|
cout << "\n la liste des grandeurs disponibles est la suivante : ";
|
||
|
|
List_io < TypeQuelconque >::iterator iet,ietfin = (tab_F_element_TypeQuelconque(n_mail)).end();
|
||
|
|
for (iet=(tab_F_element_TypeQuelconque(n_mail)).begin();iet!=ietfin;iet++)
|
||
|
|
cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
|
||
|
|
cout << "\n";
|
||
|
|
cout << "\n grandeurs que vous voulez visualiser ( rep : grandeurs?)"
|
||
|
|
<< "\n REMARQUE : il faut donner uniquement un jeu de grandeurs "
|
||
|
|
<< "\n definies au meme point d'integration "
|
||
|
|
<< "\n effacer la liste actuelle (rep : ef) "
|
||
|
|
<< "\n toutes les grandeurs : (rep : to) "
|
||
|
|
<< "\n (pour terminer tapez : fin (ou f))";
|
||
|
|
rep = "";
|
||
|
|
while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
{ cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
|
||
|
|
if (rep == "to")
|
||
|
|
// cas de toutes les grandeurs
|
||
|
|
{List_io<TypeQuelconque>& tpg_ret = (tab_F_element_TypeQuelconque_retenu_pourSM(n_mail)); // pour simplifier
|
||
|
|
List_io<TypeQuelconque>& tpg = (tab_F_element_TypeQuelconque(n_mail)); // pour simplifier
|
||
|
|
List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
|
||
|
|
for (ite = tab_F_element_TypeQuelconque(n_mail).begin();ite != itefin; ite++)
|
||
|
|
if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
|
||
|
|
{ tpg_ret.push_back(*ite);
|
||
|
|
// on enregistre également le EnumTypeQuelconque associé qui définit le point d'integ où est calculé la grandeur
|
||
|
|
li_enu_quelconque.push_back((*ite).EnuTypeQuelconque().EnumTQ());
|
||
|
|
};
|
||
|
|
}
|
||
|
|
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 = (tab_F_element_TypeQuelconque_retenu_pourSM(n_mail)); // pour simplifier
|
||
|
|
List_io<TypeQuelconque>& tpg = (tab_F_element_TypeQuelconque(n_mail)); // 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);
|
||
|
|
// on enregistre également le enum quelconque associé qui définit le point d'integ où est calculé la grandeur
|
||
|
|
// particulière
|
||
|
|
li_enu_quelconque.push_back((*il).EnuTypeQuelconque().EnumTQ());
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ cout << "\n erreur, grandeur non disponible !, recommencez ";};
|
||
|
|
}
|
||
|
|
else if (rep == "ef")
|
||
|
|
{ // on efface la liste
|
||
|
|
(tab_F_element_TypeQuelconque_retenu_pourSM(n_mail)).clear();
|
||
|
|
}
|
||
|
|
else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
cout << " erreur de syntaxe recommencez ";
|
||
|
|
};
|
||
|
|
}; //-- fin du choix sur le fait qu'il existe ou non des grandeurs quelconques
|
||
|
|
};
|
||
|
|
// -------------- on s'occupe maintenant des références associées pour le calcul des sommes moy... -----------------
|
||
|
|
{cout << "\n -------- definition des references de faces d'elements ---------";
|
||
|
|
// cas des références de faces d'élément
|
||
|
|
if ((tab_nomDeRef_F_E_SM(n_mail)).size() != 0)
|
||
|
|
{ cout << "\n liste actuelle de reference de faces d'elements : (nom refFE et num integ) ";
|
||
|
|
List_io <BlocScal >::iterator ieint1,ieintfin1 = (tab_nomDeRef_F_E_SM(n_mail)).end();
|
||
|
|
for (ieint1=(tab_nomDeRef_F_E_SM(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
|
||
|
|
cout << (*ieint1).NomRef() << " "<< (int) ((*ieint1).Val()) << " ";
|
||
|
|
cout << endl;
|
||
|
|
};
|
||
|
|
// cas des références de point d'intégration de faces d'élément
|
||
|
|
if ((tab_nomDeRef_F_ptinteg_SM(n_mail)).size() != 0)
|
||
|
|
{ cout << "\n liste actuelle de reference de pt d'integration de faces d'element: (nom refFpti) ";
|
||
|
|
List_io <string >::iterator ieint1,ieintfin1 = (tab_nomDeRef_F_ptinteg_SM(n_mail)).end();
|
||
|
|
for (ieint1=(tab_nomDeRef_F_ptinteg_SM(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
|
||
|
|
cout << (*ieint1) << " ";
|
||
|
|
cout << endl;
|
||
|
|
};
|
||
|
|
cout << "\n choix d'une reference de face d'element (avec 1 ou tous les pti) -> (choix : refFE)"
|
||
|
|
<< "\n (dans ce dernier cas il faut que toutes les faces aient le meme nbpti ) "
|
||
|
|
<< "\n choix d'une reference de point d'integration de faces d'element -> (choix : refFpti)"
|
||
|
|
<< "\n donnez le type de choix puis les infos correspondantes "
|
||
|
|
<< "\n choix de tous les ref de face d'elements -> (choix : torefFE)"
|
||
|
|
<< "\n choix de tous les ref de pti de face -> (choix : torefFpti)"
|
||
|
|
<< "\n effacer la liste actuelle des references de faces -> (rep : efrefF) "
|
||
|
|
<< "\n afficher la liste des references de faces existantes -> (rep : affrefF) "
|
||
|
|
<< "\n effacer la liste actuelle des references de pt integ de faces -> (rep : efrefFpti) "
|
||
|
|
<< "\n afficher la liste des references de pt integ de faces existantes -> (rep : affrefFpti) "
|
||
|
|
<< "\n (tapez fin pour finir(ou f))";
|
||
|
|
string rep = "";
|
||
|
|
// -- début boucle choix position sur element
|
||
|
|
while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
{ cout << "\n choix ? ";rep = lect_return_defaut(false,"f");
|
||
|
|
if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f")) break;
|
||
|
|
// def du conteneur des numéros que l'on cherche
|
||
|
|
// comme on peut en définir plusieurs d'un coup (par exemple tous les pti d'une face d'élément) on utilise une liste
|
||
|
|
list <Maillage::NBelemFAEtptInteg> list_nut; // à chaque passage elle est initialisée et donc vide au début
|
||
|
|
Maillage::NBelemFAEtptInteg nut; // idem, initialisé à chaque passage
|
||
|
|
if (rep == "refFE")
|
||
|
|
{ string nom_ref;
|
||
|
|
cout << "\n nom de la reference ? ";
|
||
|
|
nom_ref= lect_chaine();
|
||
|
|
// vérif que la référence existe
|
||
|
|
if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 3))
|
||
|
|
{ cout << "\n erreur de nom (** "<< nom_ref << " **) donne ne correspond pas a une reference de faces d'element correcte ";}
|
||
|
|
else
|
||
|
|
{ // choix du point d'intégration, ici on ne va pas utiliser la liste list_nut, mais une liste particulière
|
||
|
|
string repo;
|
||
|
|
cout << " numero d'un point d'integration ou: -1 pour tous les pti ? ";
|
||
|
|
repo= lect_chaine(); nut.nbPtInteg = ChangeEntier(repo);
|
||
|
|
if (nut.nbPtInteg != -1) // cas d'un seul pti
|
||
|
|
{// on vérifie que ce point d'intégration est valide pour tous les éléments de la référence
|
||
|
|
bool veriflocal = true;
|
||
|
|
List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_F_E_SM(n_mail).end();
|
||
|
|
|
||
|
|
// --- cas des types quelconques aux faces d'éléments
|
||
|
|
{List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
|
||
|
|
// boucle sur les grandeurs retenus
|
||
|
|
for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de faces d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbFA = reff.NumeroFA(ielem);
|
||
|
|
Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
|
||
|
|
// test si l'élément face existe
|
||
|
|
if (!ele.SurfExiste(nut.nbFA))
|
||
|
|
{cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
|
||
|
|
<< " du maillage "<< n_mail
|
||
|
|
<< " ceci pour la reference " << reff.Nom()
|
||
|
|
<< " !!!" << flush ;
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
|
||
|
|
int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
|
||
|
|
// vérification que le point d'intégration est possible
|
||
|
|
if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
|
||
|
|
{ cout << "\n le numero de pti " << nut.nbPtInteg
|
||
|
|
<< " pour la grandeur " << NomTypeQuelconque((*ite)) << " n'est pas valide "
|
||
|
|
<< " pour la face " << nut.nbFA << "pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail
|
||
|
|
<< ", car la face ne comporte que " << max_pti << " pti possible(s) "
|
||
|
|
<< " !!!! " << flush;
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
// --- on enregistre si la vérification a été ok
|
||
|
|
if (veriflocal)
|
||
|
|
{ tab_nomDeRef_F_E_SM(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
|
||
|
|
tab_nomDeRef_F_E_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_F_E_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else // cas de tous les pti
|
||
|
|
{ // il faut d'abord que l'on vérifie que tous les pti pour tous les faces d'élément sont valides
|
||
|
|
// .. on commence par tester si une première face d'élément existe vraiment et si oui, on récupère le nb de pti associé
|
||
|
|
bool veriflocal = true;
|
||
|
|
int nbpti = 0; // init-> ensuite sera == au nombre de pti pour chaque élément
|
||
|
|
{ // on encapsule pour pas de redondance de nom
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de face d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
if (taillen < 1) {veriflocal = false;} // cas d'une ref vide, on ne peut pas aller plus loin
|
||
|
|
else
|
||
|
|
{nut.nbElem = reff.NumeroElem(1);
|
||
|
|
nut.nbFA = reff.NumeroFA(1);
|
||
|
|
if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
|
||
|
|
{if (nut.nbElem < 0)
|
||
|
|
{ cout << "\n le numero d'element (ici"<<nut.nbElem<<") doit etre superieur a 0 !!!";};
|
||
|
|
if (nut.nbElem > lesMail->Nombre_element(n_mail))
|
||
|
|
{ cout << "\n chois non valide, le numero d'element (ici"<<nut.nbElem<<") doit etre inferieur ou egal "
|
||
|
|
<< " au nombre total d'element du maillage ("<<lesMail->Nombre_element(n_mail)<<") !!!";
|
||
|
|
};
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else // sinon c'est ok, on continue au niveau des pti
|
||
|
|
{Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
|
||
|
|
// test si l'élément face existe
|
||
|
|
if (!ele.SurfExiste(nut.nbFA))
|
||
|
|
{cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
|
||
|
|
<< " du maillage "<< n_mail
|
||
|
|
<< " ceci pour la reference " << reff.Nom()
|
||
|
|
<< " !!!" << flush ;
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
|
||
|
|
int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
|
||
|
|
List_io < TypeQuelconque >& li_quelc = tab_F_element_TypeQuelconque_retenu_pourSM(n_mail);
|
||
|
|
// on regarde si les listes ne sont pas toutes vides
|
||
|
|
if ((li_quelc.empty())&&(li_enu_quelconque.empty()))
|
||
|
|
{// toutes les listes sont vides, on ne pourra pas aller plus loin
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else // sinon on peut continuer
|
||
|
|
{nbpti = max_pti;};
|
||
|
|
};
|
||
|
|
}
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// .. puis on balaie l'ensemble des éléments et l'ensemble des pti
|
||
|
|
if (veriflocal)
|
||
|
|
{List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_F_E_SM(n_mail).end();
|
||
|
|
|
||
|
|
// --- cas des types quelconques aux faces d'éléments
|
||
|
|
{List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
|
||
|
|
// boucle sur les grandeurs retenus
|
||
|
|
for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de faces d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbFA = reff.NumeroFA(ielem);
|
||
|
|
Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
|
||
|
|
if (!ele.SurfExiste(nut.nbFA))
|
||
|
|
{cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
|
||
|
|
<< " du maillage "<< n_mail
|
||
|
|
<< " ceci pour la reference " << reff.Nom()
|
||
|
|
<< " !!!" << flush ;
|
||
|
|
veriflocal = false;break;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
|
||
|
|
int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
|
||
|
|
|
||
|
|
// vérification que l'on a le même nombre de pti
|
||
|
|
if (max_pti != nbpti)
|
||
|
|
{ cout << "\n ---> traitement de la reference: "<<refi.Nom()<<" : ";
|
||
|
|
cout << "\n la face "<<nut.nbFA<<" de l'element "<<nut.nbElem << " du maillage " << n_mail
|
||
|
|
<< " contient "<<max_pti<< " pti , alors qu'il en faudrait: "<<nbpti
|
||
|
|
<< "\n les faces sont donc differentes, on ne peut pas utiliser cette reference !! "
|
||
|
|
<< flush;
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
if (!veriflocal) break;
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
if (!veriflocal) break;
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// arrivée ici, si tout est ok on enregistre
|
||
|
|
if (veriflocal)
|
||
|
|
{ nut.nbPtInteg = -1;
|
||
|
|
tab_nomDeRef_F_E_SM(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
|
||
|
|
tab_nomDeRef_F_E_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_F_E_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}; // fin du choix du point d'intégration et de l'enregistrement
|
||
|
|
}
|
||
|
|
else if (rep == "refFpti")
|
||
|
|
{ string nom_ref;
|
||
|
|
cout << "\n nom de la reference ? ";nom_ref= lect_chaine();
|
||
|
|
// vérif que la référence existe
|
||
|
|
if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 7))
|
||
|
|
{ cout << "\n erreur de nom (** "<< nom_ref << " **) donne ne correspond pas a une reference de point d'integration "
|
||
|
|
<< " de face d'element correcte ";}
|
||
|
|
else
|
||
|
|
{ // on vérifie que le choix est valide
|
||
|
|
bool veriflocal = true;
|
||
|
|
// --- cas des types quelconques aux éléments
|
||
|
|
{List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
|
||
|
|
// boucle sur les grandeurs retenus
|
||
|
|
for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref de pti de faces d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbFA = reff.NumeroFA(ielem);
|
||
|
|
nut.nbPtInteg = reff.NumeroPti(ielem);
|
||
|
|
|
||
|
|
Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
|
||
|
|
if (!ele.SurfExiste(nut.nbFA))
|
||
|
|
{cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
|
||
|
|
<< " du maillage "<< n_mail
|
||
|
|
<< " ceci pour la reference " << reff.Nom()
|
||
|
|
<< " !!!" << flush ;
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
|
||
|
|
int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
|
||
|
|
// vérification que le point d'intégration est possible
|
||
|
|
if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
|
||
|
|
{ cout << "\n le numero de pti " << nut.nbPtInteg
|
||
|
|
<< " pour la grandeur " << NomTypeQuelconque((*ite)) << " n'est pas valide "
|
||
|
|
<< " pour la face " << nut.nbFA << "pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail
|
||
|
|
<< ", car la face ne comporte que " << max_pti << " pti possible(s) "
|
||
|
|
<< " !!!! " << flush;
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les grandeurs retenus
|
||
|
|
};
|
||
|
|
|
||
|
|
// on enregistre si la vérification a été ok
|
||
|
|
if (veriflocal)
|
||
|
|
{ tab_nomDeRef_F_ptinteg_SM(n_mail).push_back(nom_ref);
|
||
|
|
tab_nomDeRef_F_ptinteg_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_F_ptinteg_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
}; // fin de la vérification
|
||
|
|
}
|
||
|
|
else if (rep == "torefFE")
|
||
|
|
{ // on va balayer tous les références
|
||
|
|
const Reference* refi = lesRef->Init_et_Premiere();
|
||
|
|
list <string> inter;
|
||
|
|
while (refi != NULL)
|
||
|
|
{ if (refi->Indic() == 3)
|
||
|
|
inter.push_back(refi->Nom());
|
||
|
|
refi = lesRef->Reference_suivante();
|
||
|
|
};
|
||
|
|
// maintenant on va indiquer les pti
|
||
|
|
// choix du point d'intégration, ici on ne va pas utiliser la liste list_nut, mais une liste particulière
|
||
|
|
string repo;
|
||
|
|
cout << " numero d'un point d'integration ou: -1 pour tous les pti ? ";
|
||
|
|
repo= lect_chaine(); nut.nbPtInteg = ChangeEntier(repo);
|
||
|
|
list <string>::iterator il,ilfin=inter.end();
|
||
|
|
if (nut.nbPtInteg != -1) // cas d'un seul pti
|
||
|
|
{ bool veriflocal = true;
|
||
|
|
for (il = inter.begin();il != ilfin; il++)
|
||
|
|
{// on vérifie que ce point d'intégration est valide pour tous les faces d'éléments de la référence
|
||
|
|
// --- cas des types quelconques aux faces d'éléments
|
||
|
|
{List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
|
||
|
|
// boucle sur les grandeurs retenus
|
||
|
|
for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve((*il),n_mail);
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de faces d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbFA = reff.NumeroFA(ielem);
|
||
|
|
Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
|
||
|
|
if (!ele.SurfExiste(nut.nbFA))
|
||
|
|
{cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
|
||
|
|
<< " du maillage "<< n_mail
|
||
|
|
<< " ceci pour la reference " << reff.Nom()
|
||
|
|
<< " !!!" << flush ;
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
|
||
|
|
int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
|
||
|
|
// vérification que le point d'intégration est possible
|
||
|
|
if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
|
||
|
|
{ cout << "\n le numero de pti " << nut.nbPtInteg
|
||
|
|
<< " pour la grandeur " << NomTypeQuelconque((*ite)) << " n'est pas valide "
|
||
|
|
<< " pour la face " << nut.nbFA << "pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail
|
||
|
|
<< ", car la face ne comporte que " << max_pti << " pti possible(s) "
|
||
|
|
<< " !!!! " << flush;
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// --- on enregistre si la vérification a été ok
|
||
|
|
if (veriflocal)
|
||
|
|
for (il = inter.begin();il != ilfin; il++)
|
||
|
|
{ tab_nomDeRef_F_E_SM(n_mail).push_back(BlocScal((*il),nut.nbPtInteg));
|
||
|
|
tab_nomDeRef_F_E_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_F_E_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else // cas de tous les pti
|
||
|
|
{ bool veriflocal = true;
|
||
|
|
for (il = inter.begin();il != ilfin; il++)
|
||
|
|
{ // il faut d'abord que l'on vérifie que tous les pti pour tous les éléments sont valides
|
||
|
|
// .. on commence par tester si une première face d'élément existe vraiment et si oui, on récupère le nb de pti associé
|
||
|
|
int nbpti = 0; // init-> ensuite sera == au nombre de pti pour chaque élément
|
||
|
|
{ // on encapsule pour pas de redondance de nom
|
||
|
|
const Reference& refi = lesRef->Trouve((*il),n_mail);
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de faces d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
if (taillen < 1) {veriflocal = false;} // cas d'une ref vide, on ne peut pas aller plus loin
|
||
|
|
else
|
||
|
|
{nut.nbElem = reff.NumeroElem(1);
|
||
|
|
nut.nbFA = reff.NumeroFA(1);
|
||
|
|
if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
|
||
|
|
{if (nut.nbElem < 0)
|
||
|
|
{ cout << "\n le numero d'element doit etre superieur a 0 !!!";};
|
||
|
|
if (nut.nbElem > lesMail->Nombre_element(n_mail))
|
||
|
|
{ cout << "\n chois non valide, le numero d'element doit etre inferieur ou egal "
|
||
|
|
<< " au nombre total d'element du maillage !!!";
|
||
|
|
};
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else // sinon c'est ok, on continue au niveau des pti
|
||
|
|
{Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
|
||
|
|
// test si l'élément face existe
|
||
|
|
if (!ele.SurfExiste(nut.nbFA))
|
||
|
|
{cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
|
||
|
|
<< " du maillage "<< n_mail
|
||
|
|
<< " ceci pour la reference " << reff.Nom()
|
||
|
|
<< " !!!" << flush ;
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
|
||
|
|
int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
|
||
|
|
List_io < TypeQuelconque >& li_quelc = tab_F_element_TypeQuelconque_retenu_pourSM(n_mail);
|
||
|
|
// on regarde si les listes ne sont pas toutes vides
|
||
|
|
if ((li_quelc.empty())&&(li_enu_quelconque.empty()))
|
||
|
|
{// toutes les listes sont vides, on ne pourra pas aller plus loin
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else // sinon on peut continuer
|
||
|
|
{nbpti = max_pti;};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// .. puis on balaie l'ensemble des éléments et l'ensemble des pti
|
||
|
|
if (veriflocal)
|
||
|
|
{// --- cas des types quelconques aux faces d'éléments
|
||
|
|
{List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
|
||
|
|
// boucle sur les grandeurs retenus
|
||
|
|
for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve((*il),n_mail);
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de faces d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbFA = reff.NumeroFA(ielem);
|
||
|
|
Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
|
||
|
|
if (!ele.SurfExiste(nut.nbFA))
|
||
|
|
{cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
|
||
|
|
<< " du maillage "<< n_mail
|
||
|
|
<< " ceci pour la reference " << reff.Nom()
|
||
|
|
<< " !!!" << flush ;
|
||
|
|
veriflocal = false;break;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
|
||
|
|
int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
|
||
|
|
|
||
|
|
// vérification que l'on a le même nombre de pti
|
||
|
|
if (max_pti != nbpti)
|
||
|
|
{ cout << "\n ---> traitement de la reference: "<<refi.Nom()<<" : ";
|
||
|
|
cout << "\n la face "<<nut.nbFA<<" de l'element "<<nut.nbElem << " du maillage " << n_mail
|
||
|
|
<< " contient "<<max_pti<< " pti , alors qu'il en faudrait: "<<nbpti
|
||
|
|
<< "\n les faces sont donc differentes, on ne peut pas utiliser cette reference !! "
|
||
|
|
<< flush;
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
if (!veriflocal) break;
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
if (!veriflocal) break;
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// arrivée ici, si tout est ok on enregistre
|
||
|
|
if (veriflocal)
|
||
|
|
for (il = inter.begin();il != ilfin; il++)
|
||
|
|
{ nut.nbPtInteg = -1;
|
||
|
|
tab_nomDeRef_F_E_SM(n_mail).push_back(BlocScal((*il),nut.nbPtInteg));
|
||
|
|
tab_nomDeRef_F_E_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_F_E_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else if (rep == "torefFpti")
|
||
|
|
{ // on va balayer tous les références
|
||
|
|
const Reference* refi = lesRef->Init_et_Premiere();
|
||
|
|
while (refi != NULL)
|
||
|
|
{ if (refi->Indic() == 7)
|
||
|
|
{ // on vérifie que le choix est valide
|
||
|
|
bool veriflocal = true;
|
||
|
|
|
||
|
|
// --- cas des types quelconques aux faces d'éléments
|
||
|
|
{List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbFA = reff.NumeroFA(ielem);
|
||
|
|
nut.nbPtInteg = reff.NumeroPti(ielem);
|
||
|
|
|
||
|
|
Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
|
||
|
|
if (!ele.SurfExiste(nut.nbFA))
|
||
|
|
{cout << "\n la surface "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
|
||
|
|
<< " du maillage "<< n_mail
|
||
|
|
<< " ceci pour la reference " << reff.Nom()
|
||
|
|
<< " !!!" << flush ;
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
|
||
|
|
int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
|
||
|
|
// vérification que le point d'intégration est possible
|
||
|
|
if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
|
||
|
|
{ cout << "\n le numero de pti " << nut.nbPtInteg
|
||
|
|
<< " pour la grandeur " << NomTypeQuelconque((*ite)) << " n'est pas valide "
|
||
|
|
<< " pour la face " << nut.nbFA << "pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail
|
||
|
|
<< ", car la face ne comporte que " << max_pti << " pti possible(s) "
|
||
|
|
<< " !!!! " << flush;
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les grandeurs retenus
|
||
|
|
};
|
||
|
|
|
||
|
|
// on enregistre si la vérification a été ok
|
||
|
|
if (veriflocal)
|
||
|
|
{ tab_nomDeRef_F_ptinteg_SM(n_mail).push_back(refi->Nom());
|
||
|
|
tab_nomDeRef_F_ptinteg_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_F_ptinteg_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
}; // fin de la vérification
|
||
|
|
refi = lesRef->Reference_suivante();
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else if (rep == "efrefF")
|
||
|
|
{ // on efface la liste des références d'éléments et la liste de pt d'integ associée
|
||
|
|
(tab_nomDeRef_F_E_SM(n_mail)).clear();
|
||
|
|
}
|
||
|
|
else if (rep == "affrefF")
|
||
|
|
{ // affichage de la liste des références d'éléments enregistrées dans les maillages
|
||
|
|
cout << "\n liste des references de face d'elements ";
|
||
|
|
if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
|
||
|
|
const Reference* reff =NULL; bool prempass = true;
|
||
|
|
do {
|
||
|
|
if (prempass)
|
||
|
|
{ reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
|
||
|
|
else
|
||
|
|
{ reff = lesRef->Reference_suivante();} // récup de la ref courante
|
||
|
|
// sortie de la ref si c'est le bon maillage, et si c'est une ref de faces d'élément
|
||
|
|
if (reff != NULL)
|
||
|
|
if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 3)) cout << reff->Nom() << " ";
|
||
|
|
prempass = false;
|
||
|
|
} while (reff != NULL);
|
||
|
|
}
|
||
|
|
else if (rep == "efrefFpti")
|
||
|
|
{ // on efface la liste des références de pt d'integ de faces d'éléments
|
||
|
|
(tab_nomDeRef_F_ptinteg_SM(n_mail)).clear();
|
||
|
|
}
|
||
|
|
else if (rep == "affrefFpti")
|
||
|
|
{ // affichage de la liste des références de pti enregistrées dans les maillages
|
||
|
|
cout << "\n liste des references de pt integ de faces d'elements ";
|
||
|
|
if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
|
||
|
|
const Reference* reff =NULL; bool prempass = true;
|
||
|
|
do {
|
||
|
|
if (prempass)
|
||
|
|
{ reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
|
||
|
|
else
|
||
|
|
{ reff = lesRef->Reference_suivante();} // récup de la ref courante
|
||
|
|
// sortie de la ref si c'est le bon maillage, et si c'est une ref de faces d'élément
|
||
|
|
if (reff != NULL)
|
||
|
|
if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 7)) cout << reff->Nom() << " ";
|
||
|
|
prempass = false;
|
||
|
|
} while (reff != NULL);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ cout << "\n reponse non valide, recommencez " << endl;
|
||
|
|
};
|
||
|
|
}; // -- fin boucle choix
|
||
|
|
};
|
||
|
|
|
||
|
|
}; //-- fin de la boucle sur les maillages
|
||
|
|
};
|
||
|
|
// entrée du choix pour les moyennes sommes etc. sur ref d'arête d'E
|
||
|
|
void Choix_grandeurs_maple::Entree_somme_moy_A_E(string& rep)
|
||
|
|
{ // cas de grandeurs aux arêtes d'éléments, on boucle sur les maillages
|
||
|
|
int dim = ParaGlob::Dimension();
|
||
|
|
cout << "\n --- somme, moyenne, max, min etc. sur des references de aretes d'element et de pti ---";
|
||
|
|
// on récupère la liste des maillages à visualiser
|
||
|
|
const list <int>& list_mail = choix_mail->List_choisit();
|
||
|
|
list<int>::const_iterator ilm,ilmfin=list_mail.end();
|
||
|
|
int taille_list_maille = list_mail.size();
|
||
|
|
if (list_mail.size() == 0)
|
||
|
|
{ cout << "\n aucun maillage n'est definit ! , il faut commencer par definir les maillages pour"
|
||
|
|
<< " lesquels on veut une sortie ";
|
||
|
|
return;
|
||
|
|
};
|
||
|
|
// on balaie les différents maillages
|
||
|
|
for (ilm = list_mail.begin();ilm!=ilmfin;ilm++)
|
||
|
|
{ int n_mail = abs(*ilm); // numéro du maillage
|
||
|
|
|
||
|
|
// -- boucle sur les maillages
|
||
|
|
// affichage du nom du maillages s'il y en a plusieurs
|
||
|
|
if (taille_list_maille > 1)
|
||
|
|
cout << "\n ======>>>>> maillage : " << lesMail->NomMaillage(n_mail);
|
||
|
|
|
||
|
|
// -------------- choix des grandeurs quelconques définies aux arêtes d'éléments -----------------
|
||
|
|
// def de la liste de travail qui contient les grandeurs à visualiser,
|
||
|
|
// sert également pour vérifier que tous les grandeurs quelconques sont relatives
|
||
|
|
// à un même point d'intégration
|
||
|
|
List_io < EnumTypeQuelconque > li_enu_quelconque;
|
||
|
|
{cout << "\n -------- cas des grandeurs quelconques definies aux aretes d'elements ---------";
|
||
|
|
// dans le cas où aucune grandeur particulière sont défini on passe
|
||
|
|
if ( (tab_A_element_TypeQuelconque(n_mail)).size() == 0)
|
||
|
|
{ cout << "\n aucune grandeur particuliere n'est definit, donc aucune proposition ";}
|
||
|
|
else
|
||
|
|
{ // on affiche la liste actuelle
|
||
|
|
if ((tab_A_element_TypeQuelconque_retenu_pourSM(n_mail)).size())
|
||
|
|
{ cout << "\n liste actuelle des aretes d'element a sortir en info: < (num_ele, num_arete) > ";
|
||
|
|
List_io <int>::iterator ieint,ieintfin = tab_num_A_element(n_mail).end();
|
||
|
|
List_io <int>::iterator ifint = tab_num_A(n_mail).begin();
|
||
|
|
for (ieint=tab_num_A_element(n_mail).begin();ieint!=ieintfin;ieint++,ifint++)
|
||
|
|
cout << " (" << (*ieint) << ", "<<(*ifint)<<") ";
|
||
|
|
cout << "\n liste des grandeurs particulieres actuellement a sortir: ";
|
||
|
|
List_io < TypeQuelconque >::iterator iet,ietfin = (tab_A_element_TypeQuelconque_retenu_pourSM(n_mail)).end();
|
||
|
|
for (iet=(tab_A_element_TypeQuelconque_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
|
||
|
|
cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
|
||
|
|
cout << endl;
|
||
|
|
};
|
||
|
|
// on affiche les différentes grandeurs possibles
|
||
|
|
cout << "\n maillage nb : " << n_mail ;
|
||
|
|
cout << "\n la liste des grandeurs disponibles est la suivante : ";
|
||
|
|
List_io < TypeQuelconque >::iterator iet,ietfin = (tab_A_element_TypeQuelconque(n_mail)).end();
|
||
|
|
for (iet=(tab_A_element_TypeQuelconque(n_mail)).begin();iet!=ietfin;iet++)
|
||
|
|
cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
|
||
|
|
cout << "\n";
|
||
|
|
cout << "\n grandeurs que vous voulez visualiser ( rep : grandeurs?)"
|
||
|
|
<< "\n REMARQUE : il faut donner uniquement un jeu de grandeurs "
|
||
|
|
<< "\n definies au meme point d'integration "
|
||
|
|
<< "\n effacer la liste actuelle (rep : ef) "
|
||
|
|
<< "\n toutes les grandeurs : (rep : to) "
|
||
|
|
<< "\n (pour terminer tapez : fin (ou f))";
|
||
|
|
rep = "";
|
||
|
|
while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
{ cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
|
||
|
|
if (rep == "to")
|
||
|
|
// cas de toutes les grandeurs
|
||
|
|
{List_io<TypeQuelconque>& tpg_ret = (tab_A_element_TypeQuelconque_retenu_pourSM(n_mail)); // pour simplifier
|
||
|
|
List_io<TypeQuelconque>& tpg = (tab_A_element_TypeQuelconque(n_mail)); // pour simplifier
|
||
|
|
List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
|
||
|
|
for (ite = tab_A_element_TypeQuelconque(n_mail).begin();ite != itefin; ite++)
|
||
|
|
if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
|
||
|
|
{ tpg_ret.push_back(*ite);
|
||
|
|
// on enregistre également le EnumTypeQuelconque associé qui définit le point d'integ où est calculé la grandeur
|
||
|
|
// particulière
|
||
|
|
li_enu_quelconque.push_back((*ite).EnuTypeQuelconque().EnumTQ());
|
||
|
|
};
|
||
|
|
}
|
||
|
|
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 = (tab_A_element_TypeQuelconque_retenu_pourSM(n_mail)); // pour simplifier
|
||
|
|
List_io<TypeQuelconque>& tpg = (tab_A_element_TypeQuelconque(n_mail)); // 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);
|
||
|
|
// on enregistre l'enum quelconque associé qui définit le point d'integ où est calculé la grandeur
|
||
|
|
// particulière
|
||
|
|
li_enu_quelconque.push_back((*il).EnuTypeQuelconque().EnumTQ());
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ cout << "\n erreur, grandeur non disponible !, recommencez ";};
|
||
|
|
}
|
||
|
|
else if (rep == "ef")
|
||
|
|
{ // on efface la liste
|
||
|
|
(tab_A_element_TypeQuelconque_retenu_pourSM(n_mail)).clear();
|
||
|
|
}
|
||
|
|
else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
cout << " erreur de syntaxe recommencez ";
|
||
|
|
};
|
||
|
|
}; //-- fin du choix sur le fait qu'il existe ou non des grandeurs quelconques
|
||
|
|
};
|
||
|
|
// -------------- on s'occupe maintenant des références associées pour le calcul des sommes moy... -----------------
|
||
|
|
{cout << "\n -------- definition des references de aretes d'elements ---------";
|
||
|
|
// cas des références de arêtes d'élément
|
||
|
|
if ((tab_nomDeRef_A_E_SM(n_mail)).size() != 0)
|
||
|
|
{ cout << "\n liste actuelle de reference de aretes d'elements : (nom refFE et num integ) ";
|
||
|
|
List_io <BlocScal >::iterator ieint1,ieintfin1 = (tab_nomDeRef_A_E_SM(n_mail)).end();
|
||
|
|
for (ieint1=(tab_nomDeRef_A_E_SM(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
|
||
|
|
cout << (*ieint1).NomRef() << " "<< (int) ((*ieint1).Val()) << " ";
|
||
|
|
cout << endl;
|
||
|
|
};
|
||
|
|
// cas des références de point d'intégration d'arêtes d'élément
|
||
|
|
if ((tab_nomDeRef_A_ptinteg_SM(n_mail)).size() != 0)
|
||
|
|
{ cout << "\n liste actuelle de reference de pt d'integration d'aretes d'element: (nom refApti) ";
|
||
|
|
List_io <string >::iterator ieint1,ieintfin1 = (tab_nomDeRef_A_ptinteg_SM(n_mail)).end();
|
||
|
|
for (ieint1=(tab_nomDeRef_A_ptinteg_SM(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
|
||
|
|
cout << (*ieint1) << " ";
|
||
|
|
cout << endl;
|
||
|
|
};
|
||
|
|
cout << "\n choix d'une reference d'aretes d'element (avec 1 ou tous les pti) -> (choix : refAE)"
|
||
|
|
<< "\n (dans ce dernier cas il faut que toutes les aretes aient de meme type nbpti) "
|
||
|
|
<< "\n choix d'une reference de point d'integration d'aretes d'element -> (choix : refApti)"
|
||
|
|
<< "\n donnez le type de choix puis les infos correspondantes "
|
||
|
|
<< "\n choix de tous les ref d'aretes d'elements -> (choix : torefAE)"
|
||
|
|
<< "\n choix de tous les ref de pti d'aretes -> (choix : torefApti)"
|
||
|
|
<< "\n effacer la liste actuelle des references d'aretes -> (rep : efrefA) "
|
||
|
|
<< "\n afficher la liste des references d'aretes existantes -> (rep : affrefA) "
|
||
|
|
<< "\n effacer la liste actuelle des references de pt integ d'aretes -> (rep : efrefApti) "
|
||
|
|
<< "\n afficher la liste des references de pt integ d'aretes existantes -> (rep : affrefApti) "
|
||
|
|
<< "\n (tapez fin pour finir(ou f))";
|
||
|
|
string rep = "";
|
||
|
|
// -- début boucle choix position sur element
|
||
|
|
while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
{ cout << "\n choix ? ";rep = lect_return_defaut(false,"f");
|
||
|
|
if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f")) break;
|
||
|
|
// def du conteneur des numéros que l'on cherche
|
||
|
|
// comme on peut en définir plusieurs d'un coup (par exemple tous les pti d'une arête d'élément) on utilise une liste
|
||
|
|
list <Maillage::NBelemFAEtptInteg> list_nut; // à chaque passage elle est initialisée et donc vide au début
|
||
|
|
Maillage::NBelemFAEtptInteg nut; // idem, initialisé à chaque passage
|
||
|
|
if (rep == "refAE")
|
||
|
|
{ string nom_ref;
|
||
|
|
cout << "\n nom de la reference ? ";
|
||
|
|
nom_ref= lect_chaine();
|
||
|
|
// vérif que la référence existe
|
||
|
|
if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 4))
|
||
|
|
{ cout << "\n erreur de nom (** "<< nom_ref << " **) donne ne correspond pas a une reference d'aretes d'element correcte ";}
|
||
|
|
else
|
||
|
|
{ // choix du point d'intégration, ici on ne va pas utiliser la liste list_nut, mais une liste particulière
|
||
|
|
string repo;
|
||
|
|
cout << " numero d'un point d'integration ou: -1 pour tous les pti ? ";
|
||
|
|
repo= lect_chaine(); nut.nbPtInteg = ChangeEntier(repo);
|
||
|
|
if (nut.nbPtInteg != -1) // cas d'un seul pti
|
||
|
|
{// on vérifie que ce point d'intégration est valide pour tous les arêtes de la référence
|
||
|
|
bool veriflocal = true;
|
||
|
|
List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_A_E_SM(n_mail).end();
|
||
|
|
|
||
|
|
// --- cas des types quelconques aux arêtes d'éléments
|
||
|
|
{List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
|
||
|
|
// boucle sur les grandeurs retenus
|
||
|
|
for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbFA = reff.NumeroFA(ielem);
|
||
|
|
Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
|
||
|
|
if (!ele.AreteExiste(nut.nbFA))
|
||
|
|
{cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
|
||
|
|
<< " du maillage "<< n_mail << " !!!" << flush ;
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
|
||
|
|
int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
|
||
|
|
// vérification que le point d'intégration est possible
|
||
|
|
if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
|
||
|
|
{ cout << "\n le numero de pti " << nut.nbPtInteg
|
||
|
|
<< " pour la grandeur " << NomTypeQuelconque((*ite)) << " n'est pas valide "
|
||
|
|
<< " pour l'arete " << nut.nbFA << "pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail
|
||
|
|
<< ", car l'arete ne comporte que " << max_pti << " pti possible(s) "
|
||
|
|
<< " !!!! " << flush;
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les grandeurs retenus
|
||
|
|
};
|
||
|
|
// --- on enregistre si la vérification a été ok
|
||
|
|
if (veriflocal)
|
||
|
|
{ tab_nomDeRef_A_E_SM(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
|
||
|
|
tab_nomDeRef_A_E_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_A_E_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else // cas de tous les pti
|
||
|
|
{ // il faut d'abord que l'on vérifie que tous les pti pour tous les arêtes d'élément sont valides
|
||
|
|
// .. on commence par tester si une première arête d'élément existe vraiment et si oui, on récupère le nb de pti associé
|
||
|
|
bool veriflocal = true;
|
||
|
|
int nbpti = 0; // init-> ensuite sera == au nombre de pti pour chaque élément
|
||
|
|
{ // on encapsule pour pas de redondance de nom
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
if (taillen < 1) {veriflocal = false;} // cas d'une ref vide, on ne peut pas aller plus loin
|
||
|
|
else
|
||
|
|
{nut.nbElem = reff.NumeroElem(1);
|
||
|
|
nut.nbFA = reff.NumeroFA(1);
|
||
|
|
if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
|
||
|
|
{if (nut.nbElem < 0)
|
||
|
|
{ cout << "\n le numero d'element (ici"<<nut.nbElem<<") doit etre superieur a 0 !!!";};
|
||
|
|
if (nut.nbElem > lesMail->Nombre_element(n_mail))
|
||
|
|
{ cout << "\n chois non valide, le numero d'element (ici"<<nut.nbElem<<") doit etre inferieur ou egal "
|
||
|
|
<< " au nombre total d'element du maillage ("<<lesMail->Nombre_element(n_mail)<<") !!!";
|
||
|
|
};
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else // sinon c'est ok, on continue au niveau des pti
|
||
|
|
{Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
|
||
|
|
// test si l'arête de l'élément existe
|
||
|
|
if (!ele.AreteExiste(nut.nbFA))
|
||
|
|
{cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
|
||
|
|
<< " du maillage "<< n_mail << " !!!" << flush ;
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
|
||
|
|
int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
|
||
|
|
List_io < TypeQuelconque >& li_quelc = tab_A_element_TypeQuelconque_retenu_pourSM(n_mail);
|
||
|
|
// on regarde si les listes ne sont pas toutes vides
|
||
|
|
if ((li_quelc.empty())&&(li_enu_quelconque.empty()))
|
||
|
|
{// toutes les listes sont vides, on ne pourra pas aller plus loin
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else // sinon on peut continuer
|
||
|
|
{nbpti = max_pti;};
|
||
|
|
};
|
||
|
|
}
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// .. puis on balaie l'ensemble des arêtes et l'ensemble des pti
|
||
|
|
if (veriflocal)
|
||
|
|
{List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_A_E_SM(n_mail).end();
|
||
|
|
|
||
|
|
// --- cas des types quelconques aux arêtes d'éléments
|
||
|
|
{List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
|
||
|
|
// boucle sur les grandeurs retenus
|
||
|
|
for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbFA = reff.NumeroFA(ielem);
|
||
|
|
Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
|
||
|
|
if (!ele.AreteExiste(nut.nbFA))
|
||
|
|
{cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
|
||
|
|
<< " du maillage "<< n_mail
|
||
|
|
<< " ceci pour la reference "<< reff.Nom()
|
||
|
|
<< " !!!" << flush ;
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
|
||
|
|
int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
|
||
|
|
|
||
|
|
// vérification que l'on a le même nombre de pti
|
||
|
|
if (max_pti != nbpti)
|
||
|
|
{ cout << "\n ---> traitement de la reference: "<<refi.Nom()<<" : ";
|
||
|
|
cout << "\n l'arete "<<nut.nbFA<<" de l'element "<<nut.nbElem << " du maillage " << n_mail
|
||
|
|
<< " contient "<<max_pti<< " pti , alors qu'il en faudrait: "<<nbpti
|
||
|
|
<< "\n les faces sont donc differentes, on ne peut pas utiliser cette reference !! "
|
||
|
|
<< flush;
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
if (!veriflocal) break;
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
if (!veriflocal) break;
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// arrivée ici, si tout est ok on enregistre
|
||
|
|
if (veriflocal)
|
||
|
|
{ nut.nbPtInteg = -1;
|
||
|
|
tab_nomDeRef_A_E_SM(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
|
||
|
|
tab_nomDeRef_A_E_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_A_E_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}; // fin du choix du point d'intégration et de l'enregistrement
|
||
|
|
}
|
||
|
|
else if (rep == "refApti")
|
||
|
|
{ string nom_ref;
|
||
|
|
cout << "\n nom de la reference ? ";nom_ref= lect_chaine();
|
||
|
|
// vérif que la référence existe
|
||
|
|
if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 8))
|
||
|
|
{ cout << "\n erreur de nom (** "<< nom_ref << " **) donne ne correspond pas a une reference de point d'integration "
|
||
|
|
<< " d'arete d'element correcte ";}
|
||
|
|
else
|
||
|
|
{ // on vérifie que le choix est valide
|
||
|
|
bool veriflocal = true;
|
||
|
|
// --- cas des types quelconques aux éléments
|
||
|
|
{List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
|
||
|
|
// boucle sur les grandeurs retenus
|
||
|
|
for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve(nom_ref,n_mail);
|
||
|
|
const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref de pti d'arêtes d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les arêtes de la référence
|
||
|
|
{ nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbFA = reff.NumeroFA(ielem);
|
||
|
|
nut.nbPtInteg = reff.NumeroPti(ielem);
|
||
|
|
|
||
|
|
Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
|
||
|
|
if (!ele.AreteExiste(nut.nbFA))
|
||
|
|
{cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
|
||
|
|
<< " du maillage "<< n_mail
|
||
|
|
<< " ceci pour la reference "<< reff.Nom()
|
||
|
|
<< " !!!" << flush ;
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
|
||
|
|
int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
|
||
|
|
// vérification que le point d'intégration est possible
|
||
|
|
if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
|
||
|
|
{ cout << "\n le numero de pti " << nut.nbPtInteg
|
||
|
|
<< " pour la grandeur " << NomTypeQuelconque((*ite)) << " n'est pas valide "
|
||
|
|
<< " pour l'arete' " << nut.nbFA << "pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail
|
||
|
|
<< ", car l'arete ne comporte que " << max_pti << " pti possible(s) "
|
||
|
|
<< " !!!! " << flush;
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les grandeurs retenus
|
||
|
|
};
|
||
|
|
|
||
|
|
// on enregistre si la vérification a été ok
|
||
|
|
if (veriflocal)
|
||
|
|
{ tab_nomDeRef_A_ptinteg_SM(n_mail).push_back(nom_ref);
|
||
|
|
tab_nomDeRef_A_ptinteg_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_A_ptinteg_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
}; // fin de la vérification
|
||
|
|
}
|
||
|
|
else if (rep == "torefAE")
|
||
|
|
{ // on va balayer toutes les références
|
||
|
|
const Reference* refi = lesRef->Init_et_Premiere();
|
||
|
|
list <string> inter;
|
||
|
|
while (refi != NULL)
|
||
|
|
{ if (refi->Indic() == 4)
|
||
|
|
inter.push_back(refi->Nom());
|
||
|
|
refi = lesRef->Reference_suivante();
|
||
|
|
};
|
||
|
|
// maintenant on va indiquer les pti
|
||
|
|
// choix du point d'intégration, ici on ne va pas utiliser la liste list_nut, mais une liste particulière
|
||
|
|
string repo;
|
||
|
|
cout << " numero d'un point d'integration ou: -1 pour tous les pti ? ";
|
||
|
|
repo= lect_chaine(); nut.nbPtInteg = ChangeEntier(repo);
|
||
|
|
list <string>::iterator il,ilfin=inter.end();
|
||
|
|
if (nut.nbPtInteg != -1) // cas d'un seul pti
|
||
|
|
{ bool veriflocal = true;
|
||
|
|
for (il = inter.begin();il != ilfin; il++)
|
||
|
|
{// on vérifie que ce point d'intégration est valide pour toutes les arêtes d'éléments de la référence
|
||
|
|
// --- cas des types quelconques aux arêtes d'éléments
|
||
|
|
{List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
|
||
|
|
// boucle sur les grandeurs retenus
|
||
|
|
for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve((*il),n_mail);
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbFA = reff.NumeroFA(ielem);
|
||
|
|
Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
|
||
|
|
if (!ele.AreteExiste(nut.nbFA))
|
||
|
|
{cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
|
||
|
|
<< " du maillage "<< n_mail
|
||
|
|
<< " ceci pour la reference " << reff.Nom()
|
||
|
|
<< " !!!" << flush ;
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
|
||
|
|
int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
|
||
|
|
// vérification que le point d'intégration est possible
|
||
|
|
if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
|
||
|
|
{ cout << "\n le numero de pti " << nut.nbPtInteg
|
||
|
|
<< " pour la grandeur " << NomTypeQuelconque((*ite)) << " n'est pas valide "
|
||
|
|
<< " pour l'arete " << nut.nbFA << "pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail
|
||
|
|
<< ", car l'arete ne comporte que " << max_pti << " pti possible(s) "
|
||
|
|
<< " !!!! " << flush;
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// --- on enregistre si la vérification a été ok
|
||
|
|
if (veriflocal)
|
||
|
|
for (il = inter.begin();il != ilfin; il++)
|
||
|
|
{ tab_nomDeRef_A_E_SM(n_mail).push_back(BlocScal((*il),nut.nbPtInteg));
|
||
|
|
tab_nomDeRef_A_E_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_A_E_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else // cas de tous les pti
|
||
|
|
{ bool veriflocal = true;
|
||
|
|
for (il = inter.begin();il != ilfin; il++)
|
||
|
|
{ // il faut d'abord que l'on vérifie que tous les pti pour tous les éléments sont valides
|
||
|
|
// .. on commence par tester si une première arête d'élément existe vraiment et si oui, on récupère le nb de pti associé
|
||
|
|
int nbpti = 0; // init-> ensuite sera == au nombre de pti pour chaque élément
|
||
|
|
{ // on encapsule pour pas de redondance de nom
|
||
|
|
const Reference& refi = lesRef->Trouve((*il),n_mail);
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
if (taillen < 1) {veriflocal = false;} // cas d'une ref vide, on ne peut pas aller plus loin
|
||
|
|
else
|
||
|
|
{nut.nbElem = reff.NumeroElem(1);
|
||
|
|
nut.nbFA = reff.NumeroFA(1);
|
||
|
|
if ((nut.nbElem < 0) || (nut.nbElem > lesMail->Nombre_element(n_mail)))
|
||
|
|
{if (nut.nbElem < 0)
|
||
|
|
{ cout << "\n le numero d'element doit etre superieur a 0 !!!";};
|
||
|
|
if (nut.nbElem > lesMail->Nombre_element(n_mail))
|
||
|
|
{ cout << "\n chois non valide, le numero d'element doit etre inferieur ou egal "
|
||
|
|
<< " au nombre total d'element du maillage !!!";
|
||
|
|
};
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else // sinon c'est ok, on continue au niveau des pti
|
||
|
|
{Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
|
||
|
|
// test si l'arete de l'élément existe
|
||
|
|
if (!ele.AreteExiste(nut.nbFA))
|
||
|
|
{cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
|
||
|
|
<< " du maillage "<< n_mail << " !!!" << flush ;
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
|
||
|
|
int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
|
||
|
|
List_io < TypeQuelconque >& li_quelc = tab_A_element_TypeQuelconque_retenu_pourSM(n_mail);
|
||
|
|
// on regarde si les listes ne sont pas toutes vides
|
||
|
|
if ((li_quelc.empty())&&(li_enu_quelconque.empty()))
|
||
|
|
{// toutes les listes sont vides, on ne pourra pas aller plus loin
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else // sinon on peut continuer
|
||
|
|
{nbpti = max_pti;};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// .. puis on balaie l'ensemble des éléments et l'ensemble des pti
|
||
|
|
if (veriflocal)
|
||
|
|
{// --- cas des types quelconques aux arêtes d'éléments
|
||
|
|
{List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
|
||
|
|
// boucle sur les grandeurs retenus
|
||
|
|
for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve((*il),n_mail);
|
||
|
|
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'arêtes d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbFA = reff.NumeroFA(ielem);
|
||
|
|
Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
|
||
|
|
const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
|
||
|
|
if (!ele.AreteExiste(nut.nbFA))
|
||
|
|
{cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
|
||
|
|
<< " du maillage "<< n_mail
|
||
|
|
<< " ceci pour la reference " << reff.Nom()
|
||
|
|
<< " !!!" << flush ;
|
||
|
|
veriflocal = false;break;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
|
||
|
|
// vérification que l'on a le même nombre de pti
|
||
|
|
if (max_pti != nbpti)
|
||
|
|
{ cout << "\n ---> traitement de la reference: "<<refi.Nom()<<" : ";
|
||
|
|
cout << "\n l'arete "<<nut.nbFA<<" de l'element "<<nut.nbElem << " du maillage " << n_mail
|
||
|
|
<< " contient "<<max_pti<< " pti , alors qu'il en faudrait: "<<nbpti
|
||
|
|
<< "\n les aretes sont donc differentes, on ne peut pas utiliser cette reference !! "
|
||
|
|
<< flush;
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
if (!veriflocal) break;
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
if (!veriflocal) break;
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// arrivée ici, si tout est ok on enregistre
|
||
|
|
if (veriflocal)
|
||
|
|
for (il = inter.begin();il != ilfin; il++)
|
||
|
|
{ nut.nbPtInteg = -1;
|
||
|
|
tab_nomDeRef_A_E_SM(n_mail).push_back(BlocScal((*il),nut.nbPtInteg));
|
||
|
|
tab_nomDeRef_A_E_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_A_E_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else if (rep == "torefApti")
|
||
|
|
{ // on va balayer tous les références
|
||
|
|
const Reference* refi = lesRef->Init_et_Premiere();
|
||
|
|
while (refi != NULL)
|
||
|
|
{ if (refi->Indic() == 8)
|
||
|
|
{ // on vérifie que le choix est valide
|
||
|
|
bool veriflocal = true;
|
||
|
|
|
||
|
|
// --- cas des types quelconques aux arêtes d'éléments
|
||
|
|
{List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelconque.end();
|
||
|
|
// boucle sur les ddl retenus
|
||
|
|
for (ite = li_enu_quelconque.begin();ite != itefin; ite++)
|
||
|
|
{ // recup de la reference correspondant au mot cle
|
||
|
|
const ReferencePtiAF & reff = ((ReferencePtiAF &) refi); // transfo en ref d'arêtes d'élément
|
||
|
|
int taillen=reff.Taille(); // nombre d'éléments dans la référence
|
||
|
|
for (int ielem=1;ielem<=taillen;ielem++) // on boucle sur les éléments de la référence
|
||
|
|
{ nut.nbElem = reff.NumeroElem(ielem);
|
||
|
|
nut.nbFA = reff.NumeroFA(ielem);
|
||
|
|
nut.nbPtInteg = reff.NumeroPti(ielem);
|
||
|
|
|
||
|
|
Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // récup élément
|
||
|
|
if (!ele.AreteExiste(nut.nbFA))
|
||
|
|
{cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
|
||
|
|
<< " du maillage "<< n_mail
|
||
|
|
<< " ceci pour la reference " << reff.Nom()
|
||
|
|
<< " !!!" << flush ;
|
||
|
|
veriflocal = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
|
||
|
|
int max_pti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
|
||
|
|
// vérification que le point d'intégration est possible
|
||
|
|
if ((nut.nbPtInteg > max_pti)||(nut.nbPtInteg < 1))
|
||
|
|
{ cout << "\n le numero de pti " << nut.nbPtInteg
|
||
|
|
<< " pour la grandeur " << NomTypeQuelconque((*ite)) << " n'est pas valide "
|
||
|
|
<< " pour l'arete " << nut.nbFA << "pour l'element "
|
||
|
|
<< nut.nbElem << " du maillage " << n_mail
|
||
|
|
<< ", car l'arete ne comporte que " << max_pti << " pti possible(s) "
|
||
|
|
<< " !!!! " << flush;
|
||
|
|
veriflocal = false;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}; //-- fin de la boucle sur les éléments de la référence
|
||
|
|
}; //-- fin de la boucle sur les ddl retenus
|
||
|
|
};
|
||
|
|
|
||
|
|
// on enregistre si la vérification a été ok
|
||
|
|
if (veriflocal)
|
||
|
|
{ tab_nomDeRef_A_ptinteg_SM(n_mail).push_back(refi->Nom());
|
||
|
|
tab_nomDeRef_A_ptinteg_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_A_ptinteg_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
};
|
||
|
|
}; // fin de la vérification
|
||
|
|
refi = lesRef->Reference_suivante();
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else if (rep == "efrefA")
|
||
|
|
{ // on efface la liste des références d'éléments et la liste de pt d'integ associée
|
||
|
|
(tab_nomDeRef_A_E_SM(n_mail)).clear();
|
||
|
|
}
|
||
|
|
else if (rep == "affrefA")
|
||
|
|
{ // affichage de la liste des références d'éléments enregistrées dans les maillages
|
||
|
|
cout << "\n liste des references d'aretes d'elements ";
|
||
|
|
if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
|
||
|
|
const Reference* reff =NULL; bool prempass = true;
|
||
|
|
do {
|
||
|
|
if (prempass)
|
||
|
|
{ reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
|
||
|
|
else
|
||
|
|
{ reff = lesRef->Reference_suivante();} // récup de la ref courante
|
||
|
|
// sortie de la ref si c'est le bon maillage, et si c'est une ref d'arêtes d'élément
|
||
|
|
if (reff != NULL)
|
||
|
|
if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 4)) cout << reff->Nom() << " ";
|
||
|
|
prempass = false;
|
||
|
|
} while (reff != NULL);
|
||
|
|
}
|
||
|
|
else if (rep == "efrefApti")
|
||
|
|
{ // on efface la liste des références de pt d'integ d'arêtes d'éléments
|
||
|
|
(tab_nomDeRef_A_ptinteg_SM(n_mail)).clear();
|
||
|
|
}
|
||
|
|
else if (rep == "affrefApti")
|
||
|
|
{ // affichage de la liste des références de pti enregistrées dans les maillages
|
||
|
|
cout << "\n liste des references de pt integ d'aretes d'elements ";
|
||
|
|
if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
|
||
|
|
const Reference* reff =NULL; bool prempass = true;
|
||
|
|
do {
|
||
|
|
if (prempass)
|
||
|
|
{ reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
|
||
|
|
else
|
||
|
|
{ reff = lesRef->Reference_suivante();} // récup de la ref courante
|
||
|
|
// sortie de la ref si c'est le bon maillage, et si c'est une ref d'arêtes d'élément
|
||
|
|
if (reff != NULL)
|
||
|
|
if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 8)) cout << reff->Nom() << " ";
|
||
|
|
prempass = false;
|
||
|
|
} while (reff != NULL);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ cout << "\n reponse non valide, recommencez " << endl;
|
||
|
|
};
|
||
|
|
}; // -- fin boucle choix
|
||
|
|
};
|
||
|
|
|
||
|
|
}; //-- fin de la boucle sur les maillages
|
||
|
|
};
|
||
|
|
|
||
|
|
// entrée du choix pour les moyennes sommes etc. sur ref N
|
||
|
|
void Choix_grandeurs_maple::Entree_somme_moy_N(string& rep)
|
||
|
|
{ // cas de grandeurs aux noeuds, on boucle sur les maillages
|
||
|
|
int dim = ParaGlob::Dimension();
|
||
|
|
cout << "\n --- somme, moyenne, max, min etc. sur des references de noeuds ---";
|
||
|
|
// on récupère la liste des maillages à visualiser
|
||
|
|
const list <int>& list_mail = choix_mail->List_choisit();
|
||
|
|
list<int>::const_iterator ilm,ilmfin=list_mail.end();
|
||
|
|
int taille_list_maille = list_mail.size();
|
||
|
|
if (list_mail.size() == 0)
|
||
|
|
{ cout << "\n aucun maillage n'est definit ! , il faut commencer par definir les maillages pour"
|
||
|
|
<< " lesquels on veut une sortie ";
|
||
|
|
return;
|
||
|
|
};
|
||
|
|
// on balaie les différents maillages
|
||
|
|
for (ilm = list_mail.begin();ilm!=ilmfin;ilm++)
|
||
|
|
{int n_mail = abs(*ilm); // numéro du maillage
|
||
|
|
// -- boucle sur les maillages
|
||
|
|
// affichage du nom du maillages s'il y en a plusieurs
|
||
|
|
if (taille_list_maille > 1)
|
||
|
|
cout << "\n ======>>>>> maillage : " << lesMail->NomMaillage(n_mail);
|
||
|
|
|
||
|
|
// -------------- cas des ddl principaux définis aux noeuds -----------------
|
||
|
|
{cout << "\n -------- cas des ddl principaux definis aux noeuds ---------";
|
||
|
|
// on affiche la liste actuelle des grandeurs si elle n'est pas vide
|
||
|
|
if ((tabnoeud_type_ddl_retenu_pourSM(n_mail)).size())
|
||
|
|
{ cout << "\n liste des grandeurs actuellement a sortir: ";
|
||
|
|
List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabnoeud_type_ddl_retenu_pourSM(n_mail)).end();
|
||
|
|
for (iet=(tabnoeud_type_ddl_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
|
||
|
|
cout << (*iet) << " " ;
|
||
|
|
}
|
||
|
|
// on affiche les différentes grandeurs possibles
|
||
|
|
cout << "\n maillage nb : " << n_mail ;
|
||
|
|
cout << "\n la liste des grandeurs disponibles est la suivante : ";
|
||
|
|
List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabnoeud_type_ddl(n_mail)).end();
|
||
|
|
for (iet=(tabnoeud_type_ddl(n_mail)).begin();iet!=ietfin;iet++)
|
||
|
|
cout << (*iet) << " " ;
|
||
|
|
// if ((*iet).Nom_vide()) cout << Nom_ddl((*iet).Enum()) << " "; else cout << (*iet).Nom() << " ";
|
||
|
|
cout << "\n donnez la ou les grandeurs que vous voulez traiter (rep grandeurs?) "
|
||
|
|
<< "\n ou toutes les grandeurs sans les reactions (rep : to) "
|
||
|
|
<< "\n ou toutes les grandeurs (rep : tr) "
|
||
|
|
<< "\n effacer la liste actuelle (rep : ef) "
|
||
|
|
<< "\n (pour terminer tapez : fin (ou f)) ";
|
||
|
|
rep = "";
|
||
|
|
while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
{ cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
|
||
|
|
if (rep == "to")
|
||
|
|
// cas de toutes les grandeurs sans les réactions
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddl(n_mail).end();
|
||
|
|
for (ite = tabnoeud_type_ddl(n_mail).begin();ite != itefin; ite++)
|
||
|
|
if ( !Ddl_reaction((*ite).Enum()))
|
||
|
|
tabnoeud_type_ddl_retenu_pourSM(n_mail).push_back(*ite);
|
||
|
|
tabnoeud_type_ddl_retenu_pourSM(n_mail).sort(); // on ordonne
|
||
|
|
tabnoeud_type_ddl_retenu_pourSM(n_mail).unique();// on supprime les doublons
|
||
|
|
}
|
||
|
|
else if (rep == "tr")
|
||
|
|
// cas de toutes les grandeurs avec les réactions
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddl(n_mail).end();
|
||
|
|
for (ite = tabnoeud_type_ddl(n_mail).begin();ite != itefin; ite++)
|
||
|
|
tabnoeud_type_ddl_retenu_pourSM(n_mail).push_back(*ite);
|
||
|
|
tabnoeud_type_ddl_retenu_pourSM(n_mail).sort(); // on ordonne
|
||
|
|
tabnoeud_type_ddl_retenu_pourSM(n_mail).unique();// on supprime les doublons
|
||
|
|
}
|
||
|
|
else if (ExisteEnum_ddl(rep))
|
||
|
|
{ // on vérifie qu'il appartiend à la liste des ddl proposés
|
||
|
|
Enum_ddl enume=Id_nom_ddl (rep);
|
||
|
|
Ddl_enum_etendu enu_etendu(enume);
|
||
|
|
if (Ddl_enum_etendu::Existe_dans_la_liste(tabnoeud_type_ddl(n_mail),enu_etendu))
|
||
|
|
{ (tabnoeud_type_ddl_retenu_pourSM(n_mail)).push_back(enu_etendu);
|
||
|
|
tabnoeud_type_ddl_retenu_pourSM(n_mail).sort(); // on ordonne
|
||
|
|
(tabnoeud_type_ddl_retenu_pourSM(n_mail)).unique(); // supprime le doublon si nécessaire
|
||
|
|
}
|
||
|
|
else
|
||
|
|
cout << " erreur de choix de ddl, celui choisit n'appartient pas a la liste propose";
|
||
|
|
}
|
||
|
|
else if (rep == "ef")
|
||
|
|
{ // on efface la liste
|
||
|
|
(tabnoeud_type_ddl_retenu_pourSM(n_mail)).clear();
|
||
|
|
}
|
||
|
|
else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
cout << " erreur de syntaxe dans le ddl! recommencez ";
|
||
|
|
};
|
||
|
|
|
||
|
|
};
|
||
|
|
// -------------- cas des ddl étendus définis aux noeuds -----------------
|
||
|
|
{cout << "\n -------- cas des ddl etendus definis aux noeuds ---------";
|
||
|
|
// on affiche la liste actuelle des grandeurs si elle n'est pas vide
|
||
|
|
if ((tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail)).size())
|
||
|
|
{ cout << "\n liste des grandeurs actuellement a sortir: ";
|
||
|
|
List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail)).end();
|
||
|
|
for (iet=(tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
|
||
|
|
cout << (*iet) << " " ;
|
||
|
|
};
|
||
|
|
// on affiche les différentes grandeurs possibles
|
||
|
|
cout << "\n maillage nb : " << n_mail ;
|
||
|
|
cout << "\n la liste des grandeurs disponibles est la suivante : ";
|
||
|
|
List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabnoeud_type_ddlEtendu(n_mail)).end();
|
||
|
|
for (iet=(tabnoeud_type_ddlEtendu(n_mail)).begin();iet!=ietfin;iet++)
|
||
|
|
cout << (*iet) << " " ;
|
||
|
|
cout << "\n donnez la ou les grandeurs que vous voulez visualiser (rep grandeurs?) "
|
||
|
|
<< "\n ou toutes les grandeurs sans les reactions (rep : to) "
|
||
|
|
<< "\n ou toutes les grandeurs (rep : tr) "
|
||
|
|
<< "\n effacer la liste actuelle (rep : ef) "
|
||
|
|
<< "\n (pour terminer tapez : fin (ou f)) ";
|
||
|
|
rep = "";
|
||
|
|
while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
{cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
|
||
|
|
if (rep == "to")
|
||
|
|
// cas de toutes les grandeurs sans les réactions
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddlEtendu(n_mail).end();
|
||
|
|
for (ite = tabnoeud_type_ddlEtendu(n_mail).begin();ite != itefin; ite++)
|
||
|
|
if ( !Ddl_reaction((*ite).Enum()))
|
||
|
|
tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).push_back(*ite);
|
||
|
|
tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).sort(); // on ordonne
|
||
|
|
tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).unique();// on supprime les doublons
|
||
|
|
}
|
||
|
|
else if (rep == "tr")
|
||
|
|
// cas de toutes les grandeurs avec les réactions
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ite,itefin = tabnoeud_type_ddlEtendu(n_mail).end();
|
||
|
|
for (ite = tabnoeud_type_ddlEtendu(n_mail).begin();ite != itefin; ite++)
|
||
|
|
tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).push_back(*ite);
|
||
|
|
tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).sort(); // on ordonne
|
||
|
|
tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).unique();// on supprime les doublons
|
||
|
|
}
|
||
|
|
else if (Ddl_enum_etendu::VerifExistence(rep))
|
||
|
|
{ // on vérifie qu'il appartiend à la liste des ddl étendus proposés
|
||
|
|
Ddl_enum_etendu enu_etendu(rep);
|
||
|
|
if (Ddl_enum_etendu::Existe_dans_la_liste(tabnoeud_type_ddlEtendu(n_mail),enu_etendu))
|
||
|
|
{ (tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail)).push_back(enu_etendu);
|
||
|
|
tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).sort(); // on ordonne
|
||
|
|
(tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail)).unique(); // supprime le doublon si nécessaire
|
||
|
|
}
|
||
|
|
else
|
||
|
|
cout << " erreur de choix de ddl, celui choisit n'appartient pas a la liste propose";
|
||
|
|
}
|
||
|
|
else if (rep == "ef")
|
||
|
|
{ // on efface la liste
|
||
|
|
(tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail)).clear();
|
||
|
|
}
|
||
|
|
else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
cout << " erreur de syntaxe dans le ddl! recommencez ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// -------------- cas des grandeurs quelconques définis aux noeuds -----------------
|
||
|
|
{cout << "\n -------- cas des grandeurs quelconques definies aux noeuds ---------";
|
||
|
|
// dans le cas où aucune grandeur particulière sont défini on passe
|
||
|
|
if ( ((tabnoeud_TypeQuelconque(n_mail)).size() == 0)
|
||
|
|
&& (listeVecGlobbal.size() == 0))
|
||
|
|
{ cout << "\n aucune grandeur particuliere n'est definit, donc aucune proposition ";}
|
||
|
|
else
|
||
|
|
{ // def d'une liste de travail, pour vérifier que tous les grandeurs particuliers sont relatives
|
||
|
|
// à un même point d'intégration
|
||
|
|
List_io < Ddl_enum_etendu > li_ddl;
|
||
|
|
// on affiche la liste actuelle des grandeurs enregistrées
|
||
|
|
if ((tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)).size())
|
||
|
|
{ cout << "\n liste des grandeurs particulieres actuellement a sortir: ";
|
||
|
|
List_io < TypeQuelconque >::iterator iet,ietfin = (tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)).end();
|
||
|
|
for (iet=(tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
|
||
|
|
cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
|
||
|
|
cout << endl;
|
||
|
|
};
|
||
|
|
// on affiche les différentes grandeurs possibles
|
||
|
|
cout << "\n maillage nb : " << n_mail ;
|
||
|
|
cout << "\n la liste des grandeurs particulieres disponibles est la suivante : ";
|
||
|
|
// tout d'abord celles venant du maillage
|
||
|
|
{List_io < TypeQuelconque >::iterator iet,ietfin = (tabnoeud_TypeQuelconque(n_mail)).end();
|
||
|
|
for (iet=(tabnoeud_TypeQuelconque(n_mail)).begin();iet!=ietfin;iet++)
|
||
|
|
cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
|
||
|
|
};
|
||
|
|
// puis celles venant de l'algorithme
|
||
|
|
{List_io < TypeQuelconque >::iterator iet,ietfin = listeVecGlobbal.end();
|
||
|
|
List_io<TypeQuelconque>& tpg = (tabnoeud_TypeQuelconque(n_mail));
|
||
|
|
for (iet=listeVecGlobbal.begin();iet!=ietfin;iet++)
|
||
|
|
{ if ( find(tpg.begin(),tpg.end(),(*iet)) == tpg.end()) // on ne sort que si ça n'a pas déjà été sorti
|
||
|
|
cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
cout << "\n";
|
||
|
|
cout << "\n grandeurs que vous voulez visualiser (rep : grandeurs?)"
|
||
|
|
<< "\n effacer la liste actuelle (rep : ef) "
|
||
|
|
<< "\n toutes les grandeurs : (rep : to) "
|
||
|
|
<< "\n (pour terminer tapez : fin (ou f))";
|
||
|
|
rep = "";
|
||
|
|
while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
{ cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
|
||
|
|
// -- cas de toutes les grandeurs
|
||
|
|
if (rep == "to")
|
||
|
|
{// tout d'abord celles venant du maillage
|
||
|
|
{List_io<TypeQuelconque>& tpg_ret = (tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)); // pour simplifier
|
||
|
|
List_io<TypeQuelconque>& tpg = (tabnoeud_TypeQuelconque(n_mail)); // pour simplifier
|
||
|
|
List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
|
||
|
|
for (ite = tabnoeud_TypeQuelconque(n_mail).begin();ite != itefin; ite++)
|
||
|
|
if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
|
||
|
|
{ tpg_ret.push_back(*ite);};
|
||
|
|
};
|
||
|
|
// puis celles venant de l'algorithme
|
||
|
|
{List_io<TypeQuelconque>& tpg_ret = (tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)); // pour simplifier
|
||
|
|
List_io<TypeQuelconque>& tpg = listeVecGlobbal; // pour simplifier
|
||
|
|
List_io<TypeQuelconque>::iterator ite,itefin = tpg.end();
|
||
|
|
for (ite = listeVecGlobbal.begin();ite != itefin; ite++)
|
||
|
|
if (find(tpg_ret.begin(),tpg_ret.end(),*ite) == tpg_ret.end())
|
||
|
|
{ tpg_ret.push_back(*ite);
|
||
|
|
listeVecGlobbal_retenu.push_back(*ite); // sert pour ajouter les conteneurs aux noeuds
|
||
|
|
};
|
||
|
|
// on sort un message pour indiquer que les grandeurs globales ne seront
|
||
|
|
// disponible qu'au fil du calcul
|
||
|
|
{cout << "\n ---- attention, les grandeurs suivantes ne sont disponibles qu'au fil du calcul ----";
|
||
|
|
List_io < TypeQuelconque >::iterator iet,ietfin = listeVecGlobbal.end();
|
||
|
|
for (iet=listeVecGlobbal.begin();iet!=ietfin;iet++)
|
||
|
|
cout << "\n " << ((*iet).EnuTypeQuelconque().NomPlein()) ;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}
|
||
|
|
// -- cas d'une grandeur particulière
|
||
|
|
else if (TypeQuelconque_enum_etendu::VerifExistence(rep) ) // vérif que c'est une grandeur possible
|
||
|
|
{// maintenant on vérifie qu'elle appartient à la liste des grandeurs disponibles
|
||
|
|
TypeQuelconque a(TypeQuelconque_enum_etendu::RecupTypeQuelconque_enum_etendu(rep)); // création d'un type quelconque sans grandeur
|
||
|
|
bool trouve=false; // init pour le message d'erreur
|
||
|
|
// tout d'abord vérif pour celles venant du maillage
|
||
|
|
{List_io<TypeQuelconque>& tpg_ret = (tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)); // pour simplifier
|
||
|
|
List_io<TypeQuelconque>& tpg = (tabnoeud_TypeQuelconque(n_mail)); // pour simplifier
|
||
|
|
if (find(tpg.begin(),tpg.end(),a) != tpg.end())
|
||
|
|
{ // il existe -> enregistrement
|
||
|
|
List_io<TypeQuelconque>::iterator il = find(tpg.begin(),tpg.end(),a); // récup du réel type
|
||
|
|
// s'il n'existe pas déjà on l'enregistre vraiment
|
||
|
|
if (find(tpg_ret.begin(),tpg_ret.end(),a) == tpg_ret.end())
|
||
|
|
{ tpg_ret.push_back(*il);};
|
||
|
|
trouve = true; // on a bien trouvé une grandeur
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// puis vérif pour celles venant de l'algorithme
|
||
|
|
{List_io<TypeQuelconque>& tpg_ret = (tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)); // pour simplifier
|
||
|
|
List_io<TypeQuelconque>& tpg = listeVecGlobbal; // 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);
|
||
|
|
listeVecGlobbal_retenu.push_back(*il); // sert pour ajouter les conteneurs aux noeuds
|
||
|
|
};
|
||
|
|
trouve = true; // on a bien trouvé une grandeur
|
||
|
|
// on sort un message pour indiquer que la grandeur globale ne sera
|
||
|
|
// disponible qu'au fil du calcul
|
||
|
|
{cout << "\n ---- attention, la grandeur suivante ne sera disponible qu'au fil du calcul ----";
|
||
|
|
cout << "\n " << ((*il).EnuTypeQuelconque().NomPlein()) ;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
if (!trouve)
|
||
|
|
{ cout << "\n erreur, grandeur non disponible !, recommencez ";};
|
||
|
|
}
|
||
|
|
// -- cas où on veut effacer la liste
|
||
|
|
else if (rep == "ef")
|
||
|
|
{(tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)).clear();
|
||
|
|
listeVecGlobbal_retenu.clear();
|
||
|
|
}
|
||
|
|
// -- cas fin
|
||
|
|
else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
cout << " erreur de syntaxe recommencez ";
|
||
|
|
};
|
||
|
|
// affichage des infos actuellement enregistrées
|
||
|
|
if ( (tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)).size() != 0)
|
||
|
|
{ cout << "\n liste des grandeurs particulieres enregistrees: ";
|
||
|
|
List_io < TypeQuelconque >::iterator iet,ietfin = (tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)).end();
|
||
|
|
for (iet=(tabnoeud_TypeQuelconque_retenu_pourSM(n_mail)).begin();iet!=ietfin;iet++)
|
||
|
|
cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
|
||
|
|
cout << endl;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ cout << "\n aucune grandeur enregistree ! \n "; };
|
||
|
|
}; //-- fin du choix sur le fait qu'il existe ou non des grandeurs particulières pour le maillage
|
||
|
|
};
|
||
|
|
|
||
|
|
// -------------- on s'occupe maintenant des références associées -----------------
|
||
|
|
{cout << "\n -------- definition des references de noeuds ---------";
|
||
|
|
// choix des références des noeuds, on affiche la liste actuelle
|
||
|
|
if ((tab_nomDeRef_SM(n_mail)).size() != 0)
|
||
|
|
{ cout << "\n liste actuelle des reference de noeuds a traiter: ";
|
||
|
|
List_io <string >::iterator ieint1,ieintfin1 = (tab_nomDeRef_SM(n_mail)).end();
|
||
|
|
for (ieint1=(tab_nomDeRef_SM(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
|
||
|
|
cout << *ieint1 << " ";
|
||
|
|
cout << endl;
|
||
|
|
};
|
||
|
|
// questions
|
||
|
|
cout << "\n choix des references de noeuds a traiter "
|
||
|
|
<< "\n nouvelle reference de liste de noeuds (rep : neref)"
|
||
|
|
<< "\n effacer la liste actuelle des references de noeuds (rep : efref) "
|
||
|
|
<< "\n afficher la liste des references de noeuds existants (rep : affref) "
|
||
|
|
<< "\n (pour finir tapez : fin (ou f))";
|
||
|
|
rep = "";
|
||
|
|
while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
{ cout << "\n choix ? ";rep = lect_return_defaut(false,"f");
|
||
|
|
bool verif = true; // pour la vérification du numéro du noeud
|
||
|
|
int nu=0 ; // le numéro de noeud
|
||
|
|
if (rep =="neref")
|
||
|
|
{ string nom_ref;
|
||
|
|
cout << "\n nom de la reference ? ";nom_ref= lect_chaine();
|
||
|
|
// vérif que la référence existe
|
||
|
|
if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 1))
|
||
|
|
{ cout << "\n erreur de nom donne (** "<< nom_ref << " **) ne correspond pas a une reference de noeud correcte ";}
|
||
|
|
else // on enregistre
|
||
|
|
{ const ReferenceNE & ref =((ReferenceNE &) lesRef->Trouve(nom_ref,n_mail)); // pour simplifier
|
||
|
|
if (ref.Taille() == 0)
|
||
|
|
{ cout << "\n il n'y a aucun noeud dans la ref (** "<< nom_ref << " **) on n'en tient pas compte ";}
|
||
|
|
else
|
||
|
|
{tab_nomDeRef_SM(n_mail).push_back(nom_ref);
|
||
|
|
tab_nomDeRef_SM(n_mail).sort(); // on ordonne
|
||
|
|
tab_nomDeRef_SM(n_mail).unique();// on supprime les doublons
|
||
|
|
nu = ref.Numero(1); // servira ensuite pour la vérif de ddl
|
||
|
|
};
|
||
|
|
};
|
||
|
|
verif = false; // pour ne pas enregistrer de numéro dans la liste de noeud car ici c'est
|
||
|
|
// la liste de référence de noeud qui est en cause
|
||
|
|
}
|
||
|
|
else if (rep == "efref")
|
||
|
|
{ // on efface la liste des références de noeuds
|
||
|
|
(tab_nomDeRef_SM(n_mail)).clear();
|
||
|
|
verif = false;
|
||
|
|
}
|
||
|
|
else if (rep == "affref")
|
||
|
|
{ // affichage de la liste des références enregistrées dans les maillages
|
||
|
|
cout << "\n liste des references de noeuds ";
|
||
|
|
if (taille_list_maille > 1) cout << "pour le maillage " << lesMail->NomMaillage(n_mail);
|
||
|
|
const Reference* reff =NULL; bool prempass = true;
|
||
|
|
do {
|
||
|
|
if (prempass)
|
||
|
|
{ reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
|
||
|
|
else
|
||
|
|
{ reff = lesRef->Reference_suivante();} // récup de la ref courante
|
||
|
|
// sortie de la ref si c'est le bon maillage, et si c'est une ref de noeud
|
||
|
|
if (reff != NULL)
|
||
|
|
if ((reff->Nbmaille() == n_mail) && (reff->Indic() == 1)) cout << reff->Nom() << " ";
|
||
|
|
prempass = false;
|
||
|
|
} while (reff != NULL);
|
||
|
|
verif = false;
|
||
|
|
}
|
||
|
|
else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
|
||
|
|
{ cout << " erreur de syntaxe on attendait on a lue: " << rep << " ! recommencez ";verif = false;};
|
||
|
|
// vérif que le numéro est acceptable et enregistrement
|
||
|
|
if ((nu>0)&&(nu<=lesMail->Nombre_noeud(n_mail)))
|
||
|
|
{ // on vérifie que les ddls à sortir sont bien présent pour ce noeud
|
||
|
|
List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabnoeud_type_ddl_retenu_pourSM(n_mail).end();
|
||
|
|
for (ienu = tabnoeud_type_ddl_retenu_pourSM(n_mail).begin();ienu!=ienufin;ienu++)
|
||
|
|
{if ( (!(lesMail->Noeud_LesMaille(n_mail,nu).Existe_ici((*ienu).Enum()))) // cas où le ddl principal n'existe pas
|
||
|
|
&& (!(lesMail->Noeud_LesMaille(n_mail,nu).Existe_ici_ddlEtendu((*ienu))))) // cas où le ddl étendu n'existe pas
|
||
|
|
{cout << "\n attention le ddl " << Nom_ddl((*ienu).Enum()) << " n'existe pas pour le noeud "
|
||
|
|
<< nu << " du maillage " << n_mail
|
||
|
|
<< "\n il y aura 0 en sortie ! ";
|
||
|
|
verif = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}// -- fin de la boucle sur les maillages
|
||
|
|
}; // -- fin du cas des ddl principaux aux noeuds
|
||
|
|
|
||
|
|
|
||
|
|
// sortie pour les moyennes sommes etc. sur ref N
|
||
|
|
void Choix_grandeurs_maple::Sortie_somme_moy_N(ostream &sort,Charge* charge,bool unseul_incre)
|
||
|
|
{ // on boucle sur les maillages
|
||
|
|
int nb_maillage = tabnoeud_type_ddl.Taille();
|
||
|
|
for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
|
||
|
|
{
|
||
|
|
// ---- préparation des conteneurs de sortie
|
||
|
|
int NB_ref = tab_nomDeRef_SM(n_mail).size(); // = le nombre de ref
|
||
|
|
// on ne continue que s'il existe des ref
|
||
|
|
if (NB_ref)
|
||
|
|
{
|
||
|
|
// les ddl étendue des grandeurs principales -> grandeurs scalaires
|
||
|
|
List_io < Ddl_enum_etendu > &type_ddl_retenu_pourSM = tabnoeud_type_ddl_retenu_pourSM(n_mail);
|
||
|
|
int nb_ddl = type_ddl_retenu_pourSM.size();
|
||
|
|
// on veut : (1) la somme, (2) la moyenne, (3) le max, (4) le min, (5) le max des | | , (6) le min des | |
|
||
|
|
// tab_tab_pour_ddl_etendu(i)(j)(k) : la grandeur k pour le ddl etendu j de la ref i
|
||
|
|
// tab_tab_pour_MAXI_ddl_etendu(i)(j)(k) : k= 1 -> le numéro du noeud pour le max
|
||
|
|
// k= 2 -> le numéro du noeud pour le min
|
||
|
|
// k= 3 -> le numéro du noeud pour le max des | |
|
||
|
|
// k= 4 -> le numéro du noeud pour le min des | |
|
||
|
|
Tableau <double > t6(6); t6(4)=t6(6)=ConstMath::tresgrand; // on met les mini très grand
|
||
|
|
Tableau <Tableau <double > > toto6(nb_ddl,t6);
|
||
|
|
Tableau < Tableau <Tableau <double > > > tab_tab_pour_ddl(NB_ref,toto6);
|
||
|
|
Tableau <Tableau <int > > titi4(nb_ddl,4);
|
||
|
|
Tableau < Tableau <Tableau <int > > > tab_tab_pour_MAXI_ddl(NB_ref,titi4);
|
||
|
|
|
||
|
|
// idem pour les ddl étendus pour les grandeurs étendues -> grandeurs scalaires
|
||
|
|
List_io < Ddl_enum_etendu > &type_ddlEtendu_retenu_pourSM = tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail);
|
||
|
|
int nb_ddl_etendu = type_ddlEtendu_retenu_pourSM.size();
|
||
|
|
Tableau <Tableau <double > > toto66(nb_ddl_etendu,t6);
|
||
|
|
Tableau < Tableau <Tableau <double > > > tab_tab_pour_ddl_etendu(NB_ref,toto66);
|
||
|
|
Tableau <Tableau <int > > titi44(nb_ddl_etendu,4);
|
||
|
|
Tableau < Tableau <Tableau <int > > > tab_tab_pour_MAXI_ddl_etendu(NB_ref,titi44);
|
||
|
|
|
||
|
|
// pour les grandeurs quelconques, on ne considère que la somme et la moyenne des grandeurs brutes
|
||
|
|
List_io < TypeQuelconque > &TypeQuelconque_retenu_pourSM = tabnoeud_TypeQuelconque_retenu_pourSM(n_mail);
|
||
|
|
int nb_TypeQuelconque = TypeQuelconque_retenu_pourSM.size();
|
||
|
|
Tableau < Tableau <double > > tab_inter(nb_TypeQuelconque); // pour le dimensionnement final
|
||
|
|
// on dimensionne en fonction de la taille de la grandeur quelconque
|
||
|
|
{List_io<TypeQuelconque>::iterator ienu,ienufin=TypeQuelconque_retenu_pourSM.end();
|
||
|
|
int num_enu = 1;
|
||
|
|
for (ienu = TypeQuelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
|
||
|
|
{int nb_val = (*ienu).NbMaxiNumeroOrdre();
|
||
|
|
Tableau <double > & inter = tab_inter(num_enu);
|
||
|
|
inter.Change_taille(nb_val);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
Tableau < Tableau <Tableau <double > > > tab_tab_pour_Quelconque(NB_ref,tab_inter);
|
||
|
|
Tableau < int > tab_ref_taille(NB_ref);
|
||
|
|
|
||
|
|
// ---- on balaie les références de listes de noeuds pour récupérer les informations
|
||
|
|
int num_ref=1;
|
||
|
|
List_io <string >::iterator idl,idlfin= tab_nomDeRef_SM(n_mail).end();
|
||
|
|
for (idl=tab_nomDeRef_SM(n_mail).begin();idl!=idlfin;idl++,num_ref++)
|
||
|
|
{ Tableau <Tableau <double > > & tab_pour_ddl = tab_tab_pour_ddl(num_ref);
|
||
|
|
Tableau <Tableau <int > > & tab_pour_MAXI_ddl = tab_tab_pour_MAXI_ddl(num_ref);
|
||
|
|
Tableau <Tableau <double > > & tab_pour_ddl_etendu = tab_tab_pour_ddl_etendu(num_ref);
|
||
|
|
Tableau <Tableau <int > > & tab_pour_MAXI_ddl_etendu = tab_tab_pour_MAXI_ddl_etendu(num_ref);
|
||
|
|
Tableau <Tableau <double > > & tab_pour_Quelconque = tab_tab_pour_Quelconque(num_ref);
|
||
|
|
// recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve(*idl,n_mail);
|
||
|
|
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref de noeud
|
||
|
|
int taillen=reff.Taille();
|
||
|
|
tab_ref_taille(num_ref)=taillen; // on stocke pour les moyennes
|
||
|
|
|
||
|
|
for (int inoeu=1;inoeu<=taillen;inoeu++) // on boucle sur les noeuds
|
||
|
|
{ Noeud& noe=lesMail->Noeud_LesMaille(n_mail,inoeu);
|
||
|
|
// .... concernant les ddl principaux .....
|
||
|
|
if (!type_ddl_retenu_pourSM.empty())
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ienu,ienufin=type_ddl_retenu_pourSM.end();
|
||
|
|
int num_enu = 1;
|
||
|
|
for (ienu = type_ddl_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
|
||
|
|
{ double val_a_sortir=0.;
|
||
|
|
double val_init=0.; // ne sert pas, on le laisse au cas où
|
||
|
|
Tableau <double > & pour_ddl = tab_pour_ddl(num_enu);
|
||
|
|
Tableau <int > & pour_MAXI_ddl = tab_pour_MAXI_ddl(num_enu);
|
||
|
|
switch(type_sortie_ddl_retenue)
|
||
|
|
{ case 0: // cas où on ne considère que la grandeur
|
||
|
|
{bool asortir = true;
|
||
|
|
if (!noe.Existe_ici((*ienu).Enum()))
|
||
|
|
{ asortir=false;
|
||
|
|
#ifdef MISE_AU_POINT // on regarde si la grandeur existe
|
||
|
|
if (ParaGlob::NiveauImpression() >= 4)
|
||
|
|
{if (ParaGlob::Francais())
|
||
|
|
{cout << "\n attention la grandeur " << (*ienu).Nom_plein() << " n'est pas disponible, on met 0 a la place";}
|
||
|
|
else
|
||
|
|
{cout << "\n Warning the quantity " << (*ienu).Nom_plein() << " is not available, the output will be 0 ";};
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
};
|
||
|
|
if (asortir) // puis la valeur finale de la grandeur
|
||
|
|
{ if (charge->Temps_courant() == 0.) {val_a_sortir = noe.Valeur_0((*ienu).Enum());}
|
||
|
|
else if (noe.Tdt()) {val_a_sortir = noe.Valeur_tdt((*ienu).Enum());}
|
||
|
|
else {val_a_sortir = noe.Valeur_t((*ienu).Enum());};
|
||
|
|
};
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 1: // cas où on ne considère que la variation de la grandeur entre 0 et tdt ou t
|
||
|
|
{bool asortir = true;
|
||
|
|
if (!noe.Existe_ici((*ienu).Enum()))
|
||
|
|
{ asortir=false;
|
||
|
|
#ifdef MISE_AU_POINT // on regarde si la grandeur existe
|
||
|
|
if (ParaGlob::NiveauImpression() >= 4)
|
||
|
|
{if (ParaGlob::Francais())
|
||
|
|
{cout << "\n attention la grandeur " << (*ienu).Nom_plein() << " n'est pas disponible, on met 0 a la place";}
|
||
|
|
else
|
||
|
|
{cout << "\n Warning the quantity " << (*ienu).Nom_plein() << " is not available, the output will be 0 ";};
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
};
|
||
|
|
if (asortir) // puis la valeur finale de la grandeur
|
||
|
|
{ if (charge->Temps_courant() == 0.) {val_a_sortir = 0.;}
|
||
|
|
else if (noe.Tdt()) {val_a_sortir = noe.Valeur_tdt((*ienu).Enum())-noe.Valeur_0((*ienu).Enum());}
|
||
|
|
else {val_a_sortir = noe.Valeur_t((*ienu).Enum())-noe.Valeur_0((*ienu).Enum());};
|
||
|
|
};
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 2: // cas où on sort les grandeurs à 0 et à tdt ou t
|
||
|
|
{bool asortir = true;
|
||
|
|
if (!noe.Existe_ici((*ienu).Enum()))
|
||
|
|
{ asortir=false;
|
||
|
|
#ifdef MISE_AU_POINT // on regarde si la grandeur existe
|
||
|
|
if (ParaGlob::NiveauImpression() >= 4)
|
||
|
|
{if (ParaGlob::Francais())
|
||
|
|
{cout << "\n attention la grandeur " << (*ienu).Nom_plein() << " n'est pas disponible, on met 0 a la place";}
|
||
|
|
else
|
||
|
|
{cout << "\n Warning the quantity " << (*ienu).Nom_plein() << " is not available, the output will be 0 ";};
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
if (asortir) // puis la valeur finale de la grandeur
|
||
|
|
{ if (charge->Temps_courant() == 0.)
|
||
|
|
{val_init = val_a_sortir = noe.Valeur_0((*ienu).Enum());}
|
||
|
|
else if (noe.Tdt())
|
||
|
|
{val_a_sortir = noe.Valeur_tdt((*ienu).Enum());
|
||
|
|
val_init = noe.Valeur_0((*ienu).Enum());}
|
||
|
|
else
|
||
|
|
{val_a_sortir = noe.Valeur_t((*ienu).Enum());
|
||
|
|
val_init = noe.Valeur_0((*ienu).Enum());};
|
||
|
|
};
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}; // fin du switch sur type_sortie_ddl_retenue
|
||
|
|
|
||
|
|
// le calcul des grandeurs
|
||
|
|
pour_ddl(1) += val_a_sortir;
|
||
|
|
pour_ddl(2) += 1.; // on s'en sert ici comme compteur
|
||
|
|
int num_noeud = noe.Num_Mail();
|
||
|
|
if (pour_ddl(3) < val_a_sortir)
|
||
|
|
{ pour_ddl(3) = val_a_sortir;
|
||
|
|
pour_MAXI_ddl(1) = num_noeud;
|
||
|
|
};
|
||
|
|
if (pour_ddl(4) > val_a_sortir)
|
||
|
|
{ pour_ddl(4) = val_a_sortir;
|
||
|
|
pour_MAXI_ddl(2) = num_noeud;
|
||
|
|
};
|
||
|
|
if (Dabs(pour_ddl(5)) < Dabs(val_a_sortir))
|
||
|
|
{ pour_ddl(5) = val_a_sortir;
|
||
|
|
pour_MAXI_ddl(3) = num_noeud;
|
||
|
|
};
|
||
|
|
if (Dabs(pour_ddl(6)) > Dabs(val_a_sortir))
|
||
|
|
{ pour_ddl(6) = val_a_sortir;
|
||
|
|
pour_MAXI_ddl(4) = num_noeud;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// .... concernant les ddl étendus .....
|
||
|
|
if (!type_ddlEtendu_retenu_pourSM.empty())
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ienu,ienufin=type_ddlEtendu_retenu_pourSM.end();
|
||
|
|
int num_enu = 1;
|
||
|
|
for (ienu = type_ddlEtendu_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
|
||
|
|
{double val_a_sortir=0.;
|
||
|
|
Tableau <double > & pour_ddl_etendu = tab_pour_ddl_etendu(num_enu);
|
||
|
|
Tableau <int > & pour_MAXI_ddl_etendu = tab_pour_MAXI_ddl_etendu(num_enu);
|
||
|
|
#ifdef MISE_AU_POINT // on regarde si la grandeur existe
|
||
|
|
if (!noe.Existe_ici_ddlEtendu((*ienu)))
|
||
|
|
{ if (ParaGlob::NiveauImpression() >= 4)
|
||
|
|
{if (ParaGlob::Francais())
|
||
|
|
{cout << "\n attention la grandeur " << (*ienu).Nom_plein() << " n'est pas disponible, on met 0 a la place";}
|
||
|
|
else
|
||
|
|
{cout << "\n Warning the quantity " << (*ienu).Nom_plein() << " is not available, the output will be 0 ";};
|
||
|
|
};
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
if (noe.Existe_ici_ddlEtendu((*ienu))) {val_a_sortir = noe.DdlEtendue(*ienu).ConstValeur();}
|
||
|
|
// le calcul des grandeurs
|
||
|
|
pour_ddl_etendu(1) += val_a_sortir;
|
||
|
|
pour_ddl_etendu(2) += 1.; // on s'en sert ici comme compteur
|
||
|
|
int num_noeud = noe.Num_Mail();
|
||
|
|
if (pour_ddl_etendu(3) < val_a_sortir)
|
||
|
|
{ pour_ddl_etendu(3) = val_a_sortir;
|
||
|
|
pour_MAXI_ddl_etendu(1) = num_noeud;
|
||
|
|
};
|
||
|
|
if (pour_ddl_etendu(4) > val_a_sortir)
|
||
|
|
{ pour_ddl_etendu(4) = val_a_sortir;
|
||
|
|
pour_MAXI_ddl_etendu(2) = num_noeud;
|
||
|
|
};
|
||
|
|
if (Dabs(pour_ddl_etendu(5)) < Dabs(val_a_sortir))
|
||
|
|
{ pour_ddl_etendu(5) = val_a_sortir;
|
||
|
|
pour_MAXI_ddl_etendu(3) = num_noeud;
|
||
|
|
};
|
||
|
|
if (Dabs(pour_ddl_etendu(6)) > Dabs(val_a_sortir))
|
||
|
|
{ pour_ddl_etendu(6) = val_a_sortir;
|
||
|
|
pour_MAXI_ddl_etendu(4) = num_noeud;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// .... concernant les grandeurs quelconque aux noeud .....
|
||
|
|
if (!TypeQuelconque_retenu_pourSM.empty())
|
||
|
|
{List_io<TypeQuelconque>::iterator ienu,ienufin=TypeQuelconque_retenu_pourSM.end();
|
||
|
|
int num_enu = 1;
|
||
|
|
for (ienu = TypeQuelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
|
||
|
|
{
|
||
|
|
int nb_val = (*ienu).NbMaxiNumeroOrdre();
|
||
|
|
Tableau <double > & pour_Quelconque = tab_pour_Quelconque(num_enu);
|
||
|
|
// récup de l'énuméré
|
||
|
|
TypeQuelconque_enum_etendu enuq = (*ienu).EnuTypeQuelconque();
|
||
|
|
#ifdef MISE_AU_POINT // on regarde si la grandeur existe
|
||
|
|
if (!noe.Existe_ici(enuq))
|
||
|
|
{ if (ParaGlob::NiveauImpression() >= 4)
|
||
|
|
{if (ParaGlob::Francais())
|
||
|
|
{cout << "\n attention la grandeur " << (enuq.NomPlein()) << " n'est pas disponible, on met 0 a la place";}
|
||
|
|
else
|
||
|
|
{cout << "\n Warning the quantity " << (enuq.NomPlein()) << " is not available, the output will be 0 ";};
|
||
|
|
};
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
for (int i=1;i<= nb_val;i++)
|
||
|
|
{if (noe.Existe_ici(enuq))
|
||
|
|
{ const TypeQuelconque& grand_quelconque_noe = noe.Grandeur_quelconque(enuq);
|
||
|
|
pour_Quelconque(i) += grand_quelconque_noe.GrandeurNumOrdre(i);
|
||
|
|
};
|
||
|
|
// dans le cas où la grandeur n'existe pas on ne fait rien
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// ---- on écrit les informations
|
||
|
|
|
||
|
|
// écriture du temps que si il y a des ref et que l'on n'est pas avec un seul incrément
|
||
|
|
// sinon on écrit le temps également en commentaire
|
||
|
|
// à moins que le style de sortie force une sortie sur une seule ligne
|
||
|
|
int nbdigit = ParaGlob::NbdigdoGR();
|
||
|
|
if ((NB_ref != 0) && ((!unseul_incre) || (style_de_sortie==1)))
|
||
|
|
{ sort << setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
|
||
|
|
else if (NB_ref != 0)
|
||
|
|
// ici on écrit une fois le temps en commentaire
|
||
|
|
{ sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
|
||
|
|
|
||
|
|
for (int num_ref=1;num_ref <= NB_ref; num_ref++)
|
||
|
|
{
|
||
|
|
// ... les ddl de base
|
||
|
|
{Tableau <Tableau <double > > & tab_pour_ddl = tab_tab_pour_ddl(num_ref);
|
||
|
|
Tableau <Tableau <int > > & tab_pour_MAXI_ddl = tab_tab_pour_MAXI_ddl(num_ref);
|
||
|
|
for (int num_ddl = 1; num_ddl <= nb_ddl; num_ddl++)
|
||
|
|
{ Tableau <double > & pour_ddl = tab_pour_ddl(num_ddl);
|
||
|
|
Tableau <int > & pour_MAXI_ddl = tab_pour_MAXI_ddl(num_ddl);
|
||
|
|
// calcul finale de la moyenne
|
||
|
|
pour_ddl(2) = pour_ddl(1) / pour_ddl(2);
|
||
|
|
sort << setprecision(nbdigit)
|
||
|
|
<< pour_ddl(1) << " " << pour_ddl(2) << " "
|
||
|
|
<< pour_ddl(3) << " " << pour_MAXI_ddl(1) << " "
|
||
|
|
<< pour_ddl(4) << " " << pour_MAXI_ddl(2) << " "
|
||
|
|
<< pour_ddl(5) << " " << pour_MAXI_ddl(3) << " "
|
||
|
|
<< pour_ddl(6) << " " << pour_MAXI_ddl(4) << " ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// ... les ddl étendues
|
||
|
|
{Tableau <Tableau <double > > & tab_pour_ddl_etendu = tab_tab_pour_ddl_etendu(num_ref);
|
||
|
|
Tableau <Tableau <int > > & tab_pour_MAXI_ddl_etendu = tab_tab_pour_MAXI_ddl_etendu(num_ref);
|
||
|
|
for (int num_ddl = 1; num_ddl <= nb_ddl_etendu; num_ddl++)
|
||
|
|
{ Tableau <double > & pour_ddl_etendu = tab_pour_ddl_etendu(num_ddl);
|
||
|
|
Tableau <int > & pour_MAXI_ddl_etendu = tab_pour_MAXI_ddl_etendu(num_ddl);
|
||
|
|
// calcul finale de la moyenne
|
||
|
|
pour_ddl_etendu(2) = pour_ddl_etendu(1) / pour_ddl_etendu(2);
|
||
|
|
sort << setprecision(nbdigit)
|
||
|
|
<< pour_ddl_etendu(1) << " " << pour_ddl_etendu(2) << " "
|
||
|
|
<< pour_ddl_etendu(3) << " " << pour_MAXI_ddl_etendu(1) << " "
|
||
|
|
<< pour_ddl_etendu(4) << " " << pour_MAXI_ddl_etendu(2) << " "
|
||
|
|
<< pour_ddl_etendu(5) << " " << pour_MAXI_ddl_etendu(3) << " "
|
||
|
|
<< pour_ddl_etendu(6) << " " << pour_MAXI_ddl_etendu(4) << " ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// ... les grandeurs quelconques
|
||
|
|
{Tableau <Tableau <double > > & tab_pour_Quelconque = tab_tab_pour_Quelconque(num_ref);
|
||
|
|
for (int num_val = 1; num_val <= nb_TypeQuelconque; num_val++)
|
||
|
|
{ Tableau <double > & pour_Quelconque = tab_pour_Quelconque(num_val);
|
||
|
|
int taille = pour_Quelconque.Taille();
|
||
|
|
sort << setprecision(nbdigit);
|
||
|
|
// on sort les sommes
|
||
|
|
for (int i=1;i<=taille;i++)
|
||
|
|
sort << pour_Quelconque(i) << " ";
|
||
|
|
// puis les moyennes
|
||
|
|
int nb_pt = tab_ref_taille(num_ref);
|
||
|
|
for (int i=1;i<=taille;i++)
|
||
|
|
sort << (pour_Quelconque(i)/nb_pt) << " ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}; // fin de la boucle sur les références
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
// sortie pour les moyennes sommes etc. sur ref E
|
||
|
|
void Choix_grandeurs_maple::Sortie_somme_moy_E(ostream &sort,Charge* charge,bool unseul_incre)
|
||
|
|
{ // on boucle sur les maillages
|
||
|
|
int nb_maillage = tabelement_type_ddl.Taille();
|
||
|
|
for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
|
||
|
|
{
|
||
|
|
// ---- préparation des conteneurs de sortie
|
||
|
|
int NB_ref_E = tab_nomDeRef_E_SM(n_mail).size(); // = le nombre de ref
|
||
|
|
int NB_ref_pti = tab_nomDeRef_ptinteg_SM(n_mail).size(); // pour les pti
|
||
|
|
int NB_ref = NB_ref_E + NB_ref_pti;
|
||
|
|
// on ne continue que s'il existe des ref
|
||
|
|
if (NB_ref)
|
||
|
|
{
|
||
|
|
// les ddl étendue des grandeurs principales -> grandeurs scalaires
|
||
|
|
List_io < Ddl_enum_etendu > &type_ddl_retenu_pourSM = tabelement_type_ddl_retenu_pourSM(n_mail);
|
||
|
|
int nb_ddl = type_ddl_retenu_pourSM.size();
|
||
|
|
// on veut : (1) la somme, (2) la moyenne,
|
||
|
|
// (3) le max, (4) le min,
|
||
|
|
// (5) le max des | | , (6) le min des | |
|
||
|
|
|
||
|
|
// tab_tab_pour_ddl_etendu(i)(j)(k) : la grandeur k pour le ddl etendu j de la ref i
|
||
|
|
// tab_tab_pour_MAXI_ddl_etendu(i)(j)(k) : k= 1 -> le numéro de l'element pour le max
|
||
|
|
// k= 2 -> le numéro de l'element pour le min
|
||
|
|
// k= 3 -> le numéro de l'element pour le max des | |
|
||
|
|
// k= 4 -> le numéro de l'element pour le min des | |
|
||
|
|
// k= 5 -> le numéro du pti pour le max
|
||
|
|
// k= 6 -> le numéro du pti pour le min
|
||
|
|
// k= 7 -> le numéro du pti pour le max des | |
|
||
|
|
// k= 8 -> le numéro du pti pour le min des | |
|
||
|
|
Tableau <double > t6(6); t6(4)=t6(6)=ConstMath::tresgrand; // on met les mini très grand
|
||
|
|
Tableau <Tableau <double > > toto6(nb_ddl,t6);
|
||
|
|
Tableau < Tableau <Tableau <double > > > tab_tab_pour_ddl(NB_ref,toto6);
|
||
|
|
Tableau <Tableau <int > > titi8(nb_ddl,8);
|
||
|
|
Tableau < Tableau <Tableau <int > > > tab_tab_pour_MAXI_ddl(NB_ref,titi8);
|
||
|
|
|
||
|
|
// idem pour les grandeurs quelconques, on ne considère que la somme et la moyenne des grandeurs brutes
|
||
|
|
List_io < TypeQuelconque > & element_quelconque_retenu_pourSM = tabelement_typeParti_retenu_pourSM(n_mail);
|
||
|
|
int nb_TypeQuelconque = element_quelconque_retenu_pourSM.size();
|
||
|
|
Tableau < Tableau <double > > tab_inter_Q(nb_TypeQuelconque); // pour le dimensionnement final
|
||
|
|
// on dimensionne en fonction de la taille de la grandeur quelconque
|
||
|
|
{List_io<TypeQuelconque>::iterator ienu,ienufin=element_quelconque_retenu_pourSM.end();
|
||
|
|
int num_enu = 1;
|
||
|
|
for (ienu = element_quelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
|
||
|
|
{int nb_val = (*ienu).NbMaxiNumeroOrdre();
|
||
|
|
Tableau <double > & inter = tab_inter_Q(num_enu);
|
||
|
|
inter.Change_taille(nb_val);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
Tableau < Tableau <Tableau <double > > > tab_tab_pour_Quelconque(NB_ref,tab_inter_Q);
|
||
|
|
Tableau < int > tab_nb_pour_Quelconque(NB_ref); // la taille de la somme
|
||
|
|
|
||
|
|
// pour les grandeurs évoluées, on ne considère que la somme et la moyenne des grandeurs brutes
|
||
|
|
List_io < TypeQuelconque > &element_evoluee_retenu_pourSM = tabelement_evoluee_retenu_pourSM(n_mail);
|
||
|
|
int nb_TypeEvolue = element_evoluee_retenu_pourSM.size();
|
||
|
|
Tableau < Tableau <double > > tab_inter(nb_TypeEvolue); // pour le dimensionnement final
|
||
|
|
// on dimensionne en fonction de la taille de la grandeur quelconque
|
||
|
|
{List_io<TypeQuelconque>::iterator ienu,ienufin=element_evoluee_retenu_pourSM.end();
|
||
|
|
int num_enu = 1;
|
||
|
|
for (ienu = element_evoluee_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
|
||
|
|
{int nb_val = (*ienu).NbMaxiNumeroOrdre();
|
||
|
|
Tableau <double > & inter = tab_inter(num_enu);
|
||
|
|
inter.Change_taille(nb_val);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
Tableau < Tableau <Tableau <double > > > tab_tab_pour_Evoluee(NB_ref,tab_inter);
|
||
|
|
Tableau < int > tab_ref_taille(NB_ref);
|
||
|
|
Tableau < int > tab_nb_pour_Evoluee(NB_ref); // la taille de la somme
|
||
|
|
|
||
|
|
// ---- on balaie les références de listes des elements pour récupérer les informations
|
||
|
|
List_io <BlocScal >::iterator idl = tab_nomDeRef_E_SM(n_mail).begin();
|
||
|
|
List_io < string >::iterator idl_Rpti = tab_nomDeRef_ptinteg_SM(n_mail).begin();
|
||
|
|
|
||
|
|
for (int num_ref=1;num_ref <= NB_ref; num_ref++)
|
||
|
|
{ Tableau <Tableau <double > > & tab_pour_ddl = tab_tab_pour_ddl(num_ref);
|
||
|
|
Tableau <Tableau <int > > & tab_pour_MAXI_ddl = tab_tab_pour_MAXI_ddl(num_ref);
|
||
|
|
Tableau <Tableau <double > > & tab_pour_Quelconque = tab_tab_pour_Quelconque(num_ref);
|
||
|
|
int & nb_pour_Quelconque = tab_nb_pour_Quelconque(num_ref); // la taille de la somme
|
||
|
|
|
||
|
|
Tableau <Tableau <double > > & tab_pour_Evoluee = tab_tab_pour_Evoluee(num_ref);
|
||
|
|
int & nb_pour_Evoluee = tab_nb_pour_Evoluee(num_ref); // la taille de la somme
|
||
|
|
|
||
|
|
// recup de la reference correspondant au mot cle
|
||
|
|
const Reference * refi=NULL; // init
|
||
|
|
int taillen=0; // init
|
||
|
|
bool en_refN=true; // pour savoir ensuite si on est en refN ou refAF
|
||
|
|
if (num_ref < NB_ref_E+1)
|
||
|
|
{ refi = &(lesRef->Trouve((*idl).NomRef(),n_mail));
|
||
|
|
const ReferenceNE& reff_E = ((ReferenceNE &) *refi); // transfo en ref d'élément
|
||
|
|
taillen=reff_E.Taille();
|
||
|
|
tab_ref_taille(num_ref)=taillen; // on stocke pour les moyennes
|
||
|
|
}
|
||
|
|
else // ils s'agit d'une ref de pti
|
||
|
|
{ refi = &(lesRef->Trouve((*idl_Rpti),n_mail));
|
||
|
|
const ReferenceAF & reff_AF = ((ReferenceAF &) *refi); // transfo en ref d'élément
|
||
|
|
taillen=reff_AF.Taille();
|
||
|
|
tab_ref_taille(num_ref)=taillen; // on stocke pour les moyennes
|
||
|
|
en_refN=false;
|
||
|
|
};
|
||
|
|
for (int i_ele=1;i_ele<=taillen;i_ele++) // on boucle sur les elements
|
||
|
|
{
|
||
|
|
int nbElem = 0; // init
|
||
|
|
int nbPtInteg = 0; // init
|
||
|
|
if (en_refN)
|
||
|
|
{ const ReferenceNE& reff = ((ReferenceNE &) *refi); // transfo en ref d'élément
|
||
|
|
nbElem = reff.Numero(i_ele);
|
||
|
|
nbPtInteg = (*idl).Val();
|
||
|
|
}
|
||
|
|
else // ils s'agit d'une ref de pti
|
||
|
|
{ const ReferenceAF & reff = ((ReferenceAF &) *refi);
|
||
|
|
nbElem = reff.NumeroElem(i_ele);
|
||
|
|
nbPtInteg = reff.NumeroFA(i_ele);
|
||
|
|
};
|
||
|
|
Element& ele = lesMail->Element_LesMaille(n_mail,nbElem);
|
||
|
|
////-----debug
|
||
|
|
//if (ele.Num_elt() == 449)
|
||
|
|
// cout << "\n nb_elem "<< flush ;
|
||
|
|
////----fin debug
|
||
|
|
// .... concernant les ddl principaux .....
|
||
|
|
if (!type_ddl_retenu_pourSM.empty())
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ienu=type_ddl_retenu_pourSM.begin();
|
||
|
|
List_io<Ddl_enum_etendu>::iterator ienufin=type_ddl_retenu_pourSM.end();
|
||
|
|
// maintenant il y a deux cas, soit on travaille avec un seul pti soit
|
||
|
|
// on considère tous les pti, on va faire une boucle par défaut
|
||
|
|
int min_pti=nbPtInteg; int max_pti = nbPtInteg;
|
||
|
|
if (nbPtInteg == -1)
|
||
|
|
{min_pti = 1;
|
||
|
|
max_pti = ele.NbPtInteg((*ienu).Enum());
|
||
|
|
};
|
||
|
|
|
||
|
|
for (int ipti = min_pti;ipti <= max_pti;ipti++)
|
||
|
|
{
|
||
|
|
// on récupère directement toutes les grandeurs
|
||
|
|
Tableau <double> tab= ele.Valeur_a_diff_temps
|
||
|
|
(absolue,TEMPS_tdt,type_ddl_retenu_pourSM,ipti);
|
||
|
|
// on fait le traitement
|
||
|
|
int nb_val_plus_un = 1+tab.Taille(); // normalement == type_ddl_retenu_pourSM.size()
|
||
|
|
#ifdef MISE_AU_POINT
|
||
|
|
if (tab.Taille() != type_ddl_retenu_pourSM.size())
|
||
|
|
{ cout << "\n**** pb dans le calcul Sortie_somme_moy_E( les resultats ne seront pas exploitables" << endl ;
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
for (int num_enu = 1 ;num_enu < nb_val_plus_un;num_enu++)
|
||
|
|
{ Tableau <double > & pour_ddl = tab_pour_ddl(num_enu);
|
||
|
|
Tableau <int > & pour_MAXI_ddl = tab_pour_MAXI_ddl(num_enu);
|
||
|
|
|
||
|
|
// le calcul des grandeurs
|
||
|
|
double val_a_sortir=tab(num_enu);// pour simplifier
|
||
|
|
pour_ddl(1) += val_a_sortir;
|
||
|
|
pour_ddl(2) += 1.; // on s'en sert ici comme compteur
|
||
|
|
////-----debug
|
||
|
|
//if ((ele.Num_elt() == 449)&& (ipti == 5) )
|
||
|
|
// cout << "\n nb_elem pour_ddl(3)= "<< pour_ddl(3) << " val_a_sortir= " << val_a_sortir << flush ;
|
||
|
|
////----fin debug
|
||
|
|
|
||
|
|
int num_element = ele.Num_elt();
|
||
|
|
if (pour_ddl(3) < val_a_sortir)
|
||
|
|
{ pour_ddl(3) = val_a_sortir;
|
||
|
|
pour_MAXI_ddl(1) = num_element;
|
||
|
|
pour_MAXI_ddl(5) = ipti;
|
||
|
|
};
|
||
|
|
if (pour_ddl(4) > val_a_sortir)
|
||
|
|
{ pour_ddl(4) = val_a_sortir;
|
||
|
|
pour_MAXI_ddl(2) = num_element;
|
||
|
|
pour_MAXI_ddl(6) = ipti;
|
||
|
|
};
|
||
|
|
if (Dabs(pour_ddl(5)) < Dabs(val_a_sortir))
|
||
|
|
{ pour_ddl(5) = val_a_sortir;
|
||
|
|
pour_MAXI_ddl(3) = num_element;
|
||
|
|
pour_MAXI_ddl(7) = ipti;
|
||
|
|
};
|
||
|
|
if (Dabs(pour_ddl(6)) > Dabs(val_a_sortir))
|
||
|
|
{ pour_ddl(6) = val_a_sortir;
|
||
|
|
pour_MAXI_ddl(4) = num_element;
|
||
|
|
pour_MAXI_ddl(8) = ipti;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// .... concernant les grandeurs particulières .....
|
||
|
|
if (!element_quelconque_retenu_pourSM.empty())
|
||
|
|
{List_io<TypeQuelconque>::iterator jquefin=element_quelconque_retenu_pourSM.end();
|
||
|
|
List_io<TypeQuelconque>::iterator jque,jque_deb=element_quelconque_retenu_pourSM.begin();
|
||
|
|
if (jque_deb != jquefin) // c'est a dire: cas où existe une grandeur
|
||
|
|
{// maintenant il y a deux cas, soit on travaille avec un seul pti soit
|
||
|
|
// on considère tous les pti, on va faire une boucle par défaut
|
||
|
|
int min_pti=nbPtInteg; int max_pti = nbPtInteg;
|
||
|
|
if (nbPtInteg == -1)
|
||
|
|
{min_pti = 1;
|
||
|
|
max_pti = ele.NbPtInteg((*jque_deb).Enum());
|
||
|
|
};
|
||
|
|
|
||
|
|
for (int ipti = min_pti;ipti <= max_pti;ipti++)
|
||
|
|
{// puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
|
||
|
|
// on récupère ainsi d'un coup toutes les valeurs
|
||
|
|
// puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
|
||
|
|
ele.Grandeur_particuliere(absolue,element_quelconque_retenu_pourSM,ipti);
|
||
|
|
// on transfert dans le tableau
|
||
|
|
int num_enu = 1;
|
||
|
|
for (jque=jque_deb;jque!=jquefin;jque++,num_enu++)
|
||
|
|
{int nb_val = (*jque).NbMaxiNumeroOrdre();
|
||
|
|
Tableau <double > & pour_Quelconque = tab_pour_Quelconque(num_enu);
|
||
|
|
for (int i=1;i<= nb_val;i++)
|
||
|
|
pour_Quelconque(i) += (*jque).GrandeurNumOrdre(i);
|
||
|
|
};
|
||
|
|
// on incrément le compteur de somme
|
||
|
|
nb_pour_Quelconque++;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// .... concernant les grandeurs évoluées aux element .....
|
||
|
|
if (!element_evoluee_retenu_pourSM.empty())
|
||
|
|
{List_io<TypeQuelconque>::iterator jquefin=element_evoluee_retenu_pourSM.end();
|
||
|
|
List_io<TypeQuelconque>::iterator jque,jque_deb=element_evoluee_retenu_pourSM.begin();
|
||
|
|
if (jque_deb != jquefin) // c'est a dire: cas où existe une grandeur
|
||
|
|
{// maintenant il y a deux cas, soit on travaille avec un seul pti soit
|
||
|
|
// on considère tous les pti, on va faire une boucle par défaut
|
||
|
|
int min_pti=nbPtInteg; int max_pti = nbPtInteg;
|
||
|
|
if (nbPtInteg == -1)
|
||
|
|
{min_pti = 1;
|
||
|
|
max_pti = ele.NbPtInteg((*jque_deb).Enum());
|
||
|
|
};
|
||
|
|
|
||
|
|
for (int ipti = min_pti;ipti <= max_pti;ipti++)
|
||
|
|
{// puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
|
||
|
|
// on récupère ainsi d'un coup toutes les valeurs
|
||
|
|
ele.ValTensorielle_a_diff_temps(absolue,TEMPS_tdt,element_evoluee_retenu_pourSM,ipti);
|
||
|
|
// on transfert dans le tableau
|
||
|
|
int num_enu = 1;
|
||
|
|
for (jque=jque_deb;jque!=jquefin;jque++,num_enu++)
|
||
|
|
{int nb_val = (*jque).NbMaxiNumeroOrdre();
|
||
|
|
Tableau <double > & pour_Evoluee = tab_pour_Evoluee(num_enu);
|
||
|
|
for (int i=1;i<= nb_val;i++)
|
||
|
|
pour_Evoluee(i) += (*jque).GrandeurNumOrdre(i);
|
||
|
|
};
|
||
|
|
// on incrément le compteur de somme
|
||
|
|
nb_pour_Evoluee++;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
};
|
||
|
|
// --- incrémentation des pointeurs de ref ---
|
||
|
|
if (en_refN) {idl++;}
|
||
|
|
else { idl_Rpti++;};
|
||
|
|
};
|
||
|
|
|
||
|
|
// ---- on écrit les informations
|
||
|
|
|
||
|
|
// écriture du temps que si il y a des ref et que l'on n'est pas avec un seul incrément
|
||
|
|
// sinon on écrit le temps également en commentaire
|
||
|
|
// à moins que le style de sortie force une sortie sur une seule ligne
|
||
|
|
int nbdigit = ParaGlob::NbdigdoGR();
|
||
|
|
if ((NB_ref != 0) && ((!unseul_incre) || (style_de_sortie==1)))
|
||
|
|
{ sort << setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
|
||
|
|
else if (NB_ref != 0)
|
||
|
|
// ici on écrit une fois le temps en commentaire
|
||
|
|
{ sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
|
||
|
|
|
||
|
|
for (int num_ref=1;num_ref <= NB_ref; num_ref++)
|
||
|
|
{
|
||
|
|
// ... les ddl de base
|
||
|
|
{Tableau <Tableau <double > > & tab_pour_ddl = tab_tab_pour_ddl(num_ref);
|
||
|
|
Tableau <Tableau <int > > & tab_pour_MAXI_ddl = tab_tab_pour_MAXI_ddl(num_ref);
|
||
|
|
for (int num_ddl = 1; num_ddl <= nb_ddl; num_ddl++)
|
||
|
|
{ Tableau <double > & pour_ddl = tab_pour_ddl(num_ddl);
|
||
|
|
Tableau <int > & pour_MAXI_ddl = tab_pour_MAXI_ddl(num_ddl);
|
||
|
|
// calcul finale de la moyenne
|
||
|
|
pour_ddl(2) = pour_ddl(1) / pour_ddl(2);
|
||
|
|
sort << setprecision(nbdigit)
|
||
|
|
<< pour_ddl(1) << " " << pour_ddl(2) << " "
|
||
|
|
<< pour_ddl(3) << " " << pour_MAXI_ddl(1) << " " << pour_MAXI_ddl(5) << " "
|
||
|
|
<< pour_ddl(4) << " " << pour_MAXI_ddl(2) << " " << pour_MAXI_ddl(6) << " "
|
||
|
|
<< pour_ddl(5) << " " << pour_MAXI_ddl(3) << " " << pour_MAXI_ddl(7) << " "
|
||
|
|
<< pour_ddl(6) << " " << pour_MAXI_ddl(4) << " " << pour_MAXI_ddl(8) << " ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// ... les grandeurs quelconques
|
||
|
|
{Tableau <Tableau <double > > & tab_pour_Quelconque = tab_tab_pour_Quelconque(num_ref);
|
||
|
|
int & nb_pour_Quelconque = tab_nb_pour_Quelconque(num_ref); // la taille de la somme
|
||
|
|
for (int num_val = 1; num_val <= nb_TypeQuelconque; num_val++)
|
||
|
|
{ Tableau <double > & pour_Quelconque = tab_pour_Quelconque(num_val);
|
||
|
|
int taille = pour_Quelconque.Taille();
|
||
|
|
sort << setprecision(nbdigit);
|
||
|
|
// on sort les sommes
|
||
|
|
for (int i=1;i<=taille;i++)
|
||
|
|
sort << pour_Quelconque(i) << " ";
|
||
|
|
// puis les moyennes
|
||
|
|
for (int i=1;i<=taille;i++)
|
||
|
|
sort << (pour_Quelconque(i)/nb_pour_Quelconque) << " ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// ... les grandeurs évoluées
|
||
|
|
{Tableau <Tableau <double > > & tab_pour_Evoluee = tab_tab_pour_Evoluee(num_ref);
|
||
|
|
int & nb_pour_Evoluee = tab_nb_pour_Evoluee(num_ref); // la taille de la somme
|
||
|
|
for (int num_val = 1; num_val <= nb_TypeEvolue; num_val++)
|
||
|
|
{ Tableau <double > & pour_Evoluee = tab_pour_Evoluee(num_val);
|
||
|
|
int taille = pour_Evoluee.Taille();
|
||
|
|
sort << setprecision(nbdigit);
|
||
|
|
// on sort les sommes
|
||
|
|
for (int i=1;i<=taille;i++)
|
||
|
|
sort << pour_Evoluee(i) << " ";
|
||
|
|
// puis les moyennes
|
||
|
|
for (int i=1;i<=taille;i++)
|
||
|
|
sort << (pour_Evoluee(i)/nb_pour_Evoluee) << " ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}; // fin de la boucle sur les références
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
};
|
||
|
|
// sortie de l'entete pour les moyennes sommes etc. sur ref N
|
||
|
|
void Choix_grandeurs_maple::Sortie_entete_somme_moy_N(ostream &sort,int & num_col)
|
||
|
|
{ // on boucle sur les maillages
|
||
|
|
int nb_maillage = tabnoeud_type_ddl.Taille();
|
||
|
|
for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
|
||
|
|
{// ---- préparation
|
||
|
|
int NB_ref = tab_nomDeRef_SM(n_mail).size(); // = le nombre de ref
|
||
|
|
int num_total_grandeur=0;
|
||
|
|
// les ddl étendue des grandeurs principales -> grandeurs scalaires
|
||
|
|
List_io < Ddl_enum_etendu > &type_ddl_retenu_pourSM = tabnoeud_type_ddl_retenu_pourSM(n_mail);
|
||
|
|
int nb_ddl = type_ddl_retenu_pourSM.size();
|
||
|
|
num_total_grandeur += nb_ddl*10;
|
||
|
|
// idem pour les ddl étendus pour les grandeurs étendues -> grandeurs scalaires
|
||
|
|
List_io < Ddl_enum_etendu > &type_ddlEtendu_retenu_pourSM = tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail);
|
||
|
|
int nb_ddl_etendu = type_ddlEtendu_retenu_pourSM.size();
|
||
|
|
num_total_grandeur += nb_ddl_etendu*10;
|
||
|
|
// pour les grandeurs quelconques, on ne considère que la somme et la moyenne des grandeurs brutes
|
||
|
|
List_io < TypeQuelconque > &TypeQuelconque_retenu_pourSM = tabnoeud_TypeQuelconque_retenu_pourSM(n_mail);
|
||
|
|
int nb_TypeQuelconque = TypeQuelconque_retenu_pourSM.size();
|
||
|
|
// on dimensionne en fonction de la taille de la grandeur quelconque
|
||
|
|
{List_io<TypeQuelconque>::iterator ienu,ienufin=TypeQuelconque_retenu_pourSM.end();
|
||
|
|
int num_enu = 1;
|
||
|
|
for (ienu = TypeQuelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
|
||
|
|
{int nb_val = (*ienu).NbMaxiNumeroOrdre();
|
||
|
|
num_total_grandeur += nb_val*2;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
|
||
|
|
else {sort << "\n# mesh_" << n_mail << " : "; };
|
||
|
|
sort << NB_ref << " "<< num_total_grandeur*NB_ref << " ";
|
||
|
|
if (ParaGlob::Francais()) {sort << " (nombre de ref de noeud et nombre total de grandeurs associees) "; }
|
||
|
|
else {sort << " (number of ref of node and global number of associated values ) "; }
|
||
|
|
// if ((NB_ref != 0)&&(type_ddl_retenu_pourSM.size()>1))
|
||
|
|
// {if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
|
||
|
|
// else {sort << "\n# mesh_" << n_mail << " : "; };
|
||
|
|
// }
|
||
|
|
sort << "\n# ";
|
||
|
|
if (NB_ref != 0)
|
||
|
|
num_col++; // on passe l'affichage du temps
|
||
|
|
// puis les ref s'il y en a
|
||
|
|
if (NB_ref != 0)
|
||
|
|
{int num_ref=1;
|
||
|
|
List_io <string >::iterator idl,idlfin= tab_nomDeRef_SM(n_mail).end();
|
||
|
|
for (idl=tab_nomDeRef_SM(n_mail).begin();idl!=idlfin;idl++,num_ref++)
|
||
|
|
{ sort << (*idl) << " "; // le nom de la ref
|
||
|
|
// recup de la reference correspondant au mot cle
|
||
|
|
const Reference& refi = lesRef->Trouve(*idl,n_mail);
|
||
|
|
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref de noeud
|
||
|
|
sort << "( "<<(reff.Taille()) << " ) "<< num_total_grandeur << " "; // le nombre de noeuds
|
||
|
|
|
||
|
|
if (ParaGlob::Francais()) {sort << " (ref, (nombre de noeuds) et nombre total de grandeurs associees) "; }
|
||
|
|
else {sort << " (ref name, (number of nodes) and global number of associated values) "; };
|
||
|
|
|
||
|
|
// === les positions de chaque grandeurs ===
|
||
|
|
|
||
|
|
// --- les ddl principaux ----
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabnoeud_type_ddl_retenu_pourSM(n_mail).end();
|
||
|
|
for (ienu = tabnoeud_type_ddl_retenu_pourSM(n_mail).begin();ienu!=ienufin;ienu++)
|
||
|
|
{string inter; // init
|
||
|
|
switch (type_sortie_ddl_retenue)
|
||
|
|
{ case 0: case 2: // on ne sort pas les grandeurs à 0 moyennée
|
||
|
|
{ inter = ((*ienu).Nom_plein());
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 1:
|
||
|
|
{ inter = ("delta_0_t_"+string((*ienu).Nom_plein()));
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
// la sortie
|
||
|
|
sort << "\n#["<<num_col<<"]"<< inter << "_sum ";num_col++; // la somme
|
||
|
|
sort << " ["<<num_col<<"]"<< inter << "_moy ";num_col++; // la moyenne
|
||
|
|
|
||
|
|
sort << " ["<<num_col<<"]"<< inter << "_max ";num_col++; // le max
|
||
|
|
sort << " ["<<num_col<<"] num_noeud ";num_col++; // le numéro du max
|
||
|
|
|
||
|
|
sort << " ["<<num_col<<"]"<< inter << "_min ";num_col++; // le min
|
||
|
|
sort << " ["<<num_col<<"] num_noeud ";num_col++; // le numéro du min
|
||
|
|
|
||
|
|
sort << " ["<<num_col<<"]"<< inter << "_maxAbs ";num_col++; // le max de abs
|
||
|
|
sort << " ["<<num_col<<"] num_noeud ";num_col++; // le numéro du max
|
||
|
|
|
||
|
|
sort << " ["<<num_col<<"]"<< inter << "_minAbs ";num_col++; // le min de abs
|
||
|
|
sort << " ["<<num_col<<"] num_noeud ";num_col++; // le numéro du min
|
||
|
|
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// --- les ddl étendus ----
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).end();
|
||
|
|
for (ienu = tabnoeud_type_ddlEtendu_retenu_pourSM(n_mail).begin();ienu!=ienufin;ienu++)
|
||
|
|
{
|
||
|
|
sort << "\n#["<<num_col<<"]"<< (*ienu).Nom_plein() << "_sum ";num_col++; // la somme
|
||
|
|
sort << " ["<<num_col<<"]"<< (*ienu).Nom_plein() << "_moy ";num_col++; // la moyenne
|
||
|
|
|
||
|
|
sort << " ["<<num_col<<"]"<< (*ienu).Nom_plein() << "_max ";num_col++; // le max
|
||
|
|
sort << " ["<<num_col<<"] num_noeud ";num_col++; // le numéro du max
|
||
|
|
|
||
|
|
sort << " ["<<num_col<<"]"<< (*ienu).Nom_plein() << "_min ";num_col++; // le min
|
||
|
|
sort << " ["<<num_col<<"] num_noeud ";num_col++; // le numéro du min
|
||
|
|
|
||
|
|
sort << " ["<<num_col<<"]"<< (*ienu).Nom_plein() << "_maxAbs ";num_col++; // le max de abs
|
||
|
|
sort << " ["<<num_col<<"] num_noeud ";num_col++; // le numéro du max
|
||
|
|
|
||
|
|
sort << " ["<<num_col<<"]"<< (*ienu).Nom_plein() << "_minAbs ";num_col++; // le min de abs
|
||
|
|
sort << " ["<<num_col<<"] num_noeud ";num_col++; // le numéro du min
|
||
|
|
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// --- les grandeurs quelconques ---
|
||
|
|
{List_io<TypeQuelconque>::iterator iquefin=tabnoeud_TypeQuelconque_retenu_pourSM(n_mail).end();
|
||
|
|
List_io<TypeQuelconque>::iterator ique,ique_deb=tabnoeud_TypeQuelconque_retenu_pourSM(n_mail).begin();
|
||
|
|
for (ique = ique_deb;ique != iquefin;ique++)
|
||
|
|
{sort << "\n#"; (*ique).Ecriture_entete_grandeur(sort);
|
||
|
|
sort << " (somme) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
|
||
|
|
num_col += (*ique).NbMaxiNumeroOrdre();
|
||
|
|
sort << " (moyenne) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
|
||
|
|
num_col += (*ique).NbMaxiNumeroOrdre();
|
||
|
|
//sort << "\n# ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
//sort << " ;\n# ";
|
||
|
|
};
|
||
|
|
sort << " ;\n# ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
};
|
||
|
|
// sortie de l'entete pour les moyennes sommes etc. sur ref E
|
||
|
|
void Choix_grandeurs_maple::Sortie_entete_somme_moy_E(ostream &sort,int & num_col)
|
||
|
|
{ // on boucle sur les maillages
|
||
|
|
int nb_maillage = tabelement_type_ddl.Taille();
|
||
|
|
for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
|
||
|
|
{// ---- préparation
|
||
|
|
// ---- préparation des conteneurs de sortie
|
||
|
|
int NB_ref_E = tab_nomDeRef_E_SM(n_mail).size(); // = le nombre de ref
|
||
|
|
int NB_ref_pti = tab_nomDeRef_ptinteg_SM(n_mail).size(); // pour les pti
|
||
|
|
int NB_ref = NB_ref_E + NB_ref_pti;
|
||
|
|
int num_total_grandeur=0;
|
||
|
|
// les ddl étendue des grandeurs principales -> grandeurs scalaires
|
||
|
|
List_io < Ddl_enum_etendu > &type_ddl_retenu_pourSM = tabelement_type_ddl_retenu_pourSM(n_mail);
|
||
|
|
int nb_ddl = type_ddl_retenu_pourSM.size();
|
||
|
|
num_total_grandeur += nb_ddl*14;
|
||
|
|
|
||
|
|
// pour les grandeurs quelconques, on ne considère que la somme et la moyenne des grandeurs brutes
|
||
|
|
List_io < TypeQuelconque > &TypeQuelconque_retenu_pourSM = tabelement_typeParti_retenu_pourSM(n_mail);
|
||
|
|
int nb_TypeQuelconque = TypeQuelconque_retenu_pourSM.size();
|
||
|
|
// on dimensionne en fonction de la taille de la grandeur quelconque
|
||
|
|
{List_io<TypeQuelconque>::iterator ienu,ienufin=TypeQuelconque_retenu_pourSM.end();
|
||
|
|
int num_enu = 1;
|
||
|
|
for (ienu = TypeQuelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
|
||
|
|
{int nb_val = (*ienu).NbMaxiNumeroOrdre();
|
||
|
|
num_total_grandeur += nb_val*2;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// pour les grandeurs évoluées, on ne considère que la somme et la moyenne des grandeurs brutes
|
||
|
|
List_io < TypeQuelconque > &Type_evoluee_retenu_pourSM = tabelement_evoluee_retenu_pourSM(n_mail);
|
||
|
|
int nb_Type_evoluee = Type_evoluee_retenu_pourSM.size();
|
||
|
|
// on dimensionne en fonction de la taille de la grandeur quelconque
|
||
|
|
{List_io<TypeQuelconque>::iterator ienu,ienufin=Type_evoluee_retenu_pourSM.end();
|
||
|
|
int num_enu = 1;
|
||
|
|
for (ienu = Type_evoluee_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
|
||
|
|
{int nb_val = (*ienu).NbMaxiNumeroOrdre();
|
||
|
|
num_total_grandeur += nb_val*2;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
|
||
|
|
else {sort << "\n# mesh_" << n_mail << " : "; };
|
||
|
|
sort << NB_ref << " "<< num_total_grandeur*NB_ref << " ";
|
||
|
|
if (ParaGlob::Francais()) {sort << " (nombre de ref d'element et nombre total de grandeurs associees) "; }
|
||
|
|
else {sort << " (number of ref of element and global number of associated values ) "; }
|
||
|
|
// if ((NB_ref != 0)&&(type_ddl_retenu_pourSM.size()>1))
|
||
|
|
// {if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
|
||
|
|
// else {sort << "\n# mesh_" << n_mail << " : "; };
|
||
|
|
// }
|
||
|
|
sort << "\n# ";
|
||
|
|
if (NB_ref != 0)
|
||
|
|
num_col++; // on passe l'affichage du temps
|
||
|
|
// puis les ref s'il y en a
|
||
|
|
if (NB_ref != 0)
|
||
|
|
{List_io <BlocScal >::iterator idl = tab_nomDeRef_E_SM(n_mail).begin();
|
||
|
|
List_io < string >::iterator idl_Rpti = tab_nomDeRef_ptinteg_SM(n_mail).begin();
|
||
|
|
|
||
|
|
for (int num_ref=1;num_ref <= NB_ref; num_ref++)
|
||
|
|
{ string nom_ref; // init
|
||
|
|
// recup de la reference correspondant au mot cle
|
||
|
|
const Reference * refi=NULL; // init
|
||
|
|
int taillen=0; // init
|
||
|
|
bool en_refN=true; // pour savoir ensuite si on est en refN ou refAF
|
||
|
|
if (num_ref < NB_ref_E+1)
|
||
|
|
{ nom_ref = (*idl).NomRef();
|
||
|
|
refi = &(lesRef->Trouve(nom_ref,n_mail));
|
||
|
|
const ReferenceNE& reff_E = ((ReferenceNE &) *refi); // transfo en ref d'élément
|
||
|
|
taillen=reff_E.Taille();
|
||
|
|
}
|
||
|
|
else // ils s'agit d'une ref de pti
|
||
|
|
{ nom_ref = (*idl_Rpti);
|
||
|
|
refi = &(lesRef->Trouve(nom_ref,n_mail));
|
||
|
|
const ReferenceAF & reff_AF = ((ReferenceAF &) *refi); // transfo en ref d'élément
|
||
|
|
taillen=reff_AF.Taille();
|
||
|
|
en_refN=false;
|
||
|
|
};
|
||
|
|
if (num_ref > 1) sort << "\n# ";
|
||
|
|
sort << nom_ref << " "; // le nom de la ref
|
||
|
|
sort << "( "<< taillen << " ) " << num_total_grandeur << " "; // le nombre d'éléments
|
||
|
|
if (ParaGlob::Francais()) {sort << " (ref, (nombre d'element), nombre total de valeurs ) "; }
|
||
|
|
else {sort << " (ref name, (number of nodes) total number of values) "; };
|
||
|
|
|
||
|
|
// === les positions de chaque grandeurs ===
|
||
|
|
|
||
|
|
// --- les ddl principaux ----
|
||
|
|
{List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabelement_type_ddl_retenu_pourSM(n_mail).end();
|
||
|
|
for (ienu = tabelement_type_ddl_retenu_pourSM(n_mail).begin();ienu!=ienufin;ienu++)
|
||
|
|
{string inter; // init
|
||
|
|
switch (type_sortie_ddl_retenue)
|
||
|
|
{ case 0: case 2: // on ne sort pas les grandeurs à 0 moyennée
|
||
|
|
{ inter = ((*ienu).Nom_plein());
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 1:
|
||
|
|
{ inter = ("delta_0_t_"+string((*ienu).Nom_plein()));
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
// la sortie
|
||
|
|
sort << "\n#["<<num_col<<"]"<< inter << "_sum ";num_col++; // la somme
|
||
|
|
sort << " ["<<num_col<<"]"<< inter << "_moy ";num_col++; // la moyenne
|
||
|
|
|
||
|
|
sort << " ["<<num_col<<"]"<< inter << "_max ";num_col++; // le max
|
||
|
|
sort << " ["<<num_col<<"] num_element ";num_col++; // le numéro du max
|
||
|
|
sort << " ["<<num_col<<"] num_pti ";num_col++; // le numéro du max
|
||
|
|
|
||
|
|
sort << " ["<<num_col<<"]"<< inter << "_min ";num_col++; // le min
|
||
|
|
sort << " ["<<num_col<<"] num_element ";num_col++; // le numéro du min
|
||
|
|
sort << " ["<<num_col<<"] num_pti ";num_col++; // le numéro du min
|
||
|
|
|
||
|
|
sort << " ["<<num_col<<"]"<< inter << "_maxAbs ";num_col++; // le max de abs
|
||
|
|
sort << " ["<<num_col<<"] num_element ";num_col++; // le numéro du max
|
||
|
|
sort << " ["<<num_col<<"] num_pti ";num_col++; // le numéro du max
|
||
|
|
|
||
|
|
sort << " ["<<num_col<<"]"<< inter << "_minAbs ";num_col++; // le min de abs
|
||
|
|
sort << " ["<<num_col<<"] num_element ";num_col++; // le numéro du min
|
||
|
|
sort << " ["<<num_col<<"] num_pti ";num_col++; // le numéro du min
|
||
|
|
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// --- les grandeurs quelconques ---
|
||
|
|
{List_io<TypeQuelconque>::iterator iquefin=tabelement_typeParti_retenu_pourSM(n_mail).end();
|
||
|
|
List_io<TypeQuelconque>::iterator ique,ique_deb=tabelement_typeParti_retenu_pourSM(n_mail).begin();
|
||
|
|
for (ique = ique_deb;ique != iquefin;ique++)
|
||
|
|
{sort << "\n#"; (*ique).Ecriture_entete_grandeur(sort);
|
||
|
|
sort << " (somme) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
|
||
|
|
num_col += (*ique).NbMaxiNumeroOrdre();
|
||
|
|
sort << " (moyenne) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
|
||
|
|
num_col += (*ique).NbMaxiNumeroOrdre();
|
||
|
|
//sort << "\n# ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
// --- les grandeurs évoluées ---
|
||
|
|
{List_io<TypeQuelconque>::iterator iquefin=tabelement_evoluee_retenu_pourSM(n_mail).end();
|
||
|
|
List_io<TypeQuelconque>::iterator ique,ique_deb=tabelement_evoluee_retenu_pourSM(n_mail).begin();
|
||
|
|
for (ique = ique_deb;ique != iquefin;ique++)
|
||
|
|
{sort << "\n#"; (*ique).Ecriture_entete_grandeur(sort);
|
||
|
|
sort << " (somme) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
|
||
|
|
num_col += (*ique).NbMaxiNumeroOrdre();
|
||
|
|
sort << " (moyenne) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
|
||
|
|
num_col += (*ique).NbMaxiNumeroOrdre();
|
||
|
|
//sort << "\n# ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// --- incrémentation des pointeurs de ref ---
|
||
|
|
if (en_refN) {idl++;}
|
||
|
|
else { idl_Rpti++;};
|
||
|
|
};
|
||
|
|
sort << " ;\n# ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
// sortie pour les moyennes sommes etc. sur ref de face E
|
||
|
|
void Choix_grandeurs_maple::Sortie_somme_moy_face_E(ostream &sort,Charge* charge,bool unseul_incre)
|
||
|
|
{ // on boucle sur les maillages
|
||
|
|
int nb_maillage = tab_F_element_TypeQuelconque.Taille();
|
||
|
|
for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
|
||
|
|
{
|
||
|
|
// ---- préparation des conteneurs de sortie
|
||
|
|
int NB_ref_E = tab_nomDeRef_F_E_SM(n_mail).size(); // = le nombre de ref
|
||
|
|
int NB_ref_pti = tab_nomDeRef_F_ptinteg_SM(n_mail).size(); // pour les pti
|
||
|
|
int NB_ref = NB_ref_E + NB_ref_pti;
|
||
|
|
// on ne continue que s'il existe des ref
|
||
|
|
if (NB_ref)
|
||
|
|
{
|
||
|
|
// on veut : (1) la somme, (2) la moyenne, (3) le max, (4) le min, (5) le max des | | , (6) le min des | |
|
||
|
|
// tab_tab_pour_ddl_etendu(i)(j)(k) : la grandeur k pour le ddl etendu j de la ref i
|
||
|
|
// tab_tab_pour_MAXI_ddl_etendu(i)(j)(k) : k= 1 -> le numéro de l'element pour le max
|
||
|
|
// k= 2 -> le numéro de l'element pour le min
|
||
|
|
// k= 3 -> le numéro de l'element pour le max des | |
|
||
|
|
// k= 4 -> le numéro de l'element pour le min des | |
|
||
|
|
// k= 5 -> le numéro du pti pour le max
|
||
|
|
// k= 6 -> le numéro du pti pour le min
|
||
|
|
// k= 7 -> le numéro du pti pour le max des | |
|
||
|
|
// k= 8 -> le numéro du pti pour le min des | |
|
||
|
|
|
||
|
|
// pour les grandeurs quelconques, on ne considère que la somme et la moyenne des grandeurs brutes
|
||
|
|
List_io < TypeQuelconque > & element_quelconque_retenu_pourSM = tab_F_element_TypeQuelconque_retenu_pourSM(n_mail);
|
||
|
|
int nb_TypeQuelconque = element_quelconque_retenu_pourSM.size();
|
||
|
|
Tableau < Tableau <double > > tab_inter_Q(nb_TypeQuelconque); // pour le dimensionnement final
|
||
|
|
// on dimensionne en fonction de la taille de la grandeur quelconque
|
||
|
|
{List_io<TypeQuelconque>::iterator ienu,ienufin=element_quelconque_retenu_pourSM.end();
|
||
|
|
int num_enu = 1;
|
||
|
|
for (ienu = element_quelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
|
||
|
|
{int nb_val = (*ienu).NbMaxiNumeroOrdre();
|
||
|
|
Tableau <double > & inter = tab_inter_Q(num_enu);
|
||
|
|
inter.Change_taille(nb_val);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
Tableau < Tableau <Tableau <double > > > tab_tab_pour_Quelconque(NB_ref,tab_inter_Q);
|
||
|
|
Tableau < int > tab_nb_pour_Quelconque(NB_ref); // la taille de la somme
|
||
|
|
|
||
|
|
Tableau < int > tab_ref_taille(NB_ref);
|
||
|
|
|
||
|
|
// ---- on balaie les références de listes des elements pour récupérer les informations
|
||
|
|
List_io <BlocScal >::iterator idl = tab_nomDeRef_F_E_SM(n_mail).begin();
|
||
|
|
List_io < string >::iterator idl_Rpti = tab_nomDeRef_F_ptinteg_SM(n_mail).begin();
|
||
|
|
|
||
|
|
for (int num_ref=1;num_ref <= NB_ref; num_ref++)
|
||
|
|
{ Tableau <Tableau <double > > & tab_pour_Quelconque = tab_tab_pour_Quelconque(num_ref);
|
||
|
|
int & nb_pour_Quelconque = tab_nb_pour_Quelconque(num_ref); // la taille de la somme
|
||
|
|
|
||
|
|
// recup de la reference correspondant au mot cle
|
||
|
|
const Reference * refi=NULL; // init
|
||
|
|
int taillen=0; // init
|
||
|
|
bool en_refN=true; // pour savoir ensuite si on est refAF ou PtiAF
|
||
|
|
if (num_ref < NB_ref_E+1)
|
||
|
|
{ refi = &(lesRef->Trouve((*idl).NomRef(),n_mail));
|
||
|
|
const ReferenceAF& reff_E = ((ReferenceAF &) *refi); // transfo en ref de faces d'élément
|
||
|
|
taillen=reff_E.Taille();
|
||
|
|
tab_ref_taille(num_ref)=taillen; // on stocke pour les moyennes
|
||
|
|
}
|
||
|
|
else // ils s'agit d'une ref de pti de faces d'élément
|
||
|
|
{ refi = &(lesRef->Trouve((*idl_Rpti),n_mail));
|
||
|
|
const ReferencePtiAF & reff_AF = ((ReferencePtiAF &) *refi); // transfo en ref de pti de face d'élément
|
||
|
|
taillen=reff_AF.Taille();
|
||
|
|
tab_ref_taille(num_ref)=taillen; // on stocke pour les moyennes
|
||
|
|
en_refN=false;
|
||
|
|
};
|
||
|
|
int face = 0; // init
|
||
|
|
for (int i_ele=1;i_ele<=taillen;i_ele++) // on boucle sur les elements
|
||
|
|
{
|
||
|
|
int nbElem = 0; // init
|
||
|
|
int nbPtInteg = 0; // init
|
||
|
|
if (en_refN)
|
||
|
|
{ const ReferenceAF& reff = ((ReferenceAF &) *refi); // transfo en ref d'élément
|
||
|
|
nbElem = reff.NumeroElem(i_ele);
|
||
|
|
face = reff.NumeroFA(i_ele);
|
||
|
|
nbPtInteg = (*idl).Val();
|
||
|
|
}
|
||
|
|
else // ils s'agit d'une ref de pti
|
||
|
|
{ const ReferencePtiAF & reff = ((ReferencePtiAF &) *refi);
|
||
|
|
nbElem = reff.NumeroElem(i_ele);
|
||
|
|
face = reff.NumeroFA(i_ele);
|
||
|
|
nbPtInteg = reff.NumeroPti(i_ele);
|
||
|
|
};
|
||
|
|
Element& ele = lesMail->Element_LesMaille(n_mail,nbElem);
|
||
|
|
|
||
|
|
// .... concernant les grandeurs quelconque .....
|
||
|
|
if (!element_quelconque_retenu_pourSM.empty())
|
||
|
|
{List_io<TypeQuelconque>::iterator jquefin=element_quelconque_retenu_pourSM.end();
|
||
|
|
List_io<TypeQuelconque>::iterator jque,jque_deb=element_quelconque_retenu_pourSM.begin();
|
||
|
|
if (jque_deb != jquefin) // c'est a dire: cas où existe une grandeur
|
||
|
|
{// maintenant il y a deux cas, soit on travaille avec un seul pti soit
|
||
|
|
// on considère tous les pti, on va faire une boucle par défaut
|
||
|
|
int min_pti=nbPtInteg; int max_pti = nbPtInteg;
|
||
|
|
if (nbPtInteg == -1)
|
||
|
|
{min_pti = 1;
|
||
|
|
const ElFrontiere* elf = ele.Frontiere_surfacique(face);
|
||
|
|
max_pti = elf->ElementGeometrique().Nbi();
|
||
|
|
};
|
||
|
|
|
||
|
|
for (int ipti = min_pti;ipti <= max_pti;ipti++)
|
||
|
|
{// puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
|
||
|
|
// on récupère ainsi d'un coup toutes les valeurs
|
||
|
|
ele.Grandeur_particuliere_face(absolue,element_quelconque_retenu_pourSM,face,ipti);
|
||
|
|
// on transfert dans le tableau
|
||
|
|
int num_enu = 1;
|
||
|
|
for (jque=jque_deb;jque!=jquefin;jque++,num_enu++)
|
||
|
|
{int nb_val = (*jque).NbMaxiNumeroOrdre();
|
||
|
|
Tableau <double > & pour_Quelconque = tab_pour_Quelconque(num_enu);
|
||
|
|
for (int i=1;i<= nb_val;i++)
|
||
|
|
pour_Quelconque(i) += (*jque).GrandeurNumOrdre(i);
|
||
|
|
};
|
||
|
|
// on incrément le compteur de somme
|
||
|
|
nb_pour_Quelconque++;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
};
|
||
|
|
// --- incrémentation des pointeurs de ref ---
|
||
|
|
if (en_refN) {idl++;}
|
||
|
|
else { idl_Rpti++;};
|
||
|
|
};
|
||
|
|
|
||
|
|
// ---- on écrit les informations
|
||
|
|
|
||
|
|
// écriture du temps que si il y a des ref et que l'on n'est pas avec un seul incrément
|
||
|
|
// sinon on écrit le temps également en commentaire
|
||
|
|
// à moins que le style de sortie force une sortie sur une seule ligne
|
||
|
|
int nbdigit = ParaGlob::NbdigdoGR();
|
||
|
|
if ((NB_ref != 0) && ((!unseul_incre) || (style_de_sortie==1)))
|
||
|
|
{ sort << setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
|
||
|
|
else if (NB_ref != 0)
|
||
|
|
// ici on écrit une fois le temps en commentaire
|
||
|
|
{ sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
|
||
|
|
|
||
|
|
for (int num_ref=1;num_ref <= NB_ref; num_ref++)
|
||
|
|
{// ... les grandeurs quelconques
|
||
|
|
{Tableau <Tableau <double > > & tab_pour_Quelconque = tab_tab_pour_Quelconque(num_ref);
|
||
|
|
int & nb_pour_Quelconque = tab_nb_pour_Quelconque(num_ref); // la taille de la somme
|
||
|
|
for (int num_val = 1; num_val <= nb_TypeQuelconque; num_val++)
|
||
|
|
{ Tableau <double > & pour_Quelconque = tab_pour_Quelconque(num_val);
|
||
|
|
int taille = pour_Quelconque.Taille();
|
||
|
|
sort << setprecision(nbdigit);
|
||
|
|
// on sort les sommes
|
||
|
|
for (int i=1;i<=taille;i++)
|
||
|
|
sort << pour_Quelconque(i) << " ";
|
||
|
|
// puis les moyennes
|
||
|
|
for (int i=1;i<=taille;i++)
|
||
|
|
sort << (pour_Quelconque(i)/nb_pour_Quelconque) << " ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}; // fin de la boucle sur les références
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
};
|
||
|
|
// sortie pour les moyennes sommes etc. sur ref d'arête E
|
||
|
|
void Choix_grandeurs_maple::Sortie_somme_moy_arete_E(ostream &sort,Charge* charge,bool unseul_incre)
|
||
|
|
{ // on boucle sur les maillages
|
||
|
|
int nb_maillage = tab_A_element_TypeQuelconque.Taille();
|
||
|
|
for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
|
||
|
|
{
|
||
|
|
// ---- préparation des conteneurs de sortie
|
||
|
|
int NB_ref_E = tab_nomDeRef_A_E_SM(n_mail).size(); // = le nombre de ref
|
||
|
|
int NB_ref_pti = tab_nomDeRef_A_ptinteg_SM(n_mail).size(); // pour les pti
|
||
|
|
int NB_ref = NB_ref_E + NB_ref_pti;
|
||
|
|
// on ne continue que s'il existe des ref
|
||
|
|
if (NB_ref)
|
||
|
|
{
|
||
|
|
// on veut : (1) la somme, (2) la moyenne, (3) le max, (4) le min, (5) le max des | | , (6) le min des | |
|
||
|
|
// tab_tab_pour_ddl_etendu(i)(j)(k) : la grandeur k pour le ddl etendu j de la ref i
|
||
|
|
// tab_tab_pour_MAXI_ddl_etendu(i)(j)(k) : k= 1 -> le numéro de l'element pour le max
|
||
|
|
// k= 2 -> le numéro de l'element pour le min
|
||
|
|
// k= 3 -> le numéro de l'element pour le max des | |
|
||
|
|
// k= 4 -> le numéro de l'element pour le min des | |
|
||
|
|
// k= 5 -> le numéro du pti pour le max
|
||
|
|
// k= 6 -> le numéro du pti pour le min
|
||
|
|
// k= 7 -> le numéro du pti pour le max des | |
|
||
|
|
// k= 8 -> le numéro du pti pour le min des | |
|
||
|
|
|
||
|
|
// pour les grandeurs quelconques, on ne considère que la somme et la moyenne des grandeurs brutes
|
||
|
|
List_io < TypeQuelconque > & element_quelconque_retenu_pourSM = tab_A_element_TypeQuelconque_retenu_pourSM(n_mail);
|
||
|
|
int nb_TypeQuelconque = element_quelconque_retenu_pourSM.size();
|
||
|
|
Tableau < Tableau <double > > tab_inter_Q(nb_TypeQuelconque); // pour le dimensionnement final
|
||
|
|
// on dimensionne en fonction de la taille de la grandeur quelconque
|
||
|
|
{List_io<TypeQuelconque>::iterator ienu,ienufin=element_quelconque_retenu_pourSM.end();
|
||
|
|
int num_enu = 1;
|
||
|
|
for (ienu = element_quelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
|
||
|
|
{int nb_val = (*ienu).NbMaxiNumeroOrdre();
|
||
|
|
Tableau <double > & inter = tab_inter_Q(num_enu);
|
||
|
|
inter.Change_taille(nb_val);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
Tableau < Tableau <Tableau <double > > > tab_tab_pour_Quelconque(NB_ref,tab_inter_Q);
|
||
|
|
Tableau < int > tab_nb_pour_Quelconque(NB_ref); // la taille de la somme
|
||
|
|
|
||
|
|
Tableau < int > tab_ref_taille(NB_ref);
|
||
|
|
|
||
|
|
// ---- on balaie les références de listes des elements pour récupérer les informations
|
||
|
|
List_io <BlocScal >::iterator idl = tab_nomDeRef_A_E_SM(n_mail).begin();
|
||
|
|
List_io < string >::iterator idl_Rpti = tab_nomDeRef_A_ptinteg_SM(n_mail).begin();
|
||
|
|
|
||
|
|
for (int num_ref=1;num_ref <= NB_ref; num_ref++)
|
||
|
|
{ Tableau <Tableau <double > > & tab_pour_Quelconque = tab_tab_pour_Quelconque(num_ref);
|
||
|
|
int & nb_pour_Quelconque = tab_nb_pour_Quelconque(num_ref); // la taille de la somme
|
||
|
|
|
||
|
|
// recup de la reference correspondant au mot cle
|
||
|
|
const Reference * refi=NULL; // init
|
||
|
|
int taillen=0; // init
|
||
|
|
bool en_refN=true; // pour savoir ensuite si on est en refN ou refAF
|
||
|
|
if (num_ref < NB_ref_E+1)
|
||
|
|
{ refi = &(lesRef->Trouve((*idl).NomRef(),n_mail));
|
||
|
|
const ReferenceAF& reff_E = ((ReferenceAF &) *refi); // transfo en ref de faces d'élément
|
||
|
|
taillen=reff_E.Taille();
|
||
|
|
tab_ref_taille(num_ref)=taillen; // on stocke pour les moyennes
|
||
|
|
}
|
||
|
|
else // ils s'agit d'une ref de pti de faces d'élément
|
||
|
|
{ refi = &(lesRef->Trouve((*idl_Rpti),n_mail));
|
||
|
|
const ReferencePtiAF & reff_AF = ((ReferencePtiAF &) *refi); // transfo en ref de pti de face d'élément
|
||
|
|
taillen=reff_AF.Taille();
|
||
|
|
tab_ref_taille(num_ref)=taillen; // on stocke pour les moyennes
|
||
|
|
en_refN=false;
|
||
|
|
};
|
||
|
|
int arete = 0; // init
|
||
|
|
for (int i_ele=1;i_ele<=taillen;i_ele++) // on boucle sur les elements
|
||
|
|
{
|
||
|
|
int nbElem = 0; // init
|
||
|
|
int nbPtInteg = 0; // init
|
||
|
|
if (en_refN)
|
||
|
|
{ const ReferenceAF& reff = ((ReferenceAF &) *refi); // transfo en ref de face d'élément
|
||
|
|
nbElem = reff.NumeroElem(i_ele);
|
||
|
|
arete = reff.NumeroFA(i_ele);
|
||
|
|
nbPtInteg = (*idl).Val();
|
||
|
|
}
|
||
|
|
else // ils s'agit d'une ref de pti d'arete
|
||
|
|
{ const ReferencePtiAF & reff = ((ReferencePtiAF &) *refi);
|
||
|
|
nbElem = reff.NumeroElem(i_ele);
|
||
|
|
arete = reff.NumeroFA(i_ele);
|
||
|
|
nbPtInteg = reff.NumeroPti(i_ele);
|
||
|
|
};
|
||
|
|
Element& ele = lesMail->Element_LesMaille(n_mail,nbElem);
|
||
|
|
|
||
|
|
// .... concernant les grandeurs quelconque .....
|
||
|
|
if (!element_quelconque_retenu_pourSM.empty())
|
||
|
|
{List_io<TypeQuelconque>::iterator jquefin=element_quelconque_retenu_pourSM.end();
|
||
|
|
List_io<TypeQuelconque>::iterator jque,jque_deb=element_quelconque_retenu_pourSM.begin();
|
||
|
|
if (jque_deb != jquefin) // c'est a dire: cas où existe une grandeur
|
||
|
|
{// maintenant il y a deux cas, soit on travaille avec un seul pti soit
|
||
|
|
// on considère tous les pti, on va faire une boucle par défaut
|
||
|
|
int min_pti=nbPtInteg; int max_pti = nbPtInteg;
|
||
|
|
if (nbPtInteg == -1)
|
||
|
|
{min_pti = 1;
|
||
|
|
const ElFrontiere* elf = ele.Frontiere_lineique(arete);
|
||
|
|
max_pti = elf->ElementGeometrique().Nbi();
|
||
|
|
};
|
||
|
|
|
||
|
|
for (int ipti = min_pti;ipti <= max_pti;ipti++)
|
||
|
|
{// puis les grandeurs particulières (on modifie le flèchage de la grandeur particulière, cf. TypeQuelconque)
|
||
|
|
// on récupère ainsi d'un coup toutes les valeurs
|
||
|
|
ele.Grandeur_particuliere_arete(absolue,element_quelconque_retenu_pourSM,arete,ipti);
|
||
|
|
// on transfert dans le tableau
|
||
|
|
int num_enu = 1;
|
||
|
|
for (jque=jque_deb;jque!=jquefin;jque++,num_enu++)
|
||
|
|
{int nb_val = (*jque).NbMaxiNumeroOrdre();
|
||
|
|
Tableau <double > & pour_Quelconque = tab_pour_Quelconque(num_enu);
|
||
|
|
for (int i=1;i<= nb_val;i++)
|
||
|
|
pour_Quelconque(i) += (*jque).GrandeurNumOrdre(i);
|
||
|
|
};
|
||
|
|
// on incrément le compteur de somme
|
||
|
|
nb_pour_Quelconque++;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
};
|
||
|
|
// --- incrémentation des pointeurs de ref ---
|
||
|
|
if (en_refN) {idl++;}
|
||
|
|
else { idl_Rpti++;};
|
||
|
|
};
|
||
|
|
|
||
|
|
// ---- on écrit les informations
|
||
|
|
|
||
|
|
// écriture du temps que si il y a des ref et que l'on n'est pas avec un seul incrément
|
||
|
|
// sinon on écrit le temps également en commentaire
|
||
|
|
// à moins que le style de sortie force une sortie sur une seule ligne
|
||
|
|
int nbdigit = ParaGlob::NbdigdoGR();
|
||
|
|
if ((NB_ref != 0) && ((!unseul_incre) || (style_de_sortie==1)))
|
||
|
|
{ sort << setprecision(nbdigit) << charge->Temps_courant() << " ";} // le temps
|
||
|
|
else if (NB_ref != 0)
|
||
|
|
// ici on écrit une fois le temps en commentaire
|
||
|
|
{ sort << "# time= " << setprecision(nbdigit) << charge->Temps_courant() << " \n";}; // le temps
|
||
|
|
|
||
|
|
for (int num_ref=1;num_ref <= NB_ref; num_ref++)
|
||
|
|
{// ... les grandeurs quelconques
|
||
|
|
{Tableau <Tableau <double > > & tab_pour_Quelconque = tab_tab_pour_Quelconque(num_ref);
|
||
|
|
int & nb_pour_Quelconque = tab_nb_pour_Quelconque(num_ref); // la taille de la somme
|
||
|
|
for (int num_val = 1; num_val <= nb_TypeQuelconque; num_val++)
|
||
|
|
{ Tableau <double > & pour_Quelconque = tab_pour_Quelconque(num_val);
|
||
|
|
int taille = pour_Quelconque.Taille();
|
||
|
|
sort << setprecision(nbdigit);
|
||
|
|
// on sort les sommes
|
||
|
|
for (int i=1;i<=taille;i++)
|
||
|
|
sort << pour_Quelconque(i) << " ";
|
||
|
|
// puis les moyennes
|
||
|
|
for (int i=1;i<=taille;i++)
|
||
|
|
sort << (pour_Quelconque(i)/nb_pour_Quelconque) << " ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}; // fin de la boucle sur les références
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
};
|
||
|
|
// sortie de l'entete pour les moyennes sommes etc. sur ref de face E
|
||
|
|
void Choix_grandeurs_maple::Sortie_entete_somme_moy_face_E(ostream &sort,int & num_col)
|
||
|
|
{ // on boucle sur les maillages
|
||
|
|
int nb_maillage = tab_F_element_TypeQuelconque.Taille();
|
||
|
|
for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
|
||
|
|
{// ---- préparation
|
||
|
|
// ---- préparation des conteneurs de sortie
|
||
|
|
int NB_ref_E = tab_nomDeRef_F_E_SM(n_mail).size(); // = le nombre de ref
|
||
|
|
int NB_ref_pti = tab_nomDeRef_F_ptinteg_SM(n_mail).size(); // pour les pti
|
||
|
|
int NB_ref = NB_ref_E + NB_ref_pti;
|
||
|
|
int num_total_grandeur=0;
|
||
|
|
|
||
|
|
// pour les grandeurs quelconques, on ne considère que la somme et la moyenne des grandeurs brutes
|
||
|
|
List_io < TypeQuelconque > &TypeQuelconque_retenu_pourSM = tab_F_element_TypeQuelconque_retenu_pourSM(n_mail);
|
||
|
|
int nb_TypeQuelconque = TypeQuelconque_retenu_pourSM.size();
|
||
|
|
// on dimensionne en fonction de la taille de la grandeur quelconque
|
||
|
|
{List_io<TypeQuelconque>::iterator ienu,ienufin=TypeQuelconque_retenu_pourSM.end();
|
||
|
|
int num_enu = 1;
|
||
|
|
for (ienu = TypeQuelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
|
||
|
|
{int nb_val = (*ienu).NbMaxiNumeroOrdre();
|
||
|
|
num_total_grandeur += nb_val*2;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
|
||
|
|
else {sort << "\n# mesh_" << n_mail << " : "; };
|
||
|
|
sort << NB_ref << " "<< num_total_grandeur*NB_ref << " ";
|
||
|
|
if (ParaGlob::Francais()) {sort << " (nombre de ref de faces d'element et nombre total de grandeurs associees) "; }
|
||
|
|
else {sort << " (number of ref of element facets and global number of associated values ) "; }
|
||
|
|
// if (NB_ref != 0)
|
||
|
|
// {if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
|
||
|
|
// else {sort << "\n# mesh_" << n_mail << " : "; };
|
||
|
|
// }
|
||
|
|
sort << "\n# ";
|
||
|
|
if (NB_ref != 0)
|
||
|
|
num_col++; // on passe l'affichage du temps
|
||
|
|
// puis les ref s'il y en a
|
||
|
|
if (NB_ref != 0)
|
||
|
|
{List_io <BlocScal >::iterator idl = tab_nomDeRef_F_E_SM(n_mail).begin();
|
||
|
|
List_io < string >::iterator idl_Rpti = tab_nomDeRef_F_ptinteg_SM(n_mail).begin();
|
||
|
|
|
||
|
|
for (int num_ref=1;num_ref <= NB_ref; num_ref++)
|
||
|
|
{ string nom_ref; // init
|
||
|
|
// recup de la reference correspondant au mot cle
|
||
|
|
const Reference * refi=NULL; // init
|
||
|
|
int taillen=0; // init
|
||
|
|
bool en_refN=true; // pour savoir ensuite si on est refAF ou PtiAF
|
||
|
|
if (num_ref < NB_ref_E+1)
|
||
|
|
{ nom_ref = (*idl).NomRef();
|
||
|
|
refi = &(lesRef->Trouve(nom_ref,n_mail));
|
||
|
|
const ReferenceAF& reff_E = ((ReferenceAF &) *refi); // transfo en ref d'élément
|
||
|
|
taillen=reff_E.Taille();
|
||
|
|
}
|
||
|
|
else // ils s'agit d'une ref de pti de faces d'éléments
|
||
|
|
{ nom_ref = (*idl_Rpti);
|
||
|
|
refi = &(lesRef->Trouve(nom_ref,n_mail));
|
||
|
|
const ReferencePtiAF & reff_AF = ((ReferencePtiAF &) *refi); // transfo en ref d'élément
|
||
|
|
taillen=reff_AF.Taille();
|
||
|
|
en_refN=false;
|
||
|
|
};
|
||
|
|
if (num_ref > 1) sort << "\n# ";
|
||
|
|
sort << nom_ref << " "; // le nom de la ref
|
||
|
|
sort << "( "<< taillen << " ) " << num_total_grandeur << " "; // le nombre d'éléments
|
||
|
|
if (ParaGlob::Francais()) {sort << " (ref, (nombre de face d'element), nombre total de valeurs ) "; }
|
||
|
|
else {sort << " (ref name, (number of element facet) total number of values) "; };
|
||
|
|
|
||
|
|
// === les positions de chaque grandeurs ===
|
||
|
|
|
||
|
|
// --- les grandeurs quelconques ---
|
||
|
|
{List_io<TypeQuelconque>::iterator iquefin=tab_F_element_TypeQuelconque_retenu_pourSM(n_mail).end();
|
||
|
|
List_io<TypeQuelconque>::iterator ique,ique_deb=tab_F_element_TypeQuelconque_retenu_pourSM(n_mail).begin();
|
||
|
|
for (ique = ique_deb;ique != iquefin;ique++)
|
||
|
|
{sort << "\n#"; (*ique).Ecriture_entete_grandeur(sort);
|
||
|
|
sort << " (somme) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
|
||
|
|
num_col += (*ique).NbMaxiNumeroOrdre();
|
||
|
|
sort << " (moyenne) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
|
||
|
|
num_col += (*ique).NbMaxiNumeroOrdre();
|
||
|
|
//sort << "\n# ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// --- incrémentation des pointeurs de ref ---
|
||
|
|
if (en_refN) {idl++;}
|
||
|
|
else { idl_Rpti++;};
|
||
|
|
};
|
||
|
|
sort << " ;\n# ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
};
|
||
|
|
// sortie de l'entete pour les moyennes sommes etc. sur ref d'arête E
|
||
|
|
void Choix_grandeurs_maple::Sortie_entete_somme_moy_arete_E(ostream &sort,int & num_col)
|
||
|
|
{ // on boucle sur les maillages
|
||
|
|
int nb_maillage = tab_A_element_TypeQuelconque.Taille();
|
||
|
|
for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
|
||
|
|
{// ---- préparation
|
||
|
|
// ---- préparation des conteneurs de sortie
|
||
|
|
int NB_ref_E = tab_nomDeRef_A_E_SM(n_mail).size(); // = le nombre de ref
|
||
|
|
int NB_ref_pti = tab_nomDeRef_A_ptinteg_SM(n_mail).size(); // pour les pti
|
||
|
|
int NB_ref = NB_ref_E + NB_ref_pti;
|
||
|
|
int num_total_grandeur=0;
|
||
|
|
|
||
|
|
// pour les grandeurs quelconques, on ne considère que la somme et la moyenne des grandeurs brutes
|
||
|
|
List_io < TypeQuelconque > &TypeQuelconque_retenu_pourSM = tab_A_element_TypeQuelconque_retenu_pourSM(n_mail);
|
||
|
|
int nb_TypeQuelconque = TypeQuelconque_retenu_pourSM.size();
|
||
|
|
// on dimensionne en fonction de la taille de la grandeur quelconque
|
||
|
|
{List_io<TypeQuelconque>::iterator ienu,ienufin=TypeQuelconque_retenu_pourSM.end();
|
||
|
|
int num_enu = 1;
|
||
|
|
for (ienu = TypeQuelconque_retenu_pourSM.begin();ienu!=ienufin;ienu++,num_enu++)
|
||
|
|
{int nb_val = (*ienu).NbMaxiNumeroOrdre();
|
||
|
|
num_total_grandeur += nb_val*2;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
|
||
|
|
else {sort << "\n# mesh_" << n_mail << " : "; };
|
||
|
|
sort << NB_ref << " "<< num_total_grandeur*NB_ref << " ";
|
||
|
|
if (ParaGlob::Francais()) {sort << " (nombre de ref d'arete d'element et nombre total de grandeurs associees) "; }
|
||
|
|
else {sort << " (number of ref of element edges and global number of associated values ) "; }
|
||
|
|
// if (NB_ref != 0)
|
||
|
|
// {if (ParaGlob::Francais()) {sort << "\n# maillage_" << n_mail << " : "; }
|
||
|
|
// else {sort << "\n# mesh_" << n_mail << " : "; };
|
||
|
|
// }
|
||
|
|
sort << "\n# ";
|
||
|
|
if (NB_ref != 0)
|
||
|
|
num_col++; // on passe l'affichage du temps
|
||
|
|
// puis les ref s'il y en a
|
||
|
|
if (NB_ref != 0)
|
||
|
|
{List_io <BlocScal >::iterator idl = tab_nomDeRef_A_E_SM(n_mail).begin();
|
||
|
|
List_io < string >::iterator idl_Rpti = tab_nomDeRef_A_ptinteg_SM(n_mail).begin();
|
||
|
|
|
||
|
|
for (int num_ref=1;num_ref <= NB_ref; num_ref++)
|
||
|
|
{ string nom_ref; // init
|
||
|
|
// recup de la reference correspondant au mot cle
|
||
|
|
const Reference * refi=NULL; // init
|
||
|
|
int taillen=0; // init
|
||
|
|
bool en_refN=true; // pour savoir ensuite si on est refAF ou PtiAF
|
||
|
|
if (num_ref < NB_ref_E+1)
|
||
|
|
{ nom_ref = (*idl).NomRef();
|
||
|
|
refi = &(lesRef->Trouve(nom_ref,n_mail));
|
||
|
|
const ReferenceAF& reff_E = ((ReferenceAF &) *refi); // transfo en ref d'élément
|
||
|
|
taillen=reff_E.Taille();
|
||
|
|
}
|
||
|
|
else // ils s'agit d'une ref de pti d'arete d'éléments
|
||
|
|
{ nom_ref = (*idl_Rpti);
|
||
|
|
refi = &(lesRef->Trouve(nom_ref,n_mail));
|
||
|
|
const ReferencePtiAF & reff_AF = ((ReferencePtiAF &) *refi); // transfo en ref d'aretes d'élément
|
||
|
|
taillen=reff_AF.Taille();
|
||
|
|
en_refN=false;
|
||
|
|
};
|
||
|
|
if (num_ref > 1) sort << "\n# ";
|
||
|
|
sort << nom_ref << " "; // le nom de la ref
|
||
|
|
sort << "( "<< taillen << " ) " << num_total_grandeur << " "; // le nombre d'éléments
|
||
|
|
if (ParaGlob::Francais()) {sort << " (ref, (nombre de arete d'element), nombre total de valeurs ) "; }
|
||
|
|
else {sort << " (ref name, (number of edges) total number of values) "; };
|
||
|
|
|
||
|
|
// === les positions de chaque grandeurs ===
|
||
|
|
|
||
|
|
// --- les grandeurs quelconques ---
|
||
|
|
{List_io<TypeQuelconque>::iterator iquefin=tab_F_element_TypeQuelconque_retenu_pourSM(n_mail).end();
|
||
|
|
List_io<TypeQuelconque>::iterator ique,ique_deb=tab_F_element_TypeQuelconque_retenu_pourSM(n_mail).begin();
|
||
|
|
for (ique = ique_deb;ique != iquefin;ique++)
|
||
|
|
{sort << "\n#"; (*ique).Ecriture_entete_grandeur(sort);
|
||
|
|
sort << " (somme) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
|
||
|
|
num_col += (*ique).NbMaxiNumeroOrdre();
|
||
|
|
sort << " (moyenne) ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"] "; // l'étendue des colonnes
|
||
|
|
num_col += (*ique).NbMaxiNumeroOrdre();
|
||
|
|
//sort << "\n# ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// --- incrémentation des pointeurs de ref ---
|
||
|
|
if (en_refN) {idl++;}
|
||
|
|
else { idl_Rpti++;};
|
||
|
|
};
|
||
|
|
sort << " ;\n# ";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|