2021-09-28 14:10:44 +02:00
|
|
|
|
|
|
|
|
// This file is part of the Herezh++ application.
|
|
|
|
|
//
|
|
|
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
|
|
|
// of mechanics for large transformations of solid structures.
|
|
|
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
|
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
|
|
|
//
|
|
|
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
|
|
|
//
|
2023-05-03 17:23:49 +02:00
|
|
|
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
2021-09-28 14:10:44 +02:00
|
|
|
// AUTHOR : Gérard Rio
|
|
|
|
|
// E-MAIL : gerardrio56@free.fr
|
|
|
|
|
//
|
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
|
|
|
// it under the terms of the GNU General Public License as published by
|
|
|
|
|
// the Free Software Foundation, either version 3 of the License,
|
|
|
|
|
// or (at your option) any later version.
|
|
|
|
|
//
|
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
|
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
|
// See the GNU General Public License for more details.
|
|
|
|
|
//
|
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
|
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
|
//
|
|
|
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
|
|
|
|
|
|
|
|
|
#include "Choix_grandeurs_maple.h"
|
|
|
|
|
#include "CharUtil.h"
|
|
|
|
|
#include "ReferenceNE.h"
|
|
|
|
|
#include "ReferencePtiAF.h"
|
|
|
|
|
|
|
|
|
|
#include <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
|
2023-05-03 17:23:49 +02:00
|
|
|
//int dim = ParaGlob::Dimension();
|
2021-09-28 14:10:44 +02:00
|
|
|
// 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
|
2023-05-03 17:23:49 +02:00
|
|
|
//int dim = ParaGlob::Dimension();
|
2021-09-28 14:10:44 +02:00
|
|
|
// 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();
|
2023-05-03 17:23:49 +02:00
|
|
|
//int taille_list_maille = list_mail.size();
|
2021-09-28 14:10:44 +02:00
|
|
|
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
|
2023-05-03 17:23:49 +02:00
|
|
|
//int dim = ParaGlob::Dimension();
|
2021-09-28 14:10:44 +02:00
|
|
|
// 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();
|
2023-05-03 17:23:49 +02:00
|
|
|
//int taille_list_maille = list_mail.size();
|
2021-09-28 14:10:44 +02:00
|
|
|
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
|
2023-05-03 17:23:49 +02:00
|
|
|
//int dim = ParaGlob::Dimension();
|
2021-09-28 14:10:44 +02:00
|
|
|
// 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();
|
2023-05-03 17:23:49 +02:00
|
|
|
//int taille_list_maille = list_mail.size();
|
2021-09-28 14:10:44 +02:00
|
|
|
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
|
2023-05-03 17:23:49 +02:00
|
|
|
//int dim = ParaGlob::Dimension();
|
2021-09-28 14:10:44 +02:00
|
|
|
// 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();
|
2023-05-03 17:23:49 +02:00
|
|
|
//int taille_list_maille = list_mail.size();
|
2021-09-28 14:10:44 +02:00
|
|
|
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
|
2023-05-03 17:23:49 +02:00
|
|
|
//int dim = ParaGlob::Dimension();
|
2021-09-28 14:10:44 +02:00
|
|
|
// 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();
|
2023-05-03 17:23:49 +02:00
|
|
|
//int taille_list_maille = list_mail.size();
|
2021-09-28 14:10:44 +02:00
|
|
|
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
|
2023-05-03 17:23:49 +02:00
|
|
|
//int dim = ParaGlob::Dimension();
|
2021-09-28 14:10:44 +02:00
|
|
|
// 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();
|
2023-05-03 17:23:49 +02:00
|
|
|
//int taille_list_maille = list_mail.size();
|
2021-09-28 14:10:44 +02:00
|
|
|
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();
|
2023-05-03 17:23:49 +02:00
|
|
|
//list<int>::const_iterator ilm,ilmfin=list_mail.end();
|
2021-09-28 14:10:44 +02:00
|
|
|
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;
|
2023-05-03 17:23:49 +02:00
|
|
|
//List_io <BlocScal >::iterator idl,idlfin= nomDeRef_E(n_mail).end();
|
2021-09-28 14:10:44 +02:00
|
|
|
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)
|
2023-05-03 17:23:49 +02:00
|
|
|
{//List_io <BlocScal >::iterator idl,idlfin= nomDeRef_E(n_mail).end();
|
2021-09-28 14:10:44 +02:00
|
|
|
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;
|
2023-05-03 17:23:49 +02:00
|
|
|
//List_io <string >::iterator idl,idlfin= nomDeRef_ptinteg(n_mail).end();
|
2021-09-28 14:10:44 +02:00
|
|
|
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
|
2023-05-03 17:23:49 +02:00
|
|
|
//int dim = ParaGlob::Dimension();
|
2021-09-28 14:10:44 +02:00
|
|
|
// on récupère la liste des maillages à visualiser
|
|
|
|
|
const list <int>& list_mail = choix_mail->List_choisit();
|
2023-05-03 17:23:49 +02:00
|
|
|
//list<int>::const_iterator ilm,ilmfin=list_mail.end();
|
2021-09-28 14:10:44 +02:00
|
|
|
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;
|
2023-05-03 17:23:49 +02:00
|
|
|
//List_io <BlocScal >::iterator idl,idlfin= nomDeRef_F_E(n_mail).end();
|
2021-09-28 14:10:44 +02:00
|
|
|
|
|
|
|
|
// 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)
|
2023-05-03 17:23:49 +02:00
|
|
|
{//List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_F_E_SM(n_mail).end();
|
2021-09-28 14:10:44 +02:00
|
|
|
|
|
|
|
|
// --- cas des types quelconques aux faces d'éléments
|
|
|
|
|
{List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_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
|
2023-05-03 17:23:49 +02:00
|
|
|
//int dim = ParaGlob::Dimension();
|
2021-09-28 14:10:44 +02:00
|
|
|
// on récupère la liste des maillages à visualiser
|
|
|
|
|
const list <int>& list_mail = choix_mail->List_choisit();
|
2023-05-03 17:23:49 +02:00
|
|
|
//list<int>::const_iterator ilm,ilmfin=list_mail.end();
|
2021-09-28 14:10:44 +02:00
|
|
|
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;
|
2023-05-03 17:23:49 +02:00
|
|
|
//List_io <BlocScal >::iterator idl,idlfin= nomDeRef_A_E(n_mail).end();
|
2021-09-28 14:10:44 +02:00
|
|
|
|
|
|
|
|
// 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)
|
2023-05-03 17:23:49 +02:00
|
|
|
{//List_io <BlocScal >::iterator idl,idlfin= tab_nomDeRef_A_E_SM(n_mail).end();
|
2021-09-28 14:10:44 +02:00
|
|
|
|
|
|
|
|
// --- cas des types quelconques aux arêtes d'éléments
|
|
|
|
|
{List_io<EnumTypeQuelconque>::iterator ite,itefin = li_enu_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();
|
2023-05-03 17:23:49 +02:00
|
|
|
if ( ddl_etpas_TQ_1 && !ddl_etpas_TQ_2)
|
2021-09-28 14:10:44 +02:00
|
|
|
{ // 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));
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-05-03 17:23:49 +02:00
|
|
|
else if ( !ddl_etpas_TQ_1 && ddl_etpas_TQ_2)
|
2021-09-28 14:10:44 +02:00
|
|
|
{ // 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# ";
|
|
|
|
|
};
|
|
|
|
|
|
