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

3971 lines
256 KiB
C++
Raw Permalink Normal View History

ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
// 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
mise à jour 7.010
2023-05-03 17:23:49 +02:00
//int dim = ParaGlob::Dimension();
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
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;
mise à jour 7.010
2023-05-03 17:23:49 +02:00
//List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_E_SM(n_mail).end();
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
// --- 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)
mise à jour 7.010
2023-05-03 17:23:49 +02:00
{//List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_E_SM(n_mail).end();
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
// --- 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
mise à jour 7.010
2023-05-03 17:23:49 +02:00
//int dim = ParaGlob::Dimension();
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
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;
mise à jour 7.010
2023-05-03 17:23:49 +02:00
//List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_F_E_SM(n_mail).end();
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
// --- 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)
mise à jour 7.010
2023-05-03 17:23:49 +02:00
{//List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_F_E_SM(n_mail).end();
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
// --- 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
mise à jour 7.010
2023-05-03 17:23:49 +02:00
//int dim = ParaGlob::Dimension();
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
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;
mise à jour 7.010
2023-05-03 17:23:49 +02:00
//List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_A_E_SM(n_mail).end();
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
// --- 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)
mise à jour 7.010
2023-05-03 17:23:49 +02:00
{//List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_A_E_SM(n_mail).end();
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
// --- 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
mise à jour 7.010
2023-05-03 17:23:49 +02:00
//int dim = ParaGlob::Dimension();
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
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();
mise à jour 7.010
2023-05-03 17:23:49 +02:00
//List_io<Ddl_enum_etendu>::iterator ienufin=type_ddl_retenu_pourSM.end();
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
// 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);
mise à jour 7.010
2023-05-03 17:23:49 +02:00
//int nb_TypeQuelconque = TypeQuelconque_retenu_pourSM.size();
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
// 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);
mise à jour 7.010
2023-05-03 17:23:49 +02:00
//int nb_TypeQuelconque = TypeQuelconque_retenu_pourSM.size();
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
// 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);
mise à jour 7.010
2023-05-03 17:23:49 +02:00
//int nb_Type_evoluee = Type_evoluee_retenu_pourSM.size();
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
// 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);
mise à jour 7.010
2023-05-03 17:23:49 +02:00
//int nb_TypeQuelconque = TypeQuelconque_retenu_pourSM.size();
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
// 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);
mise à jour 7.010
2023-05-03 17:23:49 +02:00
//int nb_TypeQuelconque = TypeQuelconque_retenu_pourSM.size();
ajout des fichiers du répertoire "Resultats", ce qui correspond à tous les traitements des différentes sorties.
2021-09-28 14:10:44 +02:00
// 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# ";
};
};
};
Reference in a new issue Copy permalink