rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Maillage/maillage4.cc
Gérard Rio 49c9e51239 introduction de la version 7.00: utilisation de MPI au niveau du calcul de raideur élémentaire 
Sur la branche master
 Votre branche est à jour avec 'origin/master'.

 Modifications qui seront validées :
	nouveau fichier : Elements/Mecanique/SFE/Met_Sfe1_struc_donnees.h
	nouveau fichier : Elements/Thermique/PtIntegThermiInterne.cc
	nouveau fichier : Elements/Thermique/PtIntegThermiInterne.h
	nouveau fichier : General/Distribution_CPU.cc
	nouveau fichier : General/Distribution_CPU.h
	nouveau fichier : Lecture/LectBloc_T.cc
	nouveau fichier : Maillage/maillage4.cc
	nouveau fichier : Parametres/Banniere.h
	nouveau fichier : Parametres/banniere.cc
	nouveau fichier : Util/Courbes/Courbe_1-cos.cc
2022-09-26 14:16:07 +02:00

3097 lines
161 KiB
C++
Raw Blame History

// 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 "TriaSfe1.h"
#include "TriaSfe1_cm5pti.h"
#include "TriaSfe2.h"
#include "TriaSfe3.h"
#include "TriaSfe3_cm3pti.h"
#include "TriaSfe3_cm4pti.h"
#include "TriaSfe3_cm5pti.h"
#include "TriaSfe3_cm6pti.h"
#include "TriaSfe3_cm7pti.h"
#include "TriaSfe3_cm12pti.h"
#include "TriaSfe3_cm13pti.h"
#include "TriaSfe3_3D.h"
#include "TriaSfe3C.h"
#include "TriaQSfe1.h"
#include "TriaQSfe3.h"
#include <limits>
//------------------- on s'occupe de 3 classes de travail ----------------------------------
bool Maillage::NBelemEtFace::operator < (const Maillage::NBelemEtFace& c) const
{if (nbElem < c.nbElem) {return true;}
else if (nbElem > c.nbElem) {return false;}
else // ici cas ou nbElem == c.nbElem
{ return (nbFace < c.nbFace);};
};
bool Maillage::NBelemEtFace::operator > (const Maillage::NBelemEtFace& c) const
{if (nbElem > c.nbElem) {return true;}
else if (nbElem < c.nbElem) {return false;}
else // ici cas ou nbElem == c.nbElem
{ return (nbFace > c.nbFace);};
};
bool Maillage::NBelemEtArete::operator < (const Maillage::NBelemEtArete& c) const
{if (nbElem < c.nbElem) {return true;}
else if (nbElem > c.nbElem) {return false;}
else // ici cas ou nbElem == c.nbElem
{ return (nbArete < c.nbArete);};
};
bool Maillage::NBelemEtArete::operator > (const Maillage::NBelemEtArete& c) const
{if (nbElem > c.nbElem) {return true;}
else if (nbElem < c.nbElem) {return false;}
else // ici cas ou nbElem == c.nbElem
{ return (nbArete > c.nbArete);};
};
bool Maillage::NBelemEtptInteg::operator < (const Maillage::NBelemEtptInteg& c) const
{if (nbElem < c.nbElem) {return true;}
else if (nbElem > c.nbElem) {return false;}
else // ici cas ou nbElem == c.nbElem
{ return (nbPtInteg < c.nbPtInteg);};
};
bool Maillage::NBelemEtptInteg::operator > (const Maillage::NBelemEtptInteg& c) const
{if (nbElem > c.nbElem) {return true;}
else if (nbElem < c.nbElem) {return false;}
else // ici cas ou nbElem == c.nbElem
{ return (nbPtInteg > c.nbPtInteg);};
};
bool Maillage::NBelemFAEtptInteg::operator < (const Maillage::NBelemFAEtptInteg& c) const
{if (nbElem < c.nbElem) {return true;}
else if (nbElem > c.nbElem) {return false;}
else // ici cas ou nbElem == c.nbElem
{ if (nbFA < c.nbFA ) {return true;}
else if (nbFA > c.nbFA ) {return false;}
else // cas où il ne reste que le pti
{return (nbPtInteg < c.nbPtInteg);};
};
};
bool Maillage::NBelemFAEtptInteg::operator > (const Maillage::NBelemFAEtptInteg& c) const
{if (nbElem > c.nbElem) {return true;}
else if (nbElem < c.nbElem) {return false;}
else // ici cas ou nbElem == c.nbElem
{if (nbFA > c.nbFA) {return true;}
else if (nbFA < c.nbFA) {return false;}
else // cas où il ne reste que le pti
{ return (nbPtInteg > c.nbPtInteg);};
};
};
//----------------------- fin des classes de travail ------------------------------------------
// modification de l'orientation d'éléments
void Maillage::Modif_orientation_element(int cas_orientation,LesReferences* lesRef)
{
switch (cas_orientation)
{case -1: case 1:
// =-1: on sort une information s'il y a un pb d'orientation, mais on ne fait rien
// =1: on modifie automatiquement l'orientation des éléments lorsque le jacobien
// est purement négatif
{ // on va boucler sur les éléments
int nbelem = tab_element.Taille();
for (int ie=1;ie<=nbelem;ie++)
tab_element(ie)->Modif_orient_elem(cas_orientation);
break;
}
case 2: // cas d'une orientation semi-automatique des faces d'un maillage de coques ou de membranes
{cout << "\n processing of the mesh : " << nomDuMaillage << " nB= " << idmail;
cout << "\n this re-orientation of elements can be applied only for shell and membrane elements"
<< " the other elements are ignored. " ;
// initialisation des différents tableaux utilisés par Orientation_elements_mitoyens_recursif
Init_Orientation_elements_mitoyens_recursif();
// on commence par faire l'acquisition d'un élément particulier dont la direction servira de référence
bool fin_boucle_infinie = false;
bool calcul_frontiere = false; // pour le calcul une fois des frontières
int num_elem=0; // init du numéro de l'élément
bool fr = ParaGlob::Francais(); // pour simplifier
while (!fin_boucle_infinie)
{num_elem=0; // re-init du numéro de l'élément, dans le cas où on bouclerait
bool inverse = false; // init de l'indicateur permettant de savoir si l'on souhaite essayer
// d'inverser le premier élément, donc tous les éléments de la nouvelle ref
if (fr)
{cout << "\n --- choix d'un element dont l'orientation servira de reference ------- ";
cout << "\n le reperage peut se faire de differentes manieres :"
<< "\n par un numero d'element dans le maillage -> (choix : 1)"
<< "\n (rep -1 si l'on veut tenter une orientation inverse pour les elements) "
<< "\n par des coordonnees d'un point (meme approximatives), "
<< "\n l'element choisit sera celui le plus proche de ce point -> (choix : 2)"
<< "\n (rep -2 si l'on veut tenter une orientation inverse pour les elements) "
<< "\n fin -> (choix : f ou 0)";
}
else
{cout << "\n --- choise of a reference element for the orientation ------- ";
cout << "\n could be done by :"
<< "\n the number of the element in the mesh -> (choice : 1)"
<< "\n (choice -1 if an inverse orientation is tried for the elements) "
<< "\n the coordinates of a point (even approximately) "
<< "\n the choice will be the nearest element -> (choice : 2)"
<< "\n (choice -2 if an inverse orientation is tried for the elements) "
<< "\n end -> (choice : f or 0)";
};
string rep="";
if (fr)
{cout << "\n reponse ? ";}else {cout << "\n answer ? ";};
rep= lect_return_defaut(false,"f");
bool a_traiter=false; // pour gérer l'action d'orienter ou non
if ((rep == "1") || (rep == "-1"))
{if (rep =="-1") inverse = true; // on enregistre le souhait d'une orientation inverse
if (fr) { cout << "\n numero de l'element ? "; }
else { cout << "\n number of the element ? ";};
rep=lect_chaine(); num_elem = ChangeEntier(rep);
}
else if ((rep == "2") || (rep =="-2"))
{int dim = ParaGlob::Dimension();
if (rep =="-2") inverse = true; // on enregistre le souhait d'une orientation inverse
Coordonnee xi(dim);
if (fr) {cout << "\n coordonnee ("<<dim<<" nombre(s)) ? ";}
else {cout << "\n coordinate ("<<dim<<" scalar(s)) ? ";};
for(int j=1;j<=dim;j++) cin >> xi(j);
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
if (fr) {cout << "\n les coordonnees sont a: t = 0 ou t ou tdt (repondre 0 ou t ou tdt) ? ";}
else {cout << "\n the coordinates are at : t = 0 or t or tdt (answer 0 or t or tdt) ? ";}
rep = lect_chaine();
bool rep_exploitable = true; Enum_dure enu_temps;
if (rep == "0")
enu_temps = TEMPS_0;
else if (rep == "t")
enu_temps = TEMPS_t;
else if (rep == "tdt")
enu_temps = TEMPS_tdt;
else
{ if (fr) {cout << "\n erreur de syntaxe, on attendait: 0, t ou tdt ";}
else {cout << "\n error, the input must be : 0, t or tdt ";}
rep_exploitable = false;
};
if (rep_exploitable)
{const Element * elem_ret = Centre_de_Gravite_Element_le_plus_proche(enu_temps,xi);
if (elem_ret == NULL) // cas où l'on ne trouve pas d'élément
{ if (fr) {cout << "\n pas d'element trouve , pour le temps "
<< rep << " recommencez ! ";}
else {cout << "\n no element founded, for the time "
<< rep << " do it again ! ";};
}
else
{ if (fr) {cout << "\n le numero de l'element contenant le point: "<< elem_ret->Num_elt_const();}
else {cout << "\n the number of the element that contains the point: "<< elem_ret->Num_elt_const();};
num_elem = elem_ret->Num_elt_const();
};
};
}
else if ((Minuscules(rep) == "fin") || (Minuscules(rep) == "f") || (Minuscules(rep) == "0"))
{fin_boucle_infinie = true; a_traiter=false;}
else
{if (fr) {cout << "\n choix non valide, recommencez !";}
else {cout << "\n the choice is not valide, starts again ! ";};
};
// on vérifie que l'élément est correcte
if (!fin_boucle_infinie) // on ne vérifie pas si c'est la fin demandée
{if ((num_elem < 1) || (num_elem > tab_element.Taille()))
{if (fr) {cout << "\n choix non valide, le numero "<<num_elem<<" est en dehors de ";
cout << "l'intervalle des elements enregistres ["<<1<<":"<<tab_element.Taille()<<"]"; }
else { cout << "\n the choice is not valide, the number "<<num_elem<<" is out of the range of recorded elements ";
cout << "["<<1<<":"<<tab_element.Taille()<<"]"; };
}
else if (Type_geom_generique(tab_element(num_elem)->Id_geometrie()) != SURFACE)
{ if (fr) {cout << "\n choix non valide, l'element "<<num_elem<<" n'est pas un element de surface !! ";
cout << " c'est un element : "<< Type_geom_generique(tab_element(num_elem)->Id_geometrie()); }
else { cout << "\n the choice is not valide, the element "<<num_elem<<" is a surface element ";
cout << " it is an element: "<< Type_geom_generique(tab_element(num_elem)->Id_geometrie()); };
}
else if (TestEnum_geom_axisymetrique(tab_element(num_elem)->Id_geometrie()))
{ if (fr) {cout << "\n choix non valide, l'element "<<num_elem<<" est un element axisymetrique !! ";}
else { cout << "\n the choice is not valide, the element "<<num_elem<<" is an axisymetric element "; };
}
else // sinon c'est ok
{ a_traiter=true;};
// maintenant on va traiter éventuellement
if (a_traiter)
{double angle_maxi=0; // angle maxi entre deux éléments, au-dessus duquel, on ne traite pas
if (fr)
{cout << "\n angle maxi (en degre) au dessus duquel on considerera "
<< "\n qu'il n'y a plus de continuite : ";
}
else
{cout << "\n angle maximun (in degree) up this angle, up this value, "
<< "\n the conitnuity is not taking into account : ";
};
angle_maxi=lect_double();
cout << "\n angle= " << angle_maxi ;
// transformation en radian
angle_maxi *= ConstMath::Pi/180.;
cout << " ("<<angle_maxi <<" rd) ";
// on s'occupe du nom des ref
string nom_ref="_"; // nom par défaut
string reponse = "n";
if (fr)
{ cout << "\n gene auto du nom des ref (par defaut rep \"o\" ) ou def d'un nom particulier (rep \"n\") ";}
else
{ cout << "\n automatic name for the ref (default rep\"o\" ) or def of a specific name (rep \"n\") ";};
reponse = lect_return_defaut(false,"o");
if (reponse == "n")
{if (fr) {cout << "\n nom de la ref ? ";}
else {cout << "\n name of the reference ? ";};
nom_ref= lect_chaine();
if (fr) {cout << "\n nom lu " << nom_ref<<endl;}
else {cout << "\n reading name " << nom_ref<<endl;};
fin_boucle_infinie = false; // pour être sûr de refaire une passe
};
// --- on appelle les programmes ad hoc
// - on définie tous les Front des éléments, et leurs Front mitoyens
if (!calcul_frontiere)
{Calcul_tous_les_front_et_leurs_mitoyens();
calcul_frontiere = true;
};
// - premier passage avec le numéro choisit et éventuellement un nom donné
bool recursif = false;
list <int> nums_non_oriente = Orientation_elements_mitoyens_recursif(recursif,nom_ref,num_elem,*lesRef
,angle_maxi,inverse);
// dans le cas où la liste de retour n'est pas vide cela signifie qu'il y a des groupes d'éléments mitoyens qui n'ont pas
// la même orientation, on demande si l'on veut les orienter
if (nums_non_oriente.size() != 0)
{ if (fr) {cout << "\n des groupes d'elements mitoyens ont ete detectes comme ayant des orientations differentes "
<< " voulez-vous les orienter (arbitrairement) par groupes mitoyens "
<< " avec des noms de ref genere automatiquement ? (rep o ou n ) ";}
else {cout << "\n we have found set of elements, that have common boundaries, but have no similar orientation,"
<< " do you want to change these orientation (arbirary) for each set "
<< " with automatic generation of ref name ? (answer y or n )";};
string answer="";answer=lect_o_n(false);
if ((fr && (Minuscules(answer) == "o")) || (!fr && (Minuscules(answer) == "y")))
{ nom_ref="_";bool recursif = true;
while (nums_non_oriente.size())
{ nums_non_oriente = Orientation_elements_mitoyens_recursif
(recursif,nom_ref,*(nums_non_oriente.begin()),*lesRef,angle_maxi,inverse);}
fin_boucle_infinie = true;
};
};
};
}; // fin du cas où on n'a pas demandé de finir la boucle infinie
}; // -- fin de la boucle infinie sur le choix noeud/élément ou arrêt
break;
}
case 3: // cas d'une orientation en fonction d'un rayon
{cout << "\n processing of the mesh : " << nomDuMaillage << " nB= " << idmail;
cout << "\n this re-orientation of elements can be applied only for shell and membrane elements"
<< " the other elements are ignored. " ;
// def des tableaux de travail initialisés à rien par défaut
int dim_espace(ParaGlob::Dimension());
if (dim_espace != 3) // pour l'instant ne fonctionne qu'en dimension 3
{ cout << "\n erreur *** pour l'instant, cette fonction d'orientation ne fonctionne qu'en dimension 3 "
<< endl;
Sortie(2);
return; // normalement ne sert à rien
};
Tableau <bool> indic_G(3,false);
Coordonnee3 A;
Tableau <bool> item_renseigne(3,false); // utilisé pour savoir si tous les items ont été renseignés
string zone_a_traiter("_");
bool inverse=false;
// on définit les paramètres de l'orientation: on va utiliser un menu
string rep("_");bool traitement_pas_pret = true;
while (traitement_pas_pret)
{ while ((Minuscules(rep) != "f")&&(Minuscules(rep) != "0"))
{
try
{
cout
<< "\n (0 ou f) (fin normal avant traitement) "
<< "\n (1) definition du point de reference "
<< "\n (2) inversion eventuelle de sens "
<< "\n (3) definition de la zone a traiter "
<< "\n (4) arret du processus (sans traitement) "
<< "\n (5) affichage de la liste des ref existantes (pour info) "
<< "\n (6) affichage min max sur x y z pour info "
<< "\n ";
rep = lect_return_defaut(false,"f");
// sortie directe si tout est ok, sinon
if ((Minuscules(rep) == "f") || (Minuscules(rep) == "0"))
{if (item_renseigne(1) && item_renseigne(3))
break; // ok on peut s'arrêter
else { cout << "\n la mise en donnee n'est pas complete ! "<<endl;
if (!item_renseigne(1)) cout << " vous devez renseigner le (1) "<<endl;
if (!item_renseigne(3)) cout << " vous devez renseigner le (3) "<<endl;
};
rep = "_"; // on réinitialise pour éviter de sortir de la boucle
}
else
{
int num = ChangeEntier(rep);
bool choix_valide=false;
if ((num >= 0)&&(num<7))
{ choix_valide=true; }
else { cout << "\n Erreur on attendait un entier entre 0 et 6 !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper f ou 0 pour arreter le programme et valider les choix ";
choix_valide=false;
}
switch (num)
{ case 0: // sortie
{ break;} // normalement cela a déjà été filtré avant
case 1: // définition du point de référence
{ cout << "\n\n definition du point de reference \n";
{ string nom;
cout << "\n coord x du point ou XG pour utiliser le x du G de la facette ? ";
nom= lect_chaine();cout << " valeur lue "<< nom<<endl;
if (nom == "XG") {indic_G(1)=true;A(1)=0.;}
else { indic_G(1)=false;A(1)=ChangeReel(nom);};
}
{ string nom;
cout << "\n coord y du point ou YG pour utiliser le y du G de la facette ? ";
nom= lect_chaine();cout << " valeur lue "<< nom<<endl;
if (nom == "YG") {indic_G(2)=true;A(2)=0.;}
else { indic_G(2)=false;A(2)=ChangeReel(nom);};
}
{ string nom;
cout << "\n coord z du point ou ZG pour utiliser le z du G de la facette ? ";
nom= lect_chaine();cout << " valeur lue "<< nom<<endl;
if (nom == "ZG") {indic_G(3)=true;A(3)=0.;}
else { indic_G(3)=false;A(3)=ChangeReel(nom);};
}
item_renseigne(1)=true; // on valide l'item
break;
}
case 2: // inversion de sens
{ cout << "\n inversion eventuelle du sens rep o ou n ";
string nom;
nom= lect_chaine();cout << " valeur lue "<< nom<<endl; nom = Minuscules(nom);
if (nom == "o" ) inverse = true;
else if (nom == "n") inverse = false;
// sinon on laise en l'état
item_renseigne(2)=true; // on valide l'item
break;
}
case 3: // definition de la zone a traiter
{ cout << "\n definition de la zone a traiter \n";
cout << "\n donner la reference des elements a traiter ? ";
string nom;
nom= lect_chaine(); cout << " valeur lue "<< nom<<endl;
// on regarde si la référence existe
if (!lesRef->Existe(nom,idmail))
{cout << "\n *** cette reference n'existe pas !! "<<endl;
item_renseigne(3)=false;
}
else {zone_a_traiter=nom; item_renseigne(3)=true;};
break;
}
case 4: // arret du processus sans traitement
{ cout << "\n fin du processus, pas de traitement de re-orientation !! ";
return;
break;
}
case 5: // affichage de la liste des ref existantes
{ cout << "\n affichage de la liste de nom des ref existantes \n";
lesRef->Affiche(1);
break;
}
case 6: // affichage min max x y z pour info
{ cout << "\n affichage min max x y z pour info \n";
// on récupère la boite d'encombrement
Tableau <Vecteur> tab_vec = Taille_boiteMail();
cout << "\n min_x= "<<tab_vec(1)(1) << " max_x= "<< tab_vec(2)(1);
cout << "\n min_y= "<<tab_vec(1)(2) << " max_y= "<< tab_vec(2)(2);
cout << "\n min_z= "<<tab_vec(1)(3) << " max_z= "<< tab_vec(2)(3);
break;
}
default:
cout << "\n mauvais choix !! recommencez ! ";
};
};
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch (...)//(UtilLecture::ErrNouvelleDonnee erreur)
{ cout << "\n Erreur on attendait un des mots clés proposés !!, "
<< "\n redonnez une bonne valeur"<<endl;
};
}; //-- fin du while
// on regarde si tous les items ont été renseigné
if (item_renseigne(1) && item_renseigne(3))
{traitement_pas_pret = false;rep = "";}
else {traitement_pas_pret = true;rep = "";};
};
// arrivée ici on dispose de toutes les données ad hoc
// appel de la routine
Orientation_via_rayon(indic_G,A,zone_a_traiter,*lesRef,inverse);
break;
}
default:
cout << "\n error: case of an orientation not envisaged : cas_orientation= " << cas_orientation
<< "\n Maillage::Modif_orientation_element(... ";
Sortie(1);
};
};
// Lecture et Collapse des éléments superposés, c-a-d identiques, dans le cas où il en existe
void Maillage::LectureEtCollapse_element_superpose(UtilLecture * entreePrinc,LesReferences* lesRef)
{ if (strstr(entreePrinc->tablcar,"fusion_elements_superposes_")!=NULL)
{ if (ParaGlob::NiveauImpression() > 2) cout << "\n beginning of the process to collapse elements which are "
<< " superposed "<< endl ;
entreePrinc->NouvelleDonnee(); // on passe le mot clé
// appel de l'algo de collapse
Collapse_element_superpose(lesRef);
if (ParaGlob::NiveauImpression() > 2) cout << "\n end of the process to collapse elements which are "
<< " superposed "<< endl ;
};
};
// Collapse des éléments supperposés, c-a-d identiques, dans le cas où il en existe
void Maillage::Collapse_element_superpose(LesReferences* lesRef)
{ // création pour chaque noeud de la liste des éléments qui contiennent le noeud
Calcul_indice();
// on crée un tableau d'indicateur des éléments à supprimer
int nbelem = tab_element.Taille();
Tableau <int> elem_supprime(nbelem,0);
// on balaie les éléments, et pour chaque élément, on recherche les éléments supperposés éventuels
for (int ine = 1;ine <= nbelem;ine++)
// on ne continue que si c'est un élément qui n'a pas déjà été marqué " à supprimé "
if (elem_supprime(ine) == 0)
{Element * elem = tab_element(ine);
// on récupère uniquement le premier noeud
Noeud * noe = tab_element(ine)->Tab_noeud()(1);
// indice(i) contient la liste des éléments qui contiennent le noeud i
List_io < Element*> & li_elem = indice(noe->Num_noeud()); // pour simplifier
List_io < Element*>::iterator il,ilfin = li_elem.end();
for (il=li_elem.begin();il != ilfin;il++)
// on intervient que si le numéro de l'élément est supérieur à celui de l'élément de base
// et que ce n'est pas un élément déjà marqué à supprimé
if (((*il)->Num_elt() > ine )&&(elem_supprime((*il)->Num_elt()) == 0))
// on test si les deux éléments ont la même signature, même géométrie et appartiennent au même maillage
if (elem->Meme_signature_et_geometrie(*(*il))) // si égalité, on indique que l'élément il est à supprimer,
elem_supprime((*il)->Num_elt())=ine; // et on sauvegarde l'élément de substitution
};
// on sauvegarde les anciens numéros de noeuds, servira pour contruire nv_num
// normalement c'est directement iN mais on ne sait jamais
Tableau <int> ancien_num_ele(nbelem);
for (int ie=1;ie<=nbelem;ie++)
ancien_num_ele(ie) = tab_element(ie)->Num_elt();
// -- maintenant on va vraiment supprimer les éléments en double et mettre à jour les références
// 1- tout d'abord on s'intéresse aux éléments, dont on va mettre à jour les références
// 2- on supprime les éléments qui ne servent plus
int nb_elem_restant = nbelem; // init du nombre d'élément restant après fusion
Tableau <bool> non_referencer(nbelem,false); // un tableau intermédiaire qui servira pour les ref
for (int ine=1;ine<=nbelem;ine++)
{if (elem_supprime(ine)) // s'il est différent de 0, on doit supprimer
{ int num_nelem = elem_supprime(ine);
delete tab_element(ine); // on supprime l'élément
// -- debug
// cout << "\n Maillage::Collapse_element_superpose debug !! à remettre en service la ligne précédente "<<endl;
// -- fin debug
tab_element(ine)=NULL; // on indique qu'il n'y a plus d'élément
// non_referencer(ine)=true; // servira pour les ref
// *** modif 15 avril 2016: comme il s'agit d'éléments supperposés, cela veut dire qu'il reste un élément de substitution
// qui lui est valide donc on met false, ce qui veut dire que l'on ne veut pas supprimer l'élément dans la ref
// car sinon la ref devient différente et incomplète
non_referencer(ine)=false; // servira pour les ref
nb_elem_restant--; // on diminue le nombre d'éléments restants
if (ParaGlob::NiveauImpression() > 2)
cout << "\n collapse element " << ine << " --> " << num_nelem ;
////-- debug
//{cout << "\n debug ** Maillage::Collapse_element_superpose() ";
// Element * elem1 = tab_element(ine-1); // recup de l'element
// cout << " element " << elem1->Num_elt() << " ";
// elem1->Affiche();
//// Element * elem2 = tab_element(ine); // recup de l'element
//// cout << " element " << elem2->Num_elt() << " ";
//// elem2->Affiche();
// Element * elem3 = tab_element(ine+1); // recup de l'element
// cout << " element " << elem3->Num_elt() << " ";
// elem3->Affiche();
// cout << "\n"<<endl ;
// Sortie(1);
//
//};
////--fin debug
};
};
// maintenant on refait un nouveau tableau d'éléments avec les éléments inutiles supprimés
Tableau <Element* > tab_final(nb_elem_restant);
int nbelem_restant=0; // le nombre d'éléments restant
cout << "\n ";
for (int ijn = 1; ijn <= nbelem; ijn++)
{ if(tab_element(ijn)!=NULL)
{nbelem_restant++;
tab_final(nbelem_restant) = tab_element(ijn);
};
};
// // on redimentionne le tableau final (ses premiers restent !!)
// tab_final.Change_taille(nbn_restant);
if (ParaGlob::NiveauImpression() >= 0)
cout << "\n collapse of " << (nbelem-nbelem_restant) <<" element(s) " << endl;
// on met à jour les références
lesRef->SupprimeReference("E_tout",idmail); // on supprime la référence E_tout
Tableau <int> nv_num(nbelem,0); // nouveau num/ au ancien
for (int ia=1;ia <= nbelem_restant; ia++)
nv_num(tab_final(ia)->Num_elt()) = ia;
// *** modif 15 avril 2016: il faut tous les numéros de remplacement et pas seulement ceux
// qui restent car dans la mise à jour on commence par changer les numéros et "ensuite"
// on supprime les doublons --> donc on complète
// nv_num(num_ancien) = le nouveau numéro d'élément donc celui qui est en coincidence et qui reste
// a_fusionner(ancien_num_ele(ia)) -> le nouveau numéro dans l'ancien tableau
// qui aura comme nouveau numéro:nv_num(a_fusionner(ancien_num_ele(ia)))
for (int ia=1;ia <= nbelem; ia++)
if (nv_num(ia) == 0) // cela veut dire que c'est un numéro qui disparait
nv_num(ia) = nv_num(elem_supprime(ancien_num_ele(ia)));
// -- debug
// cout << "\n Maillage::Collapse_element_superpose debug "<<endl;
//lesRef->Affiche(); cout << endl;
// -- fin debug
lesRef->Mise_a_jour_ref_element(nv_num,idmail,non_referencer);
////-- debug
//{cout << "\n debug ** Maillage::Collapse_element_superpose() ";
// Element * elem1 = tab_final(152); // recup de l'element
// cout << " element " << elem1->Num_elt() << " ";
// elem1->Affiche();
//// Element * elem2 = tab_element(ine); // recup de l'element
//// cout << " element " << elem2->Num_elt() << " ";
//// elem2->Affiche();
// Element * elem3 = tab_final(153); // recup de l'element
// cout << " element " << elem3->Num_elt() << " ";
// elem3->Affiche();
// cout << "\n"<<endl ;
//
//};
//--fin debug
// on enregistre le nouveau tableau d'éléments
tab_element = tab_final;
// on met à jour les numéros d'éléments
for (int ia=1;ia <= nbelem_restant; ia++)
tab_element(ia)->Change_num_elt(ia);
// on recrée la référence E_tout
string Etout("E_tout");
{ // on construit le tableau des numéros de noeuds
Tableau <int> tabE(nbelem_restant); for (int i=1;i<=nbelem_restant;i++) tabE(i)=i;
ReferenceNE* rtout = new ReferenceNE(tabE,idmail,2,Etout);// construction de la référence
lesRef->Ajout_reference(rtout); // ajout de la ref, qui est maintenant géré par lesRef
};
////-- debug
//{cout << "\n debug ** Maillage::Collapse_element_superpose() ";
// Element * elem1 = tab_element(152); // recup de l'element
// cout << " element " << elem1->Num_elt() << " ";
// elem1->Affiche();
//// Element * elem2 = tab_element(ine); // recup de l'element
//// cout << " element " << elem2->Num_elt() << " ";
//// elem2->Affiche();
// Element * elem3 = tab_element(153); // recup de l'element
// cout << " element " << elem3->Num_elt() << " ";
// elem3->Affiche();
// cout << "\n"<<endl ;
//};
////--fin debug
////-- debug
//{cout << "\n debug ** Maillage::Collapse_element_superpose() ";
// int tail=tab_element.Taille();
// cout << "\n NBE= " << tail ;
// for (int ina = 1;ina <= tail;ina++)
// {Element * elem2 = tab_element(ina); // recup de l'element
// cout << " element " << elem2->Num_elt() << " ";
// elem2->Affiche();
// };
// cout << "\n"<<endl ;
// Sortie(1);
//};
//////--fin debug
};
// Lecture et collapse de noeuds très proche: appartenant à des éléments différents
void Maillage::LectureEtCollapse_noeuds_proches(UtilLecture * entreePrinc, LesReferences* lesRef)
{ if (strstr(entreePrinc->tablcar,"fusion_noeuds_proches_")!=NULL)
{ if (ParaGlob::NiveauImpression() > 2) cout << "\n beginning of the process to collapse nodes which are "
<< " nearly at the same position "<< endl ;
// on lit la distance mini
double rayon = 0;string nom;
*(entreePrinc->entree) >> nom >> rayon;
if (nom != "fusion_noeuds_proches_")
{ cout << "\n error : we expected the keyword: fusion_noeuds_proches_ but we read \""<<nom<<"\" ";
if (ParaGlob::NiveauImpression() >= 6)
cout << "\n Maillage::LectureEtCollapse_noeuds_proches(...";
Sortie(1);
};
if (ParaGlob::NiveauImpression() >= 5)
cout << "\n minimum distance = " << rayon;
entreePrinc->NouvelleDonnee(); // on passe le mot clé
// appel de l'algo de collapse
Collapse_noeuds_proches(rayon,lesRef);
if (ParaGlob::NiveauImpression() > 2) cout << "\n end of the process to collapse nodes which are "
<< " nearly at the same position "<< endl ;
};
};
// collapse de noeuds très proche: appartenant à des éléments différents
// rayon : donne la distance maxi entre les noeuds qui doivent être collapsé
void Maillage::Collapse_noeuds_proches(double rayon ,LesReferences* lesRef)
{// au niveau de l'algo on va commencer par faire un classement des noeuds pour accélérer les recherches futures
// pour cela on découpe le volume de travail en boites contenant un petit nombre de noeuds
// et on s'aide de grandeurs de référence
int NBN = tab_noeud.Taille();
int dim = ParaGlob::Dimension();
if (ParaGlob::NiveauImpression() >= 0)
cout << "\n " << NBN << " node(s) " << tab_element.Taille() << " element(s) " ;
// racine3NBN donne une idée du nombre de noeuds dans chaque direction de la dimension
int racine3NBN = (int) (exp(1./dim * log(NBN) )); // floor: extraction de la partie entière
// on veut environ 3*3*3=27 noeuds par boites en 3D par exemple
// en fait les tests on montré que c'était mieux d'avoir plus de boite, donc on ne divise pas par 3
int nb_decoupe = racine3NBN ; // 3;// on pourrait donc avoir nb_decoupe**dim cubes
// mais il faut également que la taille du cube de base soit plus grande que le rayon
// maintenant on détermine les dimensions max et min qui contiennent tous les noeuds
Tableau <Vecteur> ta_d = Taille_boiteMail();
Tableau <int> nbboite(dim); int nb_totale=1;
// on va calculer les paramètres de stockage et de calculs
Coordonnee pas_en_espace(dim); // les pas d'espace dans les différentes directions
for (int i=1;i<=dim;i++)
{double distance = ta_d(2)(i)-ta_d(1)(i);
// en générale le rayon est très petit, donc on va considérer des arêtes de boites > 5 * rayons
int nb_mini = (int)(distance / (rayon*5.));
// si nb_mini est négatif cela veut dire que l'on a dépasser la précision et que
// le nombre est trop grand on le met également à 1
if ((nb_mini == 0)
|| (nb_mini < 0)
)
nb_mini=1; // au minimum on doit avoir 1
nbboite(i) = MiN(nb_mini,nb_decoupe); // on stocke le nombre de boite dans la direction i
pas_en_espace(i) = distance / nbboite(i) + ConstMath::petit; // on stocke le pas d'espace dans la direction i
// on a ajouté un chouil pour être sur que le point le plus grand soit calculé dans les boites existantes
nb_totale *= nbboite(i); // on stocke le nombre maxi de boite
};
if (ParaGlob::NiveauImpression() >= 5)
{cout <<"\n nbboite(i)= ";for (int i=1;i<=dim;i++) cout << nbboite(i);
cout <<endl;}
// on définit des boites = listes de noeuds, qui vont nous permettre ensuite de trier rapidemment
// tout d'abord chaque noeud est associé à une boite = un élément de tab_Boite
Tableau <list <int> > tab_Boite(nb_totale); // dimensionnement des listes de noeuds principale
// pour chaque noeud de la liste , il faudra considérer tous les noeuds des boites qui l'entourent
// on comparera ce noeud avec ceux des 3 ou 9 ou 27 boites (suivant la dimension) qui entourent la boite du noeud
// étant donné que la taille de la boite est au moins plus grande que le rayon de recherche, normalement c'est ok
Tableau <list <int> > tab_BS(NBN); // les listes des numéros de boites qui seront associées à la recherche
// défini le décalage que l'on doit avoir pour le calcul des indices
Coordonnee M_ref(dim);
switch (dim)
{case 3: M_ref(3) = ta_d(1)(3);
case 2: M_ref(2) = ta_d(1)(2);
case 1: M_ref(1) = ta_d(1)(1);
};
// maintenant on va remplir les boites = listes de noeuds
for (int iN=1;iN<=NBN;iN++)
{ Noeud& no = *(tab_noeud(iN)); // pour simplifier
const Coordonnee& M0 =no.Coord0();
int indica=0; // indice de la boite
// soit i j k les indices suivants x y et z, et N1 N2 N3 les maxis de stockage suivants x y z
// le noeud est stocké dans (k-1)*N1*N2 + (j-1)*N1 + i
// - calcul de l'indice de stockage
int nb1,nb2,nb3; // les indices suivant x y z
switch (dim)
{case 3:
{nb3= ((int) ((M0(3)-M_ref(3))/pas_en_espace(3))); // le numéro -1, suivant 3
indica += nb3 * nbboite(3) * nbboite(2);
}
case 2:
{nb2= ((int) ((M0(2)-M_ref(2))/pas_en_espace(2))); // le numéro -1, suivant 2
indica += nb2 * nbboite(2);
}
case 1:
{nb1= ((int) ((M0(1)-M_ref(1))/pas_en_espace(1))); // le numéro -1, suivant 1
indica += nb1 + 1 ;
}
};
//debug
// if ((nb1 > nbboite(1)) || (nb2 > nbboite(2)) || (nb3 > nbboite(3)))
// cout << "\n nb1= "<<nb1 <<" nb2= "<<nb2 <<" nb3= "<<nb3 << endl;
//fin debug
// stockage du noeud dans la bonne boite
tab_Boite(indica).push_back(no.Num_noeud());
// def des boites qui seront associées à la recherche
list <int>& li_BS = tab_BS(no.Num_noeud()); // pour simplifier
li_BS.push_back(indica); // la boite centrale
//if (indica > nb_totale)
// cout <<"\n indica="<<indica << endl;
switch (dim)
{case 3:
{// d'abord les 8 boites du centre en plus du centre centre centre déjà entrée
int nb3_12 = nb3 * nbboite(3) * nbboite(2);
if(nb1+1 < nbboite(1)){li_BS.push_back(nb3_12+ nb2 * nbboite(2)+nb1+2);
//if (nb3_12+ nb2 * nbboite(2)+nb1+2 > nb_totale)
// cout <<"\n nb3_12+ nb2 * nbboite(2)+nb1+2="<<nb3_12+ nb2 * nbboite(2)+nb1+2<< endl;
};
if(nb1 > 0) {li_BS.push_back(nb3_12+ nb2 * nbboite(2)+nb1);
//if (nb3_12+ nb2 * nbboite(2)+nb1 > nb_totale)
// cout <<"\n nb3_12+ nb2 * nbboite(2)+nb1="<<nb3_12+ nb2 * nbboite(2)+nb1<< endl;
};
if(nb2+1 < nbboite(2))
{li_BS.push_back(nb3_12+(nb2+1) * nbboite(2)+nb1+1);
//if (nb3_12+(nb2+1) * nbboite(2)+nb1+1 > nb_totale)
// cout <<"\n nb3_12+(nb2+1) * nbboite(2)+nb1+1="<<nb3_12+(nb2+1) * nbboite(2)+nb1+1<< endl;
if(nb1+1 < nbboite(1)){li_BS.push_back(nb3_12+(nb2+1) * nbboite(2)+nb1+2);
//if (nb3_12+(nb2+1) * nbboite(2)+nb1+2 > nb_totale)
// cout <<"\n nb3_12+(nb2+1) * nbboite(2)+nb1+2="<<nb3_12+(nb2+1) * nbboite(2)+nb1+2<< endl;
};
if(nb1 > 0) {li_BS.push_back(nb3_12+(nb2+1) * nbboite(2)+nb1);
//if (nb3_12+(nb2+1) * nbboite(2)+nb1 > nb_totale)
// cout <<"\n nb3_12+(nb2+1) * nbboite(2)+nb1="<<nb3_12+(nb2+1) * nbboite(2)+nb1<< endl;
};
};
if(nb2 > 0)
{li_BS.push_back(nb3_12+(nb2-1) * nbboite(2)+nb1+1);
//if (nb3_12+(nb2-1) * nbboite(2)+nb1+1 > nb_totale)
// cout <<"\n nb3_12+(nb2-1) * nbboite(2)+nb1+1="<<nb3_12+(nb2-1) * nbboite(2)+nb1+1<< endl;
if(nb1+1 < nbboite(1)){li_BS.push_back(nb3_12+(nb2-1) * nbboite(2)+nb1+2);
//if (nb3_12+(nb2-1) * nbboite(2)+nb1+2 > nb_totale)
// cout <<"\n nb3_12+(nb2-1) * nbboite(2)+nb1+2="<<nb3_12+(nb2-1) * nbboite(2)+nb1+2<< endl;
};
if(nb1 > 0) {li_BS.push_back(nb3_12+(nb2-1) * nbboite(2)+nb1);
//if (nb3_12+(nb2-1) * nbboite(2)+nb1 > nb_totale)
// cout <<"\n nb3_12+(nb2-1) * nbboite(2)+nb1="<<nb3_12+(nb2-1) * nbboite(2)+nb1<< endl;
};
};
// les 9 au dessus dans la direction z
if(nb3+1 < nbboite(3))
{int nb3_p1_12=(nb3+1) * nbboite(3) * nbboite(2);
li_BS.push_back(nb3_p1_12+nb2 * nbboite(2)+nb1+1);
//if (nb3_p1_12+nb2 * nbboite(2)+nb1+1 > nb_totale)
// cout <<"\n nb3_p1_12+nb2 * nbboite(2)+nb1+1="<<nb3_p1_12+nb2 * nbboite(2)+nb1+1
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
if(nb1+1 < nbboite(1)){li_BS.push_back(nb3_p1_12+ nb2 * nbboite(2)+nb1+2);
//if (nb3_p1_12+ nb2 * nbboite(2)+nb1+2 > nb_totale)
// cout <<"\n nb3_p1_12+ nb2 * nbboite(2)+nb1+2="<<nb3_p1_12+ nb2 * nbboite(2)+nb1+2
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
};
if(nb1 > 0) {li_BS.push_back(nb3_p1_12+ nb2 * nbboite(2)+nb1);
//if (nb3_p1_12+ nb2 * nbboite(2)+nb1 > nb_totale)
// cout <<"\n nb3_p1_12+ nb2 * nbboite(2)+nb1="<<nb3_p1_12+ nb2 * nbboite(2)+nb1
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
};
if(nb2+1 < nbboite(2))
{li_BS.push_back(nb3_p1_12+(nb2+1) * nbboite(2)+nb1+1);
//if (nb3_p1_12+(nb2+1) * nbboite(2)+nb1+1 > nb_totale)
// cout <<"\n nb3_p1_12+(nb2+1) * nbboite(2)+nb1+1="<<nb3_p1_12+(nb2+1) * nbboite(2)+nb1+1
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
if(nb1+1 < nbboite(1)){li_BS.push_back(nb3_p1_12+(nb2+1) * nbboite(2)+nb1+2);
//if (nb3_p1_12+(nb2+1) * nbboite(2)+nb1+2 > nb_totale)
// cout <<"\n nb3_p1_12+(nb2+1) * nbboite(2)+nb1+2="<<nb3_p1_12+(nb2+1) * nbboite(2)+nb1+2
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
};
if(nb1 > 0) {li_BS.push_back(nb3_p1_12+(nb2+1) * nbboite(2)+nb1);
//if (nb3_p1_12+(nb2+1) * nbboite(2)+nb1 > nb_totale)
// cout <<"\n nb3_p1_12+(nb2+1) * nbboite(2)+nb1="<<nb3_p1_12+(nb2+1) * nbboite(2)+nb1
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
};
};
if(nb2 > 0)
{li_BS.push_back(nb3_p1_12+(nb2-1) * nbboite(2)+nb1+1);
//if (nb3_p1_12+(nb2-1) * nbboite(2)+nb1+1 > nb_totale)
// cout <<"\n nb3_p1_12+(nb2-1) * nbboite(2)+nb1+1="<<nb3_p1_12+(nb2-1) * nbboite(2)+nb1+1
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
if(nb1+1 < nbboite(1)){li_BS.push_back(nb3_p1_12+(nb2-1) * nbboite(2)+nb1+2);
//if (nb3_p1_12+(nb2-1) * nbboite(2)+nb1+2 > nb_totale)
// cout <<"\n nb3_p1_12+(nb2-1) * nbboite(2)+nb1+2="<<nb3_p1_12+(nb2-1) * nbboite(2)+nb1+2
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
};
if(nb1 > 0) {li_BS.push_back(nb3_p1_12+(nb2-1) * nbboite(2)+nb1);
//if (nb3_p1_12+(nb2-1) * nbboite(2)+nb1 > nb_totale)
// cout <<"\n nb3_p1_12+(nb2-1) * nbboite(2)+nb1="<<nb3_p1_12+(nb2-1) * nbboite(2)+nb1
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
};
};
};
// les 9 au dessus dans la direction z
if(nb3 > 0)
{int nb3_m1_12=(nb3-1) * nbboite(3) * nbboite(2);
li_BS.push_back(nb3_m1_12+nb2 * nbboite(2)+nb1+1);
//if (nb3_m1_12+nb2 * nbboite(2)+nb1+1 > nb_totale)
// cout <<"\n nb3_m1_12+nb2 * nbboite(2)+nb1+1="<<nb3_m1_12+nb2 * nbboite(2)+nb1+1
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
if(nb1+1 < nbboite(1)){li_BS.push_back(nb3_m1_12+ nb2 * nbboite(2)+nb1+2);
//if (nb3_m1_12+ nb2 * nbboite(2)+nb1+2 > nb_totale)
// cout <<"\n nb3_m1_12+ nb2 * nbboite(2)+nb1+2="<<nb3_m1_12+ nb2 * nbboite(2)+nb1+2
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
};
if(nb1 > 0) {li_BS.push_back(nb3_m1_12+ nb2 * nbboite(2)+nb1);
//if (nb3_m1_12+ nb2 * nbboite(2)+nb1 > nb_totale)
// cout <<"\n nb3_m1_12+ nb2 * nbboite(2)+nb1="<<nb3_m1_12+ nb2 * nbboite(2)+nb1
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
};
if(nb2+1 < nbboite(2))
{li_BS.push_back(nb3_m1_12+(nb2+1) * nbboite(2)+nb1+1);
//if (nb3_m1_12+(nb2+1) * nbboite(2)+nb1+1 > nb_totale)
// cout <<"\n nb3_m1_12+(nb2+1) * nbboite(2)+nb1+1="<<nb3_m1_12+(nb2+1) * nbboite(2)+nb1+1
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
if(nb1+1 < nbboite(1)){li_BS.push_back(nb3_m1_12+(nb2+1) * nbboite(2)+nb1+2);
//if (nb3_m1_12+(nb2+1) * nbboite(2)+nb1+2 > nb_totale)
// cout <<"\n nb3_m1_12+(nb2+1) * nbboite(2)+nb1+2="<<nb3_m1_12+(nb2+1) * nbboite(2)+nb1+2
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
};
if(nb1 > 0) {li_BS.push_back(nb3_m1_12+(nb2+1) * nbboite(2)+nb1);
//if (nb3_m1_12+(nb2+1) * nbboite(2)+nb1 > nb_totale)
// cout <<"\n nb3_m1_12+(nb2+1) * nbboite(2)+nb1="<<nb3_m1_12+(nb2+1) * nbboite(2)+nb1
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
};
};
if(nb2 > 0)
{li_BS.push_back(nb3_m1_12+(nb2-1) * nbboite(2)+nb1+1);
//if (nb3_m1_12+(nb2-1) * nbboite(2)+nb1+1 > nb_totale)
// cout <<"\n nb3_m1_12+(nb2-1) * nbboite(2)+nb1+1="<<nb3_m1_12+(nb2-1) * nbboite(2)+nb1+1
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
if(nb1+1 < nbboite(1)){li_BS.push_back(nb3_m1_12+(nb2-1) * nbboite(2)+nb1+2);
//if (nb3_m1_12+(nb2-1) * nbboite(2)+nb1+2 > nb_totale)
// cout <<"\n nb3_m1_12+(nb2-1) * nbboite(2)+nb1+2="<<nb3_m1_12+(nb2-1) * nbboite(2)+nb1+2
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
};
if(nb1 > 0) {li_BS.push_back(nb3_m1_12+(nb2-1) * nbboite(2)+nb1);
//if (nb3_m1_12+(nb2-1) * nbboite(2)+nb1 > nb_totale)
// cout <<"\n nb3_m1_12+(nb2-1) * nbboite(2)+nb1="<<nb3_m1_12+(nb2-1) * nbboite(2)+nb1
// <<" nb3="<<nb3<<" nb2="<<nb2<<" nb1="<<nb1 << endl;
};
};
};
break;
}
case 2: // cas 2D, on a 9 boites à considérer, sauf si l'on est dans les extrèmes
{if(nb1+1 < nbboite(1)){li_BS.push_back((nb2) * nbboite(2)+nb1+2);};
if(nb1 > 0) {li_BS.push_back((nb2) * nbboite(2)+nb1);};
if(nb2+1 < nbboite(2))
{li_BS.push_back((nb2+1) * nbboite(2)+nb1+1);
if(nb1+1 < nbboite(1)){li_BS.push_back((nb2+1) * nbboite(2)+nb1+2);};
if(nb1 > 0) {li_BS.push_back((nb2+1) * nbboite(2)+nb1);};
};
if(nb2 > 0)
{li_BS.push_back((nb2-1) * nbboite(2)+nb1+1);
if(nb1+1 < nbboite(1)){li_BS.push_back((nb2-1) * nbboite(2)+nb1+2);};
if(nb1 > 0) {li_BS.push_back((nb2-1) * nbboite(2)+nb1);};
};
break;
}
case 1: // cas 1D, on a 3 boites à considérer, sauf si l'on est dans les extrèmes
{if(nb1+1 < nbboite(1)) {li_BS.push_back(indica+1);};
if(nb1 > 0) {li_BS.push_back(indica-1);};
}
break;
};
};
// on effectue maintenant la fusion des noeuds en s'aidant des boites pour diminuer la recherche
Tableau <int> a_fusionner(NBN,0); // tableau d'indicateurs de noeuds a fusionner
for (int ib = 1; ib<=nb_totale;ib++)
{// on parcours les boites: ib: le numéro de la boite courante
list <int>::iterator il,ilfin=tab_Boite(ib).end();
for (il=tab_Boite(ib).begin();il != ilfin; il++)
{// on parcours tous les noeuds le la boite: (*il) est le numéro du noeud courant
// on ne continue que si le noeud n'a pas été déclaré fusionable par ailleurs
if (!a_fusionner(*il))
{list <int>::iterator im,imfin=tab_BS((*il)).end(); // tab_BS = une liste de numéro de boite
for (im = tab_BS((*il)).begin();im != imfin; im++) // *im c'est un numéro de boite
{
if ((*im)>nb_totale) cout << " *il="<<(*il)<<" *im="<<(*im)<<endl;//" tab_BS.size()="<<tab_BS(*il).size();
list <int>::iterator ip,ipfin=tab_Boite(*im).end(); // *ip sera un numéro de noeud
for (ip = tab_Boite(*im).begin();ip != ipfin; ip++)
// on parcours tous les noeuds à considérer
if ((!(a_fusionner(*ip)))&&((*il)!=(*ip))) // on examine que si le noeud ne sera fusionné
if ((tab_noeud(*il)->Coord0()-tab_noeud(*ip)->Coord0()).Norme() < rayon)
{ a_fusionner(*ip)=*il; // on enregistre
if (ParaGlob::NiveauImpression()>3)
cout << "\n detail du processus de collapse de noeud proche Maillage::Collapse_noeuds_proches( "
<< "\n rayon= " << rayon << " noe_afusionner ip: " << (*ip)
<< " noeud identique il: " << *il
<< "\n coor ip: " << tab_noeud(*ip)->Coord0()
<< "\n coor il: " << tab_noeud(*il)->Coord0() << endl;
};
};
};
};
};
// création pour chaque noeud de la liste des éléments qui contiennent le noeud
Calcul_indice();
// on passe en revue les noeuds et on regarde si la fusion est possible
// elle est impossible si deux noeuds a fusionner appartiennent à un même élément
// dans ce cas on désactive l'indicateur de fusion
for (int ine=1;ine<=NBN;ine++)
{if (a_fusionner(ine)) // s'il est différent de 0, indique que ine peut-être fusionné
{// on regarde si les deux noeuds : ine et a_fusionner(ine) n'appartiennent pas à un même élément
List_io < Element*>& indic = indice(ine); // pour simplifier
List_io < Element*>::iterator ie,iefin=indic.end();
bool fusion_non_possible = false; // init par défaut
int num_maitre = a_fusionner(ine);
for (ie=indic.begin();ie!=iefin;ie++)
{ Element& ele = *(*ie); // récup d'un élément qui contient a priori le numéro ine
Tableau<Noeud *>& tn = ele.Tab_noeud(); // récup des noeuds de l'élément
// maintenant on regarde si l'élément contient également le a_fusionner(ine)
int taille_tn=tn.Taille();
for (int j=1;j<=taille_tn;j++)
if (tn(j)->Num_noeud() == num_maitre)
{fusion_non_possible=true;
break;// on sort de la première boucle sur les noeuds de l'élément
};
if (fusion_non_possible)
break; // on sort de la seconde boucle sur les éléments contenant le noeud
};
//
if (fusion_non_possible) // cas où la fusion n'est pas possible
{a_fusionner(ine)=0;};
};
};
// on sauvegarde les anciens numéros de noeuds, servira pour contruire nv_num
// normalement c'est directement iN mais on ne sait jamais
Tableau <int> ancien_num_Noe(NBN);
for (int iN=1;iN<=NBN;iN++)
ancien_num_Noe(iN) = tab_noeud(iN)->Num_noeud();
// -- maintenant on va vraiment fusionner et mettre à jour les références
// 1- tout d'abord on s'intéresse aux éléments, dont on va mettre à jour les références
// 2- on supprime les noeuds qui ne servent plus
int nb_noeud_restant = NBN; // init du nombre de noeud restant après fusion
Tableau <bool> non_referencer(NBN,false); // un tableau intermédiaire qui servira pour les ref
for (int ine=1;ine<=NBN;ine++)
{if (a_fusionner(ine)) // s'il est différent de 0, on doit fusionner
{ int num_ne = a_fusionner(ine);
//cout << "\n ine= "<<ine<<" num_ne="<<num_ne<<endl;
// on va balayer uniquement les éléments qui contiennent le noeud a fusionner
List_io < Element*>& indic = indice(ine); // pour simplifier
List_io < Element*>::iterator ie,iefin=indic.end();
for (ie=indic.begin();ie!=iefin;ie++)
{ Element& ele = *(*ie); // récup de l'élément qui contient ine
Tableau<Noeud *>& tn = ele.Tab_noeud(); // récup des noeuds de l'élément
int taille_tn=tn.Taille();
for (int j=1;j<=taille_tn;j++)
if (tn(j)->Num_noeud() == ine)
{ele.Change_noeud(j,tab_noeud(num_ne)); // on change la connexion
if (tab_noeud(num_ne) == NULL)
cout << "\n*** le noeud num_ne=" <<num_ne << " est nulle !" << endl;
};
};
// on reporte le tableau de ddl de l'élément à supprimer sur celui qui reste
tab_noeud(num_ne)->PlusTabDdl(*tab_noeud(ine));
// maintenant il n'y a plus d'élément qui utilise le noeud ine donc on le supprime
delete tab_noeud(ine); // on supprime le noeud
tab_noeud(ine)=NULL; // on indique qu'il n'y a plus de noeud
// non_referencer(ine)=true; // servira pour les ref
// *** modif 15 avril 2016: comme il s'agit de noeuds supperposés, cela veut dire qu'il reste un noeud de substitution
// qui lui est valide donc on met false, ce qui veut dire que l'on ne veut pas supprimer le noeud dans la ref
// car sinon la ref devient différente et incomplète
non_referencer(ine)=false; // servira pour les ref
nb_noeud_restant--; // on diminue le nombre de noeuds restants
if (ParaGlob::NiveauImpression() > 2)
cout << "\n collapse node " << ine << " --> "<<num_ne ;
};
};
// maintenant on refait un nouveau tableau de noeud avec les noeuds inutiles supprimés
Tableau <Noeud* > tab_final(nb_noeud_restant);
int nbn_restant=0; // le nombre de noeud restant
cout << "\n ";
for (int ijn = 1; ijn <= NBN; ijn++)
{ if(tab_noeud(ijn)!=NULL)
{nbn_restant++;
tab_final(nbn_restant) = tab_noeud(ijn);
};
};
// // on redimentionne le tableau final (ses premiers restent !!)
// tab_final.Change_taille(nbn_restant);
if (ParaGlob::NiveauImpression() >= 0)
cout << "\n collapse of " << (NBN-nbn_restant) <<" node(s) " << endl;
// on met à jour les références
lesRef->SupprimeReference("N_tout",idmail); // on supprime la référence N_tout
Tableau <int> nv_num(NBN,0); // nouveau num/ au ancien, initialisé à 0
for (int ia=1;ia <= nbn_restant; ia++)
nv_num(tab_final(ia)->Num_noeud()) = ia;
// *** modif 15 avril 2016: il faut tous les numéros de remplacement et pas seulement ceux
// qui restent car dans la mise à jour on commence par changer les numéros et "ensuite"
// on supprime les doublons --> donc on complète
// nv_num(num_ancien) = le nouveau numéro de noeud donc celui qui est en coincidence et qui reste
// a_fusionner(ancien_num_Noe(ia)) -> le nouveau numéro dans l'ancien tableau
// qui aura comme nouveau numéro:nv_num(a_fusionner(ancien_num_Noe(ia)))
for (int ia=1;ia <= NBN; ia++)
if (nv_num(ia) == 0) // cela veut dire que c'est un numéro qui disparait
nv_num(ia) = nv_num(a_fusionner(ancien_num_Noe(ia)));
lesRef->Mise_a_jour_ref_noeud(nv_num,idmail,non_referencer);
// on enregistre le nouveau tableau de noeuds
tab_noeud = tab_final;
// on met à jour les numéros de noeuds
for (int ia=1;ia <= nbn_restant; ia++)
tab_noeud(ia)->Change_num_noeud(ia);
// on recrée la référence N_tout
string ntout("N_tout");
{ // on construit le tableau des numéros de noeuds
Tableau <int> tabN(nbn_restant); for (int i=1;i<=nbn_restant;i++) tabN(i)=i;
ReferenceNE* rtout = new ReferenceNE(tabN,idmail,1,ntout);// construction de la référence
lesRef->Ajout_reference(rtout); // ajout de la ref, qui est maintenant géré par lesRef
};
};
// Lecture et suppression d'elements à 2 noeuds, de distances très proches
void Maillage::LectureEtSup_Elem_noeudsConfondu(UtilLecture * entreePrinc, LesReferences* lesRef)
{ if (strstr(entreePrinc->tablcar,"suppression_elements_2noeuds_tres_proches_")!=NULL)
{ if (ParaGlob::NiveauImpression() > 2) cout << "\n beginning of the process to collapse element with two nodes which are "
<< " nearly at the same position "<< endl ;
// on lit la distance mini
double rayon = 0;string nom;
*(entreePrinc->entree) >> nom >> rayon;
if (nom != "suppression_elements_2noeuds_tres_proches_")
{ cout << "\n error : we expected the keyword: suppression_elements_2noeuds_tres_proches_ but we read \""<<nom<<"\" ";
if (ParaGlob::NiveauImpression() >= 6)
cout << "\n Maillage::LectureEtSup_Elem_noeudsConfondu(...";
Sortie(1);
};
if (ParaGlob::NiveauImpression() >= 5)
cout << "\n minimum distance = " << rayon;
entreePrinc->NouvelleDonnee(); // on passe le mot clé
// appel de l'algo de suppression
Sup_Elem_noeudsConfondu(rayon,lesRef);
if (ParaGlob::NiveauImpression() > 2) cout << "\n end of the process to collapse element with two nodes which are "
<< " nearly at the same position "<< endl ;
};
};
// suppression d'elements à 2 noeuds, de distances très proches
// rayon : donne la distance maxi entre les noeuds
void Maillage::Sup_Elem_noeudsConfondu(double rayon, LesReferences* lesRef)
{ // on crée un tableau d'indicateur des éléments à supprimer
int nbelem = tab_element.Taille();
Tableau <int> elem_supprime(nbelem,0);
// on calcul les frontières et les mitoyens de tous les éléments
Calcul_tous_les_front_et_leurs_mitoyens();
// on balaie les éléments
for (int ine = 1;ine <= nbelem;ine++)
// on ne continue que si c'est un élément qui n'a pas déjà été marqué " à supprimé "
if (elem_supprime(ine) == 0)
{Element * elem = tab_element(ine);
// on ne continue que si c'est un éléments à 2 noeuds
if (elem->Nombre_noeud() == 2)
{ // on récupère les deux noeuds
Noeud * noe1 = tab_element(ine)->Tab_noeud()(1);
Noeud * noe2 = tab_element(ine)->Tab_noeud()(2);
// on calcule la distance entre les deux noeuds
if ((noe1->Coord0()-noe2->Coord0()).Norme() < rayon)
elem_supprime(ine)=1; // on enregistre la suppression
}
else if (elem->Nombre_noeud() == 3)
{ // un élément à 3 noeuds peut également être supprimable, mais
// pour l'instant il faut qu'il ne soit relié qu'à des éléments également à 3 ou 2 noeuds
// .. on itère sur les cotés tout d'abord pour s'assurer que les mitoyens ont au plus 3 ou 2
// noeuds: car si on a un mitoyen à 4 noeuds par exemple, il faut le convertir en
// un élément à 3 noeud, c'est possible mais pas directement dans la version actuelle
bool continou = true; // init
// pour chaque élément "i" , mitoyen_de_chaque_element(i)(j) contient l'élément Front
// qui décrit la frontière "j" de l'élément et dedans, les éléments mitoyens de cette frontière
// appartenant à d'autres éléments
for (int i=0;i<3;i++)
{Front& fron = mitoyen_de_chaque_element(ine)(i+1);
const Tableau <Front*>* t_mitoy = fron.TabMitoyen();
if (t_mitoy != NULL)
{int taille = t_mitoy->Taille();
for (int j=1;j<= taille; j++)
{ if( (*t_mitoy)(j)->PtEI()->Nombre_noeud()>3)
{continou = false; break;}; // pas bon on arrête
};
}
if (!continou) break; // arrêt car mitoyen avec plus de 3 noeuds
};
// Maintenant on regarde la distance entre les noeuds de chaque frontière
// pour l'instant ne fonctionne que pour des frontières à 2 noeuds
if (continou)
for (int i=0;i<3;i++)
{ Front& fron = mitoyen_de_chaque_element(ine)(i+1);
// on ne continue que s'il s'agit d'un élément frontière à 2 noeuds
const Tableau <Noeud *>& tlocNoe = fron.Eleme()->TabNoeud();
if (tlocNoe.Taille() == 2)
{ // on récupère les deux noeuds de l'arête
Noeud * noe1 = tlocNoe(1);
Noeud * noe2 = tlocNoe(2);
// on calcule la distance entre les deux noeuds
if ((noe1->Coord0()-noe2->Coord0()).Norme() < rayon)
{elem_supprime(ine)=1; // on enregistre la suppression
// on doit également suppimer les éléments mitoyens
const Tableau <Front*>* t_mitoy = fron.TabMitoyen();
if (t_mitoy != NULL)
{ int tail = t_mitoy->Taille();
for (int a=1;a<=tail;a++)
{Front* fr = (*t_mitoy)(a);
elem_supprime(fr->PtEI()->Num_elt())=1;
};
};
};
};
};
};
};
// -- maintenant on va vraiment supprimer les éléments et mettre à jour les références
// 1- tout d'abord on s'intéresse aux éléments, dont on va mettre à jour les références
// 2- on supprime les éléments qui ne servent plus
int nb_elem_restant = nbelem; // init du nombre d'élément restant après suppression
Tableau <bool> non_referencer(nbelem,false); // un tableau intermédiaire qui servira pour les ref
for (int ine=1;ine<=nbelem;ine++)
{if (elem_supprime(ine)) // s'il est différent de 0, on doit supprimer
{ //int num_nelem = elem_supprime(ine); // ne sert à rien ici, j'ai repris l'algo Collapse_noeuds_proches
delete tab_element(ine); // on supprime l'élément
tab_element(ine)=NULL; // on indique qu'il n'y a plus d'élément
non_referencer(ine)=true; // servira pour les ref
nb_elem_restant--; // on diminue le nombre d'éléments restants
if (ParaGlob::NiveauImpression() > 2)
cout << "\n delete element " << ine << " <-- " ;
};
};
// maintenant on refait un nouveau tableau d'éléments avec les éléments inutiles supprimés
Tableau <Element* > tab_final(nb_elem_restant);
int nbelem_restant=0; // le nombre d'éléments restant
cout << "\n ";
for (int ijn = 1; ijn <= nbelem; ijn++)
{ if(tab_element(ijn)!=NULL)
{nbelem_restant++;
tab_final(nbelem_restant) = tab_element(ijn);
};
};
// // on redimentionne le tableau final (ses premières entitées restent !!)
// tab_final.Change_taille(nbn_restant);
if (ParaGlob::NiveauImpression() >= 0)
cout << "\n delete of " << (nbelem-nbelem_restant) <<" element(s) " << endl;
// on met à jour les références
lesRef->SupprimeReference("E_tout",idmail); // on supprime la référence E_tout
Tableau <int> nv_num(nbelem,0); // nouveau num/ au ancien
for (int ia=1;ia <= nbelem_restant; ia++)
nv_num(tab_final(ia)->Num_elt()) = ia;
lesRef->Mise_a_jour_ref_element(nv_num,idmail,non_referencer);
// on enregistre le nouveau tableau d'éléments
tab_element = tab_final;
// on met à jour les numéros d'éléments
for (int ia=1;ia <= nbelem_restant; ia++)
tab_element(ia)->Change_num_elt(ia);
// on recrée la référence E_tout
string Etout("E_tout");
{ // on construit le tableau des numéros de noeuds
Tableau <int> tabE(nbelem_restant); for (int i=1;i<=nbelem_restant;i++) tabE(i)=i;
ReferenceNE* rtout = new ReferenceNE(tabE,idmail,2,Etout);// construction de la référence
lesRef->Ajout_reference(rtout); // ajout de la ref, qui est maintenant géré par lesRef
};
};
// création d'éléments SFE en fonction d'éléments classiques
void Maillage::CreationMaillageSFE()
{ // une première étape est de vérifier que tous les éléments sont des triangles, sinon
// arrêt et message d'incompétance
if (!OKPourTransSfe())
{ cout << "\n error*** the mesh " << idmail << " ( " << nomDuMaillage << " ) "
<< " does not contain only triangular elements, currently "
<< " the continuation of the processing is not possible ! --> stop ";
return;
};
// sinon c'est ok, on n'a que des éléments triangulaires
// -- on demande le choix d'éléments
bool bonne_lecture=false;Enum_interpol enuSfe=SFE1;
while (!bonne_lecture)
{ cout << "\n give the type of SFE element you want: "
<< "\n SFE1 (resp 1) SFE1_3D (resp 11) "
<< "\n SFE2 (resp 2) SFE2_3D (resp 12) "
<< "\n SFE3 (resp 3) SFE3_3D (resp 13) "
<< "\n SFE3C (resp 4) SFE3C_3D (resp 14) "
<< "\n QSFE1 (resp 5) QSFE3 (resp 6) ";
string rep; rep = lect_chaine();
if (rep == "1") {enuSfe = SFE1; bonne_lecture=true;}
else if (rep == "2") {enuSfe = SFE2; bonne_lecture=true;}
else if (rep == "3") {enuSfe = SFE3; bonne_lecture=true;}
else if (rep == "4") {enuSfe = SFE3C; bonne_lecture=true;}
else if (rep == "5") {enuSfe = QSFE1; bonne_lecture=true;}
else if (rep == "6") {enuSfe = QSFE3; bonne_lecture=true;}
else if (rep == "11") {enuSfe = SFE1_3D; bonne_lecture=true;}
else if (rep == "12") {enuSfe = SFE2_3D; bonne_lecture=true;}
else if (rep == "13") {enuSfe = SFE3_3D; bonne_lecture=true;}
else if (rep == "14") {enuSfe = SFE3C_3D; bonne_lecture=true;}
else { cout << "\n bad answer, we have read : " << rep << "! try again ";};
};
cout << "\n choice read : " << Nom_interpol(enuSfe);
// On va créer des éléments en plus que ceux qui existent déjà, puis on supprimera ceux qui
// existent, et on les remplacera par ceux que l'on vient de créer
int tabelTaille = tab_element.Taille();
Tableau< Tableau <Noeud *> > t_noe_ele(tabelTaille); // les noeuds des SFE
// on commence par remplir t_noe_ele en considérant qu'il n'y a pas de mitoyen
int nbe_C = 3; // init: nb de noeud centraux
if ((enuSfe == QSFE3) || (enuSfe == QSFE1))
nbe_C = 6; // interpolation quadratique au centre
for (int i4 = 1; i4 <= tabelTaille; i4++)
{ Tableau <Noeud *>& t_noe = t_noe_ele(i4); // pour simplifier
Element * elem = tab_element(i4); // recup de l'element
t_noe.Change_taille(nbe_C+3); // nbe_C+3 noeuds pour les sfe triangles
// les noeuds du centre
for (int i=1;i<= nbe_C;i++)
t_noe(i) = &(elem->Noeud_elt(i));
// les noeuds externes initialisés aux noeuds centraux des sommets
t_noe(nbe_C+1) = &(elem->Noeud_elt(1));
t_noe(nbe_C+2) = &(elem->Noeud_elt(2));
t_noe(nbe_C+3) = &(elem->Noeud_elt(3));
// t_noe(1) = t_noe(4) = &(elem->Noeud_elt(1));
// t_noe(2) = t_noe(5) = &(elem->Noeud_elt(2));
// t_noe(3) = t_noe(6) = &(elem->Noeud_elt(3));
};
// I-- on définit les noeuds externe de chaque triangles
// I.1- on crée des tableaux permettant d'accélérer l'algorithme final
// pour chaque noeud on regarde quel élément contiend ce noeud
int tab_noeud_taille= tab_noeud.Taille();
Tableau <List_io <Element*> > indice(tab_noeud_taille);
// indice contiend les éléments succeptibles d'avoir des arrêtes communes
// on en profite également pour calculer les normales à chaque élément
Tableau <Coordonnee > tab_Nor(tabelTaille);
for (int i22 = 1; i22 <= tabelTaille; i22++)
{ Element * elem1 = tab_element(i22); // recup de l'element
Tableau<Noeud *>& tabn = elem1->Tab_noeud(); // récup de son tableau de noeud
// int tabntaille = tabn.Taille();
int tabntaille = 3; // on n'utilise que les noeuds sommets !! : 1 mars 2021
for (int ij=1;ij<= tabntaille;ij++)
indice((tabn(ij)->Num_noeud())).push_back(elem1); // on balaie ses noeuds
// calcul de la normale
Coordonnee A=tabn(1)->Coord0();Coordonnee B=tabn(2)->Coord0();
Coordonnee C=tabn(3)->Coord0();
Coordonnee AB(B-A); Coordonnee AC(C-A);
tab_Nor(i22)=Util::ProdVec_coor(AB,AC);tab_Nor(i22).Normer();
};
// I.2 - un tableau intermédiaire t_i(i) , d'indiçage local
// l'indice i = le numéro du premier noeud de l'arrête, et t_i(i) = le num du noeud externe
Tableau <int > t_i(3);
t_i(1)=6; t_i(2)=4; t_i(3)=5; // init éléments SFE lineaires
if ((enuSfe == QSFE3) || (enuSfe == QSFE1))
{t_i(1)=9; t_i(2)=7; t_i(3)=8; }// interpolation quadratique au centre
// également un tableau pour noter les éléments dont la courbure est supérieure à un maxi
// c'est à dire qui ont deux facettes avec un produit scalaire des normales suffisamment grand
// on choisit arbitrairement 30° c-a-d cos(pi/6) = 0.86603
Tableau <int> elem_courb(tabelTaille,0); // par défaut tous sont ok
double limit_inf_prod_scal = 0.86603; // la limite inf -> servira pour les SFE3
// qui sera mesuré par
// I.3- maintenant on va de nouveau boucler sur les éléments en regardant
// pour chaque arrêtes si elle est effectivement commune
for (int i1 = 1; i1 <= tabelTaille; ++i1)
{Element * elem1 = tab_element(i1); // recup de l'element
// Tableau<Noeud *>& tabn = elem1->Tab_noeud(); // récup de son tableau de noeuds
//int nb_noe_elem1 = tabn.Taille();
// on boucle sur les 3 arrêtes
// normalement les 3 premiers noeuds sont les sommets du triangle
for (int ina=1;ina<=3;ina++)
{ int noe1 = elem1->Noeud_elt(ina).Num_noeud();// num du premier noeud de l'arrête
int noe2 = 0; // init pour le second noeud
if (ina == 3) { noe2 = elem1->Noeud_elt(1).Num_noeud();}
else { noe2 = elem1->Noeud_elt(ina+1).Num_noeud();}
List_io <Element*>& indic1 = indice(noe1); // les éléments à considérer pour noe1
List_io <Element*>& indic2 = indice(noe2); // les éléments à considérer pour noe2
// on cherche un élément de l'intersection de indic1 et indic2
// qui doit également être différent de l'élément central
List_io <Element*>::iterator il1,ilfin1=indic1.end();
List_io <Element*>::iterator il2,ilfin2=indic2.end();
list <Element *> candidats; // une liste de travail
for (il1=indic1.begin();il1 != ilfin1;il1++)
for (il2=indic2.begin();il2 != ilfin2;il2++)
if (((*il1) == (*il2)) && ((*il1) != elem1 ))
{ //ele = (*il1); break;
candidats.push_back((*il1));
};
// maintenant parmi tous les candidats on va choisir celui qui conduit à l'élément le plus plat
// NB: on considère que les éléments sont correctement orientés dans le même sens
Element* ele = NULL; // init a priori
if (candidats.size() != 0)
{ list <Element *>::iterator ilfin=candidats.end();
list <Element *>::iterator il=candidats.begin();
ele = (*il); il++; // on stocke a priori le premier élément
double prodscal = tab_Nor(ele->Num_elt()) * tab_Nor(elem1->Num_elt());
// puis on parcours les éléments suivants et on garde celui dont le prodscal est le + grand
for (;il != ilfin;il++)
{ double prod = tab_Nor((*il)->Num_elt()) * tab_Nor(elem1->Num_elt());
if (prod > prodscal)
{prodscal = prod; ele = (*il);};
};
// si le produit scalaire est inférieur à limit_inf_prod_scal, on enregistre
if (prodscal < limit_inf_prod_scal)
elem_courb(elem1->Num_elt()) = 1;
};
// si on a trouvé un candidat
if (ele != NULL)
{// on recherche le noeud qui n'est pas commun avec l'arrête
for (int j=1;j<=3;j++) // on boucle sur les 3 noeuds sommets de l'élément
{int num = ele->Noeud_elt(j).Num_noeud();
if ((num != noe1) && (num != noe2))
{ // on met à jour le tableau des noeuds externes
t_noe_ele(i1)(t_i(ina)) = &(ele->Noeud_elt(j));
break;
};
};
};
// si aucun candidat n'est trouvé, t_noe_ele reste tel_quel
};
};
// II-- on crée les éléments SFE
// bool bonne_lecture=false;Enum_interpol enuSfe=SFE1;
// while (!bonne_lecture)
// { cout << "\n give the type of SFE element you want: "
// << "\n SFE1 (resp 1) SFE1_3D (resp 11) "
// << "\n SFE2 (resp 2) SFE2_3D (resp 12) "
// << "\n SFE3 (resp 3) SFE3_3D (resp 13) "
// << "\n SFE3C (resp 4) SFE3C_3D (resp 14) ";
// string rep; rep = lect_chaine();
// if (rep == "1") {enuSfe = SFE1; bonne_lecture=true;}
// else if (rep == "2") {enuSfe = SFE2; bonne_lecture=true;}
// else if (rep == "3") {enuSfe = SFE3; bonne_lecture=true;}
// else if (rep == "4") {enuSfe = SFE3C; bonne_lecture=true;}
//
// else if (rep == "11") {enuSfe = SFE1_3D; bonne_lecture=true;}
// else if (rep == "12") {enuSfe = SFE2_3D; bonne_lecture=true;}
// else if (rep == "13") {enuSfe = SFE3_3D; bonne_lecture=true;}
// else if (rep == "14") {enuSfe = SFE3C_3D; bonne_lecture=true;}
//
//
// else { cout << "\n bad answer, we have read : " << rep << "! try again ";};
// };
// cout << "\n choice read : " << Nom_interpol(enuSfe);
Element * toto = NULL;
Tableau<Element *> tab_SFE(tabelTaille,toto); // création de pointeurs nuls
// cas d'info annexe
string str_precision(""); // stockage info annexe de choix, initié à rien par défaut
bonne_lecture=false; int num_pti=0; // init
if (enuSfe == SFE3 ) // on a des nombres de pti variables que pour les SFE3
while (!bonne_lecture)
{ cout << "\n give eventually le number of integration point : "
<< "\n 2, 3, 4, 5, 6, 7, 12, 13 : ";
string rep; rep = lect_chaine();
if (rep == "2") {str_precision="";bonne_lecture=true;num_pti=2;}
else if (rep == "3") {str_precision="_cm3pti";bonne_lecture=true;num_pti=3;}
else if (rep == "4") {str_precision="_cm4pti";bonne_lecture=true;num_pti=4;}
else if (rep == "5") {str_precision="_cm5pti";bonne_lecture=true;num_pti=5;}
else if (rep == "6") {str_precision="_cm6pti";bonne_lecture=true;num_pti=6;}
else if (rep == "7") {str_precision="_cm7pti";bonne_lecture=true;num_pti=7;}
else if (rep == "12") {str_precision="_cm12pti";bonne_lecture=true;num_pti=12;}
else if (rep == "13") {str_precision="_cm13pti";bonne_lecture=true;num_pti=13;}
else { cout << "\n bad answer, we have read : " << rep << "! try again ";};
};
if (enuSfe == SFE1 ) // idem pour les SFE1
while (!bonne_lecture)
{ cout << "\n give eventually le number of integration point : "
<< "\n 2, 5 : ";
string rep; rep = lect_chaine();
if (rep == "2") {str_precision="";bonne_lecture=true;num_pti=2;}
else if (rep == "5") {str_precision="_cm5pti";bonne_lecture=true;num_pti=5;}
else { cout << "\n bad answer, we have read : " << rep << "! try again ";};
};
for (int i5 = 1; i5 <= tabelTaille; ++i5)
{ElemMeca * el = ((ElemMeca *) tab_element(i5)); // recup de l'element
Tableau <Noeud *>& t_noe = t_noe_ele(i5); // pour simplifier
Tableau<Noeud *>& tabn = el->Tab_noeud(); // récup de son tableau de noeuds
// coordonnées du centre de gravité
Coordonnee G = (tabn(1)->Coord0()+tabn(2)->Coord0()+tabn(3)->Coord0())/3.;
double epaisseur = el->Epaisseurs(TEMPS_0,G); // épaisseur à G
switch (enuSfe)
{ case SFE1: switch (num_pti)
{ case 2: tab_SFE(i5) = new TriaSfe1(epaisseur,idmail,el->Num_elt(),t_noe); break;
case 5: tab_SFE(i5) = new TriaSfe1_cm5pti(epaisseur,idmail,el->Num_elt(),t_noe);break;
default:
cout << "*** pb, le cas "<<Nom_interpol(enuSfe)
<< " avec " << num_pti << " pti "
<< " n'est pas possible pour l'instant " << endl;
};
break;
case SFE2: tab_SFE(i5) = new TriaSfe2(epaisseur,idmail,el->Num_elt(),t_noe); break;
case SFE3:
// si la courbure de l'élément est trop grande on bascule vers un SFE1
if (elem_courb(i5))
{ if (ParaGlob::NiveauImpression() > 0)
cout << " attention l'element " << Nom_interpol(enuSfe)<< " "<<i5
<< " est remplace par un SFE1 car la courbure est sup a 30° "<< endl;
switch (num_pti)
{ case 2: tab_SFE(i5) = new TriaSfe1(epaisseur,idmail,el->Num_elt(),t_noe); break;
case 5: tab_SFE(i5) = new TriaSfe1_cm5pti(epaisseur,idmail,el->Num_elt(),t_noe);break;
default:
if (ParaGlob::NiveauImpression() > 2)
cout << " attention le cas "<<Nom_interpol(enuSfe)
<< " avec " << num_pti << " pti "
<< " sera remplace par un SFE1 avec seulement 5 pti " << endl;
tab_SFE(i5) = new TriaSfe1_cm5pti(epaisseur,idmail,el->Num_elt(),t_noe);break;
};
}
else // cas normal
{switch (num_pti)
{ case 2: tab_SFE(i5) = new TriaSfe3(epaisseur,idmail,el->Num_elt(),t_noe);break;
case 3: tab_SFE(i5) = new TriaSfe3_cm3pti(epaisseur,idmail,el->Num_elt(),t_noe);break;
case 4: tab_SFE(i5) = new TriaSfe3_cm4pti(epaisseur,idmail,el->Num_elt(),t_noe);break;
case 5: tab_SFE(i5) = new TriaSfe3_cm5pti(epaisseur,idmail,el->Num_elt(),t_noe);break;
case 6: tab_SFE(i5) = new TriaSfe3_cm6pti(epaisseur,idmail,el->Num_elt(),t_noe);break;
case 7: tab_SFE(i5) = new TriaSfe3_cm7pti(epaisseur,idmail,el->Num_elt(),t_noe);break;
case 12: tab_SFE(i5) = new TriaSfe3_cm12pti(epaisseur,idmail,el->Num_elt(),t_noe);break;
case 13: tab_SFE(i5) = new TriaSfe3_cm13pti(epaisseur,idmail,el->Num_elt(),t_noe);break;
default:
cout << "*** pb, le cas "<<Nom_interpol(enuSfe)
<< " avec " << num_pti << " pti "
<< " n'est pas possible pour l'instant " << endl;
};
}
break;
case QSFE1:
{ num_pti = 2; // pour l'instant seul le cas avec 2 pti dans l'épaisseur
// existe, on laisse le choix suivant pour mémoire mais il faudra ensuite
// modifier pour demander le nb de pti en surface et en hauteur ...
switch (num_pti)
{ case 2: tab_SFE(i5) = new TriaQSfe1(epaisseur,idmail,el->Num_elt(),t_noe);
break;
default:
cout << "*** pb, le cas "<<Nom_interpol(enuSfe)
<< " avec " << num_pti << " pti "
<< " n'est pas possible pour l'instant " << endl;
};
break;
}
case QSFE3:
// si la courbure de l'élément est trop grande on bascule vers un SFE1
if (elem_courb(i5))
{ if (ParaGlob::NiveauImpression() > 0)
cout << " attention l'element " << Nom_interpol(enuSfe)<< " "<<i5
<< " est remplace par un QSFE1 car la courbure est sup a 30° "<< endl;
switch (num_pti)
{ case 2: tab_SFE(i5) = new TriaQSfe1(epaisseur,idmail,el->Num_elt(),t_noe); break;
default:
if (ParaGlob::NiveauImpression() > 2)
cout << " attention le cas "<<Nom_interpol(enuSfe)
<< " avec " << num_pti << " pti "
<< " sera remplace par un SFE1 avec seulement Sxh = 3x2 pti " << endl;
tab_SFE(i5) = new TriaQSfe1(epaisseur,idmail,el->Num_elt(),t_noe);break;
};
}
else // cas normal
{switch (num_pti)
{ case 2: tab_SFE(i5) = new TriaQSfe3(epaisseur,idmail,el->Num_elt(),t_noe);break;
default:
cout << "*** pb, le cas "<<Nom_interpol(enuSfe)
<< " avec " << num_pti << " pti "
<< " n'est pas possible pour l'instant " << endl;
};
}
break;
case SFE3C: tab_SFE(i5) = new TriaSfe3C(epaisseur,idmail,el->Num_elt(),t_noe); break;
// case SFE1_3D: tab_SFE(i5) = new TriaSfe1(epaisseur,idmail,el->Num_elt(),t_noe); break;
// case SFE2_3D: tab_SFE(i5) = new TriaSfe2(epaisseur,idmail,el->Num_elt(),t_noe); break;
case SFE3_3D: tab_SFE(i5) = new TriaSfe3_3D(idmail,el->Num_elt(),t_noe); break;
// case SFE3C_3D: tab_SFE(i5) = new TriaSfe3C(epaisseur,idmail,el->Num_elt(),t_noe); break;
default:
cout << "*** pb, le cas "<<Nom_interpol(enuSfe)
<< " avec " << num_pti << " pti "
<< " n'est pas possible pour l'instant " << endl;
};
};
// II_bis-- maintenant que les SFE sont fabriqué, on fait un dernier passage pour voir si à l'origine
// il n'y a pas un pb de calcul de courbure
double inf_normale=0.01;
switch (enuSfe)
{ case SFE3: case SFE3C: case SFE3_3D: // cas particulier des sfe3
case QSFE3 :
{cout << "\nAssocie au choix SFE3, il y a une verification"
<< " avant le calcul de la distorsion du maillage"
<< " celle-ci est controlee par le calcul de la courbure"
<< " initiale via le determinant de la matrice des composantes de courbure"
<< " si le determinant est trop petit (inf a une limite) on bascule"
<< " automatiquement vers des elements sfe1"
<< "\n valeur de la limite inf ? (rep par defaut "<<inf_normale
<<" retour chariot ou f) "<<endl;
string rep = "_";
rep = lect_return_defaut(true,"f");
// si la taille de rep == 0 cela veut dire que c'est un retour chariot
if ((rep.size()==0)||(Minuscules(rep) == "f"))
{cout << "--> valeur par defaut : " << inf_normale << endl;}
else
{inf_normale = ChangeReel(rep);
cout << "--> valeur lue "<< inf_normale << endl;
};
break;
}
default: break;
};
// pour l'instant on se fixe une limite inf mais ensuite il faudra demander à l'utilisateur
for (int i5 = 1; i5 <= tabelTaille; ++i5)
{ SfeMembT& el = *((SfeMembT*) tab_SFE(i5)); // pour simplifier
Tableau <Noeud *>& t_noe = t_noe_ele(i5); // pour simplifier
Tableau<Noeud *>& tabn = el.Tab_noeud(); // récup de son tableau de noeuds
// coordonnées du centre de gravité
Coordonnee G = (tabn(1)->Coord0()+tabn(2)->Coord0()+tabn(3)->Coord0())/3.;
double epaisseur = el.Epaisseurs(TEMPS_0,G); // épaisseur à G
int verif_courb = el.Test_courbure_anormale3(TEMPS_0,inf_normale);
// si pb inconnue
if (verif_courb == -1)
{ cout << "\n *** pb verification de l'element "<<Nom_interpol(enuSfe)<< " "<<i5
<< "\n *** on laisse tel quel mais il y a un pb !! **** "
<< "\n info sur l'element: \n ";
if (ParaGlob::NiveauImpression() > 1)
el.Affiche(2);
}
else // sinon cas normal de vérif avec remplacement éventuel
{// si pb on modifie éventuellement les éléments, a minima on signale
if (!verif_courb)
{// on crée un nouvel element intermédiaire
Element * eleinter;
switch (enuSfe)
{ case SFE1: case SFE2: case QSFE1:
cout << "*** pb, la verification de l'element "<<Nom_interpol(enuSfe)<< " "<<i5
<< " montre que le calcul de la courbure initiale est de mauvaise qualite "
<< " il faut s'attendre a des pb dans la simulation du comportement " << endl;
break;
case SFE3: case SFE3C: case SFE3_3D:
// on va remplacer l'élément par un SFE1 qui a priori de pose pas de pb
if (ParaGlob::NiveauImpression() > 0)
cout << " attention l'element " << Nom_interpol(enuSfe)<< " "<<i5
<< " est remplace par un SFE1 (calcul de la courbure"
<< " initiale de mauvaise qualite) " << endl;
switch (num_pti)
{ case 2: eleinter = new TriaSfe1(epaisseur,idmail,el.Num_elt(),t_noe); break;
case 5: eleinter = new TriaSfe1_cm5pti(epaisseur,idmail,el.Num_elt(),t_noe);break;
default:
if (ParaGlob::NiveauImpression() > 2)
cout << " attention le cas "<<Nom_interpol(enuSfe)
<< " avec " << num_pti << " pti "
<< " sera remplace par un SFE1 avec seulement 5 pti " << endl;
eleinter = new TriaSfe1_cm5pti(epaisseur,idmail,el.Num_elt(),t_noe);break;
};
break;
case QSFE3:
// on va remplacer l'élément par un QSFE1 qui a priori de pose pas de pb
if (ParaGlob::NiveauImpression() > 0)
cout << " attention l'element " << Nom_interpol(enuSfe)<< " "<<i5
<< " est remplace par un QSFE1 (calcul de la courbure"
<< " initiale de mauvaise qualite) " << endl;
switch (num_pti)
{ case 2: eleinter = new TriaQSfe1(epaisseur,idmail,el.Num_elt(),t_noe); break;
default:
if (ParaGlob::NiveauImpression() > 2)
cout << " attention le cas "<<Nom_interpol(enuSfe)
<< " avec " << num_pti << " pti "
<< " sera remplace par un SFE1 avec seulement Sxh 3x2 pti " << endl;
eleinter = new TriaQSfe1(epaisseur,idmail,el.Num_elt(),t_noe);break;
};
break;
default:
cout << "*** pb, le cas "<<Nom_interpol(enuSfe)
<< " avec " << num_pti << " pti "
<< " n'est pas possible pour l'instant " << endl;
};
// on remplace de sfe
delete tab_SFE(i5);
tab_SFE(i5)=eleinter;
// on revérifie que le nouvel élément est correct
if (!(((SfeMembT*) tab_SFE(i5))->Test_courbure_anormale3(TEMPS_0,inf_normale)))
cout << "*** pb, la verification de l'element "<<Nom_interpol(enuSfe)<< " "<<i5
<< " montre que la courbure initiale calculee est tres grande "
<< " il faut s'attendre a des pb dans la simulation du comportement " << endl;
};
}
};
// III-- on efface les éléments triangulaires et on les remplaces par les SFE
for (int i6 = 1; i6 <= tabelTaille; ++i6)
{ delete tab_element(i6);
tab_element(i6) = tab_SFE(i6);
};
};
// test pour savoir si le maillage est ok pour être transformée en sfe
bool Maillage::OKPourTransSfe()
{ // on vérifie que tous les éléments sont des triangles, sinon
// message d'incompétance
int tabelTaille = tab_element.Taille();
bool on_continue=true; // bon par défaut
// on boucle sur les elements
for (int i2 = 1; i2 <= tabelTaille; i2++)
// if ((tab_element(i2)->Id_geometrie() != TRIANGLE)
// || (tab_element(i2)->Id_interpolation() != LINEAIRE))
// 1 mars 2021 ==> maintenant on peut avoir des triangles internes quadratique
if (tab_element(i2)->Id_geometrie() != TRIANGLE)
{on_continue = false;break;};
if (!on_continue)
{ cout << "\n Warning *** the mesh " << idmail << " ( " << nomDuMaillage << " ) "
<< " does not contain only linear triangular element, currently "
<< " the continuation of the processing is not possible ! --> stop ";
};
// retour
return on_continue;
};
// lecture et suppression éventuelle des noeuds, non référencés par les éléments et les références
void Maillage::LectureEtSuppressionNoeudNonReferencer(UtilLecture * entreePrinc,LesReferences& lesRef)
{ if (strstr(entreePrinc->tablcar,"suppression_noeud_non_references_")!=NULL) // cas d'une demande de suppression
{ if (ParaGlob::NiveauImpression() > 2) cout << "\n beginning of the process to delete nodes which are "
<< " not connected with an element "<< endl ;
entreePrinc->NouvelleDonnee(); // on passe le mot clé
// appel de l'algo de suppression
SuppressionNoeudNonReferencer(lesRef);
if (ParaGlob::NiveauImpression() > 2) cout << "\n end of the process to delete nodes which are "
<< " not connected with an element "<< endl ;
};
};
// uniquement suppression éventuelle des noeuds, non référencés par les éléments et les références
void Maillage::SuppressionNoeudNonReferencer(LesReferences& lesRef)
{ if (ParaGlob::NiveauImpression() > 2)
cout << "\n delete of nodes which are not referred in the mesh "
<< nomDuMaillage << endl;
// on commence par chercher les noeuds non référencés
int taille_tabnoeud=tab_noeud.Taille();
Tableau <bool> non_referencer(taille_tabnoeud,true);
// on passe en revue tous les éléments, pour marquer les noeuds référencés
int nbelem = tab_element.Taille();
for (int ie = 1; ie <= nbelem ; ie++)
{ Tableau<Noeud *>& tnel = tab_element(ie)->Tab_noeud();
int dim_tnel = tnel.Taille();
for (int ib = 1; ib <= dim_tnel; ib++)
non_referencer(tnel(ib)->Num_noeud())=false;
};
// idem les références
// le cas des références fonctionnent, mais en fait, ce n'est pas
// une bonne idée de garder les noeuds référencés dans les références seulement
// a priori, il vaut mieux ne garder que les noeuds référencés par les éléments
// et supprimer tous les autres, d'où la mise en commentaires du cas des références
/*
const Reference* refe = lesRef.Init_et_Premiere();
while (refe != NULL)
{ if (refe->Indic() == 1)
{ // cas d'une référence de noeud
ReferenceNE* refeN = ((ReferenceNE*) refe); // on récupère la référence
if (refeN->Nom() != "N_tout")
{int nb_el = refeN->Taille();
for (int i=1; i<= nb_el; i++)
{ int num_noeud = refeN->Numero(i);
if ((num_noeud > taille_tabnoeud ) || (num_noeud < 1))
{ cout << "\n erreur: pendant la suppression des noeuds non references, "
<< " le numero " << num_noeud << " de la reference " << refeN->Nom()
<< " n'est pas correcte, peut-etre que le noeud n'existe pas ? "
<< " on arrete la procedure ";
return;
}
else
{ non_referencer(num_noeud)=false;};
};
};
};
// on passe à la référence suivante
refe = lesRef.Reference_suivante();
}; */
// maintenant on refait un nouveau tableau de noeud avec les noeuds inutiles supprimés
Tableau <Noeud* > tab_final(taille_tabnoeud);
int nbn_restant=0; // le nombre de noeud restant
cout << "\n ";
for (int ijn = 1; ijn <= taille_tabnoeud; ijn++)
{if (non_referencer(ijn) == false)
{nbn_restant++;
tab_final(nbn_restant) = tab_noeud(ijn);
}
else
{ if (ParaGlob::NiveauImpression() > 2)
cout << "\n delete of the node " << ijn ; //<< endl;
delete tab_noeud(ijn); // suppression du noeud
};
};
if (ParaGlob::NiveauImpression() > 2)
cout << " \n " << (taille_tabnoeud-nbn_restant)
<< " nodes have been deleted " << endl;
// on redimentionne le tableau final (les premiers restent !!)
tab_final.Change_taille(nbn_restant);
// on met à jour les références
lesRef.SupprimeReference("N_tout",idmail); // on supprime la référence N_tout
Tableau <int> nv_num(taille_tabnoeud); // nouveau num/ au ancien
for (int ia=1;ia <= nbn_restant; ia++)
nv_num(tab_final(ia)->Num_noeud()) = ia;
lesRef.Mise_a_jour_ref_noeud(nv_num,idmail,non_referencer);
// on enregistre le nouveau tableau de noeud
tab_noeud = tab_final;
// on met à jour les numéros de noeuds
for (int ia=1;ia <= nbn_restant; ia++)
tab_noeud(ia)->Change_num_noeud(ia);
string ntout("N_tout");
// on recrée la référence N_tout
{ // on construit le tableau des numéros de noeuds
Tableau <int> tabN(nbn_restant); for (int i=1;i<=nbn_restant;i++) tabN(i)=i;
ReferenceNE* rtout = new ReferenceNE(tabN,idmail,1,ntout);// construction de la référence
lesRef.Ajout_reference(rtout); // ajout de la ref, qui est maintenant géré par lesRef
};
};
// Affichage des noeuds, non référencés par les éléments
void Maillage::AffichageNoeudNonReferencer()
{ //if (ParaGlob::NiveauImpression() > 2)
// cout << "\n print nodes which are not referred in the mesh "
// << nomDuMaillage << endl;
// on commence par chercher les noeuds non référencés
int taille_tabnoeud=tab_noeud.Taille();
Tableau <bool> non_referencer(taille_tabnoeud,true);
// on passe en revue tous les éléments, pour marquer les noeuds référencés
int nbelem = tab_element.Taille();
for (int ie = 1; ie <= nbelem ; ie++)
{ Tableau<Noeud *>& tnel = tab_element(ie)->Tab_noeud();
int dim_tnel = tnel.Taille();
for (int ib = 1; ib <= dim_tnel; ib++)
non_referencer(tnel(ib)->Num_noeud())=false;
};
bool existe_non_reference = false; // init par défaut
// on regarde s'il faut afficher un warning
for (int ijn = 1; ijn <= taille_tabnoeud; ijn++)
{if (non_referencer(ijn))
{existe_non_reference=true;break;};
};
if (existe_non_reference)
{for (int ijn = 1; ijn <= taille_tabnoeud; ijn++)
{if (non_referencer(ijn))
{ cout << "\n --- print nodes which are not referred in the mesh --- "
<< nomDuMaillage ;
cout << "\n ** warning: the node " << tab_noeud(ijn)->Num_noeud()
<< " is not link with an element ! ";
}
};
};
};
// lecture et création éventuelle d'une ref sur les noeuds, non référencés par les éléments
void Maillage::LectureEtCreationRefNoeudNonReferencer(UtilLecture * entreePrinc,LesReferences& lesRef)
{ if (strstr(entreePrinc->tablcar,"creation_ref_noeud_non_references_")!=NULL) // cas d'une demande de création
{ if (ParaGlob::NiveauImpression() > 2) cout << "\n beginning of the process of building a new reference on nodes which are "
<< "\n not connected with an element "<< endl ;
entreePrinc->NouvelleDonnee(); // on passe le mot clé
// appel de l'algo de suppression
CreationRefNoeudNonReferencer(lesRef);
if (ParaGlob::NiveauImpression() > 2) cout << "\n end of the process of building a new reference on nodes which are "
<< "\n not connected with an element "<< endl ;
};
};
// création éventuelle d'une référence sur les noeuds, non référencés par les éléments
void Maillage::CreationRefNoeudNonReferencer(LesReferences& lesRef)
{ if (ParaGlob::NiveauImpression() > 2)
cout << "\n new ref of nodes which are not referred by an element "
<< nomDuMaillage << endl;
// on commence par chercher les noeuds non référencés
int taille_tabnoeud=tab_noeud.Taille();
Tableau <bool> non_referencer(taille_tabnoeud,true);
// on passe en revue tous les éléments, pour marquer les noeuds référencés
int nbelem = tab_element.Taille();
for (int ie = 1; ie <= nbelem ; ie++)
{ Tableau<Noeud *>& tnel = tab_element(ie)->Tab_noeud();
int dim_tnel = tnel.Taille();
for (int ib = 1; ib <= dim_tnel; ib++)
non_referencer(tnel(ib)->Num_noeud())=false;
};
// maintenant on refait une nouvel liste de noeud avec les noeuds non référencés
list <Noeud* > list_final;
cout << "\n ";
for (int ijn = 1; ijn <= taille_tabnoeud; ijn++)
{if (non_referencer(ijn) == true)
{list_final.push_back(tab_noeud(ijn));};
};
int taille = list_final.size();
if ((ParaGlob::NiveauImpression() > 2) && (taille != 0))
cout << " \n " << taille
<< " nodes are not referred by an element "
<< " new ref = N_noeud_libre "<< endl;
string nlibre("N_noeud_libre");
// on recrée la référence N_noeud_libre
{ // on construit le tableau des numéros de noeuds
list <Noeud* >::iterator il,ilfin=list_final.end();
Tableau <int> tabN(taille);
int i=1; // init
for (il = list_final.begin(); il != ilfin;il++,i++)
{tabN(i)= (*il)->Num_noeud();}
ReferenceNE* rlibre = new ReferenceNE(tabN,idmail,1,nlibre);// construction de la référence
lesRef.Ajout_reference(rlibre); // ajout de la ref, qui est maintenant géré par lesRef
};
};
// ------------------------------ partie relative à la renumérotation --------------
// lecture et renumérotation éventuelle des noeuds
// ici la renumérotation permet d'optimiser la largeur de bande relative au maillage uniquement
// par exemple on ne tiens pas compte de relations linéaires éventuelles entre des noeuds
void Maillage::LectureEtRenumerotation(UtilLecture * entreePrinc,LesReferences& lesRef)
{ if (strstr(entreePrinc->tablcar,"renumerotation_des_noeuds_")!=NULL) // cas d'une demande de renumérotation
{ if (ParaGlob::NiveauImpression() > 2) cout << "\n beginning of the new numbering of nodes " << endl ;
entreePrinc->NouvelleDonnee(); // on passe le mot clé
// appel de l'algo de renumérotation
Tableau <Tableau <Condilineaire> > condCLL; // un tableau par défaut
bool calcul_ok = Renumerotation(lesRef,condCLL);
if (!calcul_ok) // si retour false, pas de renumerotation effectué
{ cout << "\n ** warning: no new numbering of nodes !! ";};
if (ParaGlob::NiveauImpression() > 2) cout << "\n end of the new numbering of nodes \n" << endl ;
};
};
// renumérotation des noeuds du maillage, en fonction de conditions linéaires éventuelles
// ramène false si rien n'a changé (à cause d'un pb ou parce que la renumérotation n'est pas meilleure), vrai sinon
// nv_tab est tel que : nv_tab(i) est le nouveau numéro qui avait auparavant le numéro "i"
bool Maillage::Renumerotation(LesReferences& lesRef
,const Tableau <Tableau <Condilineaire> >& condCLL)
{ bool retour = false; // par défaut pour le retour
int taille_tabnoeud=tab_noeud.Taille();
// on calcul le point de départ
Tableau < LaLIST_io <Noeud* > > t_voisin; // def du tableau des voisins
list < list < Noeud_degre > > lis_descent; // stockage des descendants
// --- suppression de la création d'éléments frontières,
// c'est fait avant, dans l'algo appelant, car certaine fois on ne veut pas que cela change
// CreeElemFront(); // on crée tous les éléments frontières
if (listFrontiere.size()==0)
CreeElemFront(); // on essaie en conditionnel
// on crée un tableau intermédiaire pour appeler les routines suivantes qui sont static
Tableau <Tableau <Noeud*> *> tt_noeud_front(1);
tt_noeud_front(1) = &tab_noeud_front;
bool calcul_ok = true; // init par défaut
Noeud* noe_dep = Point_de_depart(tab_element,tab_noeud,tt_noeud_front,t_voisin,lis_descent,condCLL,calcul_ok);
if (!calcul_ok) // il y a un pb, on sort en le signalant
{ retour = false;}
else // sinon on continue
{// on appelle l'algorithme de Cuthill Mac Kee
Tableau <Noeud* > tab_N_final = Cuthill_Mac_Kee(taille_tabnoeud,noe_dep,t_voisin,lis_descent);
// --- maintenant on regarde l'évolution de la largeur de bande en noeud
// tout d'abord la largeur initiale
int largeur_initiale = LargeurBandeEnNoeuds(tab_element);
// on change la numérotation
for (int ia=1;ia <= taille_tabnoeud; ia++)
tab_N_final(ia)->Change_num_noeud(ia);
// nouvelle largeur de bande
int largeur_Cuthill = LargeurBandeEnNoeuds(tab_element);
// on change en numérotation inverse : Cuthill Mac Kee inverse
Tableau <Noeud* > tab_N_inverse(tab_N_final);
for (int ia=1;ia <= taille_tabnoeud; ia++)
{tab_N_final(ia)->Change_num_noeud(1+taille_tabnoeud-ia);
tab_N_inverse(1+taille_tabnoeud-ia) = tab_N_final(ia);
};
int largeur_Cuthill_inverse = LargeurBandeEnNoeuds(tab_element);
if (ParaGlob::NiveauImpression() > 2)
{ cout << "\n 1/2 largeur de bande en noeud, initiale " << largeur_initiale
<< " apres l'algo de Cuthill Mac Kee " << largeur_Cuthill
<< " idem en inverse " << largeur_Cuthill_inverse ;
};
// normalement le dernier est le meilleur, en tout cas il est meilleur que le cas 2
if ( (largeur_initiale <= largeur_Cuthill_inverse)
&& (largeur_initiale <= largeur_Cuthill )
)
// bizarre, cela veut dire qu'il faut revenir à la forme initiale
{ for (int ia=1;ia <= taille_tabnoeud; ia++)
tab_noeud(ia)->Change_num_noeud(ia);
if (ParaGlob::NiveauImpression() > 2)
cout << "\n pas d'amelioration, on garde la numerotation initiale "<< endl ;
retour = false; // pour signaler que rien n'a changé
}
else if (largeur_Cuthill < largeur_Cuthill_inverse)
// bizarre, cela veut dire qu'il faut revenir à la forme de Cuthill directe
{ for (int ia=1;ia <= taille_tabnoeud; ia++)
tab_N_final(ia)->Change_num_noeud(ia);
Tableau <int> nv_num(taille_tabnoeud); // nouveau num/ au ancien
for (int ia=1;ia <= taille_tabnoeud; ia++)
nv_num(ia) = tab_noeud(ia)->Num_noeud();
lesRef.Mise_a_jour_ref_noeud(nv_num,idmail);
tab_noeud = tab_N_final;
if (ParaGlob::NiveauImpression() > 2)
cout << "\n on utilise la numerotation obtenue avec l'algo Cuthill direct "<< endl ;
retour = true; // pour signaler qu'il y a eu un changement
}
else
// c'est le cas normale
{ Tableau <int> nv_num(taille_tabnoeud); // nouveau num/ au ancien
for (int ia=1;ia <= taille_tabnoeud; ia++)
nv_num(ia) = tab_noeud(ia)->Num_noeud();
lesRef.Mise_a_jour_ref_noeud(nv_num,idmail);
tab_noeud = tab_N_inverse;
if (ParaGlob::NiveauImpression() > 2)
cout << "\n on utilise la numerotation obtenue avec l'algo Cuthill inverse "<< endl ;
retour = true; // pour signaler qu'il y a eu un changement
};
};
// retour
return retour;
};
// méthode static: c-a-d indépendante des données du maillage (elle est générale)
// calcul du point de départ, en fonction de conditions linéaires éventuelles
// il y a également calcul des voisins et de la descendance du noeud de retour
// s'il y a un pb, calcul_ok en retour est false
Noeud* Maillage::Point_de_depart(const Tableau<Element *>& tab_elem
,const Tableau<Noeud *>& tab_noe
,const Tableau <Tableau <Noeud*> *> tt_noeud_front
,Tableau < LaLIST_io <Noeud* > >& t_voisin
, list < list < Noeud_degre > > & lis_descent
,const Tableau <Tableau <Condilineaire> >& condCLL,bool& calcul_ok)
{ // début de l'algorithme de gibbs, suivant la description faite par Pironneau
// cf. Pironneau_coursWebFR.pdf page 81
// • x,y,... sont les noeuds de la triangulation Th,
// • y est voisin de x s'il existe un élément T de Th tel que x et y en soient des noeuds,
// • le degré d'un noeud x est le nombre de ses voisins, il est noté d(x),
// • les voisins de x constituent N1(x) le niveau 1 de sa descendance,
// • les voisins des noeuds de N1(x) non encore répertoriés forment N2(x),
// le niveau 2 de la descendance de x (un noeud apparaît au plus une fois
// dans Nk(x) et par suite nt peut être dans les autres niveaux),
// • l'ensemble des niveaux Nk(x) constitue la descendance, notée D(x) du noeud x,
// • la profondeur p de la descendance est le nombre de niveaux de celle-ci,
// --- on recherche un bon point de départ
// " Parmi les noeuds du contour du domaine, on sélectionne le noeud x "
// " tel que d(x) soit minimal: d(x) "
calcul_ok=false; // init par défaut
Noeud* noe_dep=NULL; // par défaut
Maillage::Voisins(tab_elem,tab_noe,t_voisin,condCLL,calcul_ok); // on crée les voisins
if (calcul_ok) // on ne continue que si Voisins s'est bien passé
{// on définit le degré de chaque noeuds
int taille_tabnoeud=tab_noe.Taille();
Tableau <int> dx(taille_tabnoeud,1000000); // un tableau de dx initialisé à très grand
for (int idx = 1; idx <= taille_tabnoeud; idx++)
{ dx(idx) = t_voisin(idx).size(); };
// maintenant on cherche le plus petit dx des noeuds frontière
int nb_front = tt_noeud_front.Taille();
int numnoeuddep = 1;
int dx_mini=dx((*(tt_noeud_front(1)))(1)->Num_noeud());
for (int ifron = 1; ifron <= nb_front; ifron++)
{ Tableau <Noeud *> & tab_noeud_front = *(tt_noeud_front(ifron)); // pour simplifier
int taille_noe_front = tab_noeud_front.Taille();
for (int io =1; io <= taille_noe_front; io++)
{int num_noe=tab_noeud_front(io)->Num_noeud();
if (dx(num_noe) < dx_mini)
{ numnoeuddep = num_noe; dx_mini = dx(num_noe);};
};
};
// Soient D(x) sa descendance et Np(x) son dernier niveau; on réalise alors l'algorithme suivant:
// • Début
// • Pour tous les noeuds y de Np(x), dans l'ordre croissant de leur degré d(y),
// on calcule D(y) et sa profondeur p(y),
// • Si p(y) est supérieur à p(x) alors y est sélectionné, on fait x=y et on va à Début,
// Sinon on teste un nouvel y.
int compt=1; // un compteur pour éviter une boucle infinie
noe_dep = tab_noe(numnoeuddep);
Descendance (taille_tabnoeud,noe_dep,t_voisin,lis_descent,calcul_ok);
if (calcul_ok) // on ne continue que si Voisins s'est bien passé
{int profondeur = lis_descent.size();
bool premier_elem_ok = true;
do
{ premier_elem_ok = true; // init dans le cas d'une nouvelle boucle
// on calcul la descendance du noeud
// récup de son Np(x)
list < Noeud_degre >& lis_Npx = *(lis_descent.begin());
lis_Npx.sort(); // classement
list < Noeud_degre >::iterator ic,icfin=lis_Npx.end();
for (ic=lis_Npx.begin();ic != icfin; ic++)
{ list < list < Noeud_degre > > lis_des_inter;
Noeud * noei = (*ic).noe; // pour simplifier
Descendance (taille_tabnoeud,noei,t_voisin,lis_des_inter,calcul_ok);
if (!calcul_ok)
break; // si pb dans le calcul de la Descendance on sort de la boucle
if (lis_des_inter.size() > profondeur)
{ // cas où on a trouvé une p(y) plus grand que p(x)
profondeur = lis_des_inter.size();
noe_dep = noei;
lis_descent = lis_des_inter;
premier_elem_ok = false; // pour que l'on refasse une boucle dans le do
break;
};
};
if (!calcul_ok)
break; // si pb dans le calcul de la Descendance on sort de la boucle
compt++; // pour éviter une boucle infinie
}
while ((compt < 1000) && (!premier_elem_ok));
if (calcul_ok) // on ne continue que si Voisins s'est bien passé
{
// normalement ici soit on a fait 1000 passages et ça n'a pas marché, ou soit c'est ok
if (compt == 1000)
{ cout << "\n Maillage::Renumerotation: on a fait 1000 passage on retiens le premier !! ";
// on repasse en revue uniquement la liste des noeuds de lis_Npx pour le premier noeud
noe_dep = tab_noe(numnoeuddep);
Descendance (taille_tabnoeud,noe_dep,t_voisin,lis_descent,calcul_ok);
if (calcul_ok) // on ne continue que si Voisins s'est bien passé
{profondeur = lis_descent.size();
bool cestLePoint_deDepart = true;
// récup de son Np(x)
list < Noeud_degre >& lis_Npx = *(lis_descent.begin());
lis_Npx.sort(); // classement
list < Noeud_degre >::iterator ic,icfin=lis_Npx.end();
list < list < Noeud_degre > > lis_des_inter;
for (ic=lis_Npx.begin();ic != icfin; ic++)
{ Noeud * noei = (*ic).noe; // pour simplifier
Descendance (taille_tabnoeud,noei,t_voisin,lis_des_inter,calcul_ok);
if (!calcul_ok)
break; // si pb dans le calcul de la Descendance on sort de la boucle
if (lis_des_inter.size() > profondeur)
{ // cas où on a trouvé une p(y) plus grande que p(x)
profondeur = lis_des_inter.size();
noe_dep = noei;
cestLePoint_deDepart=false;
};
};
if (calcul_ok)
{// si la descendance n'est pas sauvegardée
if (!cestLePoint_deDepart)
lis_descent = lis_des_inter;
// ici on est sur de sortir avec le plus petit p(x)
};
};
};
};
};
};
// retour
return noe_dep;
};
// calcul des voisins de tous les noeuds du maillage en fonction des éléments et de conditions
// linéaires éventuelles,
// la méthode est en static, c-a-d qu'elle est indépendante des données du maillage (elle est générale)
// en entrée/sortie t_voisin
// restriction: il faut que tab_noe contienne tous les noeuds référencés dans tab_elem et tt_t_condCLL
// s'il y a un pb, calcul_ok en retour est false
Tableau < LaLIST_io <Noeud* > >& Maillage::Voisins(const Tableau<Element *>& tab_elem
,const Tableau<Noeud *>& tab_noe
,Tableau < LaLIST_io <Noeud* > >& t_voisin
,const Tableau <Tableau <Condilineaire> >& t_t_condCLL,bool& calcul_ok)
{ // on efface les voisins existants
int taille_tabnoeud=tab_noe.Taille();
t_voisin.Change_taille(taille_tabnoeud);
for (int it = 1; it <= taille_tabnoeud; it++)
t_voisin(it).erase(t_voisin(it).begin(),t_voisin(it).end());
// on passe en revue tous les éléments
int nbelem = tab_elem.Taille();
for (int ie = 1; ie <= nbelem ; ie++)
{ Tableau<Noeud *>& tnel = tab_elem(ie)->Tab_noeud();
int dimtab = tnel.Taille();
LaLIST_io <Noeud* > listlocal;
for (int ine = 1; ine <= dimtab; ine++) // création d'une liste locale de tous les
{ listlocal.push_front(tnel(ine)); }; // noeud de l'élément
listlocal.sort(); // on trie la liste locale
// on remplit la liste globale
for (int ine = 1; ine <= dimtab; ine++)
{ int ne = tnel(ine)->Num_noeud(); // le numéro du noeud
LaLIST_io <Noeud* > list_inter = listlocal; // recopie, list_inter est donc également ordonnée
t_voisin(ne).merge(list_inter); // on ajoute en gardant l'ordre dans la liste résultante
};
};
// on fait de même avec toutes les conditions linéaires
int nb_gr_CLL = t_t_condCLL.Taille();
for (int ig=1;ig<=nb_gr_CLL; ig++)
{Tableau <Condilineaire>& t_condCLL = t_t_condCLL(ig); // pour simplifier
int taille_t_condCLL = t_condCLL.Taille();
for (int ic = 1; ic<= taille_t_condCLL; ic++)
{const Tableau<Noeud *>& tnel = t_condCLL(ic).TabNoeud();
int dimtab = tnel.Taille();
LaLIST_io <Noeud* > listlocal;
for (int ine = 1; ine <= dimtab; ine++) // création d'une liste locale de tous les
{ listlocal.push_front(tnel(ine)); }; // noeud de l'élément
listlocal.sort(); // on trie la liste locale
// on remplit la liste globale
for (int ine = 1; ine <= dimtab; ine++)
{ int ne = tnel(ine)->Num_noeud(); // le numéro du noeud
LaLIST_io <Noeud* > list_inter = listlocal; // recopie, list_inter est donc également ordonnée
t_voisin(ne).merge(list_inter); // on ajoute en gardant l'ordre dans la liste résultante
};
};
};
// on supprime maintenant tous les doublons dans les listes des voisins
// sachant que t_voisin(i) est déjà ordonné, because on a utilisé merge()
for (int inn = 1; inn <= taille_tabnoeud; inn++)
t_voisin(inn).unique(); // on supprime les doublons
//on vérifie que tous les noeuds ont un voisin
calcul_ok = true; // init par défaut
if (ParaGlob::NiveauImpression() > 3)
{for (int i=1;i<=taille_tabnoeud;i++)
if (t_voisin(i).size() == 0)
{cout << "\n erreur dans Voisins(.., le noeud " << i << " n'a pas de voisins ! " << endl;
calcul_ok = false; // là pb, on signale qu'il y a un pb
};
};
// retour
return t_voisin;
};
// méthode static: c-a-d indépendante des données du maillage (elle est générale)
// calcul de la descendance d'un noeud noeu,
// on considère que les voisins sont dèjà correctement définis
// en entrée la liste qui est modifiée en interne et retournée en sortie
// le premier élément de la liste c'est la dernière descendance
// s'il y a un pb, calcul_ok en retour est false
list < list < Maillage::Noeud_degre > > & Maillage::Descendance(const int& taille_tabnoeud
,Noeud * noeu, Tableau < LaLIST_io <Noeud* > >& t_voisin
,list < list < Maillage::Noeud_degre > > & lient,bool& calcul_ok)
{ //int taille_tabnoeud=tab_noeud.Taille();
int nb_noeud_restant = taille_tabnoeud; // le nombre de noeud a considérer
Tableau <bool> utiliser(taille_tabnoeud); // un tableau indiquant si le noeud est utilisé ou pas
// init du niveau 0 avec le noeud
utiliser(noeu->Num_noeud())=true;
nb_noeud_restant--;
// on vide la liste d'entrée
lient.erase(lient.begin(),lient.end());
int dxxy = t_voisin(noeu->Num_noeud()).size(); // le degre du noeud
list <Maillage::Noeud_degre > list_pere; list_pere.push_back(Maillage::Noeud_degre(noeu,dxxy));
// pour le noeud, on rempli le premier niveau
LaLIST_io <Noeud* >::iterator kl,klfin;
list <Maillage::Noeud_degre >::iterator jl,jlfin;
// on boucle
while ((nb_noeud_restant > 0) && (list_pere.size() != 0))
{ list <Noeud_degre > liste_enfant; // l'étage courant
jlfin=list_pere.end(); // init
// on balaie la liste des peres
for (jl=list_pere.begin();jl != jlfin; jl++)
{ Noeud & noe = *((*jl).noe); // pour simplifier
LaLIST_io <Noeud* >& lesvoisins = t_voisin(noe.Num_noeud());
klfin=lesvoisins.end();
for (kl=lesvoisins.begin();kl != klfin; kl++)
{ Noeud * novoi = (*kl); // pour simplifier
int num_novoi = novoi->Num_noeud(); // le numéro de novoi
if (! (utiliser(num_novoi))) // si le noeud n'a pas déjà été utilisé
{ int dxx = t_voisin(num_novoi).size(); // le degre du noeud
liste_enfant.push_back(Maillage::Noeud_degre(novoi,dxx));
utiliser(num_novoi)=true;nb_noeud_restant--;
};
};
};
// on enregistre les enfants
lient.push_front(liste_enfant);
// on init la liste des peres pour la boucle suivante
list_pere = liste_enfant;
};
// vérification
calcul_ok = true; // init par défaut
if (nb_noeud_restant != 0)
{ if (ParaGlob::NiveauImpression()>3)
{cout << "\n problem dans le calcul de la descendance (algorithme de gibbs) !!! il y a "
<< nb_noeud_restant << " noeuds, qui ne sont pas "
<< " references par les elements, l'algorithme de renumeration ne fonctionne pas "
<< " dans ce cas !! ";
for (int i=1;i<=taille_tabnoeud;i++)
if (!utiliser(i)) cout << "\n c'est le numero : " << i << endl;
};
calcul_ok = false; // là pb, on signale
};
// retour
return lient;
};
// méthode static: c-a-d indépendante des données du maillage (elle est générale)
// algorithme de Cuthill Mac Kee directe
// noeu : le noeud de départ
// lis_descent : les descendants de noeud, qui va être modifié dans le processus
// ramène une nouvelle numérotation (mais les numéros internes des noeuds ne sont pas changé
Tableau <Noeud* > Maillage::Cuthill_Mac_Kee(const int& taille_tabnoeud,Noeud * noeu
,Tableau < LaLIST_io <Noeud* > >& t_voisin
, list < list < Noeud_degre > >& lis_descent)
{ // un tableau intermédiaire qui permet de savoir si un noeud a déjà été numéroté ou pas
Tableau <bool > numeroter(taille_tabnoeud,false);
// le tableau de retour
Tableau <Noeud* > tab_N_final(taille_tabnoeud);
tab_N_final(1)=noeu; // le premier noeud
numeroter(noeu->Num_noeud())=true;
int numero_courant=2; // le numéro courant de prochain noeud à numéroter
// la boucle
// on parcourt la liste des descendants
list < list < Noeud_degre > >::reverse_iterator il,ilfin = lis_descent.rend();
list <Maillage::Noeud_degre >::iterator it,itfin;
LaLIST_io <Noeud* >::iterator kl,klfin;
int nb_couche = 1;
for (il=lis_descent.rbegin(); il != ilfin; il++,nb_couche++)
{ list <Maillage::Noeud_degre >& list_pere = (*il);
//cout << "\n couche nb " << nb_couche << endl;
// on passe en revue les noeuds des peres et on recalcule le degré en tenant compte
// des noeuds déjà numérotés, qui ne doivent pas être pris en compte
itfin = list_pere.end();
for (it= list_pere.begin();it != itfin; it++)
{ Noeud* no = (*it).noe; // pour simplifier
LaLIST_io <Noeud* >& lesvoisins = t_voisin(no->Num_noeud());
klfin=lesvoisins.end();
int& degre = (*it).degre; // pour simplifier
degre = 0;
for (kl=lesvoisins.begin();kl != klfin; kl++)
{ Noeud * novoi = (*kl); // pour simplifier
int num_novoi = novoi->Num_noeud(); // le numéro de novoi
if (! (numeroter(num_novoi))) // si le noeud n'a pas déjà été numéroté
{ degre++; }; // on incrémente le degré
};
};
// maintenant on ordonne la list_pere en fonction des degrés
list_pere.sort();
// et on numérote à partir ce ceux qui ont le plus haut degré, c'est-à-dire le plus
// de voisin non encore numéroté
list <Maillage::Noeud_degre >::reverse_iterator rit,ritfin=list_pere.rend();
//int deb_num = numero_courant; // numéro le plus bas de la couche
//cout << "\n ";
for (rit= list_pere.rbegin();rit != ritfin; rit++)
{ //cout << (*rit).degre << " ";
tab_N_final(numero_courant)=(*rit).noe;
numero_courant++;
};
//int fin_num = numero_courant; // numéro le plus haut de la couche
// la largeur de bande finale est fonction du maxi de (fin_num - deb_num)
//cout << "\n largeur en noeud de la couche = " << fin_num - deb_num << endl;
};
// retour
return tab_N_final;
};
// méthode static: c-a-d indépendante des données du maillage (elle est générale)
// calcul de la largeur de bande en noeuds
int Maillage::LargeurBandeEnNoeuds(const Tableau<Element *>& tab_elem)
{ // def du retour
int largeur = 0;
// on passe en revue tous les éléments
int nbelem = tab_elem.Taille();
for (int ie = 1; ie <= nbelem ; ie++)
{ Tableau<Noeud *>& tnel = tab_elem(ie)->Tab_noeud();
int dim_tnel = tnel.Taille();
for (int ix = 1; ix <= dim_tnel; ix++)
for (int iy = ix+1; iy <= dim_tnel; iy++)
largeur = MaX(largeur, Abs(tnel(ix)->Num_noeud() - tnel(iy)->Num_noeud()) );
};
// retour
return largeur;
};
// création automatique des références globales de frontière si demandé dans le .info
void Maillage::CreationRefFrontiere(UtilLecture * entreePrinc,LesReferences& lesRef)
{ if (strstr(entreePrinc->tablcar,"def_auto_ref_frontiere_")!=NULL)
{ entreePrinc->NouvelleDonnee(); // on passe le mot clé
// on demande de créer les références
CreationRefFrontiere(lesRef);
};
};
// demande de création automatique des références globales de frontière
void Maillage::CreationRefFrontiere(LesReferences& lesRef)
{ if (ParaGlob::NiveauImpression() > 2) cout << " automatic definition of frontier references " << endl ;
bool creationEffective=false; // pour savoir s'il y a une création effective
// on regarde si les frontières existent, si oui on ne fait rien sinon on les crées
////---- debug
// { cout << "\n listFrontiere taille: " << listFrontiere.size() ;
// LaLIST <Front>::iterator ili, ilifin = listFrontiere.end();
// // on balaie les éléments frontière, et on récupère les éléments associé
// for (ili=listFrontiere.begin();ili!=ilifin;ili++)
// (*(ili)).Affiche();
// cout << endl;
// };
////---- fin debug
if (listFrontiere.size()==0) CreeElemFront();
////---- debug
// { cout << "\n listFrontiere taille: " << listFrontiere.size() ;
// LaLIST <Front>::iterator ili, ilifin = listFrontiere.end();
// // on balaie les éléments frontière, et on récupère les éléments associé
// for (ili=listFrontiere.begin();ili!=ilifin;ili++)
// (*(ili)).Affiche();
// cout << endl;
// };
////---- fin debug
// --- maintenant on commence par définir la référence des noeuds frontières
// c-a-d de tous les noeuds contenues dans les éléments frontières
string ntoutfront("N_tout_front");
if (!lesRef.Existe(ntoutfront,idmail))
{ // on construit le tableau des numéros de noeuds
int nbNf = tab_noeud_front.Taille();
Tableau <int> tabN(nbNf); for (int i=1;i<=nbNf;i++) tabN(i)=tab_noeud_front(i)->Num_noeud();
ReferenceNE* rtoutfront = new ReferenceNE(tabN,idmail,1,ntoutfront);// construction de la référence
lesRef.Ajout_reference(rtoutfront); // ajout de la ref, qui est maintenant géré par lesRef
if (ParaGlob::NiveauImpression() >= 8) rtoutfront->Affiche();
if (ParaGlob::NiveauImpression() >= 4) cout << " N_tout_front ";
creationEffective = true;
};
// --- on continue par une référence sur les éléments de la frontière
string etoutfront("E_front");
if (!lesRef.Existe(etoutfront,idmail))
{ // on définit une liste de stockage transitoire, because plusieurs éléments frontières
// peuvent se rattacher à un même élément fini
list <int> listE;
LaLIST <Front>::iterator ili, ilifin = listFrontiere.end();
// on balaie les éléments frontière, et on récupère les éléments associé
for (ili=listFrontiere.begin();ili!=ilifin;ili++)
listE.push_back((*ili).PtEI()->Num_elt());
listE.sort();// on ordonne la listE
listE.unique();// on supprime les doublons
// on crée un tableau correspondant à la liste
// on construit le tableau des numéros des éléments
int nbEfront = listE.size();
Tableau <int> tabE(nbEfront);
list <int>::iterator ibi, ibifin = listE.end();
int i=1;
for (ibi=listE.begin();ibi!=ibifin;ibi++,i++)
tabE(i)=(*ibi);
ReferenceNE* retoutfront = new ReferenceNE(tabE,idmail,2,etoutfront);// construction de la référence
lesRef.Ajout_reference(retoutfront); // ajout de la ref, qui est maintenant géré par lesRef
if (ParaGlob::NiveauImpression() >= 8) retoutfront->Affiche();
if (ParaGlob::NiveauImpression() >= 4) cout << " ref E_front ";
creationEffective = true;
};
// ---- puis une référence sur les faces des éléments de la frontière
string ftoutfront("F_front");
if (!lesRef.Existe(ftoutfront,idmail))
{ // on construit le tableau des numéros d'éléments + numéros de face
//int nbEfront = listFrontiere.size();
// on définit une liste de stockage transitoire, because on ne connait pas a priori
// le nombre de face frontière
list <NBelemEtFace> listEface;
LaLIST <Front>::iterator ili, ilifin = listFrontiere.end();
// on balaie les éléments fronitère
NBelemEtFace nu; // une grandeur de travail
for (ili=listFrontiere.begin();ili!=ilifin;ili++)
{ Enum_type_geom type_front = (*ili).Eleme()->Type_geom_front(); // le type de frontière
// on récupère le numéro de la face (éventuellement 0)
nu.nbFace = (*ili).Num_frontiere();
// on n'intervient que si la frontière est une face
if (type_front == SURFACE)
{ nu.nbElem = (*ili).PtEI()->Num_elt(); // le numéro de l'élément
// on considère que la face existe
listEface.push_back(nu);
};
};
listEface.sort();// on ordonne la listE
listEface.unique();// on supprime les doublons
// maintenant on va s'occuper de créer la référence
int numElFace = listEface.size();
if (numElFace != 0)
{ // création des tableaux de numéros d'éléments et faces
Tableau<int> tabelem(numElFace); // éléments
Tableau<int> tabface(numElFace); // idem pour les face
list <NBelemEtFace >::iterator itn,itnfin=listEface.end();
int i=1;
for (itn=listEface.begin();itn!=itnfin;itn++,i++)
{tabelem(i)=(*itn).nbElem;tabface(i) = (*itn).nbFace;};
ReferenceAF* refAF = new ReferenceAF(tabelem,tabface,idmail,3,ftoutfront);// création de la référence
lesRef.Ajout_reference( refAF);
if (ParaGlob::NiveauImpression() >= 8) refAF->Affiche();
if (ParaGlob::NiveauImpression() >= 4) cout << " F_front ";
creationEffective = true;
};
};
// ---- et enfin une référence sur les lignes des éléments
// ainsi qu'une référence des seules noeuds des lignes frontières
string atoutfront("A_front");string nAreteFront("N_A_front");
//bool n_a_front_existe = lesRef.Existe(nAreteFront,idmail);
if (!lesRef.Existe(atoutfront,idmail))
{ // on construit le tableau des numéros d'éléments + numéros des arrêtes
//int nbEfront = listFrontiere.size();
// on définit une liste de stockage transitoire, because on ne connait pas a priori
// le nombre de face frontière
list <NBelemEtArete> listEArrete;
list <int> listN_Arrete; // idem pour les noeuds
LaLIST <Front>::iterator ili, ilifin = listFrontiere.end();
// on balaie les éléments frontières
NBelemEtArete nu; // une grandeur de travail
for (ili=listFrontiere.begin();ili!=ilifin;ili++)
{ Enum_type_geom type_front = (*ili).Eleme()->Type_geom_front(); // le type de frontière
// on récupère le numéro de l'arête (éventuellement 0)
nu.nbArete = (*ili).Num_frontiere();
// on n'intervient que si la frontière est une arête
if (type_front == LIGNE)
{ nu.nbElem = (*ili).PtEI()->Num_elt(); // le numéro de l'élément
// on considère que l'arête existe
listEArrete.push_back(nu);
// idem pour les noeuds
const Tableau <Noeud *> ttn = (*ili).Eleme()->TabNoeud_const();
int taillettn = ttn.Taille();
for (int k=1;k<=taillettn;k++)
listN_Arrete.push_back(ttn(k)->Num_noeud());
};
};
// maintenant on va s'occuper de créer la référence d'arêtes
int numElArrete = listEArrete.size();
if (numElArrete != 0)
{ // création des tableaux de numéros d'éléments et d'arêtes
Tableau<int> tabelem(numElArrete); // éléments
Tableau<int> tabArrete(numElArrete); // idem pour les arêtes
list <NBelemEtArete >::iterator itn,itnfin=listEArrete.end();
int i=1;
for (itn=listEArrete.begin();itn!=itnfin;itn++,i++)
{tabelem(i)=(*itn).nbElem;tabArrete(i) = (*itn).nbArete;};
ReferenceAF* refAF = new ReferenceAF(tabelem,tabArrete,idmail,4,atoutfront);// création de la référence
lesRef.Ajout_reference( refAF);
if (ParaGlob::NiveauImpression() >= 8) refAF->Affiche();
if (ParaGlob::NiveauImpression() >= 4) cout << " A_front ";
creationEffective = true;
};
// même chose pour la référence de noeuds
listN_Arrete.sort();// on ordonne la listE
listN_Arrete.unique();// on supprime les doublons
int numNArrete = listN_Arrete.size();
if (numNArrete != 0)
{ // création des tableaux de numéros de noeuds
Tableau<int> tabNArete(numNArrete);
list <int >::iterator itn,itnfin=listN_Arrete.end();
int i=1;
for (itn=listN_Arrete.begin();itn!=itnfin;itn++,i++)
tabNArete(i)=(*itn);
ReferenceNE* refNE = new ReferenceNE(tabNArete,idmail,1,nAreteFront);// création de la référence
lesRef.Ajout_reference( refNE);
if (ParaGlob::NiveauImpression() >= 4) refNE->Affiche();
if (ParaGlob::NiveauImpression() >= 4) cout << " N_A_front ";
creationEffective = true;
};
};
if (creationEffective) cout << endl;
if (ParaGlob::NiveauImpression() >= 4) cout << " end of automatic definition of frontier references " << endl ;
};
// vérification que toutes les références de noeuds, d'éléments, d'arêtes et de faces sont valides
// c-a-d se réfèrent à des éléments existants
void Maillage::VerifReference(LesReferences& lesRef)
{ // on va balayer toutes les références
const Reference* refi = lesRef.Init_et_Premiere(); // init du balyage
while (refi != NULL)
{ // on prend en compte que si c'est le bon maillage
if (refi->Nbmaille() == idmail)
{ // choix en fonction du type de référence
switch (refi->Indic())
{case 1: // cas de noeuds
{const ReferenceNE & refN = *((ReferenceNE *) refi);
int reftaille = refN.Taille();
int nbN = tab_noeud.Taille();
for (int nn =1; nn<= reftaille;nn++)
if ((refN.Numero(nn) < 0) || (refN.Numero(nn) > nbN))
{cout << "\n **** error, the node number " << refN.Numero(nn) << " don't belong to the range of nodes of the mesh "
<< nomDuMaillage << " [1,"<< nbN << "] "
<< "\n error of definition of the reference of nodes : " << refi->Nom() << endl;
if (ParaGlob::NiveauImpression() >= 6)
cout << "\n Maillage::VerifReference(LesReferences& lesRef) ";
Sortie(1);
}
}
break;
case 2: // cas d'éléments
{const ReferenceNE & refE = *((ReferenceNE *) refi);
int reftaille = refE.Taille();
int nbE = tab_element.Taille();
for (int nn =1; nn<= reftaille;nn++)
if ((refE.Numero(nn) < 0) || (refE.Numero(nn) > nbE))
{cout << "\n **** error, the element number " << refE.Numero(nn) << " don't belong to the range of element of the mesh "
<< nomDuMaillage << " [1,"<< nbE << "] "
<< "\n error of definition of the reference of elements : " << refi->Nom() << endl;
if (ParaGlob::NiveauImpression() >= 6)
cout << "\n Maillage::VerifReference(LesReferences& lesRef) ";
Sortie(1);
}
}
break;
case 3: // cas de surfaces d'éléments
{const ReferenceAF & refF = *((ReferenceAF *) refi);
int reftaille = refF.Taille();
int nbE = tab_element.Taille();
for (int nn =1; nn<= reftaille;nn++)
{ // récupération du numéro de face et élément
const int numE = refF.NumeroElem(nn); const int numF = refF.NumeroFA(nn);
if ((numE < 0) || (numE > nbE))
{cout << "\n **** error, the element number " << numE << " don't belong to the range of element of the mesh "
<< nomDuMaillage << " [1,"<< nbE << "] "
<< "\n error of definition of the reference of elements surfaces : " << refi->Nom() << endl;
if (ParaGlob::NiveauImpression() >= 6)
cout << "\n Maillage::VerifReference(LesReferences& lesRef) ";
Sortie(1);
};
// arrivé ici, cela signifie que l'élément existe, maintenant on regarde si la face peut exister
int nbface = tab_element(numE)->ElementGeometrique().NbFe();
if ((numF < 0) || (numF > nbface))
{cout << "\n **** error, the surface number " << numF << " of the element " << numE
<< " don't belong to the range of possible surfaces numbers of the element [1,"<< nbface << "] "
<< "\n error of definition of the reference of elements surfaces : " << refi->Nom() << endl;
if (ParaGlob::NiveauImpression() >= 6)
cout << "\n Maillage::VerifReference(LesReferences& lesRef) ";
Sortie(1);
};
};
}
break;
case 4: // cas d'arêtes d'éléments
{const ReferenceAF & refA = *((ReferenceAF *) refi);
int reftaille = refA.Taille();
int nbE = tab_element.Taille();
for (int nn =1; nn<= reftaille;nn++)
{ // récupération du numéro d'arête et élément
const int numE = refA.NumeroElem(nn); const int numA = refA.NumeroFA(nn);
if ((numE < 0) || (numE > nbE))
{cout << "\n **** error, the element number " << numE << " don't belong to the range of element of the mesh "
<< nomDuMaillage << " [1,"<< nbE << "] "
<< "\n error of definition of the reference of elements edge : " << refi->Nom() << endl;
if (ParaGlob::NiveauImpression() >= 6)
cout << "\n Maillage::VerifReference(LesReferences& lesRef) ";
Sortie(1);
};
// arrivé ici, cela signifie que l'élément existe, maintenant on regarde si l'arête peut exister
int nbArete = tab_element(numE)->ElementGeometrique().NbSe();
if ((numA < 0) || (numA > nbArete))
{cout << "\n **** error, the edge number " << numA << " of the element " << numE
<< " don't belong to the range of possible edges numbers of the element [1,"<< nbArete << "] "
<< "\n error of definition of the reference of elements edges : " << refi->Nom() << endl;
if (ParaGlob::NiveauImpression() >= 6)
cout << "\n Maillage::VerifReference(LesReferences& lesRef) ";
Sortie(1);
};
};
}
break;
default:
if (ParaGlob::NiveauImpression() >= 6)
cout << " \n indication ! no verification for reference on element node and on gauss point ";
break;
}
}
refi = lesRef.Reference_suivante();
}
};
// méthode pour initialiser les différents tableaux utilisés par Orientation_elements_mitoyens_recursif
void Maillage::Init_Orientation_elements_mitoyens_recursif()
{ // - on initialise le tableau d'indicateur, permettant de savoir si un élément a été traité ou pas
int nb_elem = tab_element.Taille();
ind_elem.Change_taille(nb_elem,false); // def et init à 0, c-à-d non traité
// --- à chaque fois que l'on va inverser le sens d'un élément, le sens de ses frontières normalement devrait également changer
// mais comme on ne les recalcule pas, on utilise un tableau pour s'en rappeler et s'en servir, au début = 1 pour tous les éléments
tab_sens_element.Change_taille(nb_elem,1.); // ensuite quand le sens change, la valeur passe à -1
};
// ** pour l'instant ne fonctionne que pour les éléments surfaces
// orientation automatique des éléments mitoyens, à l'élément num_elem, et ensuite
// récursivement à tous les éléments mitoyens des mitoyens jusqu'à ce que la chaine s'arrête
// L'ensemble des éléments est alors groupé dans une référence qui est construit
// . soit à partir du numéro num_elem
// . soit à partir d'un nom passé en paramètre (cf. nom_ref, ci dessous)
// et qui est ajouté aux refs déjà existantes
// ensuite, le programme passe en revue les éléments restants, et regarde s'ils font parti
// d'un ensemble homogène orienté, si non, ramène la liste des éléments hors ensemble orienté
// *** ne concerne que les éléments surfaces, les autres sont ignorés
// ind_elem(i) : (tableau interne) indique si l'élément i a été traité (=true) ou non (=false)
// ind_elem: est pris en compte puis mis à jour par le programme, c-a-d que les nouveaux éléments orienté
// passe de false à true, par contre tous les éléments déjà à true, ne sont pas pris en compte dans le traitement
// angle_maxi : angle maximum entre deux éléments, au dessus duquel on considère qu'il y a une rupture de la mitoyenneté
// nom_ref : s'il est différent de "_", donne le nom de base voulu à la série de référence qui va être construite
// inverse : indique si l'on souhaite partir d'une orientation inverse de celle existante avant application de l'algo
// ceci pour l'élément de départ: au premier appel, l'opération est toujours possible, ensuite cela dépend
// si l'élément trouvé a déjà été traité ou pas
// recursiv : indique si l'on se situe dans une suite récursive d'appel de la méthode
// si oui, seule les éléments non déjà pris en compte dans les appels précédents, sont examiné
// c'est ind_elem qui permet de s'en assurer
// si non: cas par exemple d'un angle_maxi qui change, on réexamine tous les éléments, cependant
// la ré_orientation éventuelle n'est faite qu'une seule fois (toujours via ind_elem)
list <int> Maillage::Orientation_elements_mitoyens_recursif(bool recursif,string& nom_base_ref,int num_elem
,LesReferences& lesRef,double& angle_maxi,bool inverse)
{ double cos_angle_maxi = cos(angle_maxi); // pour simplifier
// --- à chaque fois que l'on va inverser le sens d'un élément, le sens de ses frontières normalement devrait également changer
// mais comme on ne les recalcule pas, on utilise le tableau tab_sens_element (tableau interne)
// pour s'en rappeler et s'en servir, au début = 1 pour tous les éléments
// ensuite quand le sens change, la valeur passe à -1
int nb_elem = tab_element.Taille();
int compteur_elem_inverse=0; // pour compter le nombre d'éléments inversés
// --- def de la liste des éléments qui ont été traité
list <int> ele_oriente; // la liste des éléments qui ont été orienté, donc qui ont la même orientation
// servira à la fin pour créer les références
// --- définition et initialisation de la liste d'éléments qu'il faut traiter
list <int> ele_a_traiter; // la liste des éléments qu'il faut traiter
ele_a_traiter.push_back(num_elem); // on initialise la liste à l'aide du numéro du premier élément à traiter
// si c'est possible on change l'orientation de l'élément si c'est demandé
if (inverse && (ind_elem(num_elem)==false))
{ tab_element(num_elem)->Modif_orient_elem(0);
tab_sens_element(num_elem)=-1.;
};
#ifdef MISE_AU_POINT
if (ParaGlob::NiveauImpression() > 4)
{ cout << "\n racine element nb: "<<num_elem<<" sens:"<<tab_sens_element(num_elem)<<endl;
};
#endif
ind_elem(num_elem)=true; // on signale (dans tous les cas) que l'élément a été traité
// c'est forcément une surface, car l'algo n'est appelé que dans ce cas
ele_oriente.push_back(num_elem); // init avec le premier élément
// -- def du tableau des Front qui ont été traité: elle permet d'éviter qu'une frontière (qui est dupliqué selon
// le nombre d'éléments qui la partage) soit traité plusieurs fois dans les boucles de recherches
// t_front_deja_traite(i)(j) : indique si la frontière j de l'élément i, est traité ou non
Tableau < Tableau <bool> > t_front_deja_traite(nb_elem);
for (int i=1;i<=nb_elem;i++)
t_front_deja_traite(i).Change_taille(mitoyen_de_chaque_element(i).Taille(),false);
// --- on va passer en revue tous les éléments de manière récursive, ceci à partir du premier élément: num_elem
// on n'intervient que pour les éléments surfaces en 3D et ligne en 2D
int dim = ParaGlob::Dimension(); // la dimension de l'espace de travail
Coordonnee A,B,C,AB,AC,N; // des variables de travail
Coordonnee Ap,Bp,Dp,ApBp,ApDp,N_mitoy; // """
while (ele_a_traiter.size() != 0)
{ list <int>::iterator iter_elem_a_traiter = ele_a_traiter.begin(); // récup du premier élément
int num_elem_a_traiter = (*iter_elem_a_traiter); // récup du numéro de l'élément
ele_a_traiter.erase(iter_elem_a_traiter); // on supprime l'élément de la liste à traiter
// récup des Front de l'élément
Tableau <Front>& mtce = mitoyen_de_chaque_element(num_elem_a_traiter);
// et on ne contine que s'il s'agit d'un élément surface (ajout 15 avril 2016) en 3D
// ou une ligne en 2D
if ( (Type_geom_generique(tab_element(num_elem_a_traiter)->Id_geometrie()) == SURFACE)
|| ((dim == 2)&& (Type_geom_generique(tab_element(num_elem_a_traiter)->Id_geometrie()) == LIGNE))
)
{int dim_mtce = mtce.Taille();
// on passe en revue tous les Front
for (int i=1;i<= dim_mtce;i++)
{ // on ne va s'intéresser qu'aux frontières lignes, qui sont celles qui joignent les éléments de surface
// + aux cas où il existe des éléments mitoyens + au cas où le Front n'a pas été traité
Front& fro = mtce(i); // pour simplifier
const Tableau <Front*>* tabmitoy = fro.TabMitoyen();
if ((fro.Eleme()->Type_geom_front() == LIGNE) && (tabmitoy != NULL)
&& (!t_front_deja_traite(num_elem_a_traiter)(fro.Num_frontiere())) )
{ int tail_tabmitoy = tabmitoy->Taille();
// --- on calcul une normale à l'élément à l'aide des extrémités de la frontière ligne et d'un autre point
// ou d'un déterminant, dans le cas 2D
Tableau <Noeud *>& tab_N_fro = fro.Eleme()->TabNoeud(); // récup des noeuds de la frontière ligne
int tail_N_fro=tab_N_fro.Taille(); // récup de la taille
A=tab_N_fro(1)->Coord0(); B= tab_N_fro(tail_N_fro)->Coord0(); // def des extrémités
// on récupère les numéros de A et B
int num_A=tab_N_fro(1)->Num_noeud();int num_B=tab_N_fro(tail_N_fro)->Num_noeud();
// on cherche un troisième noeud de l'élément, différent
Tableau<Noeud *>& tab_N_elem = tab_element(num_elem_a_traiter)->Tab_noeud();
int NBN=tab_N_elem.Taille();
bool trouve_C=false;
for (int j=1;j<=NBN;j++)
{ Noeud * pt_noeud=tab_N_elem(j);
if ((pt_noeud->Num_noeud() != num_A) && (pt_noeud->Num_noeud() != num_B))
{ C=pt_noeud->Coord0(); trouve_C=true;break;};
};
if (!trouve_C)
{ cout << "\n *** erreur dans l'algo Orientation_elements_mitoyens_recursif, on n'a pas"
<< " trouve de point C ?? l'orientation automatique risque d'etre erronee " << endl;
};
// calcul des vecteurs intermédiaire
AB=B-A;AC=C-A;
double deter_centrale = 0.; // util pour le cas 2D
if (dim == 3) // dans le cas 3D on utilise la normal
{ N=Util::ProdVec_coor(AB,AC); N.Normer();} // calcul de la normale, normée
else { deter_centrale = Util::Determinant(AB,AC);}; // cas 2D: on utilise le déterminant pour déterminer le sens
Front* fro_retenu=NULL; // init du Front que l'on retiendra au final
bool mitoyen_meme_sens = true; // par défaut on initialise l'élément mitoyen comme étant de même sens
// dans le cas où on a plusieurs éléments Front mitoyen, et que l'on est en dimension 3, on choisit un seul,
// celui qui correspond à un Element qui est le plus dans le prolongement de l'élément num_elem_a_traiter
// en dimension 2, il n'y a pas de choix possible, on prend le premier élément
if ((tail_tabmitoy > 1) && (dim == 3))
{ // --- on passe en revue tous les mitoyens et on retiend celui donc la normale est le plus // avec celle de l'élément
// donc dont le produit scalaire avec la normale, est le plus important
double projection = 0.; int num_front_mitoy = 0;
for (int j=1;j<=tail_tabmitoy;j++)
{ Front& fri = *(*tabmitoy)(j); // pour simplifier
// si on est récursif, on ne continue que si l'élément associé n'a pas été traité
int num_e = fri.PtEI()->Num_elt(); // récup du numéro de l'élément
// et on ne contine que s'il s'agit d'un élément surface (ajout 15 avril 2016) en 3D
if (Type_geom_generique(tab_element(num_e)->Id_geometrie()) == SURFACE)
{if (!ind_elem(num_e) || !recursif )
{ Tableau <Noeud *>& tab_N_fri = fri.Eleme()->TabNoeud(); // récup des noeuds de la frontière ligne
int tail_N_fri=tab_N_fri.Taille(); // récup de la taille
Ap=tab_N_fri(1)->Coord0(); Bp= tab_N_fri(tail_N_fro)->Coord0(); // def des extrémités
// on récupère les numéros de Ap et Bp
int num_Ap=tab_N_fri(1)->Num_noeud();int num_Bp=tab_N_fri(tail_N_fri)->Num_noeud();
// on cherche un troisième noeud de l'élément, différent des deux noeuds centraux
Tableau <Noeud *>& tab_N_elem_mitoy = fri.PtEI()->Tab_noeud(); // récup des noeuds de l'élément mitoyen
int NBN_mitoyen=tab_N_elem_mitoy.Taille();
bool trouve_Dp = false;
for (int k=1;k<=NBN_mitoyen;k++)
{ Noeud * pt_n=tab_N_elem_mitoy(k);
if ((pt_n->Num_noeud() != num_Ap) && (pt_n->Num_noeud() != num_Bp))
{ Dp=pt_n->Coord0(); trouve_Dp = true; break;};
};
if (!trouve_Dp)
{ cout << "\n *** erreur dans l'algo Orientation_elements_mitoyens_recursif, on n'a pas"
<< " trouve de point Dp ?? l'orientation automatique risque d'etre erronee " << endl;
};
// calcul de la nouvelle normale, normée ici pour que ça soit indépendant de la surface de ABD
// (on utilise que la normale, car ici on doit être en 3D vue le test en début de block)
ApBp=Bp-Ap; ApDp=Dp-Ap; N_mitoy=Util::ProdVec_coor(ApBp,ApDp);N_mitoy.Normer();
// si l'élément de référence (num_elem_a_traiter) a eu un sens modifié, on en tient compte à l'aide de tab_sens_element
double essai_projection = tab_sens_element(num_elem_a_traiter) * N * tab_sens_element(num_e) * N_mitoy;
// fro.Affiche(); fri.Affiche();
// cout << "\n tab_sens_element(num_elem_a_traiter) " << tab_sens_element(num_elem_a_traiter) << " essai_projection "<< essai_projection;
// cout << "\n ele= "<< fro.PtEI()->Num_elt() << " elem_mitoy= " << fri.PtEI()->Num_elt()
// << "\n A:" << A << " B: " << B << " C: " << C << " N: " << N
// << "\n Ap: "<<Ap<< " Bp: " << Bp << " Dp: " << Dp << " N_mitoy: " << N_mitoy << endl;
if (Abs(essai_projection) > Abs(projection))
{projection = essai_projection; num_front_mitoy = j;};
// cout << "\n ** num_front_mitoy= " << num_front_mitoy << " projection= " << projection << endl;
};
};
};
// arrivée ici on a la projection de l'élément associé, dans le cas où l'on a trouvé un élément non déjà traité
if((num_front_mitoy != 0) && (Abs(projection) > Abs(cos_angle_maxi)))
{ fro_retenu = (*tabmitoy)(num_front_mitoy); // on enregiste le front de l'élément mitoyen
if (projection < 0) {mitoyen_meme_sens = false;} // on regarde le sens
else {mitoyen_meme_sens = true;};
};
}
else if (tail_tabmitoy != 0)
{ // si on est récursif, on ne continue que si l'élément associé n'a pas été traité
int num_e = (*tabmitoy)(1)->PtEI()->Num_elt(); // récup du numéro de l'élément
// et on ne contine que s'il s'agit d'un élément surface (ajout 15 avril 2016) en 3D
// ou une ligne en 2D
if ( (Type_geom_generique(tab_element(num_e)->Id_geometrie()) == SURFACE)
|| ((dim == 2)&& (Type_geom_generique(tab_element(num_e)->Id_geometrie()) == LIGNE))
)
{ if (!ind_elem(num_e) || !recursif )
{ fro_retenu = (*tabmitoy)(1); // enreg
// on calcul une normale, pour ensuite avec la projection, savoir si le sens des éléments mitoyens est identique ou pas
Tableau <Noeud *>& tab_N_fro_retenu = fro_retenu->Eleme()->TabNoeud(); // récup des noeuds de la frontière ligne
int tail_N_fro_retenu=tab_N_fro_retenu.Taille(); // récup de la taille
Ap=tab_N_fro_retenu(1)->Coord0(); Bp= tab_N_fro_retenu(tail_N_fro)->Coord0(); // def des extrémités
// on récupère les numéros de Ap et Bp
int num_Ap=tab_N_fro_retenu(1)->Num_noeud();int num_Bp=tab_N_fro_retenu(tail_N_fro_retenu)->Num_noeud();
// on cherche un troisième noeud de l'élément, différent des deux noeuds centraux
Tableau <Noeud *>& tab_N_elem_mitoy = fro_retenu->PtEI()->Tab_noeud(); // récup des noeuds de l'élément mitoyen
int NBN_mitoyen=tab_N_elem_mitoy.Taille();
for (int k=1;k<=NBN_mitoyen;k++)
{ Noeud * pt_n=tab_N_elem_mitoy(k);
if ((pt_n->Num_noeud() != num_Ap) && (pt_n->Num_noeud() != num_Bp))
{ Dp=pt_n->Coord0(); break;};
};
// on différencie ici les cas 2D et 3D
ApBp=Bp-Ap; ApDp=Dp-Ap;
if (dim == 3)
{ // calcul de la nouvelle normale, normée ici pour que ça soit indépendant de la surface de ABD
N_mitoy=Util::ProdVec_coor(ApBp,ApDp);N_mitoy.Normer();
// si l'élément de référence (num_elem_a_traiter) a eu un sens modifié, on en tient compte à l'aide de tab_sens_element
// idem avec l'élément considéré
double projection = tab_sens_element(num_elem_a_traiter) * N * tab_sens_element(num_e) * N_mitoy;
if ( projection < 0) {mitoyen_meme_sens = false;} // on regarde le sens
else {mitoyen_meme_sens = true;};
// si l'angle est trop grand on ne tiens pas compte de la mitoyenneté
if (Abs(projection) < Abs(cos_angle_maxi))
fro_retenu = NULL;
// fro.Affiche(); fro_retenu->Affiche();
// cout << "\n tab_sens_element(num_elem_a_traiter) " << tab_sens_element(num_elem_a_traiter) << " projection "<<projection;
// cout << "\n ele= "<< fro.PtEI()->Num_elt() << " elem_mitoy= " << fro_retenu->PtEI()->Num_elt()
// << "\n A:" << A << " B: " << B << " C: " << C << " N: " << N
// << "\n Ap: "<<Ap<< " Bp: " << Bp << " Dp: " << Dp << " N_mitoy: " << N_mitoy << endl;
}
else // cas 2D, on utilise les déterminants (ici il n'y a pas le pb de l'angle)
{ double deter_mitoy = Util::Determinant(ApBp,ApDp);
if ( (deter_centrale * deter_mitoy) < 0) {mitoyen_meme_sens = false;} // on regarde le sens
else {mitoyen_meme_sens = true;};
};
};
};
};
// on ne traite que s'il y a effectivement un candidat mitoyen recevable
if (fro_retenu != NULL)
{ int num_e = fro_retenu->PtEI()->Num_elt(); // récup du numéro de l'élément
if (!t_front_deja_traite(num_e)(fro_retenu->Num_frontiere()))
{ // si il faut un changement d'orientation et que c'est possible on change
bool suite_traitement_possible = true; // init par défaut
if (!mitoyen_meme_sens) // changement d'orientation au cas où
{ if (!ind_elem(num_e))
{tab_element(num_e)->Modif_orient_elem(0); // "
tab_sens_element(num_e)=-1.;
compteur_elem_inverse++;
}
else
{suite_traitement_possible = false;
#ifdef MISE_AU_POINT
if (ParaGlob::NiveauImpression() > 4)
{ cout << "\n ref "<<nom_base_ref<<" ele:"<<num_elem_a_traiter <<" ne peut s'associer a "<< num_e
<< " car chg de sens demande impossible "<<endl;
};
#endif
};
};
// si tout est ok on enregistre
if (suite_traitement_possible)
{ ele_oriente.push_back(num_e); // enreg pour la constitution des éléments ayant la même orientation
ind_elem(num_e)=true; // on enregistre le fait que l'élément a été traité
//--debug
//cout << "\n elem pere " << num_elem_a_traiter << " élément traité qui devient père " << num_e << endl;
//--fin debug
ele_a_traiter.push_back(num_e); // ajout dans la liste des éléments à traiter en tant que père
// on indique pour les deux éléments mitoyens que la frontière commune, a été traité
t_front_deja_traite(num_elem_a_traiter)(fro.Num_frontiere())=true; // pour l'élément père
t_front_deja_traite(num_e)(fro_retenu->Num_frontiere())=true; // pour l'élément fils
};
};
};
};
};
};
};
if (ParaGlob::NiveauImpression() > 3)
{if (ParaGlob::Francais())
{cout << "\n nombre d'element inverses " << compteur_elem_inverse;}
else {cout << "\n number of elements with change of orientation : " << compteur_elem_inverse;};
};
// --- définit une nouvelle référence qui contient tous les éléments qui ont été traité
// s'il s'agit bien de surface
// on définit un nom possible pour la référence
if ( (Type_geom_generique(tab_element(num_elem)->Id_geometrie()) == SURFACE)
|| ((dim == 2)&& (Type_geom_generique(tab_element(num_elem)->Id_geometrie()) == LIGNE))
)
{string nom_ref;
if (nom_base_ref == "_")
{ nom_ref = "E_ref_de_meme_orientation_que_ele_"+ChangeEntierSTring(num_elem);}
else // cas où l'on spécifie un nom
{ nom_ref = "E_"+nom_base_ref;};
while (lesRef.Existe(nom_ref,idmail)) // on regarde si le nom existe, si oui on ajoute un tiret
nom_ref = nom_ref+"-";
ReferenceNE* refeE = new ReferenceNE(ele_oriente,idmail,2, nom_ref); // création de la ref
lesRef.Ajout_reference(refeE); // ajout de la ref
// idem pour une référence de face
string nom_refS;
if (nom_base_ref == "_")
{ nom_refS = "F_ref_de_meme_orientation_que_ele_"+ChangeEntierSTring(num_elem);}
else // cas où l'on spécifie un nom
{ nom_refS = "F_"+nom_base_ref;};
while (lesRef.Existe(nom_refS,idmail)) // on regarde si le nom existe, si oui on ajoute un tiret
nom_refS = nom_refS+"-";
// il faut définir une deuxième liste de 1 pour définir des faces
list <int> list_face(ele_oriente.size(),1);
ReferenceAF* refeS = new ReferenceAF(ele_oriente,list_face,idmail,2, nom_refS); // création de la ref
lesRef.Ajout_reference(refeS); // ajout de la ref
if (ParaGlob::NiveauImpression() > 0)
{if (ParaGlob::Francais())
{cout << "\n creation de la reference : " << nom_ref << " ("<<refeE->Taille() <<" elements )";
cout << "\n creation de la reference : " << nom_refS << " ("<<refeS->Taille() <<" surfaces )";}
else {cout << "\n creation of the reference : " << nom_ref << " ("<<refeE->Taille() <<" elements )";
cout << "\n creation of the reference : " << nom_refS << " ("<<refeS->Taille() <<" surfaces )";};
};
};
// --- on construit la liste des éléments qui n'ont pas été orienté
list <int> list_elem_non_orient; // def de la liste des éléments non orientés
for (int i=1;i<=nb_elem;i++)
if (!ind_elem(i))
list_elem_non_orient.push_back(i);
// retour
return list_elem_non_orient;
};
// change le numéro de maillage
void Maillage::Change_numero_maillage(int new_num)
{ if (idmail != new_num)
{ idmail = new_num;
// on s'occupe des noeuds,
int nbn = tab_noeud.Taille();
for (int i=1;i<=nbn;i++)
tab_noeud(i)->Change_num_Mail(new_num);
// puis les éléments
int nbelem = tab_element.Taille();
for (int ie=1;ie<=nbelem;ie++)
tab_element(ie)->Change_num_maillage(new_num);
// la liste des noms de maillages
listeNomMail[nomDuMaillage]=idmail;
};
};
// méthode pour orienter des éléments en fonction d'un rayon: AG, A étant un point donné, G étant le centre de
// gravité d'une facette
// A : coordonnée d'un point, si indic_G(i) est true, alors A(i) est remplacé par la coordonnée G(i) du centre
// de gravité de la facette
// zone_a_traiter: le nom de la référence des éléments a traiter
// inverse : si true, l'orientation des normales des facettes est identique à celles de AG, sinon c'est l'inverse
void Maillage::Orientation_via_rayon(const Tableau <bool> & indic_G,const Coordonnee & A
,const string& zone_a_traiter, LesReferences& lesRef, bool inverse)
{ // on commence par récupérer la liste des éléments sur laquelle on va travailler
const ReferenceNE & refa = ((ReferenceNE &) lesRef.Trouve(zone_a_traiter,idmail));
const Tableau<int>& tabN_de_Ref = refa.Tab_num(); // le tableau des éléments
int dim = ParaGlob::Dimension();
if (dim != 3)
{ cout << "\n la dimension de l'espace n'est pas 3, le traitement n'est pas possible !! ";
if (ParaGlob::NiveauImpression() > 2)
cout << "\n Maillage::Orientation_via_rayon(...";
cout << endl;
return;
};
// on parcours tous les éléments
int nbn_ref = tabN_de_Ref.Taille();
for (int i = 1; i <= nbn_ref;i++)
{ int nbE = tabN_de_Ref(i); // on récupère le numéro de l'élément
// on n'effectue le traitement que s'il s'agit d'une surface
Element& ele = *(tab_element(nbE));
////--- debug
//if (ele.Num_elt()==316)
// cout << "\n debug Maillage::Orientation_via_rayon(..." << endl;
//
////--- fin debug
if (Type_geom_generique(ele.Id_geometrie()) == SURFACE)
{ //calcul du centre de gravité
Coordonnee3 G(dim);
Tableau <Noeud *> taN = ele.Tab_noeud();
int nbn = taN.Taille();
for (int inn = 1;inn<=nbn;inn++)
{Noeud* noe = taN(inn);
G += noe->Coord0();
};
G /= nbn;
// calcul du vecteur rayon
Coordonnee3 AG(dim);
for (int ia = 1;ia<=dim;ia++)
{ if (indic_G(ia))
{AG(ia)=0.; } // c'est le cas où on utilise la coordonnée du centre de gravité
else {AG(ia) = G(ia) - A(ia);};
};
AG.Normer();
// // on calcul une normale moyenne à la surface
// // tout d'abord on choisit un premier point pour un premier segment
// Coordonnee3 B = taN(1)->Coord0();
// Coordonnee3 GB(B-G);
// Coordonnee3 N;
// // on parcours tous les noeuds et on ajoute les normales
// for (int inn = 2;inn<=nbn;inn++)
// {Noeud* noe = taN(inn);
// Coordonnee3 C(noe->Coord0());
// Coordonnee3 GC(C-G);
// N += Util::ProdVec_coor(GB,GC);
// };
// N /= nbn-1;
// en fait la précédente méthode peut poser des pb,
// on choisit une méthode plus simple
// une première arête
Coordonnee3 A1A2(taN(2)->Coord0()-taN(1)->Coord0());
// une seconde
Coordonnee3 A2A3(taN(3)->Coord0()-taN(2)->Coord0());
Coordonnee3 N(Util::ProdVec_coor(A1A2,A2A3));
N.Normer();
// on test le sens
bool a_inverser = false; // init
if ( (AG * N) > 0.) // même sens
{if (inverse) a_inverser = true;
else a_inverser = false;
}
else // sens inverse
{if (inverse) a_inverser = false;
else a_inverser = true;
};
////--- debug
//{if (ele.Num_elt()==1)
// cout << "\n debug Maillage::Orientation_via_rayon(..." << endl;
// cout << "\n element: " << ele.Num_elt() <<", AG * N = " << AG * N << " a_inverser= "<< a_inverser
// << " AG= "<<AG <<" N= "<< N;
//}
//
////--- fin debug
// s'il faut inverser on inverse
if (a_inverser)
ele.Modif_orient_elem(0);
};
};
};
Reference in a new issue View git blame Copy permalink