Herezh_dev/Resultats/MAPLE/Choix_grandeurs_maple2.cc

2901 lines
178 KiB
C++

// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Choix_grandeurs_maple.h"
#include "CharUtil.h"
#include "ReferenceNE.h"
#include "ReferencePtiAF.h"
#include <iomanip>
#include <limits>
// ------------------------------------------------ méthodes protégées --------------------------------------
// entrée du choix de ddl principaux aux noeuds
void Choix_grandeurs_maple::Entree_grandeur_principale_aux_noeuds(string& rep)
{ // cas de grandeurs aux noeuds, on boucle sur les maillages
int dim = ParaGlob::Dimension();
// 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);
// on affiche la liste actuelle des grandeurs si elle n'est pas vide
if ((tabnoeud_type_ddl_retenu(n_mail)).size())
{ cout << "\n liste des grandeurs actuellement a sortir: ";
List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabnoeud_type_ddl_retenu(n_mail)).end();
for (iet=(tabnoeud_type_ddl_retenu(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 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 type de sortie de ddl retenue (rep : ts) "
<< "\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(n_mail).push_back(*ite);
tabnoeud_type_ddl_retenu(n_mail).sort(); // on ordonne
tabnoeud_type_ddl_retenu(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(n_mail).push_back(*ite);
tabnoeud_type_ddl_retenu(n_mail).sort(); // on ordonne
tabnoeud_type_ddl_retenu(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(n_mail)).push_back(enu_etendu);
tabnoeud_type_ddl_retenu(n_mail).sort(); // on ordonne
(tabnoeud_type_ddl_retenu(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(n_mail)).clear();
}
else if (rep == "ts")
{ cout << "\n actuellement type_sortie_ddl_retenue= " << type_sortie_ddl_retenue << "\n";
cout << "\n sortie des grandeurs a t (par defaut) : (rep: 0)"
<< "\n sortie des grandeurs entre t et 0 : (rep: 1)"
<< "\n sortie des grandeurs a 0 et a t : (rep: 2)"
<< "\n laisser tel-quel : (rep: f)\n";
string reep="";
reep = lect_return_defaut(false,"f");
if (reep == "0") {type_sortie_ddl_retenue=0;}
else if (reep == "1") {type_sortie_ddl_retenue=1;}
else if (reep == "2") {type_sortie_ddl_retenue=2;}
cout << "\n nouvelle valeur: type_sortie_ddl_retenue= " << type_sortie_ddl_retenue << "\n";
}
else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
cout << " erreur de syntaxe dans le ddl! recommencez ";
};
// choix du ou des noeuds, on affiche la liste actuelle
if ((tab_num_noeud(n_mail)).size())
{ cout << "\n liste actuelle de noeud: ";
List_io <int>::iterator ieint,ieintfin = tab_num_noeud(n_mail).end();
for (ieint=tab_num_noeud(n_mail).begin();ieint!=ieintfin;ieint++)
cout << *ieint << " ";
cout << endl;
}
if ((nomDeRef(n_mail)).size() != 0)
{ cout << "\n liste actuelle de reference de noeuds: ";
List_io <string >::iterator ieint1,ieintfin1 = (nomDeRef(n_mail)).end();
for (ieint1=(nomDeRef(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
cout << *ieint1 << " ";
cout << endl;
}
// questions
cout << "\n choix du ou des noeuds ou l'on veut la visualisation "
<< "\n le reperage d'un noeuds peut se faire de differentes manieres :"
<< "\n par son numero dans le maillage -> (choix : 1)"
<< "\n par ses coordonnees, meme approximatives -> (choix : 2)"
<< "\n par une reference de liste de noeuds -> (choix : 3)"
<< "\n donnez pour chaque noeud le type de choix puis le numero "
<< "\n ou les cordonnees "
<< "\n effacer la liste actuelle de noeuds (rep : ef) "
<< "\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 == "1")
{ cout << " numero ? "; rep = lect_return_defaut(false,"f"); nu = ChangeEntier(rep);
}
else if (rep =="2")
{ Coordonnee xi(dim);
cout << "\n coordonnee ("<<dim<<" nombre(s)) ? ";
for(int j=1;j<=dim;j++) cin >> xi(j);
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
cout << "\n les coordonnees sont a: t = 0 ou t ou tdt (repondre 0 ou t ou tdt) ?";
rep = lect_chaine();
// recherche du noeud le plus proche
if (rep == "0") nu = lesMail->Noeud_le_plus_proche_0(xi,n_mail);
else if (rep == "t") nu = lesMail->Noeud_le_plus_proche_t(xi,n_mail);
else if (rep == "tdt") nu = lesMail->Noeud_le_plus_proche_tdt(xi,n_mail);
else
{ cout << "\n erreur de syntaxe, on attendait 0 ou t ou tdt ! ";verif = false;};
cout << "\n noeud le plus proche nb= " << nu; verif = true;
}
else if (rep =="3")
{ 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
{ nomDeRef(n_mail).push_back(nom_ref);
nomDeRef(n_mail).sort(); // on ordonne
nomDeRef(n_mail).unique();// on supprime les doublons
};
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 == "ef")
{ // on efface la liste des noeuds
(tab_num_noeud(n_mail)).clear();
verif = false;
}
else if (rep == "efref")
{ // on efface la liste des références de noeuds
(nomDeRef(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 1 ou 2 ! 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(n_mail).end();
for (ienu = tabnoeud_type_ddl_retenu(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;
}
}
}
if ((verif)&&((Minuscules(rep) != "fin") && (Minuscules(rep) != "f")))
{ // enregistrement
tab_num_noeud(n_mail).push_back(nu);
tab_num_noeud(n_mail).sort(); // on ordonne
tab_num_noeud(n_mail).unique();// on supprime les doublons
}
}// -- fin de la boucle infini sur l'entrée de numéro de noeud
}// -- fin de la boucle sur les maillages
}; // -- fin du cas des ddl principaux aux noeuds
// entrée du choix de ddl étendus secondaires aux noeuds
void Choix_grandeurs_maple::Entree_grandeur_etendue_secondaire_aux_noeuds(string& rep)
{ // cas de grandeurs aux noeuds, on boucle sur les maillages
int dim = ParaGlob::Dimension();
// 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
// dans le cas où aucune grandeur particulière sont défini on passe
if ( (tabnoeud_type_ddlEtendu(n_mail)).size() == 0)
{ cout << "\n aucune grandeur etendue n'est definit, donc aucune proposition ";}
else
{// affichage du nom du maillages s'il y en a plusieurs
rep = ""; // init
while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
{if (taille_list_maille > 1)
cout << "\n ======>>>>> maillage : " << lesMail->NomMaillage(n_mail);
// on affiche la liste actuelle des grandeurs si elle n'est pas vide
if ((tabnoeud_type_ddlEtendu_retenu(n_mail)).size())
{ cout << "\n liste des grandeurs actuellement a sortir: ";
List_io < Ddl_enum_etendu >::iterator iet,ietfin = (tabnoeud_type_ddlEtendu_retenu(n_mail)).end();
for (iet=(tabnoeud_type_ddlEtendu_retenu(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 = "";
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(n_mail).push_back(*ite);
tabnoeud_type_ddlEtendu_retenu(n_mail).sort(); // on ordonne
tabnoeud_type_ddlEtendu_retenu(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(n_mail).push_back(*ite);
tabnoeud_type_ddlEtendu_retenu(n_mail).sort(); // on ordonne
tabnoeud_type_ddlEtendu_retenu(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(n_mail)).push_back(enu_etendu);
tabnoeud_type_ddlEtendu_retenu(n_mail).sort(); // on ordonne
(tabnoeud_type_ddlEtendu_retenu(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(n_mail)).clear();
}
else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
cout << " erreur de syntaxe dans le ddl! recommencez ";
};
// maintenant si la liste de ddl étendu est vide on s'arrête sinon on choisit éventuellement des noeuds
if ( (tabnoeud_type_ddlEtendu_retenu(n_mail)).size() != 0)
{ Choix_noeud_a_retenir(n_mail,tabnoeud_type_ddlEtendu_retenu(n_mail)); }
else
{ cout << "\n aucune grandeur enregistree ! pour le maillage " << n_mail <<"\n "; };
};
};// -- fin de la boucle sur les maillages
}; // -- fin du cas des ddl étendus secondaires aux noeuds
// entrée du choix de cas de grandeurs particulières aux noeuds
void Choix_grandeurs_maple::Entree_grandeur_TypeQuelconque_secondaire_aux_noeuds(string& rep)
{ // cas de grandeurs particulières aux noeuds, on boucle sur les maillages
int dim = ParaGlob::Dimension();
// 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
// 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(n_mail)).size())
{ cout << "\n liste des grandeurs particulieres actuellement a sortir: ";
List_io < TypeQuelconque >::iterator iet,ietfin = (tabnoeud_TypeQuelconque_retenu(n_mail)).end();
for (iet=(tabnoeud_TypeQuelconque_retenu(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(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(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(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(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(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(n_mail)).size() != 0)
{ cout << "\n liste des grandeurs particulieres enregistrees: ";
List_io < TypeQuelconque >::iterator iet,ietfin = (tabnoeud_TypeQuelconque_retenu(n_mail)).end();
for (iet=(tabnoeud_TypeQuelconque_retenu(n_mail)).begin();iet!=ietfin;iet++)
cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
cout << endl;
}
else
{ cout << "\n aucune grandeur enregistree ! \n "; };
// maintenant si la liste de grandeurs quelconques est vide on s'arrête sinon on choisit éventuellement des noeuds
if ( (tabnoeud_type_ddlEtendu_retenu(n_mail)).size() != 0)
{ Choix_noeud_a_retenir(n_mail,tabnoeud_type_ddlEtendu_retenu(n_mail)); }
else
{ cout << "\n aucune grandeur enregistree ! pour le maillage " << n_mail <<"\n "; };
}; //-- fin du choix sur le fait qu'il existe ou non des grandeurs particulières pour le maillage
}; //-- fin de la boucle sur les maillages
}; // -- fin du cas des grandeurs particulières aux noeuds
// entrée du choix d'une grandeur aux éléments
void Choix_grandeurs_maple::Entree_grandeur_aux_elements(string& rep)
{ // cas de grandeurs aux éléments, on boucle sur les maillages
int dim = ParaGlob::Dimension();
// 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
// int taille_list_maille = tabelement_type_ddl.Taille();
// for (int n_mail=1;n_mail<=taille_list_maille;n_mail++)
// on affiche la liste actuelle
if ((tabelement_type_ddl_retenu(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(n_mail)).end();
for (iet=(tabelement_type_ddl_retenu(n_mail)).begin();iet!=ietfin;iet++)
cout << (*iet) << " " ;
// if ((*iet).Nom_vide()) cout << Nom_ddl((*iet).Enum()) << " "; else cout << (*iet).Nom() << " ";
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) << " " ;
// if ((*iet).Nom_vide()) cout << Nom_ddl((*iet).Enum()) << " "; else cout << (*iet).Nom() << " ";
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(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(n_mail)).push_back(a);
(tabelement_type_ddl_retenu(n_mail)).sort(); // on ordonne, pour qu'unique fonctionne
(tabelement_type_ddl_retenu(n_mail)).unique(); // supprime le doublon si nécessaire
}
else if (rep == "ef")
{ // on efface la liste
(tabelement_type_ddl_retenu(n_mail)).clear();
}
else if (((Minuscules(rep) == "fin") || (Minuscules(rep) == "f"))
&& ( (tabelement_type_ddl_retenu(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 ";
}
// maintenant si la liste de grandeur quelconque est vide on s'arrête sinon on choisit les éléments
if ( (tabelement_type_ddl_retenu(n_mail)).size() != 0)
{ Choix_element_a_retenir(n_mail,tabelement_type_ddl_retenu(n_mail)); }
else
{ cout << "\n aucune grandeur enregistree ! \n "; };
} // -- fin de la boucle sur les maillages pour les éléments
};
// entrée du choix d'une grandeur particulières (diff des ddl génériques) aux éléments
void Choix_grandeurs_maple::Entree_grandeur_particuliere_aux_elements(string& rep)
{ // cas de grandeurs particulières aux éléments, on boucle sur les maillages
int dim = ParaGlob::Dimension();
// 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
// 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
{ // 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
if ((tabelement_typeParti_retenu(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(n_mail)).end();
for (iet=(tabelement_typeParti_retenu(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(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.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(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.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(n_mail)).clear();
}
else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
cout << " erreur de syntaxe recommencez ";
};
// maintenant si la liste de grandeur quelconque est vide on s'arrête sinon on choisit les éléments
if ( (tabelement_typeParti_retenu(n_mail)).size() != 0)
{ cout << "\n liste des grandeurs particulieres enregistrees: ";
List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_typeParti_retenu(n_mail)).end();
for (iet=(tabelement_typeParti_retenu(n_mail)).begin();iet!=ietfin;iet++)
cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
cout << endl;
Choix_element_a_retenir(n_mail,li_ddl);
}
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
}; //-- fin de la boucle sur les maillages
};
// entrée du choix d'une grandeur évoluées (tensorielles) aux éléments
void Choix_grandeurs_maple::Entree_grandeur_tensorielle_aux_elements(string& rep)
{ // cas de grandeurs tensorielles aux éléments, on boucle sur les maillages
int dim = ParaGlob::Dimension();
// 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
// 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
{ // 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;
// on affiche la liste actuelle
if ((tabelement_evoluee_retenu(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(n_mail)).end();
for (iet=(tabelement_evoluee_retenu(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(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.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(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.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(n_mail)).clear();
}
else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
cout << " erreur de syntaxe recommencez ";
};
// maintenant si la liste de grandeur quelconque est vide on s'arrête sinon on choisit les éléments
if ( (tabelement_evoluee_retenu(n_mail)).size() != 0)
{ cout << "\n liste des grandeurs tensorielles enregistrees: ";
List_io < TypeQuelconque >::iterator iet,ietfin = (tabelement_evoluee_retenu(n_mail)).end();
for (iet=(tabelement_evoluee_retenu(n_mail)).begin();iet!=ietfin;iet++)
cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
cout << endl;
Choix_element_a_retenir(n_mail,li_ddl);
}
else
{ cout << "\n aucune grandeur enregistree ! \n "; };
}; //-- fin du choix sur le fait qu'il existe ou non des grandeurs évoluées pour le maillage
}; //-- fin de la boucle sur les maillages
};
// entrée du choix d'une grandeur quelconque aux faces d'éléments
void Choix_grandeurs_maple::Entree_grandeur_quelconque_aux_faces_element(string& rep)
{ // cas de grandeurs quelconques aux faces des éléments, on boucle sur les maillages
int dim = ParaGlob::Dimension();
// 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
// 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 quelconque n'est definit aux faces d'element, donc aucune proposition ";}
else
{ // 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;
// on affiche la liste actuelle
if ((tab_F_element_TypeQuelconque_retenu(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(n_mail)).end();
for (iet=(tab_F_element_TypeQuelconque_retenu(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 quelconque disponibles aux faces d'element 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(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 l'enum quelconque 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(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 l'enum quelconque associé qui définit le point d'integ où est calculé la grandeur
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(n_mail)).clear();
}
else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
cout << " erreur de syntaxe recommencez ";
};
// maintenant si la liste de grandeur quelconque est vide on s'arrête sinon on choisit les faces d'élément
if ( (tab_F_element_TypeQuelconque_retenu(n_mail)).size() != 0)
{ cout << "\n liste des grandeurs particulieres enregistrees: ";
List_io < TypeQuelconque >::iterator iet,ietfin = (tab_F_element_TypeQuelconque_retenu(n_mail)).end();
for (iet=(tab_F_element_TypeQuelconque_retenu(n_mail)).begin();iet!=ietfin;iet++)
cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
cout << endl;
Choix_faces_element_a_retenir(n_mail,li_enu_quelconque);
}
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
}; //-- fin de la boucle sur les maillages
};
// entrée du choix d'une grandeur quelconque aux arêtes d'éléments
void Choix_grandeurs_maple::Entree_grandeur_quelconque_aux_aretes_element(string& rep)
{ // cas de grandeurs quelconques aux arêtes des éléments, on boucle sur les maillages
int dim = ParaGlob::Dimension();
// 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
// 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 quelconque n'est definit aux aretes d'element, donc aucune proposition ";}
else
{ // 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;
// on affiche la liste actuelle
if ((tab_A_element_TypeQuelconque_retenu(n_mail)).size())
{ cout << "\n liste actuelle des aretes 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 quelconques actuellement a sortir: ";
List_io < TypeQuelconque >::iterator iet,ietfin = (tab_A_element_TypeQuelconque_retenu(n_mail)).end();
for (iet=(tab_A_element_TypeQuelconque_retenu(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 quelconque disponibles aux aretes d'element 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(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 l'enum quelconque 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_A_element_TypeQuelconque_retenu(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 également l'enum quelconque associé qui définit le point d'integ où est calculé la grandeur
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(n_mail)).clear();
}
else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
cout << " erreur de syntaxe recommencez ";
};
// maintenant si la liste de grandeur quelconque est vide on s'arrête sinon on choisit les arêtes élément
if ( (tab_A_element_TypeQuelconque_retenu(n_mail)).size() != 0)
{ cout << "\n liste des grandeurs particulieres enregistrees: ";
List_io < TypeQuelconque >::iterator iet,ietfin = (tab_A_element_TypeQuelconque_retenu(n_mail)).end();
for (iet=(tab_A_element_TypeQuelconque_retenu(n_mail)).begin();iet!=ietfin;iet++)
cout << ((*iet).EnuTypeQuelconque().NomPlein()) << " " ;
cout << endl;
Choix_aretes_element_a_retenir(n_mail,li_enu_quelconque);
}
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
}; //-- fin de la boucle sur les maillages
};
// choix des éléments
void Choix_grandeurs_maple::Choix_element_a_retenir(int n_mail,List_io < Ddl_enum_etendu >& li_ddl)
{
// def de grandeur globale
int dim = ParaGlob::Dimension();
// 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();
// choix du ou des elements, on affiche la liste actuelle si elle est non nulle
if (tab_num_element(n_mail).size())
{cout << "\n liste actuelle des element: ";
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 <<endl;
// cas des références d'éléments
if ((nomDeRef_E(n_mail)).size() != 0)
{ cout << "\n liste actuelle de reference d'elements: (ref et num integ) ";
List_io <BlocScal >::iterator ieint1,ieintfin1 = (nomDeRef_E(n_mail)).end();
for (ieint1=(nomDeRef_E(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 ((nomDeRef_ptinteg(n_mail)).size() != 0)
{ cout << "\n liste actuelle de reference de pt d'integration d'elements: (ref) ";
List_io <string >::iterator ieint1,ieintfin1 = (nomDeRef_ptinteg(n_mail)).end();
for (ieint1=(nomDeRef_ptinteg(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
cout << (*ieint1) << " ";
cout << endl;
}
cout << "\n choix de la position sur le ou les elements ou l'on veut la visualisation "
<< "\n le reperage peut se faire de differentes manieres : "
<< "\n par un numero d'element dans le maillage + un ou plusieurs "
<< "\n numero(s) de pt d'integration (au sens classique) -> (choix : 1)"
<< "\n par des coordonnees d'un point (interne !!), meme approximatives "
<< "\n la grandeur affichee sera a un point le plus proche ou elle existe -> (choix : 2)"
<< "\n par une reference de liste d'element (avec 1 ou tous les pti) -> (choix : 3)"
<< "\n (dans ce dernier cas il faut que tous les elements soient de meme type) "
<< "\n par une reference de liste de point d'integration d'element -> (choix : 4)"
<< "\n donnez le type de choix puis les infos correspondantes "
<< "\n effacer la liste actuelle -> (rep : ef) "
<< "\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
bool verif = true; // pour la vérification des numéros
if (rep == "1")
{ cout << " numero d'element ? "; rep = lect_chaine(); nut.nbElem = ChangeEntier(rep);
cout << " numero du point d'integration (ou -1 pour tous les pti de l'element) ? ";
rep = lect_chaine(); nut.nbPtInteg = ChangeEntier(rep);
if (nut.nbPtInteg != -1)
{list_nut.push_back(nut);} // cas d'un seul pti
else // cas de tous les pti
{// on commence par tester si l'élément existe vraiment
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 !!!";verif = false;};
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 !!!";verif = false;
};
}
else // sinon c'est ok, on continue au niveau des pti
{Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
// maintenant on va vérifier que tous les ddl correspondent aux mêmes nombre de pti
// on récupère le nb de pti pour le premier ddl retenu
List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
ite = li_ddl.begin();
int nbpti = 0; // init
bool veriflocal = true;
if (ite == li_ddl.end()) {veriflocal = false;} // la liste est vide on ne peut pas aller plus loin
else
{nbpti = ele.NbPtInteg((*ite).Enum());
for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
// boucle sur les ddl retenus
for (ite = li_ddl.begin();ite != itefin; ite++)
{ // 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 << " !!!! ";
cout << "\n une raison possible est qu'il y a des elements avec un nombre different de "
<< "points d'integration : cas non permis actuellement (se plaindre !! ) ";
veriflocal = false;
};
}; //-- fin de la boucle sur les ddl retenus
};
// si tout est ok arrivée ici on enregistre
if (veriflocal)
{ for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
list_nut.push_back(nut);
}
else // sinon on averti que c'est mauvais
{verif = false;};
};
};
}
else if (rep == "2")
{ Coordonnee xi(dim);
cout << "\n coordonnee ("<<dim<<" nombre(s)) ? ";
for(int j=1;j<=dim;j++) cin >> xi(j);
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
cout << "\n les coordonnees sont a: t = 0 ou t ou tdt (repondre 0 ou t ou tdt) ? ";
rep = lect_chaine();
bool rep_exploitable = true; Enum_dure enu_temps;
if (rep == "0")
enu_temps = TEMPS_0;
else if (rep == "t")
enu_temps = TEMPS_t;
else if (rep == "tdt")
enu_temps = TEMPS_tdt;
else
{ cout << "\n erreur de syntaxe, on attendait 0 t ou tdt ";verif = false;
rep_exploitable = false;
};
if (rep_exploitable)
{nut = lesMail->Element_le_plus_proche(enu_temps,li_ddl,xi,n_mail);
if (nut.nbElem == 0) // cas où l'on ne trouve pas d'élément
{ cout << "\n pas d'element qui contiend ce point, pour les ddl et le temps "
<< rep << " recommencez ! "; verif = false;
}
else if ( nut.nbPtInteg < 0)
{ cout << "\n il n'est pas possible de trouver un seul point d'integration pour "
<< " tous les ddl que vous avez choisi, le mieux est de recommencer avec "
<< " des ddl de meme type c-a-d par exemple contrainte ou erreur, mais "
<< " pas les deux en meme temps car ils n'utilisent pas le meme systeme de "
<< " points d'integration !! ";
verif = false;
}
else
{ cout << "\n element contenant le point nb= " << nut.nbElem
<< " et le numero d'ordre le plus proche "
<< nut.nbPtInteg << " de coordonnee a t: " ;
List_io<Ddl_enum_etendu>::iterator ienu=li_ddl.begin();
bool erreur=false; // ici on n'en tiend pas compte car déjà testé
Coordonnee ncor =
lesMail->Element_LesMaille(n_mail,nut.nbElem).CoordPtInteg
(TEMPS_t,(*ienu).Enum(),nut.nbPtInteg,erreur);
for (int ic=1;ic<=ncor.Dimension();ic++) cout << ncor(ic) << " ";
// le choix est a priori ok, on enregistre
list_nut.push_back(nut);
};
};
}
else if (rep == "3")
{ string nom_ref;
cout << "\n nom de la reference ? ";
nom_ref= lect_chaine();
// vérif que la référence existe
if ((!(lesRef->Existe(nom_ref,n_mail))) || (lesRef->Trouve(nom_ref,n_mail).Indic() != 2))
{ cout << "\n erreur de nom (** "<< nom_ref << " **) donne ne correspond pas a une reference d'element correcte ";}
else
{ // choix du point d'intégration, ici on ne va pas utiliser la liste list_nut, mais une liste particulière
string repo;
cout << " numero d'un point d'integration ou: -1 pour tous les pti ? ";
repo = lect_chaine(); nut.nbPtInteg = ChangeEntier(repo);
if (nut.nbPtInteg != -1) // cas d'un seul pti
{// on vérifie que ce point d'intégration est valide pour tous les éléments de la référence
bool veriflocal = true;
List_io <BlocScal >::iterator idl,idlfin= nomDeRef_E(n_mail).end();
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
// on enregistre si la vérification a été ok
if (veriflocal)
{ nomDeRef_E(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
nomDeRef_E(n_mail).sort(); // on ordonne
nomDeRef_E(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 !!!";verif = false;};
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 !!!";verif = 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>::iterator ite = li_ddl.begin();
if (ite == li_ddl.end()) {veriflocal = false;} // la liste est vide on ne peut pas aller plus loin
else {nbpti = ele.NbPtInteg((*ite).Enum());};
};
};
};
// .. puis on balaie l'ensemble des éléments et l'ensemble des pti
if (veriflocal)
{List_io <BlocScal >::iterator idl,idlfin= nomDeRef_E(n_mail).end();
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
};
// arrivée ici, si tout est ok on enregistre
if (veriflocal)
for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
{ nomDeRef_E(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
nomDeRef_E(n_mail).sort(); // on ordonne
nomDeRef_E(n_mail).unique();// on supprime les doublons
};
};
}; // fin du choix du point d'intégration et de l'enregistrement
verif = false; // pour ne pas enregistrer de numéro dans la liste directe d'element car ici c'est
// la liste de référence de référence d'éléments qui est en cause
}
else if (rep == "4")
{ 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;
List_io <string >::iterator idl,idlfin= nomDeRef_ptinteg(n_mail).end();
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
// on enregistre si la vérification a été ok
if (veriflocal)
{ nomDeRef_ptinteg(n_mail).push_back(nom_ref);
nomDeRef_ptinteg(n_mail).sort(); // on ordonne
nomDeRef_ptinteg(n_mail).unique();// on supprime les doublons
};
}; // fin du choix du point d'intégration et de l'enregistrement
verif = false; // pour ne pas enregistrer de numéro dans la liste directe d'element car ici c'est
// la liste de référence de référence d'éléments qui est en cause
}
else if (rep == "ef")
{ // on efface les deux listes
(tab_num_element(n_mail)).clear();
(tab_num_integ(n_mail)).clear();
verif = false;
}
else if (rep == "efref")
{ // on efface la liste des références d'éléments et la liste de pt d'integ associée
(nomDeRef_E(n_mail)).clear();
verif = false;
}
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);
verif = false;
}
else if (rep == "efrefpti")
{ // on efface la liste des références de pt d'integ d'éléments
(nomDeRef_ptinteg(n_mail)).clear();
verif = false;
}
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);
verif = false;
}
else
{ cout << "\n reponse non valide, recommencez " << endl;
};
// vérification des numéros d'éléments
if (verif)
{ // on balaie les numéros de la liste
list <Maillage::NBelemEtptInteg>::iterator i_list_nut,i_list_nut_fin = list_nut.end();
for (i_list_nut=list_nut.begin();i_list_nut != i_list_nut_fin;i_list_nut++)
{ nut = (*i_list_nut); // par simplicité
if (nut.nbElem < 0)
{ cout << "\n le numero d'element doit etre superieur a 0 !!!";verif = false;};
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 !!!";verif = false;
};
};
};
// .. vérification des numéros de pti
// tout d'abord les numéros négatifs
if (verif)
{ // on balaie les numéros de la liste
list <Maillage::NBelemEtptInteg>::iterator i_list_nut,i_list_nut_fin = list_nut.end();
for (i_list_nut=list_nut.begin();i_list_nut != i_list_nut_fin;i_list_nut++)
{ nut = (*i_list_nut); // par simplicité
if (nut.nbPtInteg < 0)
{ cout << "\n le numero du point d'integration doit etre superieur a 0 !!!";verif = false;};
};
};
// puis vérif que le pt d'integ existe
// on récupère l'élément géométrique qui correspond aux ddl
if (verif)
{ // on balaie les numéros de la liste
list <Maillage::NBelemEtptInteg>::iterator i_list_nut,i_list_nut_fin = list_nut.end();
for (i_list_nut=list_nut.begin();i_list_nut != i_list_nut_fin;i_list_nut++)
{ nut = (*i_list_nut); // par simplicité
List_io<Ddl_enum_etendu>::iterator ite,itefin = li_ddl.end();
for (ite = li_ddl.begin();ite != itefin; ite++)
{ // 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 << " !!!! ";
verif = false;
};
};
};
};
// enregistrement si tout est ok
if ((verif)&&((Minuscules(rep) != "fin") && (Minuscules(rep) != "f")))
{ // on balaie les numéros de la liste
list <Maillage::NBelemEtptInteg>::iterator i_list_nut,i_list_nut_fin = list_nut.end();
for (i_list_nut=list_nut.begin();i_list_nut != i_list_nut_fin;i_list_nut++)
{ nut = (*i_list_nut); // par simplicité
// si le groupe (élément, nb point d'intégration) n'est pas actuellement enregistré, on l'enregistre
// on boucle sur les datas déjà enregistrés
bool a_enregistrer=true;
List_io <int>::iterator ilelem,ilinteg,ilelemfin=tab_num_element(n_mail).end();
ilinteg = tab_num_integ(n_mail).begin();
for (ilelem=tab_num_element(n_mail).begin();ilelem != ilelemfin;ilelem++,ilinteg++)
if ((nut.nbElem==(*ilelem))&&(nut.nbPtInteg==(*ilinteg)))
a_enregistrer = false;
if (a_enregistrer)
{ tab_num_element(n_mail).push_back(nut.nbElem);
tab_num_integ(n_mail).push_back(nut.nbPtInteg);
};
};
// if ( (find(tab_num_element(n_mail).begin(),tab_num_element(n_mail).end(),nut.nbElem)
// == tab_num_element(n_mail).end())
// && (find(tab_num_integ(n_mail).begin(),tab_num_integ(n_mail).end(),nut.nbPtInteg)
// == tab_num_integ(n_mail).end()))
// { tab_num_element(n_mail).push_back(nut.nbElem);
// tab_num_integ(n_mail).push_back(nut.nbPtInteg);
// };
};
}; // -- fin boucle choix position sur element
};
// choix des faces d'éléments
void Choix_grandeurs_maple::Choix_faces_element_a_retenir(int n_mail,List_io < EnumTypeQuelconque >& li_enu_quelc)
{
// def de grandeur globale
int dim = ParaGlob::Dimension();
// 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();
// choix du ou des faces d'elements, on affiche la liste actuelle si elle est non nulle
if (tab_num_F_element(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 << endl;
}
// cas des références de faces d'élément
if ((nomDeRef_F_E(n_mail)).size() != 0)
{ cout << "\n liste actuelle de reference de faces d'element: (ref et num integ) ";
List_io <BlocScal >::iterator ieint1,ieintfin1 = (nomDeRef_F_E(n_mail)).end();
for (ieint1=(nomDeRef_F_E(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 ((nomDeRef_F_ptinteg(n_mail)).size() != 0)
{ cout << "\n liste actuelle de reference de pt d'integration de faces d'element: (ref) ";
List_io <string >::iterator ieint1,ieintfin1 = (nomDeRef_F_ptinteg(n_mail)).end();
for (ieint1=(nomDeRef_F_ptinteg(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
cout << (*ieint1) << " ";
cout << endl;
};
cout << "\n --- choix de la position sur le ou les faces ou l'on veut la visualisation "
<< "\n le reperage peut se faire de differentes manieres : "
<< "\n par 2 numeros (element, face) dans le maillage + un ou plusieurs "
<< "\n numero(s) de pt d'integration (au sens classique) -> (choix : 1)"
// << "\n par des coordonnees d'un point (interne !!), meme approximatives "
// << "\n la grandeur affichee sera a un point le plus proche ou elle existe -> (choix : 2)"
<< "\n par une reference de liste de faces d'element (avec 1 ou tous les pti) -> (choix : 3)"
<< "\n (dans ce dernier cas il faut que toutes les faces soient de meme type) "
<< "\n par une reference de liste de point d'integration de faces d'element -> (choix : 4)"
<< "\n ---> donnez le type de choix puis les infos correspondantes <--- "
<< "\n effacer la liste actuelle de faces d'element -> (rep : efF) "
<< "\n effacer la liste actuelle des references de faces d'element -> (rep : efrefF) "
<< "\n afficher la liste des references de faces d'element existantes -> (rep : affrefF) "
<< "\n effacer la liste actuelle des references de pti de faces d'element -> (rep : efrefFpti) "
<< "\n afficher la liste des references de pti de faces d'element existantes -> (rep : affrefFpti) "
<< "\n (tapez fin pour finir(ou f))";
string rep = "";
// -- début boucle choix
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) 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
bool verif = true; // pour la vérification des numéros
if (rep == "1")
{ cout << " numero d'element ? "; rep = lect_chaine(); nut.nbElem = ChangeEntier(rep);
cout << " numero de face ? "; rep = lect_chaine(); nut.nbFA = ChangeEntier(rep);
cout << " numero du point d'integration (ou -1 pour tous les pti de l'element) ? ";
rep = lect_chaine(); nut.nbPtInteg = ChangeEntier(rep);
if (nut.nbPtInteg != -1)
{list_nut.push_back(nut);} // cas d'un seul pti
else // cas de tous les pti
{// on commence par tester si l'élément existe vraiment
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 !!!";verif = false;};
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 !!!";verif = false;
};
}
else // sinon c'est ok pour l'élément, on continue au niveau de la face et des pti
{Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
int nbpti=0; // init
// 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
<< " !!!" << flush ;
verif = false;
}
else
{const ElFrontiere* elf = ele.Frontiere_surfacique(nut.nbFA); // récup num face
nbpti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de la face
};
// si tout est ok arrivée ici on enregistre
if (verif)
{ for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
list_nut.push_back(nut);
}
else // sinon on averti que c'est mauvais
{verif = false;};
};
};
}
else if (rep == "3")
{ string nom_ref;
cout << "\n nom de la reference de faces ? ";
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 toutes les faces de la référence
bool veriflocal = true;
List_io <BlocScal >::iterator idl,idlfin= nomDeRef_F_E(n_mail).end();
// 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
<< " 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
// --- on enregistre si la vérification a été ok
if (veriflocal)
{ nomDeRef_F_E(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
nomDeRef_F_E(n_mail).sort(); // on ordonne
nomDeRef_F_E(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(n_mail);
// on regarde si listes ne sont pas toutes vides
if ((li_quelc.empty())&&(li_enu_quelc.empty()))
{// toutes les listes sont vides, on ne pourra pas aller plus loin
cout << "\n pas encore de grandeurs choisies !! ";
veriflocal = false;
}
else // sinon on peut continuer
{nbpti = max_pti;};
};
}
};
};
// .. puis on balaie l'ensemble des éléments et l'ensemble des pti
if (veriflocal)
{List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_F_E_SM(n_mail).end();
// --- cas des types quelconques aux faces d'éléments
{List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelc.end();
// boucle sur les grandeurs retenus
for (ite = li_enu_quelc.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;
nomDeRef_F_E(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
nomDeRef_F_E(n_mail).sort(); // on ordonne
nomDeRef_F_E(n_mail).unique();// on supprime les doublons
};
};
}; // fin du choix du point d'intégration et de l'enregistrement
verif = false; // pour ne pas enregistrer de numéro dans la liste directe d'element car ici c'est
// la liste de référence de référence de faces d'élément qui est en cause
}
else if (rep == "4")
{ 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 faces 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_quelc.end();
// boucle sur les grandeurs retenus
for (ite = li_enu_quelc.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)
{ nomDeRef_F_ptinteg(n_mail).push_back(nom_ref);
nomDeRef_F_ptinteg(n_mail).sort(); // on ordonne
nomDeRef_F_ptinteg(n_mail).unique();// on supprime les doublons
};
}; // fin de la vérification
verif = false; // pour ne pas enregistrer de numéro dans la liste directe d'element car ici c'est
// la liste de référence de référence d'éléments qui est en cause
}
else if (rep == "efF")
{ // on efface les 3 listes
(tab_num_F_element(n_mail)).clear();
(tab_num_F(n_mail)).clear();
(tab_num_F_integ(n_mail)).clear();
verif = false;
}
else if (rep == "efrefF")
{ // on efface la liste des références d'éléments et la liste de pt d'integ associée
(nomDeRef_F_E(n_mail)).clear();
verif = false;
}
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);
verif = false;
}
else if (rep == "efrefFpti")
{ // on efface la liste des références de pt d'integ d'éléments
(nomDeRef_F_ptinteg(n_mail)).clear();
verif = false;
}
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);
verif = false;
}
else
{ cout << "\n reponse non valide, recommencez " << endl;
};
// enregistrement si tout est ok
if ((verif)&&((Minuscules(rep) != "fin") && (Minuscules(rep) != "f")))
{ // on balaie les numéros de la liste
list <Maillage::NBelemFAEtptInteg>::iterator i_list_nut,i_list_nut_fin = list_nut.end();
for (i_list_nut=list_nut.begin();i_list_nut != i_list_nut_fin;i_list_nut++)
{ nut = (*i_list_nut); // par simplicité
// si le groupe (élément, face et nb point d'intégration) n'est pas actuellement enregistré, on l'enregistre
// on boucle sur les datas déjà enregistrés
bool a_enregistrer=true;
List_io <int>::iterator ilelem,iliface,ilinteg,ilelemfin=tab_num_F_element(n_mail).end();
ilinteg = tab_num_F_integ(n_mail).begin();
iliface = tab_num_F(n_mail).begin();
for (ilelem=tab_num_F_element(n_mail).begin();ilelem != ilelemfin;ilelem++,iliface++,ilinteg++)
if ((nut.nbElem==(*ilelem))&&(nut.nbFA==(*iliface))&&(nut.nbPtInteg==(*ilinteg)))
a_enregistrer = false;
if (a_enregistrer)
{ tab_num_F_element(n_mail).push_back(nut.nbElem);
tab_num_F(n_mail).push_back(nut.nbFA);
tab_num_F_integ(n_mail).push_back(nut.nbPtInteg);
};
};
};
}; // -- fin boucle choix position sur element
};
// choix des arête d'éléments
void Choix_grandeurs_maple::Choix_aretes_element_a_retenir(int n_mail,List_io < EnumTypeQuelconque >& li_enu_quelc)
{
// def de grandeur globale
int dim = ParaGlob::Dimension();
// 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();
// choix du ou des arêtes d'elements, on affiche la liste actuelle si elle est non nulle
if (tab_num_A_element(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 << endl;
}
// cas des références d'arêtes d'élément
if ((nomDeRef_A_E(n_mail)).size() != 0)
{ cout << "\n liste actuelle de reference d'aretes d'element: (ref et num integ) ";
List_io <BlocScal >::iterator ieint1,ieintfin1 = (nomDeRef_A_E(n_mail)).end();
for (ieint1=(nomDeRef_A_E(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 ((nomDeRef_A_ptinteg(n_mail)).size() != 0)
{ cout << "\n liste actuelle de reference de pt d'integration d'arete d'element: (ref) ";
List_io <string >::iterator ieint1,ieintfin1 = (nomDeRef_A_ptinteg(n_mail)).end();
for (ieint1=(nomDeRef_A_ptinteg(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
cout << (*ieint1) << " ";
cout << endl;
};
cout << "\n --- choix de la position sur le ou les aretes ou l'on veut la visualisation "
<< "\n le reperage peut se faire de differentes manieres : "
<< "\n par 2 numeros (element, arete) dans le maillage + un ou plusieurs "
<< "\n numero(s) de pt d'integration (au sens classique) -> (choix : 1)"
// << "\n par des coordonnees d'un point (interne !!), meme approximatives "
// << "\n la grandeur affichee sera a un point le plus proche ou elle existe -> (choix : 2)"
<< "\n par une reference de liste d'arete d'element (avec 1 ou tous les pti) -> (choix : 3)"
<< "\n (dans ce dernier cas il faut que toutes les aretes soient de meme type) "
<< "\n par une reference de liste de point d'integration d'aretes d'element -> (choix : 4)"
<< "\n ---> donnez le type de choix puis les infos correspondantes <--- "
<< "\n effacer la liste actuelle d'aretes d'element -> (rep : efA) "
<< "\n effacer la liste actuelle des references d'aretes d'element -> (rep : efrefA) "
<< "\n afficher la liste des references d'aretes d'element existantes -> (rep : affrefA) "
<< "\n effacer la liste actuelle des references de pti d'aretes d'element -> (rep : efrefApti) "
<< "\n afficher la liste des references de pti d'aretes d'element existantes -> (rep : affrefApti) "
<< "\n (tapez fin pour finir(ou f))";
string rep = "";
// -- début boucle choix
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 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
bool verif = true; // pour la vérification des numéros
if (rep == "1")
{ cout << " numero d'element ? "; rep = lect_chaine(); nut.nbElem = ChangeEntier(rep);
cout << " numero de l'arete ? "; rep = lect_chaine(); nut.nbFA = ChangeEntier(rep);
cout << " numero du point d'integration (ou -1 pour tous les pti de l'element) ? ";
rep = lect_chaine(); nut.nbPtInteg = ChangeEntier(rep);
if (nut.nbPtInteg != -1)
{list_nut.push_back(nut);} // cas d'un seul pti
else // cas de tous les pti
{// on commence par tester si l'élément existe vraiment
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 !!!";verif = false;};
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 !!!";verif = false;
};
}
else // sinon c'est ok pour l'élément, on continue au niveau de l'arête et des pti
{Element& ele = lesMail->Element_LesMaille(n_mail,nut.nbElem); // par simplification
int nbpti=0; // init
// test si l'élément arête existe
if (!ele.SurfExiste(nut.nbFA))
{cout << "\n l'arete "<< nut.nbFA << " n'existe pas pour l'element "<<nut.nbElem
<< " du maillage "<< n_mail
<< " !!!" << flush ;
verif = false;
}
else
{const ElFrontiere* elf = ele.Frontiere_lineique(nut.nbFA); // récup num arête
nbpti = elf->ElementGeometrique().Nbi(); // récup le maxi des num pti de l'arête
};
// si tout est ok arrivée ici on enregistre
if (verif)
{ for (nut.nbPtInteg = 1; nut.nbPtInteg <= nbpti;nut.nbPtInteg++)
list_nut.push_back(nut);
}
else // sinon on averti que c'est mauvais
{verif = false;};
};
};
}
else if (rep == "3")
{ string nom_ref;
cout << "\n nom de la reference d'aretes ? ";
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 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 toutes les arêtes de la référence
bool veriflocal = true;
List_io <BlocScal >::iterator idl,idlfin= nomDeRef_A_E(n_mail).end();
// 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
// test si l'élément arête existe
if (!ele.SurfExiste(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
<< " 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
// --- on enregistre si la vérification a été ok
if (veriflocal)
{ nomDeRef_A_E(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
nomDeRef_A_E(n_mail).sort(); // on ordonne
nomDeRef_A_E(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 toutes 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'élément arête existe
if (!ele.SurfExiste(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
List_io < TypeQuelconque >& li_quelc = tab_A_element_TypeQuelconque_retenu(n_mail);
// on regarde si listes ne sont pas toutes vides
if ((li_quelc.empty())&&(li_enu_quelc.empty()))
{// toutes les listes sont vides, on ne pourra pas aller plus loin
cout << "\n pas encore de grandeurs choisies !! ";
veriflocal = false;
}
else // sinon on peut continuer
{nbpti = max_pti;};
};
}
};
};
// .. puis on balaie l'ensemble des éléments et l'ensemble des pti
if (veriflocal)
{List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_A_E_SM(n_mail).end();
// --- cas des types quelconques aux arêtes d'éléments
{List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_quelc.end();
// boucle sur les grandeurs retenus
for (ite = li_enu_quelc.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.SurfExiste(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
{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 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)
{ nut.nbPtInteg = -1;
nomDeRef_A_E(n_mail).push_back(BlocScal(nom_ref,nut.nbPtInteg));
nomDeRef_A_E(n_mail).sort(); // on ordonne
nomDeRef_A_E(n_mail).unique();// on supprime les doublons
};
};
}; // fin du choix du point d'intégration et de l'enregistrement
verif = false; // pour ne pas enregistrer de numéro dans la liste directe d'element car ici c'est
// la liste de référence d'arêtes d'élément qui est en cause
}
else if (rep == "4")
{ 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 "
<< " d'aretes 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_quelc.end();
// boucle sur les grandeurs retenus
for (ite = li_enu_quelc.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 é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 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)
{ nomDeRef_A_ptinteg(n_mail).push_back(nom_ref);
nomDeRef_A_ptinteg(n_mail).sort(); // on ordonne
nomDeRef_A_ptinteg(n_mail).unique();// on supprime les doublons
};
}; // fin de la vérification
verif = false; // pour ne pas enregistrer de numéro dans la liste directe d'element car ici c'est
// la liste de référence de référence d'éléments qui est en cause
}
else if (rep == "efA")
{ // on efface les 3 listes
(tab_num_A_element(n_mail)).clear();
(tab_num_A(n_mail)).clear();
(tab_num_A_integ(n_mail)).clear();
verif = false;
}
else if (rep == "efrefA")
{ // on efface la liste des références d'éléments et la liste de pt d'integ associée
(nomDeRef_A_E(n_mail)).clear();
verif = false;
}
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'element ";
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() == 3)) cout << reff->Nom() << " ";
prempass = false;
} while (reff != NULL);
verif = false;
}
else if (rep == "efrefApti")
{ // on efface la liste des références de pt d'integ d'éléments
(nomDeRef_A_ptinteg(n_mail)).clear();
verif = false;
}
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'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() == 7)) cout << reff->Nom() << " ";
prempass = false;
} while (reff != NULL);
verif = false;
}
else
{ cout << "\n reponse non valide, recommencez " << endl;
};
// enregistrement si tout est ok
if ((verif)&&((Minuscules(rep) != "fin") && (Minuscules(rep) != "f")))
{ // on balaie les numéros de la liste
list <Maillage::NBelemFAEtptInteg>::iterator i_list_nut,i_list_nut_fin = list_nut.end();
for (i_list_nut=list_nut.begin();i_list_nut != i_list_nut_fin;i_list_nut++)
{ nut = (*i_list_nut); // par simplicité
// si le groupe (élément, arête et nb point d'intégration) n'est pas actuellement enregistré, on l'enregistre
// on boucle sur les datas déjà enregistrés
bool a_enregistrer=true;
List_io <int>::iterator ilelem,iliAre,ilinteg,ilelemfin=tab_num_A_element(n_mail).end();
ilinteg = tab_num_A_integ(n_mail).begin();
iliAre = tab_num_A(n_mail).begin();
for (ilelem=tab_num_A_element(n_mail).begin();ilelem != ilelemfin;ilelem++,iliAre++,ilinteg++)
if ((nut.nbElem==(*ilelem))&&(nut.nbFA==(*iliAre))&&(nut.nbPtInteg==(*ilinteg)))
a_enregistrer = false;
if (a_enregistrer)
{ tab_num_A_element(n_mail).push_back(nut.nbElem);
tab_num_A(n_mail).push_back(nut.nbFA);
tab_num_A_integ(n_mail).push_back(nut.nbPtInteg);
};
};
};
}; // -- fin boucle choix position sur element
};
// choix des noeud
void Choix_grandeurs_maple::Choix_noeud_a_retenir(int n_mail,List_io < Ddl_enum_etendu >& li_ddl)
{ // def de grandeur globale
int dim = ParaGlob::Dimension();
string rep="";
while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
{ // choix du ou des noeuds, on affiche la liste actuelle
if ((tab_num_noeud(n_mail)).size())
{ cout << "\n liste actuelle de noeud: ";
List_io <int>::iterator ieint,ieintfin = tab_num_noeud(n_mail).end();
for (ieint=tab_num_noeud(n_mail).begin();ieint!=ieintfin;ieint++)
cout << *ieint << " ";
cout << endl;
};
if ((nomDeRef(n_mail)).size() != 0)
{ cout << "\n liste actuelle de reference de noeuds: ";
List_io <string >::iterator ieint1,ieintfin1 = (nomDeRef(n_mail)).end();
for (ieint1=(nomDeRef(n_mail)).begin();ieint1!=ieintfin1;ieint1++)
cout << *ieint1 << " ";
cout << endl;
};
// questions
cout << "\n choix du ou des noeuds ou l'on veut la visualisation "
<< "\n le reperage d'un noeuds peut se faire de differentes manieres :"
<< "\n par son numero dans le maillage -> (choix : 1)"
<< "\n par ses coordonnees, meme approximatives -> (choix : 2)"
<< "\n par une reference de liste de noeuds -> (choix : 3)"
<< "\n donnez pour chaque noeud le type de choix puis le numero "
<< "\n ou les cordonnees "
<< "\n effacer la liste actuelle de noeuds (rep : ef) "
<< "\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 = "";
cout << "\n choix ? ";rep = lect_return_defaut(false,"f");
bool verif = true; // pour la vérification du numéro du noeud
int nu ; // le numéro de noeud
if (rep == "1")
{ cout << " numero ? "; rep = lect_chaine(); nu = ChangeEntier(rep);
}
else if (rep =="2")
{ Coordonnee xi(dim);
cout << "\n coordonnee ("<<dim<<" nombre(s)) ? ";
for(int j=1;j<=dim;j++) cin >> xi(j);
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
cout << "\n les coordonnees sont a: t = 0 ou t ou tdt (repondre 0 ou t ou tdt) ?";
rep = lect_chaine();
// recherche du noeud le plus proche
if (rep == "0") nu = lesMail->Noeud_le_plus_proche_0(xi,n_mail);
else if (rep == "t") nu = lesMail->Noeud_le_plus_proche_t(xi,n_mail);
else if (rep == "tdt") nu = lesMail->Noeud_le_plus_proche_tdt(xi,n_mail);
else
{ cout << "\n erreur de syntaxe, on attendait 0 ou t ou tdt ! ";verif = false;};
cout << "\n noeud le plus proche nb= " << nu; verif = true;
}
else if (rep =="3")
{ 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
{ nomDeRef(n_mail).push_back(nom_ref);
nomDeRef(n_mail).sort(); // on ordonne
nomDeRef(n_mail).unique();// on supprime les doublons
};
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 == "ef")
{ // on efface la liste des noeuds
(tab_num_noeud(n_mail)).clear();
verif = false;
}
else if (rep == "efref")
{ // on efface la liste des références de noeuds
(nomDeRef(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 ";
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 1 ou 2 ! 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(n_mail).end();
for (ienu = tabnoeud_type_ddl_retenu(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;
}
}
};
if ((verif)&&((Minuscules(rep) != "fin") && (Minuscules(rep) != "f")))
{ // enregistrement
tab_num_noeud(n_mail).push_back(nu);
tab_num_noeud(n_mail).sort(); // on ordonne
tab_num_noeud(n_mail).unique();// on supprime les doublons
};
}// -- fin de la boucle infini sur l'entrée de numéro de noeud
};
// entrée du choix de grandeurs globals
void Choix_grandeurs_maple::Entree_grandeur_gobal(string& rep)
{ rep = "";
while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
{ if (list_grandeur_global.size() != 0)
{ // on utilise directement Paraglob
ParaGlob::param->Affiche_GrandeurGlobal(cout);
// cout << "\n liste des grandeurs globales disponibles en sortie:\n >>> ";
// List_io <string>::iterator jeint,jeintfin = list_grandeur_global.end();
// for (jeint=list_grandeur_global.begin();jeint!=jeintfin;jeint++)
// cout << *jeint << " ";
// il faut que l'on remette à jour les grandeurs globales car elles peuvent avoir été abondées
// pendant le calcul ex: Iteration, compteur divers ...
// comme on est en interactif le cout cpu a moins d'importance
ParaGlob::param->Recup_list_GrandeurGlobal(list_grandeur_global);
if ( list_grand_global_retenu.size() != 0)
{cout << "\n liste des grandeurs actuellement a sortir:\n <<<: ";
List_io <string>::iterator jeint,jeintfin = list_grand_global_retenu.end(); jeintfin = list_grand_global_retenu.end();
for (jeint=list_grand_global_retenu.begin();jeint!=jeintfin;jeint++)
cout << *jeint << " ";
}
cout << endl;
}
cout << "\n grandeurs que vous voulez visualiser (rep grandeurs?)"
<< "\n toutes les grandeurs (rep par defaut) (rep : to) "
<< "\n effacer la liste actuelle (rep : ef) "
<< "\n (pour terminer tapez : fin (ou f) ) ";
cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
if (rep == "to")
// cas de toutes les grandeurs
list_grand_global_retenu = list_grandeur_global;
// else if (find(list_grandeur_global.begin(),list_grandeur_global.end(),rep) != list_grandeur_global.end())
else if ( (find(list_grandeur_global.begin(),list_grandeur_global.end(),rep)
!= list_grandeur_global.end())
|| (ParaGlob::param->GrandeurGlobal(rep) != NULL)
)
list_grand_global_retenu.push_back(rep);
else if (rep == "ef")
list_grand_global_retenu.erase(list_grand_global_retenu.begin(),list_grand_global_retenu.end());
else if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f"))
{cout << "\n liste des grandeurs enregistrees : ";
List_io <string>::iterator jfint,jfintfin = list_grand_global_retenu.end();
for (jfint=list_grand_global_retenu.begin();jfint!=jfintfin;jfint++)
cout << *jfint << " ";
cout << "\n";
}
else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
cout << " erreur de syntaxe dans le ddl! recommencez ";
}
};
// entrée du choix des torseurs de réaction
void Choix_grandeurs_maple::Entree_torseurs_reaction(string& rep)
{ int nbmail = tab_list_torseur_condLim.Taille();
// on boucle sur les maillages
bool aucunesortie = true; // pour mettre un message si aucun torseur n'est dispo
for (int imail = 1; imail <= nbmail; imail++)
{ rep = "";
List_io <String_et_entier >& list_torseur_condLim = tab_list_torseur_condLim(imail);
List_io <String_et_entier >& list_torseur_condLim_retenu = tab_list_torseur_condLim_retenu(imail);
if (list_torseur_condLim.size() != 0)
{ aucunesortie=false;
while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
{ cout << "\n ---- maillage: " << lesMail->NomMaillage(imail);
cout << "\n liste des ref de torseur de reaction disponibles:\n >>> ";
List_io <String_et_entier>::iterator jeint,jeintfin = list_torseur_condLim.end();
for (jeint=list_torseur_condLim.begin();jeint!=jeintfin;jeint++)
cout << (*jeint).nom << " ";
if ( list_torseur_condLim_retenu.size() != 0)
{cout << "\n liste des ref de torseur actuellement a sortir:\n <<<: ";
List_io <String_et_entier>::iterator intfin = list_torseur_condLim_retenu.end();
for (jeint=list_torseur_condLim_retenu.begin();jeint!=intfin;jeint++)
cout << (*jeint).nom << " ";
}
cout << endl;
cout << "\n ref que vous voulez visualiser (rep grandeurs?)"
<< "\n toutes les ref (rep par defaut) (rep : to) "
<< "\n effacer la liste actuelle (rep : ef) "
<< "\n (pour terminer tapez : fin (ou f) ) ";
cout << "\n grandeur ? ";rep = lect_return_defaut(false,"f");
// on regarde si la ref est bonne
bool choix_valide = false;
for (jeint=list_torseur_condLim.begin();jeint!=jeintfin;jeint++)
{ if ((*jeint).nom == rep)
{ list_torseur_condLim_retenu.push_back(*jeint);
choix_valide = true;
break;
};
};
if (!choix_valide)
{if (rep == "to")
// cas de toutes les grandeurs
list_torseur_condLim_retenu = list_torseur_condLim;
else if (rep == "ef")
list_torseur_condLim_retenu.erase(list_torseur_condLim_retenu.begin(),list_torseur_condLim_retenu.end());
else if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f"))
{cout << "\n liste des grandeurs enregistrees : ";
List_io <String_et_entier>::iterator intfin = list_torseur_condLim_retenu.end();
for (jeint=list_torseur_condLim_retenu.begin();jeint!=intfin;jeint++)
cout << (*jeint).nom << " ";
cout << "\n";
}
else if ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
cout << " erreur de syntaxe dans le ddl! recommencez ";
}; // -- fin du test choix_valide
}; // -- fin du while
}; //-- fin du test sur la taille de la liste
}; //-- fin de la boucle sur les maillages
// sortie éventuelle d'un message
if (aucunesortie)
cout << "\n ??? il n'y a aucun torseur de reaction a sortir ???? ";
};
// dans le cas d'une animation, il n'y a pas de sortie directe mais la création de listes qui sont transmises
// à animation_maple
void Choix_grandeurs_maple::Construction_liste_pour_animation
(int numMail ,LesMaillages * lesMail,Charge* charge)
{List_io <DeuxDoubles> liste_sortie; // la liste à sortir
// on balaie la liste des grandeurs a visualiser, dans le cas ou l'on trouve la bonne grandeur on
// sauvegarde dans la liste à sortir
if (type_xi)
{ // --------- cas des grandeurs aux noeuds ------------
List_io<int>::iterator inoeud,inoeudfin=tab_num_noeud(numMail).end();
// on crée une liste intermédiaire qui contient tous les noeuds à sortir,
List_io <int> tab_total_noeud = tab_num_noeud(numMail); // tout d'abord récup de la liste de noeuds
// puis les références de listes de noeuds
List_io <string >::iterator idl,idlfin= nomDeRef(numMail).end();
for (idl=nomDeRef(numMail).begin();idl!=idlfin;idl++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve(*idl,numMail);
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref de noeud
int taillen=reff.Taille();
for (int inoeu=1;inoeu<=taillen;inoeu++) // on boucle et enregistre les noeuds
tab_total_noeud.push_back(reff.Numero(inoeu));
}
inoeudfin=tab_total_noeud.end();
// maintenant on affiche les infos pour la liste totale de noeuds
for (inoeud = tab_total_noeud.begin();inoeud!=inoeudfin;inoeud++)
{ // la grandeurs en x1
bool asortir = true; double valx_a_sortir;
// on regarde si la grandeur existe
if (!lesMail->Noeud_LesMaille(numMail,*inoeud).Existe_ici((x1).Enum()))
{ asortir=false;
#ifdef MISE_AU_POINT
cout << "\n attention la grandeur " << Nom_ddl((x1).Enum()) << " n'est pas disponible, on mais 0 a la place";
#endif
}
if ((asortir) && (!accroi_x1)) // cas où l'on sort la grandeur
{if (charge->Temps_courant() == 0.) {valx_a_sortir = lesMail->Noeud_LesMaille(numMail,*inoeud).Valeur_0((x1).Enum());}
else {valx_a_sortir = lesMail->Noeud_LesMaille(numMail,*inoeud).Valeur_t((x1).Enum());}
}
else if ((asortir) && (accroi_x1)) // cas où l'on sort la variation entre 0 et t de la grandeur
{if (charge->Temps_courant() == 0.) {valx_a_sortir = 0.;}
else { double val_init = lesMail->Noeud_LesMaille(numMail,*inoeud).Valeur_0((x1).Enum());
valx_a_sortir = lesMail->Noeud_LesMaille(numMail,*inoeud).Valeur_t((x1).Enum()) - val_init;}
}
else {valx_a_sortir = 0.;}
// la grandeurs en x2
asortir = true; double valy_a_sortir;
// on regarde si la grandeur existe
if (!lesMail->Noeud_LesMaille(numMail,*inoeud).Existe_ici((x2).Enum()))
{ asortir=false;
#ifdef MISE_AU_POINT
cout << "\n attention la grandeur " << Nom_ddl((x2).Enum()) << " n'est pas disponible, on mais 0 a la place";
#endif
};
if ((asortir) && (!accroi_x2)) // cas où l'on sort la grandeur
{if (charge->Temps_courant() == 0.) {valy_a_sortir = lesMail->Noeud_LesMaille(numMail,*inoeud).Valeur_0((x2).Enum());}
else {valy_a_sortir = lesMail->Noeud_LesMaille(numMail,*inoeud).Valeur_t((x2).Enum());}
}
else if ((asortir) && (accroi_x2)) // cas où l'on sort la variation entre 0 et t de la grandeur
{if (charge->Temps_courant() == 0.) {valy_a_sortir = 0.;}
else { double val_init = lesMail->Noeud_LesMaille(numMail,*inoeud).Valeur_0((x2).Enum());
valy_a_sortir = lesMail->Noeud_LesMaille(numMail,*inoeud).Valeur_t((x2).Enum()) - val_init;}
}
else {valy_a_sortir = 0.;}
// enregistrement
liste_sortie.push_back(DeuxDoubles(valx_a_sortir,valy_a_sortir));
}
} //-- fin des grandeurs pour un noeud
else
{ // --------- cas des grandeurs aux éléments ------------
List_io<int>::iterator ielement,ielementfin=tab_num_element(numMail).end();
// on crée une liste intermédiaire qui contient tous les éléments et point d'integ à sortir,
List_io <int> tab_total_elem = tab_num_element(numMail); // tout d'abord récup de la liste des éléments
List_io <int> tab_total_ptint = tab_num_integ(numMail); // et les points d'intégration correspondant
// puis les références de listes d'éléments
{List_io <BlocScal>::iterator idl,idlfin= nomDeRef_E(numMail).end();
for (idl=nomDeRef_E(numMail).begin();idl!=idlfin;idl++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*idl).NomRef(),numMail);
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'éléments
int taillen=reff.Taille(); // nombre d'éléments dans la liste
for (int ielem=1;ielem<=taillen;ielem++) // on boucle et enregistre les elements et le point
{tab_total_elem.push_back(reff.Numero(ielem)); // d'intégration
tab_total_ptint.push_back((int) ((*idl).Val())); // associé (le même pour toute la référence)
}
};
}; // encapsulage
// puis les références de listes de points d'intégration d'éléments
{List_io <string>::iterator ids,idsfin= nomDeRef_ptinteg(numMail).end();
for (ids=nomDeRef_ptinteg(numMail).begin();ids!=idsfin;ids++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*ids),numMail);
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref de pt d'integ
int taillen=reff.Taille(); // nombre d'éléments dans la liste
for (int ielem=1;ielem<=taillen;ielem++) // on boucle et enregistre les elements et le point
{tab_total_elem.push_back(reff.NumeroElem(ielem)); // d'intégration
tab_total_ptint.push_back(reff.NumeroFA(ielem)); // associé (le même pour toute la référence)
}
}
}; // encapsulé
ielementfin=tab_total_elem.end();
// dans le cas où il s'agit de ddl
if (ddl_etpas_TQ_1 && ddl_etpas_TQ_2)
{// on crée une liste intermédiaire pour stocker x1 et x2 , ceci pour l'appel de "Valeur_a_diff_temps "
List_io < Ddl_enum_etendu > x1x2; x1x2.push_back(x1); x1x2.push_back(x2);
// maintenant on affiche les infos pour la liste totale d'éléments
List_io <int>::iterator iptinteg = tab_total_ptint.begin();
for (ielement = tab_total_elem.begin();ielement!=ielementfin;ielement++,iptinteg++)
{ // les grandeurs
Tableau <double> tab=
lesMail->Element_LesMaille(numMail,*ielement).Valeur_a_diff_temps(absolue,TEMPS_tdt,x1x2,*iptinteg);
// enregistrement
liste_sortie.push_back(DeuxDoubles(tab(1),tab(2)));
}
}
else // cas où x ou y sont des grandeurs particulières
{// on crée une liste intermédiaire pour stocker x1 ou x2 , ceci pour l'appel de "Valeur_a_diff_temps "
List_io < Ddl_enum_etendu > x1x2; List_io<TypeQuelconque> lix1x2;
if (ddl_etpas_TQ_1) {x1x2.push_back(x1);} else {lix1x2.push_back(xx1);};
if (ddl_etpas_TQ_2) {x1x2.push_back(x2);} else {lix1x2.push_back(xx1);};
List_io<TypeQuelconque>::iterator ilix1x2 = lix1x2.begin();
List_io<TypeQuelconque>::iterator ilix1x2_fin = ilix1x2;ilix1x2_fin++;
// maintenant on affiche les infos pour la liste totale d'éléments
List_io <int>::iterator iptinteg = tab_total_ptint.begin();
if ( ddl_etpas_TQ_1 & !ddl_etpas_TQ_2)
{ // cas où la première grandeur est ddl et la seconde particulière
for (ielement = tab_total_elem.begin();ielement!=ielementfin;ielement++,iptinteg++)
{ // les grandeurs de type enum
Tableau <double> tab=
lesMail->Element_LesMaille(numMail,*ielement).Valeur_a_diff_temps(absolue,TEMPS_tdt,x1x2,*iptinteg);
// les grandeurs particulières
lesMail->Element_LesMaille(numMail,*ielement).Grandeur_particuliere(absolue,lix1x2,*iptinteg);
// enregistrement
double val2= (*ilix1x2).GrandeurNumOrdre(nb_ordre_2);
liste_sortie.push_back(DeuxDoubles(tab(1),val2));
}
}
else if ( !ddl_etpas_TQ_1 & ddl_etpas_TQ_2)
{ // cas où la première grandeur est particulière et la seconde ddl
for (ielement = tab_total_elem.begin();ielement!=ielementfin;ielement++,iptinteg++)
{ // les grandeurs de type enum
Tableau <double> tab=
lesMail->Element_LesMaille(numMail,*ielement).Valeur_a_diff_temps(absolue,TEMPS_tdt,x1x2,*iptinteg);
// les grandeurs particulières
lesMail->Element_LesMaille(numMail,*ielement).Grandeur_particuliere(absolue,lix1x2,*iptinteg);
// enregistrement
double val1= (*ilix1x2).GrandeurNumOrdre (nb_ordre_1);
liste_sortie.push_back(DeuxDoubles(val1,tab(1)));
}
}
else // sinon les deux grandeurs sont particulière
{ for (ielement = tab_total_elem.begin();ielement!=ielementfin;ielement++,iptinteg++)
{// les grandeurs particulières
lesMail->Element_LesMaille(numMail,*ielement).Grandeur_particuliere(absolue,lix1x2,*iptinteg);
// enregistrement
double val1= (*ilix1x2).GrandeurNumOrdre(nb_ordre_1);
double val2= (*ilix1x2_fin).GrandeurNumOrdre(nb_ordre_2);
liste_sortie.push_back(DeuxDoubles(val1,val2));
}
};
}; //-- fin du cas où il y a au moins une grandeur particulière
}; // fin du else sur les grandeurs aux éléments
// ajout de la courbe à l'animation
animation_maple->Ajout_courbe(liste_sortie);
};
// entrée du choix de l'utilisation sur le style de sortie
void Choix_grandeurs_maple::Style_de_sortie(string& rep)
{rep = ""; // init
while ((Minuscules(rep) != "fin") && (Minuscules(rep) != "f"))
{// on expliques les différentes possibles possibles
cout << "\n differents choix possibles "
<< "\n sortie avec standart automatique (rep : st)"
<< "\n forcer l'ecriture sur une ligne unix pour chaque increment (rep : ul)"
<< "\n tenseur en absolue (rep : ab)"
<< "\n tenseur dans un repere le plus ad hoc (rep : ad)"
<< "\n aide (rep : ?)"
<< "\n pas de changement et retour (rep : fin (ou f)) ";
cout << "\n ( valeur actuelle du choix: ";
if (style_de_sortie==0) {cout << " st )\n";} else {cout << " ul )\n";};
rep = "";
cout << "\n choix ? ";rep = lect_return_defaut(false,"f");
if (rep == "st") { style_de_sortie = 0;}
else if (rep == "ul") { style_de_sortie = 1;}
else if (rep == "ab") { absolue = 1;}
else if (rep == "ad") { absolue = 0;}
else if (rep == "?")
{ cout << "\n dans le cas d'une sortie standart automatique, chaque increment est sortie sur une ligne"
<< " unix, sauf dans le cas ou un seul increment est en sortie. Dans ce dernier cas,"
<< " les informations sont decoupees par defaut, par exemple selon: une ligne = un noeud , "
<< " et le temps n'est pas indique. Dans certain cas cette modification automatique de format"
<< " n'est pas interressante (par exemple pour les sorties au fil du calcul), il est alors possible"
<< " de forcer une sortie globale de l'increment sur une seule ligne meme dans le cas d'un seul increment"
<< " c'est l'option ul. "
<< " \n concernant la sortie des tenseurs: par defaut les tenseurs sont exprimes dans le repere "
<< " absolu. Dans le cas de coque par exemple, il est plus interessant d'exprimer les tenseurs "
<< " dans un repere tangent a l'element (repere ad hoc) "
;
}
else
{ cout << "\n erreur de syntaxe, recommencez ! ";};
};
};
// vérification des listes de pt d'integ et d'éléments relativement au grandeur à sortir
void Choix_grandeurs_maple::VerifListes()
{ // on vérifie que les grandeurs principale de type enum étendue que l'on veut sortir sont possible
// par contre pas de vérif pour les grandeurs quelconques
int nb_maillage = tabelement_type_ddl.Taille();
// def d'un conteneur de travail
Maillage::NBelemEtptInteg nut;
for (int n_mail = 1;n_mail<=nb_maillage;n_mail++)
{
List_io<Ddl_enum_etendu>::iterator ienufin=tabelement_type_ddl_retenu(n_mail).end();
List_io<Ddl_enum_etendu>::iterator ienu_deb=tabelement_type_ddl_retenu(n_mail).begin();
List_io<Ddl_enum_etendu>::iterator ienu;
// 1) liste d'éléments
{List_io <BlocScal>::iterator idl,idlfin= nomDeRef_E(n_mail).end();
for (idl=nomDeRef_E(n_mail).begin();idl!=idlfin;idl++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*idl).NomRef(),n_mail);
const ReferenceNE & reff = ((ReferenceNE &) refi); // transfo en ref d'éléments
int taillen=reff.Taille(); // nombre d'éléments dans la liste
for (int ielem=1;ielem<=taillen;ielem++) // on boucle et on test
{
// boucle sur les ddl retenus
for (ienu = ienu_deb;ienu != ienufin; ienu++)
{ nut.nbElem = reff.Numero(ielem);
nut.nbPtInteg = (int) ((*idl).Val());
// 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,(*ienu).Enum())))
{ cout << "\n warning : le numero " << nut.nbPtInteg << " de numero d'ordre "
<< " pour le ddl " << Nom_ddl((*ienu).Enum()) << " n'est pas valide pour l'element "
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
};
}; // fin de la boucle sur les ddl retenus
};//-- fin de la boucle sur les éléments de la référence
}; //-- fin de la boucle sur les références d'éléments
};// fin encapsulage
// 2) liste de points d'intégrations d'éléments
{List_io <string>::iterator idl,idlfin= nomDeRef_ptinteg(n_mail).end();
for (idl=nomDeRef_ptinteg(n_mail).begin();idl!=idlfin;idl++)
{ // recup de la reference correspondant au mot cle
const Reference& refi = lesRef->Trouve((*idl),n_mail);
const ReferenceAF & reff = ((ReferenceAF &) refi); // transfo en ref d'éléments
int taillen=reff.Taille(); // nombre d'éléments dans la liste
for (int ielem=1;ielem<=taillen;ielem++) // on boucle et on test
{
// boucle sur les ddl retenus
for (ienu = ienu_deb;ienu != ienufin; ienu++)
{ 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,(*ienu).Enum())))
{ cout << "\n warning : le numero " << nut.nbPtInteg << " de numero d'ordre "
<< " pour le ddl " << Nom_ddl((*ienu).Enum()) << " n'est pas valide pour l'element "
<< nut.nbElem << " du maillage " << n_mail << " !!!! ";
};
}; // fin de la boucle sur les ddl retenus
};//-- fin de la boucle sur les éléments de la référence
}; //-- fin de la boucle sur les références d'éléments
};// fin encapsulage
}; // fin de la boucle sur les maillages
};
// utilitaire de sortie d'entête pour les noeuds:
void Choix_grandeurs_maple::Sortie_entete_noeud_unitaire(list<int>::const_iterator imail,ostream & sort, int& num_col)
{ // on sort la position des xyz
switch (ParaGlob::Dimension())
{case 1: sort << " ["<<num_col<<"]X "; num_col++; break;
case 2: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y " ;num_col+=2; break;
case 3: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y "<< " ["<<num_col+2<<"]Z ";num_col+=3; break;
};
// les positions de chaque grandeurs
// --- les ddl principaux ----
{List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabnoeud_type_ddl_retenu(*imail).end();
for (ienu = tabnoeud_type_ddl_retenu(*imail).begin();ienu!=ienufin;ienu++)
{ switch (type_sortie_ddl_retenue)
{ case 0: sort << " ["<<num_col<<"]"<< (*ienu).Nom_plein() << " ";num_col++;break;
case 1: sort << " ["<<num_col<<"]"<< ("delta_0_t_"+string((*ienu).Nom_plein())) << " ";num_col++;break;
case 2: sort << " ["<<num_col<<"]"<< (string((*ienu).Nom_plein())+"_0")<<" "
<< " ["<<num_col+1<<"]"<< (*ienu).Nom_plein() << " ";num_col+=2; break;
};
};
};
// --- les ddl étendus ----
{List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabnoeud_type_ddlEtendu_retenu(*imail).end();
for (ienu = tabnoeud_type_ddlEtendu_retenu(*imail).begin();ienu!=ienufin;ienu++)
{ sort << " ["<<num_col<<"]"<< (*ienu).Nom_plein() << " ";num_col++; };
};
// --- les grandeurs quelconques ---
{List_io<TypeQuelconque>::iterator iquefin=tabnoeud_TypeQuelconque_retenu(*imail).end();
List_io<TypeQuelconque>::iterator ique,ique_deb=tabnoeud_TypeQuelconque_retenu(*imail).begin();
for (ique = ique_deb;ique != iquefin;ique++)
{(*ique).Ecriture_entete_grandeur(sort);
sort << " ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"]"; // l'étendue des colonnes
num_col += (*ique).NbMaxiNumeroOrdre();
sort << "\n# ";
};
};
sort << " ;\n# ";
};
// utilitaire de sortie d'entête pour les éléments:
void Choix_grandeurs_maple::Sortie_entete_element_unitaire(list<int>::const_iterator imail,ostream & sort, int& num_col, bool & temps_deja_affiche)
{
// a) les Ddl_enum_etendu
List_io<Ddl_enum_etendu>::iterator ienu,ienufin=tabelement_type_ddl_retenu(*imail).end();
List_io<Ddl_enum_etendu>::iterator ienu_deb=tabelement_type_ddl_retenu(*imail).begin();
if (ienu_deb != ienufin) // c'est a dire: cas où existe une grandeur
{ // on sort la position des xyz du point d'intégration
if (!temps_deja_affiche) num_col++; // on passe l'affichage du temps si besoin
temps_deja_affiche=true;
switch (ParaGlob::Dimension())
{case 1: sort << " ["<<num_col<<"]X "; num_col++; break;
case 2: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y " ;num_col+=2; break;
case 3: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y "<< " ["<<num_col+2<<"]Z ";num_col+=3; break;
};
// les positions de chaque grandeurs
for (ienu = tabelement_type_ddl_retenu(*imail).begin();ienu!=ienufin;ienu++,num_col++)
sort << " ["<<num_col<<"]"<< (*ienu) << " ";
};
{// maintenant les grandeurs particulières
List_io<TypeQuelconque>::iterator iquefin=tabelement_typeParti_retenu(*imail).end();
List_io<TypeQuelconque>::iterator ique,ique_deb=tabelement_typeParti_retenu(*imail).begin();
if (ique_deb != iquefin) // c'est a dire: cas où existe une grandeur
{ // on sort la position des xyz du point d'intégration
sort << "\n# ";
if (!temps_deja_affiche) num_col++; // on passe l'affichage du temps si on ne l'a pas déjà passé
switch (ParaGlob::Dimension())
{case 1: sort << " ["<<num_col<<"]X "; num_col++; break;
case 2: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y " ;num_col+=2; break;
case 3: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y "<< " ["<<num_col+2<<"]Z ";num_col+=3; break;
};
sort << "\n# ";
// puis l'intervalle des grandeurs
for (ique = tabelement_typeParti_retenu(*imail).begin();ique!=iquefin;ique++)
{(*ique).Ecriture_entete_grandeur(sort);
sort << " ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"]"; // l'étendue des colonnes
num_col += (*ique).NbMaxiNumeroOrdre();
sort << "\n# ";
};
};
}; // fin encapsulage pour les grandeurs particulières
{// maintenant les grandeurs évoluées
List_io<TypeQuelconque>::iterator iquefin=tabelement_evoluee_retenu(*imail).end();
List_io<TypeQuelconque>::iterator ique,ique_deb=tabelement_evoluee_retenu(*imail).begin();
if (ique_deb != iquefin) // c'est a dire: cas où existe une grandeur
{ // on sort la position des xyz du point d'intégration
sort << "\n# ";
if (!temps_deja_affiche)
{num_col++; // on passe l'affichage du temps si on ne l'a pas déjà passé
temps_deja_affiche=true;
};
switch (ParaGlob::Dimension())
{case 1: sort << " ["<<num_col<<"]X "; num_col++; break;
case 2: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y " ;num_col+=2; break;
case 3: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y "<< " ["<<num_col+2<<"]Z ";num_col+=3; break;
};
sort << "\n# ";
// puis l'intervalle des grandeurs
for (ique = tabelement_evoluee_retenu(*imail).begin();ique!=iquefin;ique++)
{(*ique).Ecriture_entete_grandeur(sort);
sort << " ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"]"; // l'étendue des colonnes
num_col += (*ique).NbMaxiNumeroOrdre();
sort << "\n# ";
};
};
}; // fin encapsulage pour les grandeurs évoluées
sort << "\n# ";
};
// utilitaire de sortie d'entête pour les faces d'élément:
void Choix_grandeurs_maple::Sortie_entete_face_element_unitaire(list<int>::const_iterator imail,ostream & sort, int& num_col, bool & temps_deja_affiche)
{
{// cas des grandeurs quelconques
List_io<TypeQuelconque>::iterator iquefin=tab_F_element_TypeQuelconque_retenu(*imail).end();
List_io<TypeQuelconque>::iterator ique,ique_deb=tab_F_element_TypeQuelconque_retenu(*imail).begin();
if (ique_deb != iquefin) // c'est a dire: cas où existe une grandeur
{ // on sort la position des xyz du point d'intégration
sort << "\n# ";
if (!temps_deja_affiche)
{num_col++; // on passe l'affichage du temps si on ne l'a pas déjà passé
temps_deja_affiche=true;
};
switch (ParaGlob::Dimension())
{case 1: sort << " ["<<num_col<<"]X "; num_col++; break;
case 2: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y " ;num_col+=2; break;
case 3: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y "<< " ["<<num_col+2<<"]Z ";num_col+=3; break;
};
sort << "\n# ";
// puis l'intervalle des grandeurs
for (ique = tab_F_element_TypeQuelconque_retenu(*imail).begin();ique!=iquefin;ique++)
{(*ique).Ecriture_entete_grandeur(sort);
sort << " ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"]"; // l'étendue des colonnes
num_col += (*ique).NbMaxiNumeroOrdre();
sort << "\n# ";
};
};
}; // fin encapsulage pour les grandeurs quelconques
sort << "\n# ";
};
// utilitaire de sortie d'entête pour les arêtes d'élément:
void Choix_grandeurs_maple::Sortie_entete_arete_element_unitaire(list<int>::const_iterator imail,ostream & sort, int& num_col, bool & temps_deja_affiche)
{
{// cas des grandeurs quelconques
List_io<TypeQuelconque>::iterator iquefin=tab_A_element_TypeQuelconque_retenu(*imail).end();
List_io<TypeQuelconque>::iterator ique,ique_deb=tab_A_element_TypeQuelconque_retenu(*imail).begin();
if (ique_deb != iquefin) // c'est a dire: cas où existe une grandeur
{ // on sort la position des xyz du point d'intégration
sort << "\n# ";
if (!temps_deja_affiche)
{num_col++; // on passe l'affichage du temps si on ne l'a pas déjà passé
temps_deja_affiche=true;
};
switch (ParaGlob::Dimension())
{case 1: sort << " ["<<num_col<<"]X "; num_col++; break;
case 2: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y " ;num_col+=2; break;
case 3: sort << " ["<<num_col<<"]X " << " ["<<num_col+1<<"]Y "<< " ["<<num_col+2<<"]Z ";num_col+=3; break;
};
sort << "\n# ";
// puis l'intervalle des grandeurs
for (ique = tab_A_element_TypeQuelconque_retenu(*imail).begin();ique!=iquefin;ique++)
{(*ique).Ecriture_entete_grandeur(sort);
sort << " ["<<num_col << "..." << num_col+(*ique).NbMaxiNumeroOrdre()-1<<"]"; // l'étendue des colonnes
num_col += (*ique).NbMaxiNumeroOrdre();
sort << "\n# ";
};
};
}; // fin encapsulage pour les grandeurs quelconques
sort << "\n# ";
};