Herezh_dev/Maillage/Maillage3.cc
2023-05-03 17:23:49 +02:00

3363 lines
164 KiB
C++

// FICHIER : Maillage.cp
// CLASSE : Maillage
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Maillage.h"
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
#include <stdio.h>
#include <vector>
#include "List_io.h"
#include "CharUtil.h"
#ifndef SYSTEM_MAC_OS_X_unix
#include "Frontier.h"
#endif
#include "ConstMath.h"
#include "ReferenceNE.h"
#include "ReferenceAF.h"
#include "Util.h"
#include "MvtSolide.h"
#include "Basiques.h"
#include <limits>
// définition interactive de listes de références
void Maillage::CreationInteractiveListesRef(LesReferences* lesRef)
{ string reponse="";
bool fr = ParaGlob::Francais(); // pour simplifier
while ((reponse != "f")&&(reponse != "fi")&&(reponse != "fin"))
{ // def de la liste des types de références voulues
list <string > list_typeReference;
Enum_ddl enu_ddl; // associé aux pt d'integ nécessite un enuméré associé
list <string >::iterator it;
string typeReference="";
while (!((typeReference == "f")||(typeReference == "fi")||(typeReference == "fin")))
{// on initialise les listes de ref utilisées pour la def des nouvelles ref
// de manière à ne pas utiliser les refs déjà définies
list_refIn.clear();
list_refOut.clear();
// debug
// cout << "\n effacement de list_refIn et list_refOut " << endl;
// fin debug
// affichage du menu du type de référence voulu
if (list_typeReference.size()!= 0)
{ if (fr) {cout << "\n type de reference a creer actuellement enregistre ";}
else {cout << "\n type(s) already read ";};
for (it=list_typeReference.begin();it!=list_typeReference.end();it++)
cout << " " << *it;
};
if (fr)
{cout << "\n ref de noeuds (rep no) "
<< "\n ref d'elements (rep el) "
<< "\n ref de faces (rep fa) "
<< "\n ref d'arretes (rep ar) "
<< "\n ref de pt d'integration d'element (rep pt) "
<< "\n toutes les ref de frontiere (rep tfr) "
<< "\n effacer la liste actuelle (rep ef) "
<< "\n fin def des types de ref voulu (rep f) "
<< "\n reponses : (il peut y en avoir plusieurs differentes) ";
}
else
{cout << "\n reference of nodes (rep no) "
<< "\n reference of elements (rep el) "
<< "\n reference of facets (rep fa) "
<< "\n reference of edges (rep ar) "
<< "\n reference of integration points (rep pt) "
<< "\n all the references of the boundary (rep tfr) "
<< "\n deletion of the registered references (rep ef) "
<< "\n end of the def of the type of ref (rep f) "
<< "\n answer : (you can set several different ) ";
};
typeReference=lect_return_defaut(false,"f");
if ((typeReference=="no")||(typeReference=="el")||(typeReference=="fa")
||(typeReference=="ar")||(typeReference=="pt"))
{ if (find(list_typeReference.begin(),list_typeReference.end(),typeReference) == list_typeReference.end())
{list_typeReference.push_back(typeReference);}
else
{if (fr){cout << "\n type deja enregistre !! on n'en tient pas compte ";}
else {cout << "\n ype already registered !! we don't consider this choice ";};
};
}
else if (typeReference=="tfr")
{// là on crée directement les références et on continue
CreationRefFrontiere(*lesRef);
////--- debug
//cout << "\n debug Maillage::CreationInteractiveListesRef( ";
//lesRef->Affiche(1);
//
////--- fin debug
}
else if (typeReference=="ef")
list_typeReference.erase(list_typeReference.begin(),list_typeReference.end());
else if ((typeReference == "f")||(typeReference == "fi")||(typeReference == "fin"))
{ // fin demandé: on ne fait rien
}
else
{if (fr){cout << "\n mauvais choix lu : " << typeReference << ", verifiez la syntaxe et recommencez ";}
else {cout << "\n bad choice : " << typeReference << ", check your answer ";}
};
};
// définition du nom des références
string nomref; string rep = "";
bool existe_demande_pti = false;
if (fr){cout << "\n \n ---- acquisition des noms de references ---- ";}
else {cout << "\n \n ---- reading of the reference names ---- ";}
list <string > list_nomReference;
list <string >::iterator il, ilfin = list_typeReference.end();
// si la liste est non vide on continue
if ( list_typeReference.size()!= 0)
{while ((rep != "f")&&(rep != "fi")&&(rep != "fin"))
{ // affichage du menu du type de référence voulu
list <string >::iterator il;
if (list_typeReference.size()!= 0)
{ if (fr){cout << "\n liste de nom de reference a creer actuellement enregistre ";}
else {cout << "\n list of the already registered new reference names ";}
for (il=list_nomReference.begin();il!=list_nomReference.end();il++)
cout << " " << *il;
};
for (il = list_typeReference.begin();il != ilfin; il++)
{if (*il == "no")
{ bool nom_correcte = false;
while (!nom_correcte)
{if (fr){cout << "\n nom de la reference de noeud ? ";}else{cout << "\n name of the node reference ? ";};
nomref= lect_chaine();
nomref = "N_"+nomref;
if (!(lesRef->Existe(nomref,idmail)))
{list_nomReference.push_back(nomref);
nom_correcte=true;
}
else
{ if (fr){cout << "\n la reference " << nomref << " existe deja, choissez un autre nom ";}
else {cout << "\n the reference " << nomref << " already exists, choose another name ";};
};
}; // fin du while
}
else if (*il == "el")
{ bool nom_correcte = false;
while (!nom_correcte)
{if (fr){cout << "\n nom de la reference d'element ? "; nomref= lect_chaine();}
else {cout << "\n name of the element reference ? "; nomref= lect_chaine();};
nomref = "E_"+nomref;
if (!(lesRef->Existe(nomref,idmail)))
{list_nomReference.push_back(nomref);
nom_correcte=true;
}
else
{ if (fr){cout << "\n la reference " << nomref << " existe deja, choissez un autre nom ";}
else {cout << "\n the reference " << nomref << " already exists, choose another name ";};
};
}; // fin du while
}
else if (*il == "fa")
{ bool nom_correcte = false;
while (!nom_correcte)
{if (fr){cout << "\n nom de la reference de face ? "; nomref= lect_chaine();}
else {cout << "\n name of the facet reference ? "; nomref= lect_chaine();};
nomref = "F_"+nomref;
if (!(lesRef->Existe(nomref,idmail)))
{list_nomReference.push_back(nomref);
nom_correcte=true;
}
else
{ if (fr){cout << "\n la reference " << nomref << " existe deja, choissez un autre nom ";}
else {cout << "\n the reference " << nomref << " already exists, choose another name ";};
};
}; // fin du while
}
else if (*il == "ar")
{ bool nom_correcte = false;
while (!nom_correcte)
{if (fr){cout << "\n nom de la reference d'arrete ? "; nomref= lect_chaine();}
else {cout << "\n name of the edge reference ? "; nomref= lect_chaine();};
nomref = "A_"+nomref;
if (!(lesRef->Existe(nomref,idmail)))
{list_nomReference.push_back(nomref);
nom_correcte=true;
}
else
{ if (fr){cout << "\n la reference " << nomref << " existe deja, choissez un autre nom ";}
else {cout << "\n the reference " << nomref << " already exists, choose another name ";};
};
}; // fin du while
}
else if (*il == "pt")
{ bool nom_correcte = false;
while (!nom_correcte)
{if (fr){cout << "\n nom de la reference de point d'integration ? " << endl; }
else {cout << "\n name of integration point reference ? "<< endl;};
nomref= lect_chaine();
string nomddl="";
nomref = "G_"+nomref;
if (!(lesRef->Existe(nomref,idmail)))
{list_nomReference.push_back(nomref);
while (!ExisteEnum_ddl(nomddl))
{ if (fr) {cout << "\n donnez un nom d'un ddl de base associe aux points d'integration ";
cout << "\n liste de ddl possible : " << endl;}
else {cout << "\n give a dof name associated to this integration point ";
cout << "\n list of possible dof : " << endl;};
for (int i=1;i<nombre_maxi_de_type_de_ddl;i++)
cout << Nom_ddl(Enum_ddl(i)) << " ";
if (fr) {cout << "\n nom du ddl ? " << endl ;}else{cout << "\n name of the dof ? " << endl ;};
nomddl= lect_chaine();
if (!ExisteEnum_ddl(nomddl))
{ if (fr) {cout << "\n nom de ddl incorrecte, recommencez ! " << endl;}
else {cout << "\n wrong name for the dof, test another name ! " << endl;};
};
};
enu_ddl = Id_nom_ddl(nomddl);
nom_correcte=true;
existe_demande_pti = true; // pour la sortie d'info par la suite
}
else
{ if (fr){cout << "\n la reference " << nomref << " existe deja, choissez un autre nom "<< endl;}
else {cout << "\n the reference " << nomref << " already exists, choose another name "<< endl;};
};
}; // fin du while
}
};
if (fr){cout << "\n voulez vous "
<< "\n effacer la liste actuelle et recommencer la def des nom (rep efc) "
<< "\n fin (rep f) " << endl;
}
else {cout << "\n do you want to delete the already registered "
<< "\n list and define again the list of reference names (rep efc) "
<< "\n end (rep f) " << endl;
};
rep = lect_return_defaut(false,"f");
if (rep == "efc")
{list_nomReference.clear();
enu_ddl = NU_DDL;
};
}; // fin du choix des noms
// s'il y a une demande de ref de pt integ sortie éventuelle d'information
if (existe_demande_pti)
{ string dem = "";
list <string >::iterator il, ilfin = list_typeReference.end();
for (il = list_typeReference.begin(); il!=ilfin;il++)
{if (*il == "pt")
while ((dem != "f")&&(dem != "fi")&&(dem != "fin"))
{ List_io <Ddl_enum_etendu> li_inter; li_inter.push_back(Ddl_enum_etendu(enu_ddl)); // liste de travail
if (fr){cout << "\n ---- information concernant les pt d'integ existant ------ "
<< "\n les coor d'un pt d'integ d'un ele choisit par numero (elem+integ) (rep chnbe ) "
<< "\n les coor d'un pt d'integ d'un ele choisit le plus pres de (rep npres ) "
<< "\n tous les coor des pt d'integ d'un elem choisit par numero (rep lespti ) "
<< "\n fin (f )" << endl;
}
else {cout << "\n -- information concerning the existing integration points ------ "
<< "\n the coord of an integ pt, choosen by its number+elem number (rep chnbe ) "
<< "\n the coordinates of an integ pt, choosen with a nearest point (rep npres ) "
<< "\n all the coord of an integ pt of an elem, choosen by its elem number (rep lespti ) "
<< "\n end (f )" << endl;
};
dem= lect_return_defaut(false,"f");
int nbe, nbpti;
if (dem == "chnbe")
{ if (fr){cout << "\n num element ? " << endl;}else{cout << "\n element number ? " << endl;};
nbe=(int)lect_double();
if ((nbe > 0) || (nbe <= tab_noeud.Taille()))
{if (fr){cout << "\n num pt integ ? " << endl;}else{cout << "\n integretion number ? " << endl;};
nbpti=(int)lect_double();
// vérification de l'existence d'un point d'intégration correspondant à un ddl
bool erreur=false;
if (tab_element(nbe)->Existe_pt_integ (nbpti,enu_ddl))
{ Coordonnee M = tab_element(nbe)->CoordPtInteg(TEMPS_0 ,enu_ddl,nbpti,erreur);
if (!erreur)
{cout << "\n " << M << "\n ";}
else {if (fr){cout << "\n ** erreur en sortie du point ?? " << endl;}
else{cout << "\n ** error in output of the point ?? " << endl;};
};
}
else
{if (fr){cout << " num de pt d'integ non correcte, recommencez !" << endl;}
else {cout << " bad number of integ pt, start again !" << endl;};
};
}
else {if (fr){cout << " num d'element non correcte, recommencez !"<< endl;}
else {cout << " bad number of element, start again !" << endl;};
};
}
else if (dem == "npres")
{ int dima = ParaGlob::Dimension();
Coordonnee xi(dima);
if (fr){cout << "\n coordonnee d'un point dans la matiere !! ("<< dima <<" nombre(s)) ? ";}
else {cout << "\n coordinate of a point in the material !! ("<< dima <<" number(s)) ? ";};
for(int j=1;j<=dima;j++) cin >> xi(j);
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
Maillage::NBelemEtptInteg nu = Element_le_plus_proche(TEMPS_0,li_inter,xi);
bool erreur=false;
if (nu.nbElem != 0)
{ Coordonnee M = tab_element(nu.nbElem)->CoordPtInteg(TEMPS_0 ,enu_ddl,nu.nbPtInteg,erreur);
if (!erreur)
{cout << "\n element: " <<nu.nbElem << ", pt_integ: " <<nu.nbPtInteg << "\n "<< M << "\n ";}
else {if (fr){cout << "\n ** erreur en sortie du point ?? ";}
else {cout << "\n ** error in the output of the point ?? ";};
};
}
else
{ if (fr){ cout << "\n on n'a pas trouve d'element contenant ce point, le point est peut-etre en dehors"
<< " de la matiere ! , recommencez avec un point dans la matiere. ";
}
else { cout << "\n we do not find an element that contains the point, perhaps the point is outside "
<< " the material ! , try again with a point inside the material. ";
};
};
}
else if (dem == "lespti")
{ cout << "\n num element ? " << endl; nbe=(int)lect_double();
if ((nbe > 0) || (nbe <= tab_noeud.Taille()))
{ int nbpti = tab_element(nbe)->NbPtInteg(enu_ddl);
bool erreur=false;
for (int i=1;i<=nbpti;i++)
cout << "\n pti "<<i << " : " << tab_element(nbe)->CoordPtInteg(TEMPS_0 ,enu_ddl,i,erreur)
<< "\n ";
}
else {if (fr){cout << " num d'element non correcte, recommencez !";}
else {cout << " wrong number of element, try again !";}
};
}
else if (dem == "f") {}
else
{if (fr){cout << "\n syntaxe non correcte recommencez ! ";}
else {cout << "\n wrong syntaxes, try again ! ";}
};
}; //-- fin du while
}; //-- fin de la boucle sur les type de ref
}; // -- fin du if demande pti
// def de la méthode pour définir la liste d'éléments associé à la référence
string methode="";
list <string> list_methode;
int dima = ParaGlob::Dimension();
while ((methode != "f")&&(methode != "fi")&&(methode != "fin"))
{// affichage du menu du type de référence voulu
switch (dima)
{case 3:
if (fr)
{cout << "\n pres d'un plan (rep pres_plan) "
<< "\n d'un cote du plan (rep cote_plan) "
<< "\n entre deux plans // (rep entre_plans) "
<< "\n entre plan // +- distance (rep entre_plans_dist) "
<< "\n pres d'un cylindre (rep pres_cylindre) "
<< "\n a l'interieur d'un cylindre (rep in_cylindre) "
<< "\n a l'exterieur cylindre (rep ex_cylindre) "
<< "\n entre deux cylindres // (rep entre_cylindres) "
<< "\n pres d'une sphere (rep pres_sphere) "
<< "\n dans une sphere (rep in_sphere) "
<< "\n a l'exterieur d'une sphere (rep ex_sphere) "
<< "\n entre deux spheres concentriques (rep entre_spheres) "
<< "\n entre deux spheres concentriques (rep entre_spheres) "
// << "\n pres d'un parallelepipede (rep pres_para) "
// << "\n dans une parallelepipede (rep in_para) "
// << "\n a l'exterieur d'une parallelepipede (rep ex_para) "
// << "\n entre deux parallelepipedes (rep entre_para) "
<< "\n pres d'un point (rep pres_point) "
<< "\n pres d'une droite (rep pres_droite) "
<< "\n pres d'un cercle (rep pres_cercle) "
<< "\n addition d'une ref deja existante (rep in_ref) "
<< "\n hors une ref dejà existante (rep out_ref) "
<< "\n ordonner N et ptint / project sur une droite (rep ord_droite ) ";
break;
}
else
{cout << "\n near a plane (rep pres_plan) "
<< "\n on one side of a plane (rep cote_plan) "
<< "\n between two planes // (rep entre_plans) "
<< "\n between plane // +- distance (rep entre_plans_dist) "
<< "\n near a cylinder (rep pres_cylindre) "
<< "\n inside a cylinder (rep in_cylindre) "
<< "\n outside a cylinder (rep ex_cylindre) "
<< "\n between two cylinders // (rep entre_cylindres) "
<< "\n near a sphere (rep pres_sphere) "
<< "\n into a sphere (rep in_sphere) "
<< "\n outside a sphere (rep ex_sphere) "
<< "\n between two concentric spheres (rep entre_spheres) "
// << "\n pres d'un parallelepipede (rep pres_para) "
// << "\n dans une parallelepipede (rep in_para) "
// << "\n a l'exterieur d'une parallelepipede (rep ex_para) "
// << "\n entre deux parallelepipedes (rep entre_para) "
<< "\n near a point (rep pres_point) "
<< "\n near a line (rep pres_droite) "
<< "\n near a cercle (rep pres_cercle) "
<< "\n addition of an already existing reference (rep in_ref) "
<< "\n outside to an already existing reference (rep out_ref) "
<< "\n sort N and Gauss points / projection on a line (rep ord_droite ) ";
break;
}
case 2:
if (fr)
{ cout << "\n pres d'un point (rep pres_point) "
<< "\n pres d'une droite (rep pres_droite) "
<< "\n d'un cote d'une droite (rep cote_droite) "
<< "\n entre deux droites // (rep entre_droites) "
<< "\n entre droite // +- distance (rep entre_droites_dist) "
<< "\n pres d'un cercle (rep pres_cercle) "
<< "\n a l'interieur d'un cercle (rep in_cercle) "
<< "\n a l'exterieur d'un cercle (rep ex_cercle) "
<< "\n entre deux cercles concentriques (rep entre_cercles) "
<< "\n addition d'une ref deja existante (rep in_ref) "
<< "\n hors une ref dejà existante (rep out_ref) "
<< "\n ordonner N et ptint / project sur une droite (rep ord_droite ) ";
// << "\n pres d'un rectangle (rep pres_rec) "
// << "\n a l'interieur d'un rectangle (rep in_rec) "
// << "\n a l'exterieur d'un rectangle (rep ex_rec) "
// << "\n entre deux rectangles (rep entre_rec) ";
break;
}
else
{ cout << "\n near a point (rep pres_point) "
<< "\n near a line (rep pres_droite) "
<< "\n on one side of a line (rep cote_droite) "
<< "\n between two lines // (rep entre_droites) "
<< "\n between line // +- distance (rep entre_droites_dist) "
<< "\n near a cercle (rep pres_cercle) "
<< "\n inside a cercle (rep in_cercle) "
<< "\n outside a cercle (rep ex_cercle) "
<< "\n between two concentric cercles (rep entre_cercles) "
<< "\n addition of an already existing reference (rep in_ref) "
<< "\n outside to an already existing reference (rep out_ref) "
<< "\n sort N and Gauss points / projection on a line (rep ord_droite ) ";
// << "\n pres d'un rectangle (rep pres_rec) "
// << "\n a l'interieur d'un rectangle (rep in_rec) "
// << "\n a l'exterieur d'un rectangle (rep ex_rec) "
// << "\n entre deux rectangles (rep entre_rec) ";
break;
}
case 1:
if (fr)
{ cout << "\n pres d'un point (rep pres_point) "
<< "\n d'un cote d'un point (rep cote_point) "
<< "\n entre deux points (rep entre_points) "
<< "\n entre point +- distance (rep entre_points_dist) "
<< "\n addition d'une ref deja existante (rep in_ref) "
<< "\n hors une ref dejà existante (rep out_ref) "
<< "\n ordonner N et ptint / project sur l'axe (rep ord_droite ) ";
break;
}
else
{ cout << "\n near a point (rep pres_point) "
<< "\n on one side of a point (rep cote_point) "
<< "\n between two points (rep entre_points) "
<< "\n between point +- distance (rep entre_points_dist) "
<< "\n addition of an already existing reference (rep in_ref) "
<< "\n outside to an already existing reference (rep out_ref) "
<< "\n sort N and Gauss points / projection on the axe (rep ord_droite ) ";
break;
}
};
if (fr){cout << "\n effacer la liste des methode (rep ef) "
<< "\n fin def methodes (rep f) ";}
else {cout << "\n clear the list of method (rep ef) "
<< "\n end def methods (rep f) ";};
if (list_methode.size()!=0)
{if (fr) { cout << "\n (pour info: list actuellement enreg: ";}
else { cout << "\n (for info: list currently stored: ";};
for (it=list_methode.begin();it!=list_methode.end();it++)
cout << " " << *it;
cout << " ) ";
};
if (fr) {cout << "\n reponses : (il peut y en avoir plusieurs ) "<< endl;}
else {cout << "\n answers : (several if needed ) "<< endl;}
methode= lect_return_defaut(false,"f"); // lecture
if (methode=="ef")
{list_methode.erase(list_methode.begin(),list_methode.end());}
else
{switch (dima)
{case 1 :
if ((methode == "pres_point")||(methode == "cote_point")
||(methode == "entre_points")||(methode == "entre_points_dist")
||(methode == "ord_droite") ||(methode == "in_ref")||(methode == "out_ref"))
{ list_methode.push_back(methode);}
else if ((methode == "f") || (methode == "fi") || (methode != "fin")) { } // on ne fait rien
else
{if (fr) {cout << "\n mauvais choix lu : " << methode << ", verifiez la syntaxe et recommencez ";}
else {cout << "\n wrong choice read : " << methode << ", take a look on the syntaxes or spelling and do it again ";}
};
break;
case 2 :
if ((methode == "pres_point")||(methode == "pres_droite")||(methode == "cote_droite")
||(methode == "entre_droites")||(methode == "entre_droites_dist")
||(methode == "pres_cercle")||(methode == "in_cercle")||(methode == "ex_cercle")||(methode == "entre_cercles")
||(methode == "pres_rec")||(methode == "in_rec")||(methode == "ex_rec")||(methode == "entre_rec")
||(methode == "ord_droite") ||(methode == "in_ref")||(methode == "out_ref"))
{ list_methode.push_back(methode);}
else if ((methode == "f") || (methode == "fi") || (methode != "fin")) { } // on ne fait rien
else
{if (fr) {cout << "\n mauvais choix lu : " << methode << ", verifiez la syntaxe et recommencez ";}
else {cout << "\n wrong choice read : " << methode << ", take a look on the syntaxes or spelling and do it again ";}
};
break;
case 3 :
if ((methode == "pres_plan")||(methode == "cote_plan")||(methode == "entre_plans")
||(methode == "entre_plans_dist")
||(methode == "pres_cylindre")||(methode == "in_cylindre")||(methode == "ex_cylindre")||(methode == "entre_cylindres")
||(methode == "pres_sphere")||(methode == "in_sphere")||(methode == "ex_sphere")||(methode == "entre_spheres")
// ||(methode == "pres_para")||(methode == "in_para")||(methode == "ex_para")||(methode == "entre_para")
||(methode == "pres_point")||(methode == "pres_droite")||(methode == "pres_cercle")
||(methode == "ord_droite") ||(methode == "in_ref")||(methode == "out_ref"))
{ list_methode.push_back(methode);}
else if ((methode == "f") || (methode == "fi") || (methode != "fin")) { } // on ne fait rien
else
{if (fr) {cout << "\n mauvais choix lu : " << methode << ", verifiez la syntaxe et recommencez ";}
else {cout << "\n wrong choice read : " << methode << ", take a look on the syntaxes or spelling and do it again ";}
};
break;
};
};
};
// on récupère pour le passe en interne la liste des références existantes
lesRefin = lesRef; // sert pour InitInRef(), ExeInRef (), InitOutRef(), ExeOutRef()
// execution en fonction des réponses
try // on met le calcul sous surveillance au cas d'un fausse manip
{switch (dima)
{ case 1: CalculListRef_1D(list_nomReference,lesRef,list_methode,enu_ddl); break;
case 2: CalculListRef_2D(list_nomReference,lesRef,list_methode,enu_ddl); break;
case 3: CalculListRef_3D(list_nomReference,lesRef,list_methode,enu_ddl); break;
};
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch ( ... )
{ if (fr) {cout << "\n erreur dans la constitution des listes, recommencer ou modifer ";}
else {cout << "\n error in the constitution of lists, try again or modify something ";}
};
};
if (fr) {cout << "\n fin def reference ? (rep f) "
<< "\n (ou n'importe quoi d'autre si l'on veut continuer ) " << endl;
reponse = lect_return_defaut(false,"f");;
}
else { cout << "\n end def reference ? (rep f) "
<< "\n (or anything else if you want to continue ) " << endl;
reponse = lect_return_defaut(false,"f");;
}
};
};
// calcul des listes de références en fonction de la demande:
// list_nomReference: contient les types de refs que l'on veut
// list_methode: contient la ou les méthodes que l'on veut utiliser
// cas 1D
void Maillage::CalculListRef_1D(list<string>& list_nomReference,LesReferences* lesRef
,list<string>& list_methode,const Enum_ddl & enu_ddl)
{ // def des listes de noeuds et d'éléments à considérer: ces listes diminuent à mesure que l'on
// appliques des contraintes
// au début on part avec tous les noeuds et éléments
list <Noeud *> list_noeud_restant;
int nbnoeud = tab_noeud.Taille();
for (int ne = 1; ne <= nbnoeud; ne++)
list_noeud_restant.push_back(tab_noeud(ne));
list <Element *> list_element_restant;
int nbelement = tab_element.Taille();
for (int nel = 1; nel <= nbelement; nel++)
list_element_restant.push_back(tab_element(nel));
// def des listes de faces, arêtes, pt integ, là on démarre avec des listes vides et
// on rempli la liste avec la première contrainte, puis avec les autres contraintes on diminue la liste
// les booleen sont utiliser pour savoir si c'est la première contrainte ou pas
list <NBelemEtFace> list_elemFace_restant; bool premLpti = true;
list <NBelemEtArete> list_elemArrete_restant; bool premLface = true;
list <NBelemEtptInteg> list_elemPtin_restant; bool premLarrete = true;
bool fr = ParaGlob::Francais(); // pour simplifier
// on balaie la liste des méthodes
list<string>::iterator il,ilfin=list_methode.end();
for (il = list_methode.begin();il!=ilfin;il++)
{ string methode = *il;
if (methode == "pres_point" )
{ initConditionPresDe = & Maillage::InitPresPoint;
ExeConditionPresDe = & Maillage::ExePresPoint;
// appel de la fonction générique
PresDe(list_nomReference,list_noeud_restant,list_element_restant,enu_ddl
,list_elemPtin_restant,premLpti,list_elemFace_restant,premLface
,list_elemArrete_restant,premLarrete);
}
else if ( (methode == "cote_point")||(methode == "entre_points")
|| (methode == "entre_point_dist")
||(methode == "in_ref")||(methode == "out_ref")
)
// sinon c'est du type Toutdedans
{ if (methode == "cote_point")
{ initConditionToutDedans = & Maillage::InitCotePoint;
ExeConditionToutDedans = & Maillage::ExeCotePoint;
}
else if (methode == "entre_point")
{ initConditionToutDedans = & Maillage::InitEntrePoint;
ExeConditionToutDedans = & Maillage::ExeEntrePoint;
}
else if (methode == "entre_point_dist")
{ initConditionToutDedans = & Maillage::InitEntrePoint_avec_distance;
ExeConditionToutDedans = & Maillage::ExeEntrePoint_avec_distance;
}
else if (methode == "in_ref")
{ initConditionToutDedans = & Maillage::InitInRef;
ExeConditionToutDedans = & Maillage::Exe_In_out_avecRefExistantes;
}
else if (methode == "out_ref")
{ initConditionToutDedans = & Maillage::InitOutRef;
ExeConditionToutDedans = & Maillage::Exe_In_out_avecRefExistantes;
}
// appel de la fonction générique
ToutDedans(list_nomReference,list_noeud_restant,list_element_restant,enu_ddl
,list_elemPtin_restant,premLpti,list_elemFace_restant,premLface
,list_elemArrete_restant,premLarrete);
}
else if (methode == "ord_droite") {} // on ne fait rien ici, ce sera au deuxième balayage
else
{ if (fr) {cout << "\n desole, la condition " << methode << " n'est pas encore implantee "
<< " il faut se plaindre !! ";}
else {cout << "\n sorry, the method " << methode << " is not yet implemented "
<< " you must complain !! ";}
};
}; //-- fin du balayage 1) des méthodes
// on balaie une seconde fois la liste des méthodes, pour voir si éventuellement il faut ordonner
// une liste de noeuds ou de points d'intégration
for (il = list_methode.begin();il!=ilfin;il++)
{ string methode = *il;
if (methode == "ord_droite")
{ // on regarde s'il faut ordonner des noeuds et des pt d'integ, ou un des deux, ou aucun
list<string>::const_iterator ie,iefin=list_nomReference.end();
bool ordo_noeud = false; bool ordo_ptinteg = false;
for (ie=list_nomReference.begin();ie!=iefin;ie++)
{ if ((*ie)[0] == 'N') ordo_noeud = true;
if ((*ie)[0] == 'G') ordo_ptinteg = true;
};
if (ordo_noeud || ordo_ptinteg)
InitOrdonneLigne(); // on initialise que s'il y a quelque chose à faire
if (ordo_noeud && ordo_ptinteg)
{ OrdonneLigne(list_noeud_restant,list_elemPtin_restant,enu_ddl);}
else if (ordo_noeud)
{ list <NBelemEtptInteg> toto; // une liste vide qui ne sera pas ordonnée
OrdonneLigne(list_noeud_restant,toto,enu_ddl);
}
else if (ordo_ptinteg)
{ list <Noeud *> titi; // une liste vide qui ne sera pas ordonnée
OrdonneLigne(titi,list_elemPtin_restant,enu_ddl);
};
}
};
// constitution des références
EnregRef(list_nomReference,list_noeud_restant,list_elemPtin_restant,list_element_restant
,list_elemFace_restant,list_elemArrete_restant,lesRef);
};
// calcul des listes de références en fonction de la demande:
// list_nomReference: contient les types de refs que l'on veut
// list_methode: contient la ou les méthodes que l'on veut utiliser
// cas 2D
void Maillage::CalculListRef_2D(list<string>& list_nomReference,LesReferences* lesRef
,list<string>& list_methode,const Enum_ddl & enu_ddl)
{ // def des listes de noeuds et d'éléments à considérer: ces listes diminuent à mesure que l'on
// appliques des contraintes
// au début on part avec tous les noeuds et éléments
list <Noeud *> list_noeud_restant;
int nbnoeud = tab_noeud.Taille();
for (int ne = 1; ne <= nbnoeud; ne++)
list_noeud_restant.push_back(tab_noeud(ne));
list <Element *> list_element_restant;
int nbelement = tab_element.Taille();
for (int nel = 1; nel <= nbelement; nel++)
list_element_restant.push_back(tab_element(nel));
// def des listes de faces, arêtes, pt integ, là on démarre avec des listes vides et
// on rempli la liste avec la première contrainte, puis avec les autres contraintes on diminue la liste
// les booleen sont utiliser pour savoir si c'est la première contrainte ou pas
list <NBelemEtFace> list_elemFace_restant; bool premLpti = true;
list <NBelemEtArete> list_elemArrete_restant; bool premLface = true;
list <NBelemEtptInteg> list_elemPtin_restant; bool premLarrete = true;
bool fr = ParaGlob::Francais(); // pour simplifier
// on balaie une première fois la liste des méthodes
list<string>::iterator il,ilfin=list_methode.end();
for (il = list_methode.begin();il!=ilfin;il++)
{ string methode = *il;
if ((methode == "pres_point")||(methode == "pres_droite")||(methode == "pres_cercle")
||(methode == "pres_rec"))
{ if (methode == "pres_point" )
{ initConditionPresDe = & Maillage::InitPresPoint;
ExeConditionPresDe = & Maillage::ExePresPoint;
}
else if (methode == "pres_droite")
{ initConditionPresDe = & Maillage::InitPresLigne;
ExeConditionPresDe = & Maillage::ExePresLigne;
}
else if (methode == "pres_cercle")
{ initConditionPresDe = & Maillage::InitPresCercle;
ExeConditionPresDe = & Maillage::ExePresCercle;
}
// appel de la fonction générique
PresDe(list_nomReference,list_noeud_restant,list_element_restant,enu_ddl
,list_elemPtin_restant,premLpti,list_elemFace_restant,premLface
,list_elemArrete_restant,premLarrete);
}
else if ( (methode == "cote_droite")||(methode == "entre_droites")
||(methode == "entre_droites_dist")
||(methode == "in_cercle")||(methode == "ex_cercle")||(methode == "entre_cercles")
||(methode == "in_ref")||(methode == "out_ref")
)
// sinon c'est du type Toutdedans
{ if (methode == "cote_droite")
{ initConditionToutDedans = & Maillage::InitCoteDroite;
ExeConditionToutDedans = & Maillage::ExeCoteDroite;
}
else if (methode == "entre_droites")
{ initConditionToutDedans = & Maillage::InitEntreDroite;
ExeConditionToutDedans = & Maillage::ExeEntreDroite;
}
else if (methode == "entre_droites_dist")
{ initConditionToutDedans = & Maillage::InitEntreDroite_avec_distance;
ExeConditionToutDedans = & Maillage::ExeEntreDroite_avec_distance;
}
else if (methode == "in_cercle")
{ initConditionToutDedans = & Maillage::InitDansCercle;
ExeConditionToutDedans = & Maillage::ExeDansCercle;
}
else if (methode == "ex_cercle")
{ initConditionToutDedans = & Maillage::InitDansCercle;
ExeConditionToutDedans = & Maillage::ExeOutCercle;
}
else if (methode == "entre_cercles")
{ initConditionToutDedans = & Maillage::InitEntreCercles;
ExeConditionToutDedans = & Maillage::ExeEntreCercles;
}
else if (methode == "in_ref")
{ initConditionToutDedans = & Maillage::InitInRef;
ExeConditionToutDedans = & Maillage::Exe_In_out_avecRefExistantes;
}
else if (methode == "out_ref")
{ initConditionToutDedans = & Maillage::InitOutRef;
ExeConditionToutDedans = & Maillage::Exe_In_out_avecRefExistantes;
}
// appel de la fonction générique
ToutDedans(list_nomReference,list_noeud_restant,list_element_restant,enu_ddl
,list_elemPtin_restant,premLpti,list_elemFace_restant,premLface
,list_elemArrete_restant,premLarrete);
}
else if (methode == "ord_droite") {} // on ne fait rien ici, ce sera au deuxième balayage
else
{ if (fr) {cout << "\n desole, la condition " << methode << " n'est pas encore implantee "
<< " il faut se plaindre !! ";}
else {cout << "\n sorry, the method " << methode << " is not yet implemented "
<< " you must complain !! ";}
};
}; //-- fin du balayage des méthodes
// on balaie une seconde fois la liste des méthodes, pour voir si éventuellement il faut ordonner
// une liste de noeuds ou de points d'intégration
for (il = list_methode.begin();il!=ilfin;il++)
{ string methode = *il;
if (methode == "ord_droite")
{ // on regarde s'il faut ordonner des noeuds et des pt d'integ, ou un des deux, ou aucun
list<string>::const_iterator ie,iefin=list_nomReference.end();
bool ordo_noeud = false; bool ordo_ptinteg = false;
for (ie=list_nomReference.begin();ie!=iefin;ie++)
{ if ((*ie)[0] == 'N') ordo_noeud = true;
if ((*ie)[0] == 'G') ordo_ptinteg = true;
};
if (ordo_noeud || ordo_ptinteg)
InitOrdonneLigne(); // on initialise que s'il y a quelque chose à faire
if (ordo_noeud && ordo_ptinteg)
{ OrdonneLigne(list_noeud_restant,list_elemPtin_restant,enu_ddl);}
else if (ordo_noeud)
{ list <NBelemEtptInteg> toto; // une liste vide qui ne sera pas ordonnée
OrdonneLigne(list_noeud_restant,toto,enu_ddl);
}
else if (ordo_ptinteg)
{ list <Noeud *> titi; // une liste vide qui ne sera pas ordonnée
OrdonneLigne(titi,list_elemPtin_restant,enu_ddl);
};
}
};
// constitution des références
EnregRef(list_nomReference,list_noeud_restant,list_elemPtin_restant,list_element_restant
,list_elemFace_restant,list_elemArrete_restant,lesRef);
};
// calcul des listes de références en fonction de la demande:
// list_nomReference: contient les types de refs que l'on veut
// list_methode: contient la ou les méthodes que l'on veut utiliser
// cas 3D
void Maillage::CalculListRef_3D(list<string>& list_nomReference,LesReferences* lesRef
,list<string>& list_methode,const Enum_ddl & enu_ddl)
{ // def des listes de noeuds et d'éléments à considérer: ces listes diminuent à mesure que l'on
// appliques des contraintes
// au début on part avec tous les noeuds et éléments
list <Noeud *> list_noeud_restant;
int nbnoeud = tab_noeud.Taille();
for (int ne = 1; ne <= nbnoeud; ne++)
list_noeud_restant.push_back(tab_noeud(ne));
list <Element *> list_element_restant;
int nbelement = tab_element.Taille();
for (int nel = 1; nel <= nbelement; nel++)
list_element_restant.push_back(tab_element(nel));
// def des listes de faces, arêtes, pt integ, là on démarre avec des listes vides et
// on rempli la liste avec la première contrainte, puis avec les autres contraintes on diminue la liste
// les booleen sont utiliser pour savoir si c'est la première contrainte ou pas
list <NBelemEtFace> list_elemFace_restant; bool premLpti = true;
list <NBelemEtArete> list_elemArrete_restant; bool premLface = true;
list <NBelemEtptInteg> list_elemPtin_restant; bool premLarrete = true;
bool fr = ParaGlob::Francais(); // pour simplifier
// on balaie une première fois la liste des méthodes
list<string>::iterator il,ilfin=list_methode.end();
for (il = list_methode.begin();il!=ilfin;il++)
{ string methode = *il;
if ((methode == "pres_plan")||(methode == "pres_cylindre")||(methode == "pres_sphere")
// ||(methode == "pres_para")
||(methode == "pres_point")||(methode == "pres_cercle")||(methode == "pres_droite"))
{ if (methode == "pres_point" )
{ initConditionPresDe = & Maillage::InitPresPoint;
ExeConditionPresDe = & Maillage::ExePresPoint;
}
else if (methode == "pres_droite")
{ initConditionPresDe = & Maillage::InitPresLigne;
ExeConditionPresDe = & Maillage::ExePresLigne;
}
else if (methode == "pres_cercle")
{ initConditionPresDe = & Maillage::InitPresCercle;
ExeConditionPresDe = & Maillage::ExePresCercle;
}
else if (methode == "pres_plan")
{ initConditionPresDe = & Maillage::InitPresPlan;
ExeConditionPresDe = & Maillage::ExePresPlan;
}
else if (methode == "pres_cylindre")
{ initConditionPresDe = & Maillage::InitPresCylindre;
ExeConditionPresDe = & Maillage::ExePresCylindre;
}
else if (methode == "pres_sphere")
{ initConditionPresDe = & Maillage::InitPresSphere;
ExeConditionPresDe = & Maillage::ExePresSphere;
}
// else if (methode == "pres_para")
// { cout << "\n methode " << methode << " non encore implante, il faut se plaindre !! ";
// }
// appel de la fonction générique
PresDe(list_nomReference,list_noeud_restant,list_element_restant,enu_ddl
,list_elemPtin_restant,premLpti,list_elemFace_restant,premLface
,list_elemArrete_restant,premLarrete);
}
else if ((methode == "cote_plan")||(methode == "entre_plans")||(methode == "entre_plans_dist")
||(methode == "in_cylindre")||(methode == "ex_cylindre")||(methode == "entre_cylindres")
||(methode == "in_sphere")||(methode == "ex_sphere")||(methode == "entre_spheres")
||(methode == "in_ref")||(methode == "out_ref")
// ||(methode == "in_para")||(methode == "ex_para")||(methode == "entre_para")
)
// sinon c'est du type Toutdedans
{ if (methode == "cote_plan")
{ initConditionToutDedans = & Maillage::InitCotePlan;
ExeConditionToutDedans = & Maillage::ExeCotePlan;
}
else if (methode == "entre_plans")
{ initConditionToutDedans = & Maillage::InitEntrePlan;
ExeConditionToutDedans = & Maillage::ExeEntrePlan;
}
else if (methode == "entre_plans_dist")
{ initConditionToutDedans = & Maillage::InitEntrePlan_avec_distance;
ExeConditionToutDedans = & Maillage::ExeEntrePlan_avec_distance;
}
else if (methode == "in_cylindre")
{ initConditionToutDedans = & Maillage::InitDansCylindre;
ExeConditionToutDedans = & Maillage::ExeDansCylindre;
}
else if (methode == "ex_cylindre")
{ initConditionToutDedans = & Maillage::InitDansCylindre;
ExeConditionToutDedans = & Maillage::ExeOutCylindre;
}
else if (methode == "entre_cylindres")
{ initConditionToutDedans = & Maillage::InitEntreCylindre;
ExeConditionToutDedans = & Maillage::ExeEntreCylindre;
}
else if (methode == "in_sphere")
{ initConditionToutDedans = & Maillage::InitDansSphere;
ExeConditionToutDedans = & Maillage::ExeDansSphere;
}
else if (methode == "ex_sphere")
{ initConditionToutDedans = & Maillage::InitDansSphere;
ExeConditionToutDedans = & Maillage::ExeOutSpheres;
}
else if (methode == "entre_spheres")
{ initConditionToutDedans = & Maillage::InitEntreSpheres;
ExeConditionToutDedans = & Maillage::ExeEntreSpheres;
}
else if (methode == "in_ref")
{ initConditionToutDedans = & Maillage::InitInRef;
ExeConditionToutDedans = & Maillage::Exe_In_out_avecRefExistantes;
}
else if (methode == "out_ref")
{ initConditionToutDedans = & Maillage::InitOutRef;
ExeConditionToutDedans = & Maillage::Exe_In_out_avecRefExistantes;
}
// else if (methode == "in_para")
// { cout << "\n methode " << methode << " non encore implante, il faut se plaindre !! ";
// }
// else if (methode == "ex_para")
// { cout << "\n methode " << methode << " non encore implante, il faut se plaindre !! ";
// }
// else if (methode == "entre_paras")
// { cout << "\n methode " << methode << " non encore implante, il faut se plaindre !! ";
// }
// appel de la fonction générique
ToutDedans(list_nomReference,list_noeud_restant,list_element_restant,enu_ddl
,list_elemPtin_restant,premLpti,list_elemFace_restant,premLface
,list_elemArrete_restant,premLarrete);
}
else if (methode == "ord_droite") {} // on ne fait rien ici, ce sera au deuxième balayage
else
{ if (fr) {cout << "\n desole, la condition " << methode << " n'est pas encore implantee "
<< " il faut se plaindre !! ";}
else {cout << "\n sorry, the method " << methode << " is not yet implemented "
<< " you must complain !! ";}
};
}; //-- fin du balayage des méthodes
// on balaie une seconde fois la liste des méthodes, pour voir si éventuellement il faut ordonner
// une liste de noeuds ou de points d'intégration
for (il = list_methode.begin();il!=ilfin;il++)
{ string methode = *il;
if (methode == "ord_droite")
{ // on regarde s'il faut ordonner des noeuds et des pt d'integ, ou un des deux, ou aucun
list<string>::const_iterator ie,iefin=list_nomReference.end();
bool ordo_noeud = false; bool ordo_ptinteg = false;
for (ie=list_nomReference.begin();ie!=iefin;ie++)
{ if ((*ie)[0] == 'N') ordo_noeud = true;
if ((*ie)[0] == 'G') ordo_ptinteg = true;
};
if (ordo_noeud || ordo_ptinteg)
InitOrdonneLigne(); // on initialise que s'il y a quelque chose à faire
if (ordo_noeud && ordo_ptinteg)
{ OrdonneLigne(list_noeud_restant,list_elemPtin_restant,enu_ddl);}
else if (ordo_noeud)
{ list <NBelemEtptInteg> toto; // une liste vide qui ne sera pas ordonnée
OrdonneLigne(list_noeud_restant,toto,enu_ddl);
}
else if (ordo_ptinteg)
{ list <Noeud *> titi; // une liste vide qui ne sera pas ordonnée
OrdonneLigne(titi,list_elemPtin_restant,enu_ddl);
};
}
};
// constitution des références
EnregRef(list_nomReference,list_noeud_restant,list_elemPtin_restant,list_element_restant
,list_elemFace_restant,list_elemArrete_restant,lesRef);
};
// fonction générique pour des condition PresDe
void Maillage::PresDe(const list<string>& list_nomReference, list <Noeud *>& list_noeud_restant
,list <Element *>& list_element_restant,const Enum_ddl & enu_ddl
,list <NBelemEtptInteg>& list_elemPtin_restant,bool& premLpti
,list <NBelemEtFace>& list_elemFace_restant,bool& premLface
,list <NBelemEtArete>& list_elemArrete_restant,bool& premLarrete)
{ // a) on commence par initialiser la condition
bool fr = ParaGlob::Francais(); // pour simplifier
double dist = 0.;
// puis on appelle la fonction d'initialisation
(this->*initConditionPresDe)(dist);
// b) deuxième temps, on exécute la condition associée (il doit y en avoir qu'une
// car avant chaque condition il faut appeler init !!)
// par contre la condition peut-être appliquée plusieurs fois
// on balaie la liste des nom de ref pour savoir quel type de ref on cherche
list<string>::const_iterator al,alfin = list_nomReference.end();
for (al=list_nomReference.begin();al!=alfin;al++)
if ((*al)[0] == 'N')
{// cas d'une liste de noeuds: on balaie la liste et on cherche
list <Noeud *>::iterator nit,nits;
// on calcul à chaque fois la borne finale car elle peut changer dans la boucle
nit = list_noeud_restant.begin(); nits = nit; // init
while (nits != list_noeud_restant.end())
{ nit = nits; nits++; // nits pointeur sur le suivant
// on supprime si la condition n'est pas remplie
Coordonnee M=(*nit)->Coord0();
bool condi = (this->*ExeConditionPresDe)(dist,M);
if (!condi)
list_noeud_restant.erase(nit);
};
}
else if ((*al)[0] == 'E')
{// cas d'une liste d'éléments: on balaie la liste et on cherche
// il faut que un des noeuds de l'élément remplit la condition
list <Element *>::iterator nit,nits;
// on calcul à chaque fois la borne finale car elle peut changer dans la boucle
nit = list_element_restant.begin(); nits = nit; // init
while (nits != list_element_restant.end())
{ nit = nits; nits++; // nits pointeur sur le suivant
// recup du tableau de noeuds de l'élément
const Tableau<Noeud *>& t_N = (*nit)->Tab_noeud();
int nbne = t_N.Taille();
bool condition = false; // par défaut
for (int ie=1;ie<=nbne;ie++)
{ Coordonnee M=t_N(ie)->Coord0();
condition = (this->*ExeConditionPresDe)(dist,M);
};
// on supprime si la condition n'est pas remplie
if (!condition)
list_element_restant.erase(nit);
};
}
else if ((*al)[0] == 'G')
{// cas d'une liste de point d'intégration d'éléments: on balaie la liste des éléments
// et dedans la liste des points d'intégration et on cherche
if (premLpti) // cas d'une première contrainte
{// on va balayer tous les éléments existant
int nbne = tab_element.Taille();
for (int ine=1;ine<=nbne;ine++)
{ Element& el = *(tab_element(ine));
// recup du nombre de point d'intégration de l'élément
int nbpti = el.NbPtInteg(enu_ddl);
// on boucle sur les pt d'integ
for (int ipt = 1;ipt<=nbpti;ipt++)
{ bool erreur =false;
Coordonnee Mpti0 = el.CoordPtInteg(TEMPS_0,enu_ddl,ipt,erreur);
if (erreur)
{ if (fr) {cout << "\n erreur bizarre, on ne peut pas trouver les coordoonees t0 du pt d'integ "
<< ipt << "de l'element " << el.Num_elt() << " du maillage "
<< el.Num_maillage() << " on ne le test donc pas pour la liste des pt d'integ ! ";
}
else {cout << "\n strange error, we cannot find the coordinates at t0 of the gauss point "
<< ipt << "of the element " << el.Num_elt() << " of the mesh "
<< el.Num_maillage() << " so, we do not test it, for the list of integ points ! ";
};
}
else
{ // cas ok
bool condition = (this->*ExeConditionPresDe)(dist,Mpti0);
NBelemEtptInteg nu; nu.nbElem=el.Num_elt(); nu.nbPtInteg = ipt;
if (condition)
{ list_elemPtin_restant.push_back(nu);}; // première fois on ajoute
};
}; //-- fin de la boucle des pt d'integ
}; //-- fin de la boucle sur tous les éléments
// on signale pour la suite qu'une contrainte a déjà été appliqué
premLpti = false;
}
else // cas d'une contrainte qui n'est pas la première
{// on boucle sur les éléments déjà enregistrée
list <NBelemEtptInteg>::iterator nit,nits;
// on calcul à chaque fois la borne finale car elle peut changer dans la boucle
nit = list_elemPtin_restant.begin(); nits = nit; // init
while (nits != list_elemPtin_restant.end())
{nit = nits; nits++; // nits pointeur sur le suivant
// for (nit=list_elemPtin_restant.begin();nit!=list_elemPtin_restant.end();nit++)
Element& el = *(tab_element((*nit).nbElem)); // récup élément
int ipt = (*nit).nbPtInteg; // récup le pt d'integ
bool erreur =false;
Coordonnee Mpti0 = el.CoordPtInteg(TEMPS_0,enu_ddl,ipt,erreur);
if (erreur)
{ if (fr) {cout << "\n erreur bizarre, on ne peut pas trouver les coordoonees t0 du pt d'integ "
<< ipt << "de l'element " << el.Num_elt() << " du maillage "
<< el.Num_maillage() << " on ne le test donc pas pour la liste des pt d'integ ! ";
}
else {cout << "\n strange error, we cannot find the coordinates at t0 of the gauss point "
<< ipt << "of the element " << el.Num_elt() << " of the mesh "
<< el.Num_maillage() << " so, we do not test it, for the list of integ points ! ";
};
}
else
{ // cas ok pour la gestion d'erreur
bool condition = (this->*ExeConditionPresDe)(dist,Mpti0);
NBelemEtptInteg nu; nu.nbElem=el.Num_elt(); nu.nbPtInteg = ipt;
if (!condition)
// il ne satisfait pas la contrainte, on le supprime
{list_elemPtin_restant.erase(nit);};
};
};
}; //-- fin du test sur première contrainte ou pas
}
else if ((*al)[0] == 'F')
{// cas d'une liste de face d'éléments: on balaie la liste des éléments
// et dedans la liste des faces et on cherche
if (premLface) // cas d'une première contrainte
{// on va balayer tous les éléments existant
int nbne = tab_element.Taille();
for (int ine=1;ine<=nbne;ine++)
{ Element& el = *(tab_element(ine));
ElemGeomC0& elgeom = el.ElementGeometrique(); // récup de l'élément géométrique
const Tableau<Tableau<int> > nonf = elgeom.Nonf(); // récup de la connection des faces
int nbptface = nonf.Taille();
const Tableau<Noeud *>& t_N = el.Tab_noeud(); // récup du tableau de noeud de l'élément
// on boucle sur les faces
for (int iface = 1;iface<=nbptface;iface++)
{ // on regarde si un des noeuds de la face remplit la condition
int nbnoeudface = nonf(iface).Taille();
for (int ino = 1; ino<= nbnoeudface; ino++)
{ Coordonnee M = (t_N(nonf(iface)(ino)))->Coord0();
bool condition = (this->*ExeConditionPresDe)(dist,M);
if (condition)
{ NBelemEtFace nu; nu.nbElem = el.Num_elt(); nu.nbFace = iface;
list_elemFace_restant.push_back(nu);
break; // pour éviter d'enregistrer n fois la même face
};
};
};
}; //-- fin de la boucle sur tous les éléments
////--- debug
// cout << "\n Maillage::PresDe(..";
// cout << "\n list finale de face après traitement : nb face ="<< list_elemFace_restant.size() << endl;
////--- fin debug
// on signale pour la suite qu'une contrainte a déjà été appliqué
premLface = false;
}
else // cas d'une contrainte qui n'est pas la première
{// on boucle sur les éléments déjà enregistrée
list <NBelemEtFace>::iterator nit,nits;
// on calcul à chaque fois la borne finale car elle peut changer dans la boucle
nit = list_elemFace_restant.begin(); nits = nit; // init
while (nits != list_elemFace_restant.end())
{nit = nits; nits++; // nits pointeur sur le suivant
// for (nit=list_elemFace_restant.begin();nit!=list_elemFace_restant.end();nit++)
Element& el = *(tab_element((*nit).nbElem)); // récup élément
ElemGeomC0& elgeom = el.ElementGeometrique(); // récup de l'élément géométrique
const Tableau<Tableau<int> > nonf = elgeom.Nonf(); // récup de la connection des faces
const Tableau<Noeud *>& t_N = el.Tab_noeud(); // récup du tableau de noeud de l'élément
bool condition = false; // a priori
int iface = (*nit).nbFace;
// on regarde si un des noeuds de la face rempli la condition
int nbnoeudface = nonf(iface).Taille();
for (int ino = 1; ino<= nbnoeudface; ino++)
{ Coordonnee M = (t_N(nonf(iface)(ino)))->Coord0();
condition = (this->*ExeConditionPresDe)(dist,M);
if (condition)
break;
};
if (!condition)
// cas où la condition n'est pas satisfaite on supprime l'élément
{list_elemFace_restant.erase(nit);};
};
}; //-- fin du test sur première contrainte ou pas
}
else if ((*al)[0] == 'A')
{// cas d'une liste de d'arêtes d'éléments: on balaie la liste des éléments
// et dedans la liste des arêtes et on cherche
if (premLarrete) // cas d'une première contrainte
{// on va balayer tous les éléments existant
int nbne = tab_element.Taille();
for (int ine=1;ine<=nbne;ine++)
{ Element& el = *(tab_element(ine));
ElemGeomC0& elgeom = el.ElementGeometrique(); // récup de l'élément géométrique
const Tableau<Tableau<int> > nons = elgeom.NonS(); // récup de la connection des arêtes
int nbptarr = nons.Taille();
const Tableau<Noeud *>& t_N = el.Tab_noeud(); // récup du tableau de noeud de l'élément
// on boucle sur les arêtes
for (int iarr = 1;iarr <=nbptarr;iarr++)
{ // on regarde si un des noeuds de l'arête remplit la condition
int nbnoeudarr = nons(iarr).Taille();
for (int ino = 1; ino<= nbnoeudarr; ino++)
{ Coordonnee M = (t_N(nons(iarr)(ino)))->Coord0();
bool condition = (this->*ExeConditionPresDe)(dist,M);
if (condition)
{ NBelemEtArete nu; nu.nbElem = el.Num_elt(); nu.nbArete = iarr;
list_elemArrete_restant.push_back(nu);
break; // pour éviter d'enregistrer n fois la même arête
};
};
};
}; //-- fin de la boucle sur tous les éléments
// on signale pour la suite qu'une contrainte a déjà été appliqué
premLarrete = false;
}
else // cas d'une contrainte qui n'est pas la première
{// on boucle sur les éléments déjà enregistrée
list <NBelemEtArete>::iterator nit,nits;
// on calcul à chaque fois la borne finale car elle peut changer dans la boucle
nit = list_elemArrete_restant.begin(); nits = nit; // init
while (nits != list_elemArrete_restant.end())
{ nit = nits; nits++; // nits pointeur sur le suivant
// for (nit=list_elemArrete_restant.begin();nit!=list_elemArrete_restant.end();nit++)
Element& el = *(tab_element((*nit).nbElem)); // récup élément
ElemGeomC0& elgeom = el.ElementGeometrique(); // récup de l'élément géométrique
const Tableau<Tableau<int> > nons = elgeom.NonS(); // récup de la connection des arêtes
const Tableau<Noeud *>& t_N = el.Tab_noeud(); // récup du tableau de noeud de l'élément
bool condition = false; // a priori
int iarr = (*nit).nbArete;
// on regarde si un des noeuds de l'arête remplit la condition
int nbnoeudarr = nons(iarr).Taille();
for (int ino = 1; ino<= nbnoeudarr; ino++)
{ Coordonnee M = (t_N(nons(iarr)(ino)))->Coord0();
condition = (this->*ExeConditionPresDe)(dist,M);
if (condition)
break;
};
if (!condition)
// cas où la condition n'est pas satisfaite on supprime l'élément
{list_elemArrete_restant.erase(nit);};
};
}; //-- fin du test sur première contrainte ou pas
}
};
// fonction générique pour des condition "tout dedans"
void Maillage::ToutDedans(const list<string>& list_nomReference, list <Noeud *>& list_noeud_restant
,list <Element *>& list_element_restant,const Enum_ddl & enu_ddl
,list <NBelemEtptInteg>& list_elemPtin_restant,bool& premLpti
,list <NBelemEtFace>& list_elemFace_restant,bool& premLface
,list <NBelemEtArete>& list_elemArrete_restant,bool& premLarrete)
{ // a) on commence par initialiser la condition
bool fr = ParaGlob::Francais(); // pour simplifier
// puis on appelle la fonction d'initialisation
(this->*initConditionToutDedans)();
// b) deuxième temps, on exécute la condition associée (il doit y en avoir qu'une
// car avant chaque condition il faut appeler init !!)
// par contre la condition peut-être appliquée plusieurs fois
// on balaie la liste des nom de ref pour savoir quel type de ref on cherche
list<string>::const_iterator al,alfin = list_nomReference.end();
for (al=list_nomReference.begin();al!=alfin;al++)
if ((*al)[0] == 'N')
{// cas d'une liste de noeuds: on balaie la liste et on cherche
list <Noeud *>::iterator nit,nits;
Tableau <Coordonnee > t_coor(1); // tableau de travail
// on calcul à chaque fois la borne finale car elle peut changer dans la boucle
nit = list_noeud_restant.begin(); nits = nit; // init
while (nits != list_noeud_restant.end())
{ nit = nits; nits++; // nits pointeur sur le suivant
// on supprime si la condition n'est pas remplie
t_coor(1)=(*nit)->Coord0();
bool condi = (this->*ExeConditionToutDedans)(t_coor);
if (!condi)
list_noeud_restant.erase(nit);
};
}
else if ((*al)[0] == 'E')
{// cas d'une liste d'éléments: on balaie la liste et on cherche
// il faut que tous les noeuds de l'élément remplisse la condition
list <Element *>::iterator nit,nits;
// on calcul à chaque fois la borne finale car elle peut changer dans la boucle
nit = list_element_restant.begin(); nits = nit; // init
while (nits != list_element_restant.end())
{ nit = nits; nits++; // nits pointeur sur le suivant
// recup du tableau de noeuds de l'élément
const Tableau<Noeud *>& t_N = (*nit)->Tab_noeud();
int nbne = t_N.Taille();
bool condition = false; // par défaut
// on définit le tableau de coordonnées de tous les noeuds
Tableau <Coordonnee > t_coor(nbne);
for (int ie=1;ie<=nbne;ie++)
{ t_coor(ie)=t_N(ie)->Coord0();};
// on vérifie la condition
condition = (this->*ExeConditionToutDedans)(t_coor);
// on supprime si la condition n'est pas remplie
if (!condition)
list_element_restant.erase(nit);
};
}
else if ((*al)[0] == 'G')
{// cas d'une liste de point d'intégration d'éléments: on balaie la liste des éléments
// et dedans la liste des points d'intégration et on cherche
Tableau <Coordonnee > t_coor(1); // tableau de travail
if (premLpti) // cas d'une première contrainte
{// on va balayer tous les éléments existant
int nbne = tab_element.Taille();
for (int ine=1;ine<=nbne;ine++)
{ Element& el = *(tab_element(ine));
// recup du nombre de point d'intégration de l'élément
int nbpti = el.NbPtInteg(enu_ddl);
// on boucle sur les pt d'integ
for (int ipt = 1;ipt<=nbpti;ipt++)
{ bool erreur =false;
t_coor(1) = el.CoordPtInteg(TEMPS_0,enu_ddl,ipt,erreur);
if (erreur)
{ if (fr) {cout << "\n erreur bizarre, on ne peut pas trouver les coordoonees t0 du pt d'integ "
<< ipt << "de l'element " << el.Num_elt() << " du maillage "
<< el.Num_maillage() << " on ne le test donc pas pour la liste des pt d'integ ! ";
}
else {cout << "\n strange error, we cannot find the coordinates at t0 of the gauss point "
<< ipt << "of the element " << el.Num_elt() << " of the mesh "
<< el.Num_maillage() << " so, we do not test it, for the list of integ points ! ";
};
}
else
{ // cas ok
bool condition = (this->*ExeConditionToutDedans)(t_coor);
NBelemEtptInteg nu; nu.nbElem=el.Num_elt(); nu.nbPtInteg = ipt;
if (condition)
{ list_elemPtin_restant.push_back(nu);}; // première fois on ajoute
};
}; //-- fin de la boucle des pt d'integ
}; //-- fin de la boucle sur tous les éléments
// on signale pour la suite qu'une contrainte a déjà été appliqué
premLpti = false;
}
else // cas d'une contrainte qui n'est pas la première
{// on boucle sur les éléments déjà enregistrée
list <NBelemEtptInteg>::iterator nit,nits;
// on calcul à chaque fois la borne finale car elle peut changer dans la boucle
nit = list_elemPtin_restant.begin(); nits = nit; // init
while (nits != list_elemPtin_restant.end())
{ nit = nits; nits++; // nits pointeur sur le suivant
// for (nit=list_elemPtin_restant.begin();nit!=list_elemPtin_restant.end();nit++)
Element& el = *(tab_element((*nit).nbElem)); // récup élément
int ipt = (*nit).nbPtInteg; // récup le pt d'integ
bool erreur =false;
t_coor(1) = el.CoordPtInteg(TEMPS_0,enu_ddl,ipt,erreur);
if (erreur)
{ if (fr) {cout << "\n erreur bizarre, on ne peut pas trouver les coordoonees t0 du pt d'integ "
<< ipt << "de l'element " << el.Num_elt() << " du maillage "
<< el.Num_maillage() << " on ne le test donc pas pour la liste des pt d'integ ! ";
}
else {cout << "\n strange error, we cannot find the coordinates at t0 of the gauss point "
<< ipt << "of the element " << el.Num_elt() << " of the mesh "
<< el.Num_maillage() << " so, we do not test it, for the list of integ points ! ";
};
}
else
{ // cas ok pour la gestion d'erreur
bool condition = (this->*ExeConditionToutDedans)(t_coor);
NBelemEtptInteg nu; nu.nbElem=el.Num_elt(); nu.nbPtInteg = ipt;
if (!condition)
// il ne satisfait pas la contrainte, on le supprime
{list_elemPtin_restant.erase(nit);};
};
};
}; //-- fin du test sur première contrainte ou pas
}
else if ((*al)[0] == 'F')
{// cas d'une liste de face d'éléments: on balaie la liste des éléments
// et dedans la liste des faces et on cherche
if (premLface) // cas d'une première contrainte
{// on va balayer tous les éléments existant
int nbne = tab_element.Taille();
for (int ine=1;ine<=nbne;ine++)
{ Element& el = *(tab_element(ine));
ElemGeomC0& elgeom = el.ElementGeometrique(); // récup de l'élément géométrique
const Tableau<Tableau<int> > nonf = elgeom.Nonf(); // récup de la connection des faces
int nbptface = nonf.Taille();
const Tableau<Noeud *>& t_N = el.Tab_noeud(); // récup du tableau de noeud de l'élément
// on boucle sur les faces
for (int iface = 1;iface<=nbptface;iface++)
{ // on regarde si tous les noeuds de la face remplissent la condition
int nbnoeudface = nonf(iface).Taille();
Tableau <Coordonnee> t_coor(nbnoeudface); // tableau intermédiaire
bool condition = true; // condition vraie par défaut
for (int ino = 1; ino<= nbnoeudface; ino++)
t_coor(ino) = (t_N(nonf(iface)(ino)))->Coord0();
// on update la condition
condition = (this->*ExeConditionToutDedans)(t_coor);
if (condition)
{NBelemEtFace nu; nu.nbElem = el.Num_elt(); nu.nbFace = iface;
list_elemFace_restant.push_back(nu);
};
};
}; //-- fin de la boucle sur tous les éléments
// on signale pour la suite qu'une contrainte a déjà été appliqué
premLface = false;
////--- debug
// cout << "\n Maillage::ToutDedans(..";
// cout << "\n PREMIER PASSAGE: list finale de face après traitement : nb face ="<< list_elemFace_restant.size() << endl;
////--- fin debug
}
else // cas d'une contrainte qui n'est pas la première
{// on boucle sur les éléments déjà enregistrée
list <NBelemEtFace>::iterator nit,nits;
// on calcul à chaque fois la borne finale car elle peut changer dans la boucle
nit = list_elemFace_restant.begin(); nits = nit; // init
while (nits != list_elemFace_restant.end())
{ nit = nits; nits++; // nits pointeur sur le suivant
// for (nit=list_elemFace_restant.begin();nit!=list_elemFace_restant.end();nit++)
Element& el = *(tab_element((*nit).nbElem)); // récup élément
ElemGeomC0& elgeom = el.ElementGeometrique(); // récup de l'élément géométrique
const Tableau<Tableau<int> > nonf = elgeom.Nonf(); // récup de la connection des faces
const Tableau<Noeud *>& t_N = el.Tab_noeud(); // récup du tableau de noeud de l'élément
bool condition = true; // a priori
int iface = (*nit).nbFace;
// on regarde si tous les noeuds de la face remplissent la condition
int nbnoeudface = nonf(iface).Taille();
Tableau <Coordonnee> t_coor(nbnoeudface); // tableau intermédiaire
for (int ino = 1; ino<= nbnoeudface; ino++)
t_coor(ino) = (t_N(nonf(iface)(ino)))->Coord0();
// on update la condition
condition = (this->*ExeConditionToutDedans)(t_coor);
if (!condition)
// cas où la condition n'est pas satisfaite on supprime l'élément
{list_elemFace_restant.erase(nit);};
};
////--- debug
// cout << "\n Maillage::ToutDedans(..";
// cout << "\n PASSAGE SECONDAIRE: list finale de face après traitement : nb face ="<< list_elemFace_restant.size() << endl;
////--- fin debug
}; //-- fin du test sur première contrainte ou pas
}
else if ((*al)[0] == 'A')
{// cas d'une liste d'arêtes d'éléments: on balaie la liste des éléments
// et dedans la liste des arêtes et on cherche
if (premLarrete) // cas d'une première contrainte
{// on va balayer tous les éléments existant
int nbne = tab_element.Taille();
for (int ine=1;ine<=nbne;ine++)
{ Element& el = *(tab_element(ine));
ElemGeomC0& elgeom = el.ElementGeometrique(); // récup de l'élément géométrique
const Tableau<Tableau<int> > nons = elgeom.NonS(); // récup de la connection des arêtes
int nbptarr = nons.Taille();
const Tableau<Noeud *>& t_N = el.Tab_noeud(); // récup du tableau de noeud de l'élément
// on boucle sur les arêtes
for (int iarr = 1;iarr <=nbptarr;iarr++)
{ // on regarde si un des noeuds de l'arête est près du point
int nbnoeudarr = nons(iarr).Taille();
Tableau <Coordonnee> t_coor(nbnoeudarr); // tableau intermédiaire
for (int ino = 1; ino<= nbnoeudarr; ino++)
t_coor(ino) = (t_N(nons(iarr)(ino)))->Coord0();
bool condition = (this->*ExeConditionToutDedans)(t_coor);
if (condition)
{NBelemEtArete nu; nu.nbElem = el.Num_elt(); nu.nbArete = iarr;
list_elemArrete_restant.push_back(nu);
};
};
}; //-- fin de la boucle sur tous les éléments
// on signale pour la suite qu'une contrainte a déjà été appliqué
premLarrete = false;
}
else // cas d'une contrainte qui n'est pas la première
{// on boucle sur les éléments déjà enregistrée
list <NBelemEtArete>::iterator nit,nits;
// on calcul à chaque fois la borne finale car elle peut changer dans la boucle
nit = list_elemArrete_restant.begin(); nits = nit; // init
while (nits != list_elemArrete_restant.end())
{ nit = nits; nits++; // nits pointeur sur le suivant
// for (nit=list_elemArrete_restant.begin();nit!=list_elemArrete_restant.end();nit++)
Element& el = *(tab_element((*nit).nbElem)); // récup élément
ElemGeomC0& elgeom = el.ElementGeometrique(); // récup de l'élément géométrique
const Tableau<Tableau<int> > nons = elgeom.NonS(); // récup de la connection des arêtes
const Tableau<Noeud *>& t_N = el.Tab_noeud(); // récup du tableau de noeud de l'élément
bool condition = false; // a priori
int iarr = (*nit).nbArete;
// on regarde si un des noeuds de l'arête est près du point
int nbnoeudarr = nons(iarr).Taille();
Tableau <Coordonnee> t_coor(nbnoeudarr); // tableau intermédiaire
for (int ino = 1; ino<= nbnoeudarr; ino++)
t_coor(ino) = (t_N(nons(iarr)(ino)))->Coord0();
condition = (this->*ExeConditionToutDedans)(t_coor);
if (!condition)
// cas où la condition n'est pas satisfaite on supprime l'élément
{list_elemArrete_restant.erase(nit);};
};
}; //-- fin du test sur première contrainte ou pas
}
};
// constitution des références
void Maillage::EnregRef(const list<string>& list_nomReference,list <Noeud *>& list_noeud_restant
,list <NBelemEtptInteg>& list_elemPtin_restant,list <Element *>& list_element_restant
,list <NBelemEtFace>& list_elemFace_restant,list <NBelemEtArete>& list_elemArrete_restant
,LesReferences* lesRef)
{
bool fr = ParaGlob::Francais(); // pour simplifier
// on balaie la liste des nom de ref
list<string>::const_iterator ag,agfin = list_nomReference.end();
for (ag=list_nomReference.begin();ag!=agfin;ag++)
if ((*ag)[0] == 'N')
{ // cas d'une liste de noeuds
// mise en place de la condition d'appartenance ou d'exclusion à des références existantes
Exe_In_out_avecRefExistantes_N(list_noeud_restant);
// on crée la nouvelle référence que s'il reste des noeuds
if (list_noeud_restant.size() != 0)
{ // mise en place de la condition d'appartenance ou d'exclusion à des références existantes
// Exe_In_out_avecRefExistantes_N(list_noeud_restant);
// on ordonne et supprime les noeuds redondants
//list_noeud_restant.sort();list_noeud_restant.unique();
// création d'un tableau de numéros de noeuds
Tableau<int> tab(list_noeud_restant.size());
list <Noeud *>::iterator itn,itnfin=list_noeud_restant.end();
int i=1;
for (itn=list_noeud_restant.begin();itn!=itnfin;itn++,i++)
tab(i)=(*itn)->Num_noeud();
ReferenceNE* refN = new ReferenceNE(tab,idmail,1,(*ag));// construction de la référence
lesRef->Ajout_reference( refN);
if (fr) {cout << "\n enregistrement ref noeuds " << (*ag) << " de " << tab.Taille() << " item " << endl;}
else {cout << "\n storage of nodes reference " << (*ag) << " of " << tab.Taille() << " item " << endl;};
};
}
else if ((*ag)[0] == 'E')
{ // cas d'une liste d'éléments
// mise en place de la condition d'appartenance ou d'exclusion à des références existantes
Exe_In_out_avecRefExistantes_E(list_element_restant);
// on crée la nouvelle référence que s'il reste des éléments
if (list_element_restant.size() != 0)
{// on ordonne et supprime les noeuds redondants
//list_element_restant.sort();list_element_restant.unique();
// création d'un tableau de numéros d'éléments
Tableau<int> tab(list_element_restant.size());
list <Element *>::iterator itn,itnfin=list_element_restant.end();
int i=1;
for (itn=list_element_restant.begin();itn!=itnfin;itn++,i++)
tab(i)=(*itn)->Num_elt();
ReferenceNE* refN = new ReferenceNE(tab,idmail,2,(*ag));// création de la référence
lesRef->Ajout_reference( refN);
if (fr) {cout << "\n enregistrement ref elements " << (*ag) << " de " << tab.Taille() << " item " << endl;}
else {cout << "\n storage of elements reference " << (*ag) << " of " << tab.Taille() << " item " << endl;};
};
}
else if ((*ag)[0] == 'G')
{ // cas d'une liste de points d'intégration d'éléments
// mise en place de la condition d'appartenance ou d'exclusion à des références existantes
Exe_In_out_avecRefExistantes_G(list_elemPtin_restant);
// on crée la nouvelle référence que s'il reste des pti
if (list_elemPtin_restant.size() != 0)
{// on supprime les refs redondantes, mais comme on gère deux listes, on fait le travail à la main
//list_elemPtin_restant.sort();list_elemPtin_restant.unique();
// création d'un tableau de numéros d'éléments
Tableau<int> tabelem(list_elemPtin_restant.size());
Tableau<int> tabpti(list_elemPtin_restant.size()); // idem pour les pti
list <NBelemEtptInteg >::iterator itn,itnfin=list_elemPtin_restant.end();
int i=1;
for (itn=list_elemPtin_restant.begin();itn!=itnfin;itn++,i++)
{tabelem(i)=(*itn).nbElem;tabpti(i) = (*itn).nbPtInteg;};
ReferenceAF* refAF = new ReferenceAF(tabelem,tabpti,idmail,6,(*ag));// création de la référence
lesRef->Ajout_reference( refAF);
if (fr) {cout << "\n enregistrement ref pt integ " << (*ag) << " de " << tabelem.Taille() << " item " << endl;}
else {cout << "\n storage of integ points reference " << (*ag) << " of " << tabelem.Taille() << " item " << endl;};
};
}
else if ((*ag)[0] == 'F')
{ // cas d'une liste de face d'éléments
// mise en place de la condition d'appartenance ou d'exclusion à des références existantes
Exe_In_out_avecRefExistantes_F(list_elemFace_restant);
// on crée la nouvelle ref que s'il reste des faces
if (list_elemFace_restant.size() != 0)
{ // on ordonne et supprime les noeuds redondants
//list_elemFace_restant.sort();list_elemFace_restant.unique();
// création d'un tableau de numéros d'éléments
Tableau<int> tabelem(list_elemFace_restant.size());
Tableau<int> tabface(list_elemFace_restant.size()); // idem pour les face
list <NBelemEtFace >::iterator itn,itnfin=list_elemFace_restant.end();
int i=1;
for (itn=list_elemFace_restant.begin();itn!=itnfin;itn++,i++)
{tabelem(i)=(*itn).nbElem;tabface(i) = (*itn).nbFace;};
ReferenceAF* refAF = new ReferenceAF(tabelem,tabface,idmail,3,(*ag));// création de la référence
lesRef->Ajout_reference( refAF);
if (fr) {cout << "\n enregistrement ref faces " << (*ag) << " de " << tabelem.Taille() << " item " << endl;}
else {cout << "\n storage of facets reference " << (*ag) << " of " << tabelem.Taille() << " item " << endl;};
if (ParaGlob::NiveauImpression()> 7)
{ for (int i=1; i<= tabelem.Taille(); i++)
{int Ne = refAF->NumeroElem(i);
int Nf = refAF->NumeroFA(i);
Element * el = tab_element(Ne);
ElFrontiere* fron = el->Frontiere_surfacique(Nf,true);
fron->Affiche(TEMPS_0);
};
};
};
}
else if ((*ag)[0] == 'A')
{ // cas d'une liste d'arêtes d'éléments
// mise en place de la condition d'appartenance ou d'exclusion à des références existantes
Exe_In_out_avecRefExistantes_A(list_elemArrete_restant);
// on crée la nouvelle référence que s'il reste des arêtes d'éléments
if (list_elemArrete_restant.size() != 0)
{// on ordonne et supprime les noeuds redondants
//list_elemArrete_restant.sort();list_elemArrete_restant.unique();
// création d'un tableau de numéros d'éléments
Tableau<int> tabelem(list_elemArrete_restant.size());
Tableau<int> tabarr(list_elemArrete_restant.size()); // idem pour les arêtes
list <NBelemEtArete >::iterator itn,itnfin=list_elemArrete_restant.end();
int i=1;
for (itn=list_elemArrete_restant.begin();itn!=itnfin;itn++,i++)
{tabelem(i)=(*itn).nbElem;tabarr(i) = (*itn).nbArete;};
ReferenceAF* refAF = new ReferenceAF(tabelem,tabarr,idmail,4,(*ag));// création de la référence
lesRef->Ajout_reference( refAF);
if (fr) {cout << "\n enregistrement ref aretes " << (*ag) << " de " << tabelem.Taille() << " item " << endl;}
else {cout << "\n storage of edges reference " << (*ag) << " of " << tabelem.Taille() << " item " << endl;};
};
}
};
// recherche près d'un point
// def interactive du point et de la distance
void Maillage::InitPresPoint(double& dist)
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
Coordonnee poin(dima);
if (fr) {cout << "\n -- condition : près d'un point ---- "<< endl;
}
else {cout << "\n -- condition : near a point ---- "<< endl;
};
// acquisition d'un point
poin = Acquisition_interactive_point();
if (fr) {cout << "\n distance au point (on retient la partie positive) " << endl;}
else {cout << "\n distance to the point (only the absolute value will be kept) " << endl;}
dist=lect_double();
dist = Dabs(dist);
t_poi.Change_taille(1);
t_poi(1) = poin;
};
// exécution de la condition : ramène true si ok, false sinon
bool Maillage::ExePresPoint(const double& dist,const Coordonnee& M) const
{ return ((M - t_poi(1)).Norme() < dist);
};
// recherche d'un coté d'un point (en 1D)
void Maillage::InitCotePoint()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
Coordonnee poin1(dima),poin2(dima);
if (fr) {cout << "\n -- condition : d'un cote d'un point (en 1D) ---- "<< endl;
}
else {cout << "\n -- condition : on one side of a point (in 1D) ---- " << endl;
};
// acquisition d'un point
poin1 = Acquisition_interactive_point();
if (fr) {cout << "\n donner un second point qui positionne le cote que l'on veut garder " << endl;
}
else {cout << "\n give a second point which locate the side " << endl;
};
// acquisition d'un point
poin2 = Acquisition_interactive_point();
t_poi.Change_taille(2);
t_poi(1) = poin1;
t_poi(2) = poin2;
};
// ramène true si tous les points sont du même coté que t_poi(2)
bool Maillage::ExeCotePoint(const Tableau <Coordonnee> & t_M) const
{ int tMtaille = t_M.Taille();
// on regarde si c'est ok pour tous les points
for (int i=1;i<=tMtaille;i++)
if ((t_M(i) - t_poi(1)) * (t_poi(2)-t_poi(1)) < 0)
return false;
// sinon c'est ok
return true;
};
// recherche entre deux points (1D)
void Maillage::InitEntrePoint()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
Coordonnee poin1(dima),poin2(dima);
if (fr) {cout << "\n -- condition : entre deux points (en 1D) ---- ";
cout << "\n premier point " << endl;
}
else {cout << "\n -- condition : between two points (in 1D) ---- ";
cout << "\n first point " << endl;
};
// acquisition d'un point
poin1 = Acquisition_interactive_point();
if (fr) {cout << "\n second point " << endl;}
else {cout << "\n second point " << endl;}
// acquisition d'un point
poin2 = Acquisition_interactive_point();
t_poi.Change_taille(2);
t_poi(1) = poin1;
t_poi(2) = poin2;
};
// ramène true si tous les points sont entre t_poi(1) et t_poi(2)
bool Maillage::ExeEntrePoint(const Tableau <Coordonnee> & t_M)const
{ int tMtaille = t_M.Taille();
// on regarde si c'est ok pour tous les points
for (int i=1;i<=tMtaille;i++)
if ((t_M(i) - t_poi(1)) * (t_poi(2)-t_M(i)) > 0)
return false;
// sinon c'est ok
return true;
};
// recherche entre deux points (1D) _avec_distance
void Maillage::InitEntrePoint_avec_distance()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
Coordonnee poin1(dima),poin2(dima);
if (fr) {cout << "\n -- condition : entre point (en 1D) +- une distance ---- ";
cout << "\n point median: " << endl;
}
else {cout << "\n -- condition : between point (in 1D) +- a distance ---- ";
cout << "\n median point " << endl;
};
// acquisition d'un point
Coordonnee A = Acquisition_interactive_point();
double dist=0.;
if (fr) {cout << "\n distance au point median (on retient la partie positive) " << endl;}
else {cout << "\n distance to the median point (only the absolute value will be kept) " << endl;}
dist=lect_double();
dist = Dabs(dist);
// on va déplacer le plan via sa normale
poin1(1) = A(1) - dist;
poin2(1) = A(1) + dist;
t_poi.Change_taille(2);
t_poi(1) = poin1;
t_poi(2) = poin2;
};
// ramène true si tous les points sont entre t_poi(1) et t_poi(2) _avec_distance
bool Maillage::ExeEntrePoint_avec_distance(const Tableau <Coordonnee> & t_M)const
{ int tMtaille = t_M.Taille();
// on regarde si c'est ok pour tous les points
for (int i=1;i<=tMtaille;i++)
if ((t_M(i) - t_poi(1)) * (t_poi(2)-t_M(i)) > 0)
return false;
// sinon c'est ok
return true;
};
// recherche près d'une ligne
void Maillage::InitPresLigne(double& dist)
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
Coordonnee poin1(dima),poin2(dima);
if (fr) {cout << "\n -- condition : pres d'une ligne ---- ";
cout << "\n la ligne est defini par deux points "<< endl;
}
else {cout << "\n -- condition : near a line ---- ";
cout << "\n the line is defined by two points " << endl;
};
// acquisition d'un point
poin1 = Acquisition_interactive_point();
if (fr) {cout << "\n second point " << endl;}
else {cout << "\n second point " << endl;}
// acquisition d'un point
poin2 = Acquisition_interactive_point();
dist=0.;
if (fr) {cout << "\n distance à la ligne (on retient la partie positive) " << endl;}
else {cout << "\n distance to the line (only the absolute value will be kept) " << endl;}
dist=lect_double(); cout << " distance lue: "<< dist << flush;
dist = Dabs(dist);
t_droit.Change_taille(1);
t_droit(1).change_donnees(poin1,(poin2-poin1));
};
bool Maillage::ExePresLigne(const double& dist,const Coordonnee& M) const
{ return (t_droit(1).Distance_a_la_droite(M) < dist);
};
// recherche près d'un cercle
void Maillage::InitPresCercle(double& dist)
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
Coordonnee centre(dima);
if (fr) {cout << "\n -- condition : pres d'un cercle ---- ";
cout << "\n centre du cercle " << endl;
}
else {cout << "\n -- condition : near a cercle ---- ";
cout << "\n cercle center " << endl;
};
// acquisition d'un point
centre = Acquisition_interactive_point();
double rayon=0.;
if (fr) {cout << "\n rayon (on retient la partie positive) " << endl;}
else {cout << "\n radius (only the absolute value will be kept) " << endl;}
rayon=lect_double();
rayon = Dabs(rayon);
t_cercle.Change_taille(1,Cercle(dima));
t_cercle(1).change_donnees(centre,rayon,NULL);
dist=0.;
if (fr) {cout << "\n distance au cercle (on retient la partie positive) " << endl;}
else {cout << "\n distance to the cercle (only the absolute value will be kept) " << endl;}
dist=lect_double();
dist = Dabs(dist);
};
bool Maillage::ExePresCercle(const double& dist,const Coordonnee& M) const
{ return (t_cercle(1).Distance_au_Cercle(M) < dist);
};
// recherche près d'un plan
void Maillage::InitPresPlan( double& dist)
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
Coordonnee poin(dima);
if (fr) {cout << "\n -- condition : pres d'un plan ---- " << endl;
}
else {cout << "\n -- condition : near a plane ---- " << endl;
};
// acquisition d'un plan
Plan pl = Acquisition_interactive_plan();
t_plan.Change_taille(1);
t_plan(1)=pl; //.change_donnees(poin,normal);
dist=0.;
if (fr) {cout << "\n distance au plan (on retient la partie positive) " << endl;}
else {cout << "\n distance to the plane (only the absolute value will be kept) " << endl;}
dist=lect_double();
dist = Dabs(dist);
};
bool Maillage::ExePresPlan(const double& dist,const Coordonnee& M) const
{ return (t_plan(1).Distance_au_plan(M) < dist);
};
// recherche près d'un cylindre
void Maillage::InitPresCylindre(double& dist)
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
Coordonnee centre(dima);
if (fr) {cout << "\n -- condition : pres d'un cylindre ---- ";
cout << "\n un point de l'axe du cylindre " << endl;
}
else {cout << "\n -- condition : near a cylinder ---- ";
cout << "\n a point belonging to the axis of the cylinder " << endl;
};
// acquisition d'un point
centre = Acquisition_interactive_point();
double rayon=0.;
cout << "\n rayon du cylindre (on retient la partie positive) " << endl;
rayon=lect_double();
rayon = Dabs(rayon); cout << " rayon retenu: "<< rayon << endl;
Coordonnee axe(dima);
if (fr) {cout << "\n coordonnee du vecteur definissant l'axe du cylindre ("<< dima << " reels) " << endl;}
else {cout << "\n coordinate of the vector of the axis of the cylinder ("<< dima << " reals) " << endl;};
// acquisition d'un vecteur=direction
axe = Acquisition_interactive_vecteur();
Cercle cer(centre,rayon,&axe);
t_cylindre.Change_taille(1);
t_cylindre(1).change_donnees(cer);
dist=0.;
if (fr) {cout << "\n distance au cylindre (on retient la partie positive) " << endl;}
else {cout << "\n distance to the cylinder (only the absolute value will be kept) " << endl;}
dist=lect_double();
dist = Dabs(dist);
};
bool Maillage::ExePresCylindre(const double& dist,const Coordonnee& M) const
{ return (t_cylindre(1).Distance_au_Cylindre(M) < dist);
};
// recherche près d'un cylindre
void Maillage::InitPresSphere(double& dist)
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
Coordonnee centre(dima);
if (fr) {cout << "\n -- condition : pres d'une sphere ---- ";
cout << "\n centre de la sphere " << endl;
}
else {cout << "\n -- condition : near a sphere ---- ";
cout << "\n the sphere center " << endl;
};
// acquisition d'un point
centre = Acquisition_interactive_point();
double rayon=0.;
if (fr) {cout << "\n rayon de la sphere (on retient la partie positive) " << endl;}
else {cout << "\n radius of the sphere (only the absolute value will be kept) " << endl;};
rayon=lect_double();
rayon = Dabs(rayon);
t_sphere.Change_taille(1);
t_sphere(1).change_donnees(centre,rayon);
dist=0.;
if (fr) {cout << "\n distance a la sphere (on retient la partie positive) " << endl;}
else {cout << "\n distance to the sphere (only the absolute value will be kept) " << endl;}
dist=lect_double();
dist = Dabs(dist);
};
bool Maillage::ExePresSphere(const double& dist,const Coordonnee& M) const
{ return (t_sphere(1).Distance_a_sphere(M) < dist);
};
// recherche d'un coté d'un plan
void Maillage::InitCotePlan()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
Coordonnee poin(dima);
if (fr) {cout << "\n -- condition : d'un cote d'un plan ---- "
<< "\n le plan: " << endl;
}
else {cout << "\n -- condition : on one side of a plane ---- ";
cout << "\n the plane: " << endl;
}
// acquisition d'un plan
Plan pl = Acquisition_interactive_plan();
t_plan.Change_taille(1);
t_plan(1)=pl; //.change_donnees(poin,normal);
t_poi.Change_taille(1);
if (fr) {cout << "\n un point d'un cote du plan " << endl;}
else {cout << "\n a point on one side of the plane " << endl;}
poin = Acquisition_interactive_point();
t_poi(1)=poin;
};
// ramène true si tous les points sont du même coté que t_poi(1) du plan
bool Maillage::ExeCotePlan(const Tableau <Coordonnee> & t_M)const
{ int tMtaille = t_M.Taille();
for (int i=1;i<=tMtaille;i++)
if (!(t_plan(1).DuMemeCote(t_poi(1),t_M(i))))
return false;
// sinon c'est ok
return true;
};
// condition entre plans
void Maillage::InitEntrePlan()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
if (fr) {cout << "\n -- condition : entre deux plans // ---- ";
cout << "\n premier plan " << endl;
}
else {cout << "\n -- condition : between two planes // ---- ";
cout << "\n first plane " << endl;
}
// acquisition d'un plan
Plan pl = Acquisition_interactive_plan();
t_plan.Change_taille(1);
t_plan(1) = pl; //.change_donnees(poin,normal);
t_poi.Change_taille(1);
if (fr) {cout << "\n un point du second plan "<< endl;}
else {cout << "\n a point of the second plane "<< endl;}
// acquisition d'un point
Coordonnee poin(Acquisition_interactive_point());
t_poi(1)=poin;
};
// ramène true si tous les points sont entre les deux plans
bool Maillage::ExeEntrePlan(const Tableau <Coordonnee> & t_M)const
{ int tMtaille = t_M.Taille();
// on regarde si d'une part les points sont du même coté que t_poi(1) et
// d'autre part si la distance du points au premier plan est <= à celle de t_poi(1)
double dist = t_plan(1).Distance_au_plan(t_poi(1));
for (int i=1;i<=tMtaille;i++)
if (!(t_plan(1).DuMemeCote(t_poi(1),t_M(i)) && (t_plan(1).Distance_au_plan(t_M(i)) < dist )))
return false;
// sinon c'est ok
return true;
};
// condition entre plans _avec_distance
void Maillage::InitEntrePlan_avec_distance()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
if (fr) {cout << "\n -- condition : entre un plan +- une distance ---- ";
cout << "\n le plan median: " << endl;
}
else {cout << "\n -- condition : between a plane +- a distance ---- ";
cout << "\n the median plane " << endl;
}
// acquisition d'un plan
Plan pl = Acquisition_interactive_plan();
double dist=0.;
if (fr) {cout << "\n distance au plan (on retient la partie positive) " << endl;}
else {cout << "\n distance to the plane (only the absolute value will be kept) " << endl;}
dist=lect_double();
dist = Dabs(dist);
// on va déplacer le plan via sa normale
const Coordonnee& A = pl.PointPlan();
const Coordonnee& N = pl.Vecplan();
Coordonnee Ap = A - dist*N;
pl.Change_ptref(Ap); // nouveau pt de ref du plan
// maintenant le point idem entre plan originale
Coordonnee poin = A + 2.*dist*N;
// on enregistre
t_plan.Change_taille(1);
t_plan(1) = pl;
t_poi.Change_taille(1);
t_poi(1)=poin;
};
// ramène true si tous les points sont entre les deux plans _avec_distance
bool Maillage::ExeEntrePlan_avec_distance(const Tableau <Coordonnee> & t_M)const
{ int tMtaille = t_M.Taille();
// on regarde si d'une part les points sont du même coté que t_poi(1) et
// d'autre part si la distance du points au premier plan est <= à celle de t_poi(1)
////-- debug
//cout << "\n debug Maillage::ExeEntrePlan_avec_distance( \n"
// << t_plan(1) << "\n point " << t_poi(1);
//
////--- fin debug
double dist = t_plan(1).Distance_au_plan(t_poi(1));
for (int i=1;i<=tMtaille;i++)
if (!(t_plan(1).DuMemeCote(t_poi(1),t_M(i)) && (t_plan(1).Distance_au_plan(t_M(i)) < dist )))
return false;
// sinon c'est ok
return true;
};
// condition dans ou dehors un cylindre
void Maillage::InitDansCylindre()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
if (fr) {cout << "\n -- condition : dans ou a l'exterieur d'un cylindre ---- ";
cout << "\n un point de l'axe du cylindre " << endl;
}
else {cout << "\n -- condition : inside or outside a cylinder ---- ";
cout << "\n a point belonging to the axis of the cylinder " << endl;
};
// acquisition d'un point
Coordonnee centre(Acquisition_interactive_point());
double rayon=0.;
if (fr) {cout << "\n rayon du cylindre (on retient la partie positive) " << endl;}
else {cout << "\n radius of the cylinder (only the absolute value will be kept) " << endl;};
rayon=lect_double();
rayon = Dabs(rayon); cout << " rayon retenu: "<< rayon << endl;
if (fr) {cout << "\n le vecteur definissant l'axe des cylindres " << endl;}
else {cout << "\n the vector of the axis of the cylinders " << endl;};
// acquisition d'un vecteur=direction
Coordonnee axe(Acquisition_interactive_vecteur());
Cercle cer(centre,rayon,&axe);
t_cylindre.Change_taille(1);
t_cylindre(1).change_donnees(cer);
};
// ramène true si tous les points sont dans le cylindre
bool Maillage::ExeDansCylindre(const Tableau <Coordonnee> & t_M)const
{ int tMtaille = t_M.Taille();
for (int i=1;i<=tMtaille;i++)
if (!(t_cylindre(1).Dedans(t_M(i))))
return false;
// sinon c'est ok
return true;
};
// ramène true si tous les points sont à l'extérieur du cylindre
bool Maillage::ExeOutCylindre(const Tableau <Coordonnee> & t_M)const
{ int tMtaille = t_M.Taille();
for (int i=1;i<=tMtaille;i++)
if ((t_cylindre(1).Dedans(t_M(i))))
return false;
// sinon c'est ok
return true;
};
// condition entre deux cylindre
void Maillage::InitEntreCylindre()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
if (fr) {cout << "\n -- condition : entre deux cylindres ---- ";
cout << "\n un point de l'axe des deux cylindres " << endl;
}
else {cout << "\n -- condition : between two cylinders ---- ";
cout << "\n a point belonging to the axis of the cylinders " << endl;
};
// acquisition d'un point
Coordonnee centre(Acquisition_interactive_point());
double rayon1=0.;
if (fr) {cout << "\n rayon du premier cylindre (on retient la partie positive) " << endl;}
else {cout << "\n radius of the first cylinder (only the absolute value will be kept) " << endl;};
rayon1=lect_double();
rayon1 = Dabs(rayon1);
double rayon2=0.;
if (fr) {cout << "\n rayon du second cylindre (on retient la partie positive) " << endl;}
else {cout << "\n radius of the second cylinder (only the absolute value will be kept) " << endl;};
rayon2=lect_double();
rayon2 = Dabs(rayon2);
if (fr) {cout << "\n vecteur definissant l'axe des cylindres " << endl;}
else {cout << "\n vector of the axis of the cylinders " << endl;};
// acquisition d'un vecteur=direction
Coordonnee axe(Acquisition_interactive_vecteur());
Cercle cer1(centre,MaX(rayon1,rayon2),&axe);
Cercle cer2(centre,MiN(rayon1,rayon2),&axe);
t_cylindre.Change_taille(2);
t_cylindre(1).change_donnees(cer1);
t_cylindre(2).change_donnees(cer2);
};
// ramène true si tous les points sont entre les deux cylindres
bool Maillage::ExeEntreCylindre(const Tableau <Coordonnee> & t_M) const
{ int tMtaille = t_M.Taille();
// on regarde si d'une part les points sont à l'intérieur du cylindre (le plus grand) et
// a l'extérieur du plus petit
for (int i=1;i<=tMtaille;i++)
if ( (!(t_cylindre(1).Dedans(t_M(i))))
|| ((t_cylindre(2).Dedans(t_M(i)))) )
return false;
// sinon c'est ok
return true;
};
// condition dans ou dehors d'une sphére
void Maillage::InitDansSphere()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
if (fr) {cout << "\n -- condition : dans ou a l'exterieur d'une sphere ---- ";
cout << "\n le centre de la sphere " << endl;
}
else {cout << "\n -- condition : inside or outside of a sphere ---- ";
cout << "\n the sphere center " << endl;
};
// acquisition d'un point
Coordonnee centre(Acquisition_interactive_point());
double rayon=0.;
if (fr) {cout << "\n rayon de la sphere (on retient la partie positive) " << endl;}
else {cout << "\n radius of the sphere (only the absolute value will be kept) " << endl;};
rayon=lect_double();
rayon = Dabs(rayon);
t_sphere.Change_taille(1);
t_sphere(1).change_donnees(centre,rayon);
};
// ramène true si tous les points sont dans la sphère
bool Maillage::ExeDansSphere(const Tableau <Coordonnee> & t_M)const
{ int tMtaille = t_M.Taille();
for (int i=1;i<=tMtaille;i++)
if (!(t_sphere(1).Dedans(t_M(i))))
return false;
// sinon c'est ok
return true;
};
// ramène true si tous les points sont à l'extérieur de la sphère
bool Maillage::ExeOutSpheres(const Tableau <Coordonnee> & t_M)const
{ int tMtaille = t_M.Taille();
for (int i=1;i<=tMtaille;i++)
if ((t_sphere(1).Dedans(t_M(i))))
return false;
// sinon c'est ok
return true;
};
// condition entre deux sphères concentriques
void Maillage::InitEntreSpheres()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
if (fr) {cout << "\n -- condition : entre deux spheres ---- ";
cout << "\n le centre des spheres " << endl;
}
else {cout << "\n -- condition :between two spheres ---- ";
cout << "\n the center of the spheres " << endl;
};
// acquisition d'un point
Coordonnee centre(Acquisition_interactive_point());
double rayon1=0.;
if (fr) {cout << "\n rayon de la premiere sphere (on retient la partie positive) " << endl;}
else {cout << "\n radius of the first sphere (only the absolute value will be kept) " << endl;};
rayon1=lect_double();
rayon1 = Dabs(rayon1);
double rayon2=0.;
if (fr) {cout << "\n rayon de la seconde sphere (on retient la partie positive) " << endl;}
else {cout << "\n radius of the second sphere (only the absolute value will be kept) " << endl;};
rayon2=lect_double();
rayon2 = Dabs(rayon2);
t_sphere.Change_taille(2);
t_sphere(1).change_donnees(centre,MaX(rayon1,rayon2));
t_sphere(2).change_donnees(centre,MiN(rayon1,rayon2));
};
// ramène true si tous les points sont entre les deux sphères
bool Maillage::ExeEntreSpheres(const Tableau <Coordonnee> & t_M)const
{ int tMtaille = t_M.Taille();
// on regarde si d'une part les points sont à l'intérieur de la sphère 1 (la plus grande) et
// a l'extérieur de la plus petite
for (int i=1;i<=tMtaille;i++)
if ( (!(t_sphere(1).Dedans(t_M(i))))
|| ((t_sphere(2).Dedans(t_M(i)))) )
return false;
// sinon c'est ok
return true;
};
// condition du même coté d'une droite
void Maillage::InitCoteDroite()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
//Coordonnee poin1(dima),poin2(dima);
if (fr) {cout << "\n -- condition : d'un meme cote d'une droite (2D) ---- ";
cout << "\n def de la ligne: " << endl;
}
else {cout << "\n -- condition : on one side of a line (2D) ---- ";
cout << "\n the line : " << endl;
};
// acquisition d'une droite
Droite dr(Acquisition_interactive_droite());
t_droit.Change_taille(1);
t_droit(1)=dr; //change_donnees(poin1,(poin2-poin1));
t_poi.Change_taille(1);
if (fr) {cout << "\n un point d'un cote de la droite " << endl;}
else {cout << "\n a point on one side of the line " << endl;};
// acquisition d'un point
Coordonnee poin(Acquisition_interactive_point());
t_poi(1)=poin;
};
// ramène true si tous les points sont du même coté que t_poi(1) de la droite (en 2D uniquement)
bool Maillage::ExeCoteDroite(const Tableau <Coordonnee> & t_M)const
{ int tMtaille = t_M.Taille();
for (int i=1;i<=tMtaille;i++)
if (!(t_droit(1).DuMemeCote(t_poi(1),t_M(i))))
return false;
// sinon c'est ok
return true;
};
// condition entre 2 droites (en 2D seulement)
void Maillage::InitEntreDroite()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
if (fr) {cout << "\n -- condition : entre deux droite (2D) ---- ";
cout << "\n la premiere ligne: " << endl;
}
else {cout << "\n -- condition : between two lines (2D) ---- ";
cout << "\n the first line: " << endl;
}
// acquisition d'une droite
Droite dr(Acquisition_interactive_droite());
t_droit.Change_taille(1);
t_droit(1)=dr; //
t_poi.Change_taille(1);
if (fr) {cout << "\n un point de la seconde droite (//) " << endl;}
else {cout << "\n a point belonging to the second line (//) " << endl;};
// acquisition d'un point
Coordonnee poin(Acquisition_interactive_point());
t_poi(1)=poin;
};
// ramène true si tous les points sont entre les 2 droites (en 2D uniquement)
bool Maillage::ExeEntreDroite(const Tableau <Coordonnee> & t_M)const
{ int tMtaille = t_M.Taille();
// on regarde si d'une part les points sont du même coté que t_poi(1) et
// d'autre part si la distance du points à la première droite est <= à celle de t_poi(1)
double dist = t_droit(1).Distance_a_la_droite(t_poi(1));
for (int i=1;i<=tMtaille;i++)
if (!(t_droit(1).DuMemeCote(t_poi(1),t_M(i)) && (t_droit(1).Distance_a_la_droite(t_M(i)) < dist )))
return false;
// sinon c'est ok
return true;
};
// condition entre 2 droites (en 2D seulement) _avec_distance
void Maillage::InitEntreDroite_avec_distance()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
if (fr) {cout << "\n -- condition : entre droite (2D) +- une distance ---- ";
cout << "\n la ligne mediane : " << endl;
}
else {cout << "\n -- condition : between line (2D) +- a distance---- ";
cout << "\n the mediane line: " << endl;
}
// acquisition d'une droite
Droite dr(Acquisition_interactive_droite());
const Coordonnee& A = dr.PointDroite();
// retourne le vecteur directeur de la droite (de norme = 1 )
const Coordonnee& U = dr.VecDroite();
double dist=0.;
if (fr) {cout << "\n distance a la droite (on retient la partie positive) " << endl;}
else {cout << "\n distance to the line (only the absolute value will be kept) " << endl;}
dist=lect_double();
dist = Dabs(dist);
Coordonnee Ap = A - dist * U;
dr.Change_ptref(Ap);
Coordonnee poin = A + 2.*dist * U;
// enreg
t_droit.Change_taille(1);
t_droit(1)=dr; //
t_poi.Change_taille(1);
t_poi(1)=poin;
};
// ramène true si tous les points sont entre les 2 droites (en 2D uniquement) _avec_distance
bool Maillage::ExeEntreDroite_avec_distance(const Tableau <Coordonnee> & t_M)const
{ int tMtaille = t_M.Taille();
// on regarde si d'une part les points sont du même coté que t_poi(1) et
// d'autre part si la distance du points à la première droite est <= à celle de t_poi(1)
double dist = t_droit(1).Distance_a_la_droite(t_poi(1));
for (int i=1;i<=tMtaille;i++)
if (!(t_droit(1).DuMemeCote(t_poi(1),t_M(i)) && (t_droit(1).Distance_a_la_droite(t_M(i)) < dist )))
return false;
// sinon c'est ok
return true;
};
// condition dans ou dehors un cercle (en 2D seulement)
void Maillage::InitDansCercle()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
if (fr) {cout << "\n -- condition : dans ou a l'exterieur d'un cercle (2D) ---- ";
cout << "\n le centre du cercle : " << endl;
}
else {cout << "\n -- condition : inside or outside a cercle (2D) ---- ";
cout << "\n the cercle center: " << endl;
}
// acquisition d'un point
Coordonnee centre(Acquisition_interactive_point());
double rayon=0.;
if (fr) {cout << "\n rayon du cercle (on retient la partie positive) "<< endl; }
else {cout << "\n radius of the cercle (only the absolute value will be kept) "<< endl; };
rayon=lect_double();
rayon = Dabs(rayon);
t_cercle.Change_taille(1,Cercle(dima));
t_cercle(1).change_donnees(centre,rayon,NULL);
};
// ramène true si tous les points sont dans le cercle (en 2D seulement)
bool Maillage::ExeDansCercle(const Tableau <Coordonnee> & t_M)const
{ int tMtaille = t_M.Taille();
for (int i=1;i<=tMtaille;i++)
if (!(t_cercle(1).Dedans(t_M(i))))
return false;
// sinon c'est ok
return true;
};
// ramène true si tous les points sont à l'extérieur du cercle (en 2D seulement)
bool Maillage::ExeOutCercle(const Tableau <Coordonnee> & t_M)const
{ int tMtaille = t_M.Taille();
for (int i=1;i<=tMtaille;i++)
if ((t_cercle(1).Dedans(t_M(i))))
return false;
// sinon c'est ok
return true;
};
// condition entre cercles concentriques (en 2D seulement)
void Maillage::InitEntreCercles()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
if (fr) {cout << "\n -- condition : entre deux cercles concentriques ---- ";
cout << "\n centre des cercle: " << endl;
}
else {cout << "\n -- condition : between two concentric cercles ---- ";
cout << "\n the center of the cercles: " << endl;
};
// acquisition d'un point
Coordonnee centre(Acquisition_interactive_point());
double rayon1=0.;
if (fr) {cout << "\n rayon du premier cercle (on retient la partie positive) "<< endl; }
else {cout << "\n radius of the first cercle (only the absolute value will be kept) "<< endl; };
rayon1=lect_double();
rayon1 = Dabs(rayon1);
double rayon2=0.;
if (fr) {cout << "\n rayon du second cercle (on retient la partie positive) " << endl;}
else {cout << "\n radius of the second cercle (only the absolute value will be kept) "<< endl; };
rayon2=lect_double();
rayon2 = Dabs(rayon2);
t_cercle.Change_taille(2,Cercle(dima));
t_cercle(1).change_donnees(centre,MaX(rayon1,rayon2),NULL);
t_cercle(2).change_donnees(centre,MiN(rayon1,rayon2),NULL);
};
// ramène true si tous les points sont entre les deux cercles concentriques
bool Maillage::ExeEntreCercles(const Tableau <Coordonnee> & t_M)const
{ int tMtaille = t_M.Taille();
// on regarde si d'une part les points sont à l'intérieur du cercle 1 (le plus grand) et
// a l'extérieur du plus petit
for (int i=1;i<=tMtaille;i++)
if ( (!(t_cercle(1).Dedans(t_M(i))))
|| ((t_cercle(2).Dedans(t_M(i)))) )
return false;
// sinon c'est ok
return true;
};
// acquisition d'un plan
Plan Maillage::Acquisition_interactive_plan()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
Coordonnee poin(dima);
Coordonnee normal(dima);
if (fr) {cout << "\n coordonnee d'un point du premier plan ("<< dima << " reels) "
<< "\n ou un noeud -> rep: noeud= <un num noeud> "
<< "\n ou 3 noeuds pour tout le plan "
<< "\n -> noeudi= <num1> <num2> <num3>"
<< endl;
}
else {cout << "\n coordinates of a point of the first plane ("<< dima << " reals) "
<< "\n or one node -> answer: noeud= <un num noeud> "
<< "\n or 3 nodes for the whole plane "
<< "\n -> noeudi= <num1> <num2> <num3>"
<< endl;
}
int c=getchar();
string inter("");// une chaîne vide
string rep;
std::getline (std::cin,rep);
if (isalnum(c)|| (c=='-')) // si jamais on a lu quelque chose de viable dans c on le rajoute
{inter.push_back(c);
rep = inter + rep;
};
// si la taille de rep == 0 cela veut dire que c'est un retour chariot
// if (rep.size()==0)
char * chh = (char*)rep.c_str();
#ifndef ENLINUX_STREAM
istringstream flux (chh);
#else
istrstream flux (chh);
#endif
if(strstr(chh,"oeud=")!=0)
{int numn; string toto;
flux >> toto >> numn;
cout << "\n numero de noeud lu "<< numn;
poin = tab_noeud(numn)->Coord0();
cout << "\n --> coordonnees lues: "; poin.Affiche_1(cout) ;
if (fr) {cout << "\n coordonnees de la normale du plan ("<< dima << " reels) " << endl;}
else {cout << "\n coordinates of the plane normal ("<< dima << " reals) " << endl;}
for (int i = 1; i<= dima; i++) cin >> normal(i);
cout << "\n --> normale lue: "; normal.Affiche_1(cout) ;
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
}
else if(strstr(chh,"oeudi=")!=0)
{ int n1,n2,n3; string toto;
flux >> toto >> n1 >> n2 >> n3;
cout << "\n numeros de noeud lu "<< n1 <<", "<<n2<<", "<<n3 ;
poin = tab_noeud(n1)->Coord0();
// on fait le produit vectoriel pour la normale
Coordonnee v1( tab_noeud(n2)->Coord0() - poin);
Coordonnee v2( tab_noeud(n3)->Coord0() - poin);
normal = Util::ProdVec_coor(v1,v2);
}
else
{ for (int i = 1; i<= dima; i++) flux >> poin(i);
cout << "\n --> coordonnees lues: "; poin.Affiche_1(cout) ;
if (fr) {cout << "\n coordonnees de la normale du plan ("<< dima << " reels) " << endl;}
else {cout << "\n coordinates of the plane normal ("<< dima << " reals) " << endl;}
for (int i = 1; i<= dima; i++) cin >> normal(i);
cout << "\n --> normale lue: "; normal.Affiche_1(cout) ;
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
};
Plan pl(poin,normal);
return pl;
};
// acquisition d'un point
Coordonnee Maillage::Acquisition_interactive_point()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
Coordonnee poin(dima);
if (fr) {cout << "\n coordonnee d'un point ("<< dima << " reels) "
<< "\n ou un noeud -> rep: noeud= <un num noeud> "
<< flush;
}
else {cout << "\n coordinates of a point ("<< dima << " reals) "
<< "\n or one node -> answer: noeud= <un num noeud> "
<< flush;
}
using namespace std;
// on passe un caractère, *** je ne sais pas pourquoi *** pour que getline fonctionne !! (pas d'indication au niveau de rdstate
// cout << "\n cin.iostat good(): "<< cin.good() << " eof: "<< cin.eof()
// << " fail: "<< cin.fail() << " bad: "<< cin.bad()
// << "\n rdstate(): " << cin.rdstate() << endl;
int c=getchar();
string inter("");// une chaîne vide
string rep;
std::getline (std::cin,rep);
if (isalnum(c) || (c=='-')) // si jamais on a lu quelque chose de viable dans c on le rajoute
{inter.push_back(c);
// cout << "\n** valeur de c "<< c << flush;
rep = inter + rep;
};
// si la taille de rep == 0 cela veut dire que c'est un retour chariot
// if (rep.size()==0)
char * chh = (char*)rep.c_str();
#ifndef ENLINUX_STREAM
istringstream flux (chh);
#else
istrstream flux (chh);
#endif
if(strstr(chh,"oeud=")!=0)
{int numn; string toto;
flux >> toto >> numn;
cout << "\n numero de noeud lu "<< numn;
poin = tab_noeud(numn)->Coord0();
}
else
{ for (int i = 1; i<= dima; i++) flux >> poin(i);
cout << "\n --> coordonnees lues: "; poin.Affiche_1(cout) ;
};
return poin;
};
// acquisition d'une droite
Droite Maillage::Acquisition_interactive_droite()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
Coordonnee poin1(dima);
// --- le premier point ----
if (fr) {cout << "\n coordonnee d'un point de la droite ("<< dima << " reels) "
<< "\n ou un noeud -> rep: noeud= <un num noeud> "
<< endl;
}
else {cout << "\n coordinates of a point of the line ("<< dima << " reals) "
<< "\n or one node -> answer: noeud= <un num noeud> "
<< endl;
}
using namespace std;
{// on passe un caractère, *** je ne sais pas pourquoi *** pour que getline fonctionne !! (pas d'indication au niveau de rdstate
// cout << "\n cin.iostat good(): "<< cin.good() << " eof: "<< cin.eof()
// << " fail: "<< cin.fail() << " bad: "<< cin.bad()
// << "\n rdstate(): " << cin.rdstate() << endl;
int c=getchar();
string inter("");// une chaîne vide
string rep;
std::getline (std::cin,rep);
if (isalnum(c)) // si jamais on a lu quelque chose de viable dans c on le rajoute
{inter.push_back(c);
rep = inter + rep;
};
// si la taille de rep == 0 cela veut dire que c'est un retour chariot
// if (rep.size()==0)
char * chh = (char*)rep.c_str();
#ifndef ENLINUX_STREAM
istringstream flux (chh);
#else
istrstream flux (chh);
#endif
if(strstr(chh,"oeud=")!=0)
{int numn; string toto;
flux >> toto >> numn;
cout << "\n numero de noeud lu "<< numn;
poin1 = tab_noeud(numn)->Coord0();
}
else
{ for (int i = 1; i<= dima; i++) flux >> poin1(i);
cout << "\n --> coordonnees lues: "; poin1.Affiche_1(cout) ;
};
};
// --- le second point ----
Coordonnee poin2(dima);
if (fr) {cout << "\n coordonnee du second point de la droite ("<< dima << " reels) "
<< "\n ou un noeud -> rep: noeud= <un num noeud> "
<< endl;
}
else {cout << "\n coordinates of the second point of the line ("<< dima << " reals) "
<< "\n or one node -> answer: noeud= <un num noeud> "
<< endl;
}
{// on passe un caractère, *** je ne sais pas pourquoi *** pour que getline fonctionne !! (pas d'indication au niveau de rdstate
// cout << "\n cin.iostat good(): "<< cin.good() << " eof: "<< cin.eof()
// << " fail: "<< cin.fail() << " bad: "<< cin.bad()
// << "\n rdstate(): " << cin.rdstate() << endl;
int c=getchar();
string inter("");// une chaîne vide
string rep;
std::getline (std::cin,rep);
if (isalnum(c)|| (c=='-')) // si jamais on a lu quelque chose de viable dans c on le rajoute
{inter.push_back(c);
rep = inter + rep;
};
// si la taille de rep == 0 cela veut dire que c'est un retour chariot
// if (rep.size()==0)
char * chh = (char*)rep.c_str();
#ifndef ENLINUX_STREAM
istringstream flux (chh);
#else
istrstream flux (chh);
#endif
if(strstr(chh,"oeud=")!=0)
{int numn; string toto;
flux >> toto >> numn;
cout << "\n numero de noeud lu "<< numn;
poin2 = tab_noeud(numn)->Coord0();
}
else
{ for (int i = 1; i<= dima; i++) flux >> poin2(i);
cout << "\n --> coordonnees lues: "; poin2.Affiche_1(cout) ;
};
};
Coordonnee V(poin2-poin1);
Droite dl(poin1,V);
return dl;
};
// acquisition d'un vecteur=direction
Coordonnee Maillage::Acquisition_interactive_vecteur()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
Coordonnee V(dima);
if (fr) {cout << "\n coordonnee du vecteur ("<< dima << " reels) "
<< "\n ou 2 noeuds pour tout le plan "
<< "\n -> noeudi= <num1> <num2> "
<< endl;
}
else {cout << "\n coordinates of a the vector ("<< dima << " reals) "
<< "\n or 2 nodes for the whole plane "
<< "\n -> noeudi= <num1> <num2> "
<< endl;
}
int c=getchar();
string inter("");// une chaîne vide
string rep;
std::getline (std::cin,rep);
if (isalnum(c) || (c=='-')) // si jamais on a lu quelque chose de viable dans c on le rajoute
{inter.push_back(c);
rep = inter + rep;
};
// si la taille de rep == 0 cela veut dire que c'est un retour chariot
// if (rep.size()==0)
char * chh = (char*)rep.c_str();
#ifndef ENLINUX_STREAM
istringstream flux (chh);
#else
istrstream flux (chh);
#endif
if(strstr(chh,"noeudi=")!=0)
{
Coordonnee poin1(dima);
Coordonnee poin2(dima);
int n1,n2; string toto;
flux >> toto >> n1 >> n2 ;
cout << "\n numeros de noeud lu "<< n1 <<", "<<n2 ;
poin1 = tab_noeud(n1)->Coord0();
poin2 = tab_noeud(n2)->Coord0();
V = poin2-poin1;
}
else
{ for (int i = 1; i<= dima; i++) flux >> V(i);
cout << "\n --> coordonnees lues: "; V.Affiche_1(cout) ;
};
return V;
};
// condition d'appartenance à une référence existante
void Maillage::InitInRef()
{ bool fr = ParaGlob::Francais(); // pour simplifier
string nom_ref; const Reference * refIn = NULL;
bool demande_fin = false;
while (!demande_fin)
{if (fr) {cout << "\n -- init condition : appartenance a une reference ---- \n (liste in actuelle: ";
{list <const Reference*>::const_iterator il,ilfin=list_refIn.end();
if (list_refIn.size() == 0 ) {cout << " aucune ref " ;}
else {
for (il = list_refIn.begin(); il != ilfin; il++)
cout << " "<< (*il)->Nom();
cout << " ) ";
}
}
cout << "\n nom de la reference existante ? (seules les ref de "
<< "\n meme type seront comparees) " << endl;
}
else {cout << "\n -- init condition : belonging to an already existing reference ---- \n list in use: ";
{list <const Reference*>::const_iterator il,ilfin=list_refIn.end();
if (list_refIn.size() == 0 ) {cout << " no ref " ;}
else {
for (il = list_refIn.begin(); il != ilfin; il++)
cout << " "<< (*il)->Nom();
cout << " ) ";
}
}
cout << "\n name of the reference ? (only a reference of a "
<< "\n same type can be used) " << endl;
};
nom_ref=lect_return_defaut(true,"f");
if (nom_ref == "f" ) {demande_fin = true;}
// sinon on essaie de récupérer la référence
else if (!(lesRefin->Existe(nom_ref,idmail)))
{if (fr) {cout << "\n le nom lue " << nom_ref << " ne correspond pas a une reference existante "
<< " donnez un autre nom ou taper f pour finir ";
}
else {cout << "\n the input name " << nom_ref << " does not belong to an existing reference "
<< " give another name, or f for leaving ";
};
}
else
{ // on récupère la référence
refIn = &(lesRefin->Trouve(nom_ref,idmail));
list_refIn.push_back(refIn);
demande_fin=true; // seul cas où tout est ok
}
};
};
// ramène true si tous les points appartiennent à la ref
//bool Maillage::ExeInRef (const Tableau <Coordonnee> & t_M)const
// { //const ReferenceNE & refi = *((ReferenceNE *) refIn);
// on récupère tous les noeuds de la référence
// };
// condition d'exclusion à une référence existante
void Maillage::InitOutRef()
{ bool fr = ParaGlob::Francais(); // pour simplifier
string nom_ref; const Reference * refOut = NULL;
bool demande_fin = false;
while (!demande_fin)
{if (fr) {cout << "\n -- init condition : hors d'une reference ---- \n (liste in actuelle: ";
{list <const Reference*>::const_iterator il,ilfin=list_refOut.end();
if (list_refOut.size() == 0 ) {cout << " aucune ref " ;}
else {
for (il = list_refOut.begin(); il != ilfin; il++)
cout << " "<< (*il)->Nom();
cout << " ) ";
}
}
cout << "\n nom de la reference existante ? (seules les ref de "
<< "\n meme type seront comparees) " << endl;
}
else {cout << "\n -- init condition : out of to an already existing reference ---- \n list in use: ";
{list <const Reference*>::const_iterator il,ilfin=list_refOut.end();
if (list_refOut.size() == 0 ) {cout << " aucune ref " ;}
else {
for (il = list_refOut.begin(); il != ilfin; il++)
cout << " "<< (*il)->Nom();
cout << " ) ";
}
}
cout << "\n name of the reference ? (only a reference of a "
<< "\n same type can be used) " << endl;
};
nom_ref=lect_return_defaut(true,"f");
if (nom_ref == "f" ) {demande_fin = true;}
// sinon on essaie de récupérer la référence
else if (!(lesRefin->Existe(nom_ref,idmail)))
{if (fr) {cout << "\n le nom lue " << nom_ref << " ne correspond pas a une reference existante "
<< " donnez un autre nom ou taper f pour finir ";
}
else {cout << "\n the input name " << nom_ref << " does not belong to an existing reference "
<< " give another name, or f for leaving ";
}
}
else
{ // on récupère la référence
refOut = &(lesRefin->Trouve(nom_ref,idmail));
list_refOut.push_back(refOut);
demande_fin=true; // seul cas où tout est ok
}
};
};
// 1) une fonction qui ne fait rien, mais est là pour que le tout fonctionne normalement
bool Maillage::Exe_In_out_avecRefExistantes(const Tableau <Coordonnee> & t_M)const
{return true;}; // ne fait rien
// 2) fonctions qui réellement font quelque chose: utilisées dans la méthode EnregRef
// a - cas des ref de noeuds
void Maillage::Exe_In_out_avecRefExistantes_N(list <Noeud *>& list_noeud_restant)
{
// ---- cas des ref in
list <Noeud *> liste_finale_in;
{ // on commence par concaténer l'ensemble des noeuds des refs In
list <const Reference*>::iterator lref,lref_fin= list_refIn.end();
for (lref=list_refIn.begin();lref != lref_fin; lref++)
{// on ne continue que si c'est une ref de noeud, du même maillage
if (((*lref)->Indic() == 1) && ((*lref)->Nbmaille() == idmail))
{ ReferenceNE * refi = ((ReferenceNE *) (*lref));
const Tableau<int>& tab_num = refi->Tab_num();
int tailmax = tab_num.Taille();
for (int i=1;i<=tailmax;i++)
{liste_finale_in.push_back(tab_noeud(tab_num(i)));};
};
};
// on trie et on supprime les doublons
liste_finale_in.sort();
liste_finale_in.unique();
};
list <Noeud *>::iterator lf_in_deb=liste_finale_in.begin();
list <Noeud *>::iterator lf_in_end=liste_finale_in.end();
// ---- cas des ref out
list <Noeud *> liste_finale_out;
{ // on commence par concaténer l'ensemble des noeuds des refs out
list <const Reference*>::iterator lref,lref_fin= list_refOut.end();
for (lref=list_refOut.begin();lref != lref_fin; lref++)
{ // on ne continue que si c'est une ref de noeud, du même maillage
if (((*lref)->Indic() == 1) && ((*lref)->Nbmaille() == idmail))
{ ReferenceNE * refi = ((ReferenceNE *) (*lref));
const Tableau<int>& tab_num = refi->Tab_num();
int tailmax = tab_num.Taille();
for (int i=1;i<=tailmax;i++)
{liste_finale_out.push_back(tab_noeud(tab_num(i)));};
};
};
// on trie et on supprime les doublons
liste_finale_out.sort();
liste_finale_out.unique();
};
list <Noeud *>::iterator lf_out_deb=liste_finale_out.begin();
list <Noeud *>::iterator lf_out_end=liste_finale_out.end();
////--- debug
// cout << "\n Maillage::Exe_In_out_avecRefExistantes_N(..";
// cout << "\n list in ";
// list < Noeud*>::iterator lnn;
// for (lnn=lf_in_deb;lnn != lf_in_end; lnn++)
// cout << (*lnn)->Num_noeud() << " ";
// cout << "\n list out ";
// for (lnn=lf_out_deb;lnn != lf_out_end; lnn++)
// cout << (*lnn)->Num_noeud() << " ";
// cout << "\n list finale avant traitement ";
// for (lnn=list_noeud_restant.begin();lnn != list_noeud_restant.end(); lnn++)
// cout << (*lnn)->Num_noeud() << " ";
////--- fin debug
// ---- application
// on passe en revue les noeuds et on regarde s'ils font partie d'une des listes In
// et s'ils sont en dehors des out
bool liste_finale_in_a_considerer = liste_finale_in.size();
bool liste_finale_out_a_considerer = liste_finale_out.size();
////--- debug
// cout << "liste_finale_in_a_considerer" << liste_finale_in_a_considerer
// << "liste_finale_out_a_considerer" << liste_finale_out_a_considerer << endl;
////--- fin debug
list <Noeud*>::iterator li;
list <Noeud*> liinter(list_noeud_restant);
int nb_trouve_in=0; int nb_trouve_out=0;
// comme on supprime en cours de route des ref de noeuds on recalcul la borne sup à chaque passage
for (li=list_noeud_restant.begin();li != list_noeud_restant.end();li++)
{ bool deja_supprime = false; // pour indiquer si un element a déjà ete supprimer, ce qui evite une double
////--- fin debug
// cout << "(*li)->Num_noeud()=" << (*li)->Num_noeud() << endl;
// cout << "\n taper un lettre "; string unelettre ; cin >> unelettre;
////--- fin debug
if (liste_finale_in_a_considerer) // prise en compte que si la liste est non vide
{if (find(lf_in_deb, lf_in_end, *li) == lf_in_end)
// on n'a pas trouvé de noeud appartenant à la liste, on supprime le noeud
{//list <Noeud*>::iterator toto = li;
liinter.remove(*li);//
// list_noeud_restant.remove(*li);
nb_trouve_in++;deja_supprime=true;
}
};
if ((liste_finale_out_a_considerer)&&(!deja_supprime)) // prise en compte que si la liste est non vide
{if (find(lf_out_deb, lf_out_end, *li) != lf_out_end)
// on a trouvé un noeud appartenant à la liste, on supprime le noeud
{//list_noeud_restant.erase(li);
liinter.remove(*li);//
nb_trouve_out++;
};
};
};
list_noeud_restant = liinter;
if (ParaGlob::NiveauImpression() > 4)
{ if (liste_finale_in_a_considerer)
cout << "\n "<<nb_trouve_in<<" elements ajoutes a partir des refs in ";
if (liste_finale_out_a_considerer)
cout << "\n "<<nb_trouve_out<<" elements supprimes a partir des refs out ";
cout << endl;
};
};
// b - cas des ref d'éléments
void Maillage::Exe_In_out_avecRefExistantes_E(list <Element *>& list_element_restant)
{
// ---- cas des ref in
list <Element *> liste_finale_in;
{ // on commence par concaténer l'ensemble des Elements des refs In
list <const Reference*>::iterator lref,lref_fin= list_refIn.end();
for (lref=list_refIn.begin();lref != lref_fin; lref++)
{// on ne continue que si c'est une ref de Element, du même maillage
if (((*lref)->Indic() == 2) && ((*lref)->Nbmaille() == idmail))
{ ReferenceNE * refi = ((ReferenceNE *) (*lref));
const Tableau<int>& tab_num = refi->Tab_num();
int tailmax = tab_num.Taille();
for (int i=1;i<=tailmax;i++)
{liste_finale_in.push_back(tab_element(tab_num(i)));};
};
};
// on trie et on supprime les doublons
liste_finale_in.sort();
liste_finale_in.unique();
};
list <Element *>::iterator lf_in_deb=liste_finale_in.begin();
list <Element *>::iterator lf_in_end=liste_finale_in.end();
// ---- cas des ref out
list <Element *> liste_finale_out;
{ // on commence par concaténer l'ensemble des Elements des refs out
list <const Reference*>::iterator lref,lref_fin= list_refOut.end();
for (lref=list_refOut.begin();lref != lref_fin; lref++)
{ // on ne continue que si c'est une ref de Element, du même maillage
if (((*lref)->Indic() == 2) && ((*lref)->Nbmaille() == idmail))
{ ReferenceNE * refi = ((ReferenceNE *) (*lref));
const Tableau<int>& tab_num = refi->Tab_num();
int tailmax = tab_num.Taille();
for (int i=1;i<=tailmax;i++)
{liste_finale_out.push_back(tab_element(tab_num(i)));};
};
};
// on trie et on supprime les doublons
liste_finale_out.sort();
liste_finale_out.unique();
};
list <Element *>::iterator lf_out_deb=liste_finale_out.begin();
list <Element *>::iterator lf_out_end=liste_finale_out.end();
////--- debug
// cout << "\n Maillage::Exe_In_out_avecRefExistantes_N(..";
// cout << "\n list in ";
// list < Element*>::iterator lnn;
// for (lnn=lf_in_deb;lnn != lf_in_end; lnn++)
// cout << (*lnn)->Num_Element() << " ";
// cout << "\n list out ";
// for (lnn=lf_out_deb;lnn != lf_out_end; lnn++)
// cout << (*lnn)->Num_Element() << " ";
// cout << "\n list finale avant traitement ";
// for (lnn=list_element_restant.begin();lnn != list_element_restant.end(); lnn++)
// cout << (*lnn)->Num_Element() << " ";
////--- fin debug
// ---- application
// on passe en revue les Elements et on regarde s'ils font partie d'une des listes In
// et s'ils sont en dehors des out
bool liste_finale_in_a_considerer = liste_finale_in.size();
bool liste_finale_out_a_considerer = liste_finale_out.size();
list <Element*>::iterator li;
int nb_trouve_in=0; int nb_trouve_out=0;
// comme on supprime en cours de route des ref de Elements on recalcul la borne sup à chaque passage
for (li=list_element_restant.begin();li != list_element_restant.end();li++)
{ bool deja_supprime = false; // pour indiquer si un element a déjà ete supprimer, ce qui evite une double
if (liste_finale_in_a_considerer) // prise en compte que si la liste est non vide
if (find(lf_in_deb, lf_in_end, *li) == lf_in_end)
// on n'a pas trouvé de Element appartenant à la liste, on supprime le Element
{list_element_restant.erase(li);nb_trouve_in++;deja_supprime=true;}
if ((liste_finale_out_a_considerer)&&(!deja_supprime)) // prise en compte que si la liste est non vide
if (find(lf_out_deb, lf_out_end, *li) != lf_out_end)
// on a trouvé un Element appartenant à la liste, on supprime le Element
{list_element_restant.erase(li);nb_trouve_out++;}
};
if (ParaGlob::NiveauImpression() > 4)
{ if (liste_finale_in_a_considerer)
cout << "\n "<<nb_trouve_in<<" elements ajoutes a partir des refs in ";
if (liste_finale_out_a_considerer)
cout << "\n "<<nb_trouve_out<<" elements supprimes a partir des refs out ";
cout << endl;
};
};
// c - cas des ref de points d'intégration
void Maillage::Exe_In_out_avecRefExistantes_G(list <NBelemEtptInteg>& list_elemPtin_restant)
{
// ---- cas des ref in pour les pti
list <NBelemEtptInteg > liste_finale_in;
{ // on commence par concaténer l'ensemble des pti des refs In
list <const Reference*>::iterator lref,lref_fin= list_refIn.end();
for (lref=list_refIn.begin();lref != lref_fin; lref++)
{// on ne continue que si c'est une ref de pti, du même maillage
if (((*lref)->Indic() == 6) && ((*lref)->Nbmaille() == idmail))
{ ReferenceAF * refi = ((ReferenceAF *) (*lref));
const Tableau<int>& tab_elem = refi->Tab_Elem();
const Tableau<int>& tab_fa = refi->Tab_FA();
int tailmax = tab_elem.Taille();
for (int i=1;i<=tailmax;i++)
{ NBelemEtptInteg nu; nu.nbElem = tab_elem(i); nu.nbPtInteg = tab_fa(i);
liste_finale_in.push_back(nu);
};
};
};
// on trie et on supprime les doublons
liste_finale_in.sort();
liste_finale_in.unique();
};
list <NBelemEtptInteg >::iterator lf_in_deb=liste_finale_in.begin();
list <NBelemEtptInteg >::iterator lf_in_end=liste_finale_in.end();
// ---- cas des ref out
list <NBelemEtptInteg > liste_finale_out;
{ // on commence par concaténer l'ensemble des pti des refs out
list <const Reference*>::iterator lref,lref_fin= list_refOut.end();
for (lref=list_refOut.begin();lref != lref_fin; lref++)
{ // on ne continue que si c'est une ref de pti, du même maillage
if (((*lref)->Indic() == 6) && ((*lref)->Nbmaille() == idmail))
{ ReferenceAF * refi = ((ReferenceAF *) (*lref));
const Tableau<int>& tab_elem = refi->Tab_Elem();
const Tableau<int>& tab_fa = refi->Tab_FA();
int tailmax = tab_elem.Taille();
for (int i=1;i<=tailmax;i++)
{ NBelemEtptInteg nu; nu.nbElem = tab_elem(i); nu.nbPtInteg = tab_fa(i);
liste_finale_out.push_back(nu);
};
};
};
// on trie et on supprime les doublons
liste_finale_out.sort();
liste_finale_out.unique();
};
list <NBelemEtptInteg >::iterator lf_out_deb=liste_finale_out.begin();
list <NBelemEtptInteg >::iterator lf_out_end=liste_finale_out.end();
////--- debug
//
////--- debug
// cout << "\n Maillage::Exe_In_out_avecRefExistantes_F(..";
// cout << "\n list in ";
// list < NBelemEtptInteg>::iterator lnn;
// for (lnn=lf_in_deb;lnn != lf_in_end; lnn++)
// cout << (*lnn).nbElem << " "<< (*lnn).nbPtInteg << " ";
// cout << "\n list out ";
// for (lnn=lf_out_deb;lnn != lf_out_end; lnn++)
// cout << (*lnn).nbElem << " "<< (*lnn).nbPtInteg << " ";
// cout << "\n list finale avant traitement ";
// for (lnn=list_elemPtin_restant.begin();lnn != list_elemPtin_restant.end(); lnn++)
// cout << (*lnn).nbElem << " "<< (*lnn).nbPtInteg << " ";
////--- fin debug
// ---- application
// on passe en revue les pti et on regarde s'ils font partie d'une des listes In
// et s'ils sont en dehors des out
bool liste_finale_in_a_considerer = liste_finale_in.size();
bool liste_finale_out_a_considerer = liste_finale_out.size();
list <NBelemEtptInteg>::iterator li;
int nb_trouve_in=0; int nb_trouve_out=0;
// comme on supprime en cours de route des ref de face on recalcul la borne sup à chaque passage
for (li=list_elemPtin_restant.begin();li != list_elemPtin_restant.end();li++)
{ bool deja_supprime = false; // pour indiquer si un element a déjà ete supprimer, ce qui evite une double
if (liste_finale_in_a_considerer) // prise en compte que si la liste est non vide
if (find(lf_in_deb, lf_in_end, *li) == lf_in_end)
// on n'a pas trouvé de face appartenant à la liste, on supprime le pti
{list_elemPtin_restant.erase(li);nb_trouve_in++;deja_supprime=true;}
if ((liste_finale_out_a_considerer)&&(!deja_supprime)) // prise en compte que si la liste est non vide
if (find(lf_out_deb, lf_out_end, *li) != lf_out_end)
// on a trouvé une face appartenant à la liste, on supprime le pti
{list_elemPtin_restant.erase(li);nb_trouve_out++;}
};
if (ParaGlob::NiveauImpression() > 4)
{ if (liste_finale_in_a_considerer)
cout << "\n "<<nb_trouve_in<<" elements ajoutes a partir des refs in ";
if (liste_finale_out_a_considerer)
cout << "\n "<<nb_trouve_out<<" elements supprimes a partir des refs out ";
cout << endl;
};
////--- debug
// cout << "\n Maillage::Exe_In_out_avecRefExistantes_F(..";
// cout << "\n list finale après traitement ";
// for (lnn=list_elemFace_restant.begin();lnn != list_elemFace_restant.end(); lnn++)
// cout << (*lnn).nbElem << " "<< (*lnn).nbPtInteg << " ";
////--- fin debug
};
// d - cas des ref des faces
void Maillage::Exe_In_out_avecRefExistantes_F(list <NBelemEtFace>& list_elemFace_restant)
{
// ---- cas des ref in pour les faces
list <NBelemEtFace > liste_finale_in;
{ // on commence par concaténer l'ensemble des faces des refs In
list <const Reference*>::iterator lref,lref_fin= list_refIn.end();
for (lref=list_refIn.begin();lref != lref_fin; lref++)
{// on ne continue que si c'est une ref de face, du même maillage
if (((*lref)->Indic() == 3) && ((*lref)->Nbmaille() == idmail))
{ ReferenceAF * refi = ((ReferenceAF *) (*lref));
const Tableau<int>& tab_elem = refi->Tab_Elem();
const Tableau<int>& tab_fa = refi->Tab_FA();
int tailmax = tab_elem.Taille();
for (int i=1;i<=tailmax;i++)
{ NBelemEtFace nu; nu.nbElem = tab_elem(i); nu.nbFace = tab_fa(i);
liste_finale_in.push_back(nu);
};
};
};
// on trie et on supprime les doublons
liste_finale_in.sort();
liste_finale_in.unique();
};
list <NBelemEtFace >::iterator lf_in_deb=liste_finale_in.begin();
list <NBelemEtFace >::iterator lf_in_end=liste_finale_in.end();
// ---- cas des ref out
list <NBelemEtFace > liste_finale_out;
{ // on commence par concaténer l'ensemble des faces des refs out
list <const Reference*>::iterator lref,lref_fin= list_refOut.end();
for (lref=list_refOut.begin();lref != lref_fin; lref++)
{ // on ne continue que si c'est une ref de face, du même maillage
if (((*lref)->Indic() == 3) && ((*lref)->Nbmaille() == idmail))
{ ReferenceAF * refi = ((ReferenceAF *) (*lref));
const Tableau<int>& tab_elem = refi->Tab_Elem();
const Tableau<int>& tab_fa = refi->Tab_FA();
int tailmax = tab_elem.Taille();
for (int i=1;i<=tailmax;i++)
{ NBelemEtFace nu; nu.nbElem = tab_elem(i); nu.nbFace = tab_fa(i);
liste_finale_out.push_back(nu);
};
};
};
// on trie et on supprime les doublons
liste_finale_out.sort();
liste_finale_out.unique();
};
list <NBelemEtFace >::iterator lf_out_deb=liste_finale_out.begin();
list <NBelemEtFace >::iterator lf_out_end=liste_finale_out.end();
////--- debug
//
////--- debug
// cout << "\n Maillage::Exe_In_out_avecRefExistantes_F(..";
// cout << "\n list in ";
// list < NBelemEtFace>::iterator lnn;
// for (lnn=lf_in_deb;lnn != lf_in_end; lnn++)
// cout << (*lnn).nbElem << " "<< (*lnn).nbFace << " ";
// cout << "\n list out ";
// for (lnn=lf_out_deb;lnn != lf_out_end; lnn++)
// cout << (*lnn).nbElem << " "<< (*lnn).nbFace << " ";
// cout << "\n list finale avant traitement ";
// for (lnn=list_elemFace_restant.begin();lnn != list_elemFace_restant.end(); lnn++)
// cout << (*lnn).nbElem << " "<< (*lnn).nbFace << " ";
////--- fin debug
// ---- application
// on passe en revue les faces et on regarde s'ils font partie d'une des listes In
// et s'ils sont en dehors des out
bool liste_finale_in_a_considerer = liste_finale_in.size();
bool liste_finale_out_a_considerer = liste_finale_out.size();
list <NBelemEtFace>::iterator li;
int nb_trouve_in=0; int nb_trouve_out=0;
// comme on supprime en cours de route des ref de face on recalcul la borne sup à chaque passage
for (li=list_elemFace_restant.begin();li != list_elemFace_restant.end();li++)
{ bool deja_supprime = false; // pour indiquer si un element a déjà ete supprimer, ce qui evite une double
if (liste_finale_in_a_considerer) // prise en compte que si la liste est non vide
if (find(lf_in_deb, lf_in_end, *li) == lf_in_end)
// on n'a pas trouvé de face appartenant à la liste, on supprime le face
{list_elemFace_restant.erase(li);nb_trouve_in++;deja_supprime=true;}
if ((liste_finale_out_a_considerer)&&(!deja_supprime)) // prise en compte que si la liste est non vide
if (find(lf_out_deb, lf_out_end, *li) != lf_out_end)
// on a trouvé une face appartenant à la liste, on supprime le face
{list_elemFace_restant.erase(li);nb_trouve_out++;}
};
if (ParaGlob::NiveauImpression() > 4)
{ if (liste_finale_in_a_considerer)
cout << "\n "<<nb_trouve_in<<" faces ajoutes a partir des refs in ";
if (liste_finale_out_a_considerer)
cout << "\n "<<nb_trouve_out<<" faces supprimes a partir des refs out ";
cout << endl;
};
////--- debug
// cout << "\n Maillage::Exe_In_out_avecRefExistantes_F(..";
// cout << "\n list finale après traitement ";
// for (lnn=list_elemFace_restant.begin();lnn != list_elemFace_restant.end(); lnn++)
// cout << (*lnn).nbElem << " "<< (*lnn).nbFace << " ";
////--- fin debug
};
// e - cas des ref des arêtes d'éléments
void Maillage::Exe_In_out_avecRefExistantes_A(list <NBelemEtArete>& list_elemArrete_restant)
{
// ---- cas des ref in pour les arêtes
list <NBelemEtArete > liste_finale_in;
{ // on commence par concaténer l'ensemble des arêtes des refs In
list <const Reference*>::iterator lref,lref_fin= list_refIn.end();
for (lref=list_refIn.begin();lref != lref_fin; lref++)
{// on ne continue que si c'est une ref de arêtes, du même maillage
if (((*lref)->Indic() == 4) && ((*lref)->Nbmaille() == idmail))
{ ReferenceAF * refi = ((ReferenceAF *) (*lref));
const Tableau<int>& tab_elem = refi->Tab_Elem();
const Tableau<int>& tab_fa = refi->Tab_FA();
int tailmax = tab_elem.Taille();
for (int i=1;i<=tailmax;i++)
{ NBelemEtArete nu; nu.nbElem = tab_elem(i); nu.nbArete = tab_fa(i);
liste_finale_in.push_back(nu);
};
};
};
// on trie et on supprime les doublons
liste_finale_in.sort();
liste_finale_in.unique();
};
list <NBelemEtArete >::iterator lf_in_deb=liste_finale_in.begin();
list <NBelemEtArete >::iterator lf_in_end=liste_finale_in.end();
// ---- cas des ref out
list <NBelemEtArete > liste_finale_out;
{ // on commence par concaténer l'ensemble des arêtes des refs out
list <const Reference*>::iterator lref,lref_fin= list_refOut.end();
for (lref=list_refOut.begin();lref != lref_fin; lref++)
{ // on ne continue que si c'est une ref de arête, du même maillage
if (((*lref)->Indic() == 4) && ((*lref)->Nbmaille() == idmail))
{ ReferenceAF * refi = ((ReferenceAF *) (*lref));
const Tableau<int>& tab_elem = refi->Tab_Elem();
const Tableau<int>& tab_fa = refi->Tab_FA();
int tailmax = tab_elem.Taille();
for (int i=1;i<=tailmax;i++)
{ NBelemEtArete nu; nu.nbElem = tab_elem(i); nu.nbArete = tab_fa(i);
liste_finale_out.push_back(nu);
};
};
};
// on trie et on supprime les doublons
liste_finale_out.sort();
liste_finale_out.unique();
};
list <NBelemEtArete >::iterator lf_out_deb=liste_finale_out.begin();
list <NBelemEtArete >::iterator lf_out_end=liste_finale_out.end();
////--- debug
//
////--- debug
// cout << "\n Maillage::Exe_In_out_avecRefExistantes_F(..";
// cout << "\n list in ";
// list < NBelemEtArete>::iterator lnn;
// for (lnn=lf_in_deb;lnn != lf_in_end; lnn++)
// cout << (*lnn).nbElem << " "<< (*lnn).nbArete << " ";
// cout << "\n list out ";
// for (lnn=lf_out_deb;lnn != lf_out_end; lnn++)
// cout << (*lnn).nbElem << " "<< (*lnn).nbArete << " ";
// cout << "\n list finale avant traitement ";
// for (lnn=list_elemArrete_restant.begin();lnn != list_elemArrete_restant.end(); lnn++)
// cout << (*lnn).nbElem << " "<< (*lnn).nbArete << " ";
////--- fin debug
// ---- application
// on passe en revue les arêtes et on regarde s'ils font partie d'une des listes In
// et s'ils sont en dehors des out
bool liste_finale_in_a_considerer = liste_finale_in.size();
bool liste_finale_out_a_considerer = liste_finale_out.size();
int nb_trouve_in=0; int nb_trouve_out=0;
list <NBelemEtArete>::iterator li;
// comme on supprime en cours de route des ref de arête on recalcul la borne sup à chaque passage
for (li=list_elemArrete_restant.begin();li != list_elemArrete_restant.end();li++)
{ bool deja_supprime = false; // pour indiquer si un element a déjà ete supprimer, ce qui evite une double
if (liste_finale_in_a_considerer) // prise en compte que si la liste est non vide
if (find(lf_in_deb, lf_in_end, *li) == lf_in_end)
// on n'a pas trouvé de arête appartenant à la liste, on supprime le arête
{list_elemArrete_restant.erase(li);nb_trouve_in++;deja_supprime=true;}
if ((liste_finale_out_a_considerer)&&(!deja_supprime)) // prise en compte que si la liste est non vide
if (find(lf_out_deb, lf_out_end, *li) != lf_out_end)
// on a trouvé une arête appartenant à la liste, on supprime le arête
{list_elemArrete_restant.erase(li);nb_trouve_out++;}
};
if (ParaGlob::NiveauImpression() > 4)
{ if (liste_finale_in_a_considerer)
cout << "\n "<<nb_trouve_in<<" aretes ajoutes a partir des refs in ";
if (liste_finale_out_a_considerer)
cout << "\n "<<nb_trouve_out<<" aretes supprimes a partir des refs out ";
cout << endl;
};
////--- debug
// cout << "\n Maillage::Exe_In_out_avecRefExistantes_F(..";
// cout << "\n list finale après traitement ";
// for (lnn=list_elemArrete_restant.begin();lnn != list_elemArrete_restant.end(); lnn++)
// cout << (*lnn).nbElem << " "<< (*lnn).nbArete << " ";
////--- fin debug
};
// dans le cas particulier d'une ligne, on peut ordonner certaines listes résultantes / à la lignes
// il s'agit des noeuds et des pt d'integ: on les ordonnes par rapport à leurs projections sur la lignes
void Maillage::InitOrdonneLigne()
{ int dima = ParaGlob::Dimension();
bool fr = ParaGlob::Francais(); // pour simplifier
Coordonnee poin1(dima),poin2(dima);
if (fr) {cout << "\n -- condition : ordonne noeuds et pt integ par rapport a la projection sur une ligne ---- ";
cout << "\n la ligne est defini par deux points ";
cout << "\n premier point: " << endl;
// acquisition d'un point
poin1 = Acquisition_interactive_point();
cout << "\n second point: " << endl;
}
else {cout << "\n -- condition : sorting of the nodes and integ pt relatively to their projections on a line ---- ";
cout << "\n the line is defined by two points ";
cout << "\n first point " << endl;
// acquisition d'un point
poin1 = Acquisition_interactive_point();
cout << "\n second point " << endl;
};
// acquisition d'un point
poin2 = Acquisition_interactive_point();
t_droit.Change_taille(1);
t_droit(1).change_donnees(poin1,(poin2-poin1));
};
void Maillage::OrdonneLigne(list <Noeud *>& list_noeud_restant,list <NBelemEtptInteg>& list_elemPtin_restant
,const Enum_ddl & enu_ddl)
{ // --- cas des noeuds ---
bool fr = ParaGlob::Francais(); // pour simplifier
// on crée un tableau des noeuds restants
if (list_noeud_restant.size() != 0)
{int nbtn = list_noeud_restant.size();
Tableau <Noeud *> tab_n(nbtn);
list <Noeud *>::iterator il,ilfin=list_noeud_restant.end();
int i=1;
for (il = list_noeud_restant.begin();il != ilfin;il++,i++)
tab_n(i) = *il;
// maintenant on crée une liste de Entier_et_Double qui contient le numéro dans le tableau et la coordonnée
// curviligne de la projection
list <Entier_et_Double> list_curvi;
// on rempli la liste
Droite & dr = t_droit(1); // pour simplifier
for (int i=1;i<=nbtn;i++)
{ Coordonnee M = tab_n(i)->Coord0();
Coordonnee Mp = dr.Projete(M);
double xcurv = (Mp-dr.PointDroite()) * dr.VecDroite();
list_curvi.push_front(Entier_et_Double(i,xcurv));
};
// on ordonne la liste
list_curvi.sort();
// on reconstruit la liste de noeud restant
list_noeud_restant.clear();
list <Entier_et_Double>::iterator ia,iafin= list_curvi.end();
for (ia=list_curvi.begin();ia!=iafin;ia++)
list_noeud_restant.push_front(tab_n((*ia).n));
}; // encapsulation
// --- cas des points d'intégrations ---
if (list_elemPtin_restant.size() != 0)
{list <Entier_et_Double> list_curvi;
// on crée un tableau des ptint
int nbptint = list_elemPtin_restant.size();
Tableau <NBelemEtptInteg> tab_ptint(nbptint);
list <NBelemEtptInteg>::iterator jl,jlfin=list_elemPtin_restant.end();
int j=1;
for (jl = list_elemPtin_restant.begin();jl != jlfin;jl++,j++)
tab_ptint(j) = *jl;
// maintenant on crée une liste de Entier_et_Double qui contient le numéro dans le tableau et la coordonnée
// curviligne de la projection:
list_curvi.clear(); // en fait on utilise la précédente liste
// on rempli la liste
Droite & dr = t_droit(1); // pour simplifier
for (int i=1;i<=nbptint;i++)
{ Element& el = *(tab_element(tab_ptint(i).nbElem));
bool erreur =false;
Coordonnee M = el.CoordPtInteg(TEMPS_0,enu_ddl,tab_ptint(i).nbPtInteg,erreur);
if (erreur)
{ int num = tab_ptint(i).nbPtInteg;
if (fr) {cout << "\n erreur bizarre, on ne peut pas trouver les coordoonees t0 du pt d'integ "
<< num << "de l'element " << el.Num_elt() << " du maillage "
<< el.Num_maillage() << " on arrete d'ordonner les pt d'integ ! ! ";
}
else {cout << "\n strange error, we cannot find the coordinates at t0 of the gauss point "
<< num << "of the element " << el.Num_elt() << " of the mesh "
<< el.Num_maillage() << " we stop the process of sorting the integ pt ! ! ";
}
return;
}
Coordonnee Mp = dr.Projete(M);
double xcurv = (Mp-dr.PointDroite()) * dr.VecDroite();
list_curvi.push_front(Entier_et_Double(i,xcurv));
};
// on ordonne la liste
list_curvi.sort();
// on reconstruit la liste des ptinteg restants
list_elemPtin_restant.clear();
list <Entier_et_Double>::iterator ja,jafin= list_curvi.end();
for (ja=list_curvi.begin();ja!=jafin;ja++)
list_elemPtin_restant.push_front(tab_ptint((*ja).n));
}; // encapsulation
};
//- il faut faire la doc en ligne d'herehz++
//- il faut mettre un ordre pour sauvegarder le nouveau maillage
//- mettre un sous-ordre dans l'algo, qui a pour objet de rien faire au niveau algo mettre de faire
// l'exécution des choses prévu dans les classes utilisées: ici les maillages