rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/herezh_pp/Maillage/Maillage.h

960 lines
53 KiB
C
Raw Normal View History

mise en place des sources d'Herezh, d'un makefile, et d'un readme pour l'installation d'un exécutable
2021-10-14 08:59:14 +02:00
// FICHIER : Maillage.h
// 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-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
/************************************************************************
* DATE: 23/01/97 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: def de la classe Maillage, *
* Une instance de la classe Maillage est identifiee a partir *
* de la dimension, des tableaux des noeuds et des elements. *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef MAILLAGE_H
#define MAILLAGE_H
#include <iostream>
#include <map>
#include "Noeud.h"
#include "Element.h"
#include "Tableau_T.h"
#include "UtilLecture.h"
#include "Enum_geom.h"
#include "Enum_interpol.h"
#include "LesReferences.h"
#include "Front.h"
#include "LaList.h"
#include "Nb_assemb.h"
#include "Ddl_enum_etendu.h"
#include "Droite.h"
#include "Plan.h"
#include "Sphere.h"
#include "Cylindre.h"
#include "Cercle.h"
#include "Condilineaire.h"
#include "DiversStockage.h"
/// @addtogroup Les_Maillages
/// @{
///
//------------------------------------------------------------------
//! Maillage: un maillage particulier
//------------------------------------------------------------------
/// \author Gérard Rio
/// \version 1.0
/// \date 23/01/97
class Maillage
{
public :
friend class LesMaillages;
// CONSTRUCTEURS :
// pour tous les constructeurs: map < string, int , std::less <string> >* lisNomMail,
// est un tableau associatif nom <=> numéro de maillage, qui est utilisé par
// les maillages, mais mis à jour par chaque maillage.
// nom_maillage : est facultatif, s'il est différent de ".", il est pris en compte
// Constructeur par defaut
Maillage (map < string, int , std::less <string> > & lisNomMail,int nmail=1,int dim=3
,const string& nom_maillage = ".");
// Constructeur fonction d'une dimension, du nombre de noeuds
// du nombre d'elements, et d'un numero d'identification (le nb de maillage)
Maillage (map < string, int , std::less <string> > & lisNomMail
,int dim,int n_noeud,int n_elt,int nmail
,const string& nom_maillage = ".");
// Constructeur fonction de la plupart des informations (qui peuvent être vide
// mais doivent être cohérentes)
// *** il n'y a pas de création de nouveaux noeuds et de nouveaux éléments,
// ce sont les éléments et noeuds passés en paramètres qui sont ceux du maillage créé
Maillage (map < string, int , std::less <string> > & lisNomMail
,int dim,list <Noeud* >& li_noeud, list <Element* > li_element
,int nmail
,const string& nom_maillage = ".");
// Constructeur de copie, cependant ici il n'y a pas de création de noeud ni d'élément
// c'est seulement une création de nouveaux conteneurs de pointeurs
// cependant le numéro de maillage et le nom de maillage n'est pas valide, il faut
// ensuite les définir
Maillage (const Maillage& mail);
// Constructeur de copie, avec création de nouveaux noeuds et éléments identiques à ceux passées
// en argument, nmail: donne le numéro du nouveau maillage créée, qui est donc a priori différent
// de celui de mail, idem pour le nom du maillage
// les frontières ne sont pas transmises ni calculées !
Maillage (map < string, int , std::less <string> > & lisNomMail
,int nmail, const string& nomDuMaillage, const Maillage& mail);
// DESTRUCTEUR :
~Maillage ();
// METHODES :
// lecture de maillages au travers des outils de la classe
// UtilLecture et def des references s'y rapportant
void LectureMaillage(UtilLecture * entreePrinc,LesReferences& lesRef);
// lecture et application des opérations d'affinages sur le maillage: ex:déplacement solide
void LectureEtApplicationAffinage(UtilLecture * entreePrinc,LesReferences& lesRef);
// ajout d'une liste de noeud à un maillage
// si le numéro de maillage associé au noeud est nul, il est remplacé par celui du maillage
// si le numéro de maillage est déjà existant et est différent ce celui de this, il y a
// création d'un nouveau noeud identique, avec le numéro this
// ajout éventuel d'une liste de référence de noeuds, si celle-ci est non-nulle
// il y a création de nouvelles ref correspondantes au numéro de maillage de this
// et ces références sont rajoutées à lesRef
void Ajout_de_Noeuds(const list <Noeud *> & taN,list <const Reference*>* lref=NULL,LesReferences* lesRef=NULL );
// ajout d'une liste d'éléments et de noeud à un maillage
// si le numéro de maillage associé à l'élément ou noeud est nul, il est remplacé par celui du maillage
// si le numéro de maillage est déjà existant et est différent ce celui de this, il y a
// création d'un nouvel item identique, avec le numéro this
// ajout éventuel d'une liste de références associées , si celle-ci est non-nulle
// il y a création de nouvelles ref correspondantes au numéro de maillage de this
// et ces références sont rajoutées à lesRef
// les noeuds qui sont associés aux éléments de taE, doivent faire partie : soit de taN, soit du maillage this
void Ajout_elements_et_noeuds(const list <Noeud *> & taN, const list <Element *> & taE,list <const Reference*>* lref,LesReferences* lesRef );
// affichage et definition interactive des commandes
// cas = 1: interactif complet
// cas = 2: entrée uniquement de noms de fichier
void Info_commande_Maillages(UtilLecture * entreePrinc,LesReferences& lesRef, int cas);
// Affiche les donnees du maillage
void Affiche () const ;
// Affiche les donnees du maillage dans un fichier
// dont le nom est construit à partir du nom du maillage
// au format ".her" et ".lis"
void Affiche_dans_her_lis(LesReferences &lesRef,Enum_dure temps);
//modification du maillage pour le restreindre aux seuls éléments de la référence passée en paramètre
// toutes les infos relatives à des éléments supprimés, sont également supprimés
void Restreint_sous_maillage(LesReferences* lesRef, string nom_ref);
// Surcharge de l'operateur = : realise l'egalite de deux maillages
// cependant le numéro de maillage et le nom de maillage n'est pas valide, il faut
// ensuite les définir
Maillage& operator= (Maillage& mail);
inline int Dimension () const
// Retourne la dimension
{ return dimension; };
// ramène la liste des problèmes physiques gérés par les éléments du maillage
inline const Tableau <Enum_ddl >& Ddl_representatifs_des_physiques()const
{return ddl_representatifs_des_physiques;};
// ramene la liste des degrés de liberté inconnus, associés aux pb
// physiques gérés par les éléments qui existent dans le maillage
// Si éléments mécaniques -> ddl Xi voir Vi et gamma_i
// Si éléments thermiques -> ddl de température
// Si éléments méca + éléments thermiques -> ddl Xi et température
// etc. en fonction des éléments qui existent dans le maillage
inline const Tableau <EnumElemTypeProblem >& Types_de_problemes() const
{return types_de_problemes;};
inline int Nombre_noeud_elt(int i) const
// Retourne le nombre de noeuds lies au ieme element
{ return tab_element(i)->Nombre_noeud(); };
inline int Nombre_noeud() const
// Retourne le nombre de noeuds du maillage
{ return tab_noeud.Taille(); };
inline int Nombre_element() const
// Retourne le nombre d'elements du maillage
{ return tab_element.Taille(); };
inline Tableau<Noeud *>& Tab_noeud()
// Retourne le tableau des noeuds
{ return tab_noeud; };
inline Tableau<Element *>& Tab_element()
// Retourne le tableau des elements
{ return tab_element; };
inline Noeud& Noeud_mail(int i)
// Retourne le ieme noeud Noeud du tableau tab_noeud
{ return *tab_noeud(i); };
inline Element& Element_mail(int i)
// Retourne le ieme element Element du tableau tab_element
{ return *tab_element(i); };
// idem mais en version constant
inline const Element& Element_mail_const(int i)
{ return *tab_element(i); };
// test si toutes les informations des maillages sont completes
// = true -> complet
// = false -> incomplet
bool Complet();
// ramene la demi largeur de bande en ddl et la largeur de bande
void Largeur_Bande(int& demi, int& total,const Nb_assemb& nb_casAssemb);
// test pour savoir si tous les coordonnées des noeuds d'un maillage sont imposé
// ramène 1 si tout est fixé, 0 sinon
int Tous_Xi_fixes(const Nb_assemb& casAss) const;
// calcule des normales aux noeuds: dans le cas d'éléments 1D ou 2D uniquement
// a priori le calcul s'effectue par une moyenne des normales des éléments qui
// entourent le noeud.
// init -> calcul des normales à t=0
// et ajout conteneur aux noeuds des normales à t = 0 et t
void InitNormaleAuxNoeuds();
// mise à jour -> mise à jour des normales à t
void MiseAjourNormaleAuxNoeuds();
// mise à jour -> mise à jour des normales à t
// mais ici, on calcule les normales à tdt, et on transfert à t
// cette méthode est utile si on veut utiliser des normales à t pour une valeur
// particulière (transitoire) de la géométrie à tdt
// cf: l'algo non dyna par exempel
void MiseAjourNormaleAuxNoeuds_de_tdt_vers_T();
// creation des elements frontiere
void CreeElemFront();
// ramene un pointeur sur la liste des elements frontieres
inline LaLIST <Front>* ListFront() { return &listFrontiere;};
// ramene le tableau des noeuds de la frontière
Tableau<Noeud *>& Tab_noeud_front() {return tab_noeud_front; };
// ramene le nom du maillage
string NomDuMaillage() {return nomDuMaillage;};
// change le nom et le numéro du maillage
void ChangeNomNumeroMaillage(const string & nom,int num);
// ramène le numéro du noeud le plus proche du point donné à t=0,
int Noeud_le_plus_proche_0(const Coordonnee& M);
// idem à t
int Noeud_le_plus_proche_t(const Coordonnee& M);
// idem à tdt
int Noeud_le_plus_proche_tdt(const Coordonnee& M);
// ramène le maximum de variation de coordonnée entre t et tdt de tous les noeuds du maillage
double Max_var_dep_t_a_tdt() const;
// ramène le minimum de la distance entre deux noeuds de l'ensemble des éléments
double Min_dist2Noeud_des_elements(Enum_dure temps) const;
// transfert de grandeurs des points d'intégration aux noeuds
// 1- en entrée les type de ddl internes que l'on veut transférer
// idem pour les type évoluées et les types particuliers
// 2- en entrée: cas qui indique la méthode de transfert à utiliser
// =1 : les valeurs aux noeuds sont obtenue par moyennage des valeurs des pts d'integ les plus près
// des éléments qui entourent le noeud
// on décompose le processus en trois étapes pour éviter d'initialiser plusieurs fois lorque l'on refait à chaque fois
// le même transfert
// A) première étape def des conteneurs et c'est tout, la méthode peut donc être utilisée
// pour autre chose. tabQ: permet d'avoir plusieurs listes de TypeQuelconque
// en entrée: tabQ doit-être de dimension 2, donc pointe sur 2 listes, si un des pointeur
// est nulle on n'en tient pas compte
void AjoutConteneurAuNoeud(const List_io < Ddl_enum_etendu >& lienu
,const Tableau <List_io < TypeQuelconque > * >& tabQ);
// B) initialisation des updates sur les noeuds
void InitUpdateAuNoeud(const List_io < Ddl_enum_etendu >& lienu
,const Tableau <List_io < TypeQuelconque > * >& tabQ,int cas);
// C) exécution du transfert
// transfert incrémental (pour un élément et tous les pt d'integ):
// transfert de ddl de tous les pt d'integ aux noeuds d'un éléments (on ajoute aux noeuds, on ne remplace pas)
// les ddl doivent déjà exister aux noeuds sinon erreur
// il doit s'agir du même type de répartition de pt d'integ pour toutes les grandeurs
void TransfertPtIntegAuNoeud(Element& ele,const List_io < Ddl_enum_etendu >& lietendu
,const Tableau <Tableau <double> > & tab_val,int cas)
{ele.TransfertAjoutAuNoeuds(lietendu,tab_val,cas);};
// idem pour des grandeurs quelconques, transfert de "tous" les points d'intégration en même temps
// ceci pour optimiser, les informations sont ici contenues dans les types quelconques
// liQ_travail: est une liste de travail qui sera utilisée dans le transfert
// - transfert de type quelconque des points d'intégrations (de tous) aux noeuds d'un éléments (on ajoute aux noeuds,
// - on ne remplace pas). Les types quelconques doivent déjà exister.
// - un tableau tab_liQ correspondent aux grandeurs quelconque pour tous les pt integ. tab_liQ(i) est associé au pt d'integ i
// - Toutes les listes sont identiques au niveau des descripteurs (types...) ce sont uniquement les valeurs numériques
// - c-a-dire les valeurs associées à TypeQuelconque::Grandeur qui sont différentes (elles sont associées à chaque pt d'integ)
// - liQ_travail: est une liste de travail qui sera utilisée dans le transfert
void TransfertPtIntegAuNoeud(Element& ele,const Tableau <List_io < TypeQuelconque > >& tab_liQ
,List_io < TypeQuelconque > & liQ_travail,int cas)
{ele.TransfertAjoutAuNoeuds(tab_liQ,liQ_travail,cas);};
// D) dernière étape: (par exemple calcul des moyennes en chaque noeuds)
// les résultats sont stockés aux noeuds
void FinTransfertPtIntegAuNoeud(const List_io < Ddl_enum_etendu >& lienu
,const Tableau <List_io < TypeQuelconque > * >& tabQ,int cas);
// ..... cumul et moyenne de grandeurs venant des éléments vers les noeuds (exemple la pression appliquée) .....
// on décompose le processus en 4 étapes pour éviter d'initialiser plusieurs fois lorque l'on refait à chaque fois
// la même opération (typiquement à chaque incrément)
// on peut utiliser:
// A) AjoutConteneurAuNoeud : pour ajouter des conteneurs ad hoc aux noeuds
// B) InitUpdateAuNoeud: avant le cumul, initialise les conteneurs
// C) Accumul_aux_noeuds : balaie les éléments avec cumul aux noeuds
// D) MoyenneCompteurAuNoeud : effectue les moyennes aux noeuds
// accumulation aux noeuds de grandeurs venant des éléments vers leurs noeuds (exemple la pression appliquée)
// autres que celles aux pti classiques, mais directements disponibles
// le contenu du conteneur stockées dans liQ est utilisé en variable intermédiaire
void Accumul_aux_noeuds(const List_io < Ddl_enum_etendu >& lietendu
,List_io < TypeQuelconque > & liQ,int cas)
{int NBE=tab_element.Taille();
for (int i=1;i<=NBE;i++)
tab_element(i)->Accumul_aux_noeuds(lietendu,liQ,cas);
};
// fonctions utilitaires du même genre
// ajout sur le maillage d'un conteneur particulier quelconque
void AjoutConteneurAuNoeud(TypeQuelconque& tQ);
// ajout sur le maillage d'un ou plusieur ddl_enum_etendu comme conteneur
void AjoutConteneurAuNoeud(const List_io < Ddl_enum_etendu >& lienu);
// initialisation des updates de ddl_étendu uniquement sur les noeuds: on met à 0 les ddl_etendu correspondant,
// les compteurs, comptant le nombre de fois où les noeuds sont modifiés, sont mis à 0
void InitUpdateAuNoeud(const List_io < Ddl_enum_etendu >& lienu);
// idem pour un seul ddl_etendu
void InitUpdateAuNoeud(const Ddl_enum_etendu & enu);
// moyenne des valeurs aux noeuds (en fonction du nombre ou le noeud a été modifié)
void MoyenneCompteurAuNoeud(const Ddl_enum_etendu & enu);
// initialisation des coordonnées à t et tdt aux mêmes valeurs qu'à 0
// utile quand on veut utiliser les métriques pour un pb non couplés
void Init_Xi_t_et_tdt_de_0();
// def d'un conteneur pour deux numéros: elem et pti
class NBelemEtptInteg
{public: int nbElem; int nbPtInteg;
// surcharge de l'operator de lecture
friend istream & operator >> (istream & ent, NBelemEtptInteg & de)
{ ent >> de.nbElem >> de.nbPtInteg; return ent;};
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream & sort , const NBelemEtptInteg & de)
{ sort << de.nbElem <<" " << de.nbPtInteg << " "; return sort;};
bool operator < (const NBelemEtptInteg& c) const; bool operator > (const NBelemEtptInteg& c) const;
bool operator == (const NBelemEtptInteg& c) const {return ((nbElem==c.nbElem)&&(nbPtInteg==c.nbPtInteg));};
bool operator != (const NBelemEtptInteg& c) const {return !((nbElem==c.nbElem)&&(nbPtInteg==c.nbPtInteg));};
};
// def d'un conteneur pour 3 numéros: elem, num face ou arete, et pti
class NBelemFAEtptInteg
{public: int nbElem; int nbFA; int nbPtInteg;
// surcharge de l'operator de lecture
friend istream & operator >> (istream & ent, NBelemFAEtptInteg & de)
{ ent >> de.nbElem >> de.nbFA >> de.nbPtInteg; return ent;};
// surcharge de l'operator d'ecriture
friend ostream & operator << (ostream & sort , const NBelemFAEtptInteg & de)
{ sort << de.nbElem <<" "<< de.nbFA <<" " << de.nbPtInteg << " "; return sort;};
bool operator < (const NBelemFAEtptInteg& c) const; bool operator > (const NBelemFAEtptInteg& c) const;
bool operator == (const NBelemFAEtptInteg& c) const {return ((nbElem==c.nbElem)&&(nbFA==c.nbFA)&&(nbPtInteg==c.nbPtInteg));};
bool operator != (const NBelemFAEtptInteg& c) const {return !((nbElem==c.nbElem)&&(nbFA==c.nbFA)&&(nbPtInteg==c.nbPtInteg));};
};
// ramène le numéro de l'élément qui contiend un point donné et le numéro du point
// d'intégration le plus proche pour les ddl de la liste, (ddl spécifique à l'élément c'est-a-dire
// hors des ddl des noeuds de l'éléments)
// si pas de numéro d'élément ramène un numéro d'élément nulle
// si les numéros de point d'intégration ne sont pas identique pour l'ensemble
// des ddl, pb !!, le numéro du pt integ de retour est alors négatif
// enu_temps: dit si les coordonnées du point M sont à 0 ou t ou tdt
NBelemEtptInteg Element_le_plus_proche
(Enum_dure enu_temps,const List_io <Ddl_enum_etendu>& list_enu,const Coordonnee& M);
// ramène le numéro de l'élément dont le centre de gravité à t = enu_temps est le plus proche d'un point donné
// Le point peut être n'importe où, en particulier à l'extérieur de la matière
// si pb retour de null
const Element* Centre_de_Gravite_Element_le_plus_proche(Enum_dure enu_temps,const Coordonnee& M);
// ramène pour chaque noeud, la liste des éléments qui contiennent le noeud
// si le tableau n'existe pas, il est construit, sinon uniquement un retour
// et la miss à jour est uniquement faite lors de la création des frontières
const Tableau <List_io < Element* > >& Indice()
{if (indice.Taille() == 0) Calcul_indice();
return indice; };
//----- lecture écriture dans base info -----
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Lecture_base_info(ifstream& ent,const int cas);
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas);
// sortie du schemaXML: en fonction de enu
static void SchemaXML_Maillages(ofstream& sort,const Enum_IO_XML enu) ;
// ------ informations utiles par exemples pour la visualisation
// retourne les dimensions minis et maxi suivant les axes du repère
// absolu du maillage (en faite le calcul est fondé
// uniquement sur la position des noeuds du maillage
// le premier vecteur contient les minimums
// le deuxième vecteur contient les maximums
Tableau <Vecteur> Taille_boiteMail();
// --------- utilitaires de manipulation de maillage
// test pour savoir si le maillage contiend des éléments à interpolation linéaire
bool Contient_lineaire();
// test pour savoir si le maillage contiend des éléments à interpolation quadratique incomplète
bool Contient_quadratique_incomplet();
// transformation des éléments linéaires du maillage en quadratiques.
// les éléments linéaires sont supprimés,
// Important: dans la procédure de renumérotation, la routine modifie la numérotation initiale des noeuds !!
// il y a également création de référence adaptée au nouveau maillage en cohérence avec l'ancien maillage
void Transfo_lin_quadraIncomp(LesReferences &lesRef);
// transformation des éléments quadratiques incomplet du maillage en quadratiques complets.
// les éléments incomplets sont supprimée,
// Important: dans la procédure de renumérotation, la routine modifie la numérotation initiale des noeuds !!
// il y a également création de référence adaptée au nouveau maillage en cohérence avec l'ancien maillage
void Transfo_quadraIncomp_quadraComp(LesReferences &lesRef);
// relocalisation des points milieux des arrêtes des éléments quadratiques
void RelocPtMilieuMailleQuadra();
// définition interactive de listes de références
void CreationInteractiveListesRef(LesReferences* lesRef);
// modification de l'orientation d'éléments
void Modif_orientation_element(int cas_orientation,LesReferences* lesRef);
// Lecture et Collapse des éléments supperposés, c-a-d identiques, dans le cas où il en existe
void LectureEtCollapse_element_superpose(UtilLecture * entreePrinc,LesReferences* lesRef);
// Collapse des éléments supperposés, c-a-d identiques, dans le cas où il en existe
void Collapse_element_superpose(LesReferences* lesRef);
// Lecture et collapse de noeuds très proche: appartenant à des éléments différents
void LectureEtCollapse_noeuds_proches(UtilLecture * entreePrinc, LesReferences* lesRef);
// 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 Collapse_noeuds_proches(double rayon, LesReferences* lesRef);
// Lecture et suppression d'elements à 2 noeuds, de distances très proches
void LectureEtSup_Elem_noeudsConfondu(UtilLecture * entreePrinc, LesReferences* lesRef);
// suppression d'elements à 2 noeuds, de distances très proches
// rayon : donne la distance maxi entre les noeuds
void Sup_Elem_noeudsConfondu(double rayon, LesReferences* lesRef);
// création d'éléments SFE en fonction d'éléments classiques
void CreationMaillageSFE();
// test pour savoir si le maillage est ok pour être transformée en sfe
bool OKPourTransSfe();
// lecture et suppression éventuelle des noeuds, non référencés par les éléments et les références
void LectureEtSuppressionNoeudNonReferencer(UtilLecture * entreePrinc,LesReferences& lesRef);
// uniquement suppression éventuelle des noeuds, non référencés par les éléments et les références
void SuppressionNoeudNonReferencer(LesReferences& lesRef);
// Affichage des noeuds, non référencés par les éléments
void AffichageNoeudNonReferencer();
// lecture et création éventuelle d'une ref sur les noeuds, non référencés par les éléments
void LectureEtCreationRefNoeudNonReferencer(UtilLecture * entreePrinc,LesReferences& lesRef);
// création éventuelle d'une référence sur les noeuds, non référencés par les éléments
void CreationRefNoeudNonReferencer(LesReferences& lesRef);
// 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 VerifReference(LesReferences& lesRef);
// lecture et renumérotation éventuelle des noeuds
void LectureEtRenumerotation(UtilLecture * entreePrinc,LesReferences& lesRef);
// 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
bool Renumerotation(LesReferences& lesRef,const Tableau <Tableau <Condilineaire> >& condCLL);
// création automatique des références globales de frontière si demandé dans le .info
void CreationRefFrontiere(UtilLecture * entreePrinc,LesReferences& lesRef);
// demande de création automatique des références globales de frontière
void CreationRefFrontiere(LesReferences& lesRef);
// force la mise à une valeur d'un ddl (ou de la liste de ddl fonction de la dimention) particulier, quelques soit son activité
// si fonction_de_la_dimension = true : c'est toute les ddl fct de la dimension qui sont mis à la valeur
void Force_Ddl_aux_noeuds_a_une_valeur(Enum_ddl enu, const double& val,Enum_dure temps, bool fonction_de_la_dimension);
// mise à zéro de dd_enum_etendu aux noeuds : force la mise à une valeur à 0
void Force_Ddl_etendu_aux_noeuds_a_zero(const Tableau<Ddl_enum_etendu>& tab_enu);
protected :
int idmail ; // numero de maillage
string nomDuMaillage;
// liste communes de tous les noms de maillages associée à un numéro
// sous forme d'un arbre pour faciliter la recherche
// cette liste n'est modifiée que par chaque maillage
map < string, int , std::less <string> >& listeNomMail;
int dimension; // dimension du maillage
Tableau<Noeud *> tab_noeud; // tableau des noeuds du maillage
Tableau<Element *> tab_element; // tableau des elements du maillage
// list des elements frontieres du maillage, c-a-d des frontières uniques
LaLIST <Front> listFrontiere;
// tableau des noeuds des éléments frontières
Tableau <Noeud *> tab_noeud_front;
// tableau utilitaire:
// indice(i) contient la liste des éléments qui contiennent le noeud i
Tableau <List_io < Element*> > indice;
// 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 (ce tableau est construit par la méthode : Mitoyen())
Tableau < Tableau <Front> > mitoyen_de_chaque_element;
// définie la liste des types de degrés de liberté inconnus, qui vont être calculés par la résolution des problèmes
// physiques gérés par les éléments qui existent dans le maillages
// Si éléments mécaniques -> ddl Xi voir Vi et gamma_i
// Si éléments thermiques -> ddl de température
// Si éléments méca + éléments thermiques -> ddl Xi et température
// etc. en fonction des éléments qui existent dans les maillages
// (généré à la lecture du maillage, ce qui permet d'optimiser la consultation par la suite)
Tableau <Enum_ddl > ddl_representatifs_des_physiques;
// idem au niveau des types de problèmes gérés par les éléments
Tableau <EnumElemTypeProblem > types_de_problemes;
//indicateur uniquement utilisé pour la destruction, par défaut est toujours vrai
// via la méthode Preparation_destruction_avec_conservation_noeuds_elements(), on peut le modifier
bool detruire_les_noeuds_et_elements;
// -- variables internes utilisées par Orientation_elements_mitoyens_recursif
// tab_sens_element(i) : = 1 au début, puis vaut -1 si le sens de l'élément i à été changé
Tableau <double> tab_sens_element; // pendant les différents appels de Orientation_elements_mitoyens_recursif
// - on définit un tableau d'indicateur, permettant de savoir si un élément a été traité ou pas
// une fois qu'un élément a été traité: a) on ne permet plus son changement de sens
// b) de plus dans le cas d'une suite d'appels récursif, il n'est plus retenue pour les nouvelles listes
Tableau <bool> ind_elem; // def et init à 0, c-à-d non traité
// -- fin variables internes utilisées par Orientation_elements_mitoyens_recursif
// METHODES PROTEGEES :
// cas particulier de destruction, sans suppression des noeuds et éléments
// l'utilisation de la méthode suivante, permet ensuite de supprimer le maillage
// tout en évitant la destruction des noeuds internes et éléments internes
// à utiliser avec précaution, intéressant si l'on veut créer un nouveau maillage
// avec les noeuds et éléments de ce maillage
void Preparation_destruction_avec_conservation_noeuds_elements()
{ detruire_les_noeuds_et_elements = false; };
// change le numéro de maillage
void Change_numero_maillage(int new_num);
// definition des elements mitoyens aux elements de frontiere
// à la fin du programme tous les éléments mitoyens sont stocké dant les éléments
// Front et non les éléments frontières qui eux sont supprimés
void MitoyenFront();
// création pour chaque noeud de la liste des éléments qui contiennent le noeud
void Calcul_indice();
// definition d'un stockage contenant tous les Front associés à toutes les frontières de tous les éléments
// puis définition des elements mitoyens à ces Front : deux éléments Front sont mitoyens
// s'ils correspondent à des Element différents, et si les frontières associées possèdent les mêmes noeuds
// toutes ces informations sont stockées dans : mitoyen_de_chaque_element (cf. sa description)
void Calcul_tous_les_front_et_leurs_mitoyens();
// dans le cas où les éléments frontières sont des lignes, on les ordonnes
// de manière à former une ligne continue
void OrdonancementDesLigne();
// lectures des infos pour le choix d'un élément
void Lecture_info_1element(UtilLecture * entreePrinc,int& num_elt,Enum_geom& id_geom
,Enum_interpol& id_interpol,EnumElemTypeProblem& id_typeProb
,string& discriminant);
// lecture des mouvements solides si nécessaire
void Lecture_des_mouvements_solides(UtilLecture * entreePrinc);
// une classe de travail qui sert pour pouvoir classer les noeuds par leur position géométrique initiale
// deux élément sont identiques si leur position initiale sont identique
// a >= b si : soit a.x >= b.x, ou a.x==b.x et a.y >= b.y, ou a.x==b.x et a.y == b.y et a.z >= b.z
class PosiEtNoeud
{ public:
Noeud * noe; // le noeud
Element * el; // l'élément auquel il est rattaché
// -------- constructeur ------------
PosiEtNoeud() : noe(NULL),el(NULL) {}; // constructeur par défaut
PosiEtNoeud(Noeud * no,Element * e) : noe(no),el(e) {}; // constructeur normal
PosiEtNoeud(const PosiEtNoeud& po) : noe(po.noe),el(po.el) {}; // constructeur de copie
//------ surcharges qui ne travaillent que sur la position --------
PosiEtNoeud& operator= (const PosiEtNoeud& po); // affectation
bool operator == (const PosiEtNoeud& po) const ; // test d'égalité
bool operator != (const PosiEtNoeud& po) const ; // test d'inégalité
bool operator < (const PosiEtNoeud& po) const ; // relation d'ordre
bool operator <= (const PosiEtNoeud& po) const ; // relation d'ordre
bool operator > (const PosiEtNoeud& po) const ; // relation d'ordre
bool operator >= (const PosiEtNoeud& po) const ; // relation d'ordre
};
// fonctions simples ayant pour but de bien repérer des opérations dangereuses
// affectation d'un noeud au maillage c-a-d au tableau de pointeur de noeud,
// a condition que la place ne soit pas déjà occupée sinon on change le numéro
// de noeud et on augmente le tableau
void Affectation_noeud (Noeud& noeud);
// affectation d'un element au maillage c-a-d au tableau de pointeur d'element,
// a condition que la place ne soit pas déjà occupée sinon on change le numéro
// de l'élément et on augmente le tableau
void Affectation_element (Element& element);
// Modifie le nombre de noeuds du maillage (N.B.: Fait appel
// a la methode Change_taille de la classe Tableau<Noeud>)
// les éléments supplémentaires ont un pointeur mis à Null
void Change_nb_noeud (int nouveau_nb);
// Modifie le nombre d'elements du maillage (N.B.: Fait appel
// a la methode Change_taille de la classe Tableau<Element>)
// les éléments supplémentaires ont un pointeur mis à Null
void Change_nb_element (int nouveau_nb);
// ** 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 à partir du numéro num_elem
// 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> Orientation_elements_mitoyens_recursif(bool recursif,string& nom_ref,int num_elem
, LesReferences& lesRef,double& angle_maxi,bool inverse);
// méthode pour initialiser les différents tableaux utilisés par Orientation_elements_mitoyens_recursif
void Init_Orientation_elements_mitoyens_recursif();
// 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 Orientation_via_rayon(const Tableau <bool> & indic_G,const Coordonnee & A
,const string& zone_a_traiter, LesReferences& lesRef, bool inverse);
// ------- pour la définition interactive de liste de ref -------------
// def d'un conteneur pour deux numéros: nb element nb face
class NBelemEtFace {public: int nbElem; int nbFace;
bool operator < (const NBelemEtFace& c) const; bool operator > (const NBelemEtFace& c) const;
bool operator == (const NBelemEtFace& c) const {return ((nbElem==c.nbElem)&&(nbFace==c.nbFace));};
bool operator != (const NBelemEtFace& c) const {return !((nbElem==c.nbElem)&&(nbFace==c.nbFace));};
};
// def d'un conteneur pour deux numéros: nb element nb arête
class NBelemEtArete {public: int nbElem; int nbArete;
bool operator < (const NBelemEtArete& c) const; bool operator > (const NBelemEtArete& c) const;
bool operator == (const NBelemEtArete& c) const {return ((nbElem==c.nbElem)&&(nbArete==c.nbArete));};
bool operator != (const NBelemEtArete& c) const {return !((nbElem==c.nbElem)&&(nbArete==c.nbArete));};
};
// calcul des listes de références en fonction de la demande:
// list_nomReference: contient les types de refs que l'on veut
// list_methode: contient la ou les méthodes que l'on veut utiliser
// cas 1D
void CalculListRef_1D(list<string>& list_nomReference,LesReferences* lesRef,list<string>& list_methode
,const Enum_ddl & enu_ddl);
// cas 2D
void CalculListRef_2D(list<string>& list_nomReference,LesReferences* lesRef,list<string>& list_methode
,const Enum_ddl & enu_ddl);
// cas 3D
void CalculListRef_3D(list<string>& list_nomReference,LesReferences* lesRef,list<string>& list_methode
,const Enum_ddl & enu_ddl);
// les méthodes de bases
// fonction générique pour des condition PresDe
void PresDe(const list<string>& list_nomReference, list <Noeud *>& list_noeud_restant
,list <Element *>& list_element_restant,const Enum_ddl& enu_ddl
,list <NBelemEtptInteg>& list_elemPtin_restant,bool& premLpti
,list <NBelemEtFace>& list_elemFace_restant,bool& premLface
,list <NBelemEtArete>& list_elemArrete_restant,bool& premLarrete);
// fonction générique pour des condition "tout dedans"
void ToutDedans(const list<string>& list_nomReference, list <Noeud *>& list_noeud_restant
,list <Element *>& list_element_restant,const Enum_ddl& enu_ddl
,list <NBelemEtptInteg>& list_elemPtin_restant,bool& premLpti
,list <NBelemEtFace>& list_elemFace_restant,bool& premLface
,list <NBelemEtArete>& list_elemArrete_restant,bool& premLarrete);
// constitution des références
void EnregRef(const list<string>& list_nomReference,list <Noeud *>& list_noeud_restant
,list <NBelemEtptInteg>& list_elemPtin_restant,list <Element *>& list_element_restant
,list <NBelemEtFace>& list_elemFace_restant,list <NBelemEtArete>& list_elemArrete_restant
,LesReferences* lesRef);
// définition des fonctions conditions
// def de data internes qui servent pour les fonctions init et exe: dimensionnées dans init, utilisé dans exe
// donc: init et exe doivent être utilisé absolument à suivre
Tableau <Coordonnee> t_poi;
Tableau <Droite> t_droit;
Tableau <double> t_para;
Tableau <Plan> t_plan;
Tableau <Sphere> t_sphere;
Tableau <Cylindre> t_cylindre;
Tableau <Cercle> t_cercle;
// cas de croisement avec des références existantes: def de variables de passage pour InRef et OutRef
// les pointeurs qui suivent ne servent pas à créer des refs, mais uniquement a récupérer les adresses
list <const Reference*> list_refIn;
list <const Reference*> list_refOut;
LesReferences* lesRefin; // variable utilisée uniquement pour le passage d'info à
// ,InitInRef(), ExeInRef (), InitOutRef(), ExeOutRef()
// tout d'abord les pointeurs de fonctions en cours
// - pour les conditions Presde
// acquisition interactive des paramètres de la condition
void (Maillage::*initConditionPresDe) (double& dist);
// exécution de la condition : ramène true si ok, false sinon
bool (Maillage::*ExeConditionPresDe) (const double& dist,const Coordonnee& M)const;
// - pour les condition ToutDedans
// acquisition interactive des paramètres de la condition
void (Maillage::*initConditionToutDedans) ();
// exécution de la condition : ramène true si ok, false sinon
bool (Maillage::*ExeConditionToutDedans) (const Tableau <Coordonnee> & tab_M)const;
// recherche près d'un point
// def interactive du point et de la distance
void InitPresPoint(double& dist);
// exécution de la condition
bool ExePresPoint(const double& dist,const Coordonnee& M) const;
// recherche d'un coté d'un point (en 1D)
void InitCotePoint();
// ramène true si tous les points sont du même coté que t_poi(1)
bool ExeCotePoint(const Tableau <Coordonnee> & t_M)const;
// recherche entre deux points (1D)
void InitEntrePoint();
// ramène true si tous les points sont entre t_poi(1) et t_poi(2)
bool ExeEntrePoint(const Tableau <Coordonnee> & t_M)const;
// recherche entre deux points (1D) _avec_distance
void InitEntrePoint_avec_distance();
// ramène true si tous les points sont entre t_poi(1) et t_poi(2)
bool ExeEntrePoint_avec_distance(const Tableau <Coordonnee> & t_M)const;
// recherche près d'une ligne
void InitPresLigne(double& dist);
bool ExePresLigne(const double& dist,const Coordonnee& M)const;
// dans le cas particulier d'une ligne, on peut ordonner certaines listes résultantes / à la lignes
// il s'agit des noeuds et des pt d'integ: on les ordonnes par rapport à leurs projections sur la lignes
void InitOrdonneLigne();
void OrdonneLigne(list <Noeud *>& list_noeud_restant,list <NBelemEtptInteg>& list_elemPtin_restant
,const Enum_ddl& enu_ddl);
// recherche près d'un cercle
void InitPresCercle(double& dist);
bool ExePresCercle(const double& dist,const Coordonnee& M)const;
// recherche près d'un plan
void InitPresPlan(double& dist);
bool ExePresPlan(const double& dist,const Coordonnee& M)const;
// recherche près d'un cylindre
void InitPresCylindre(double& dist);
bool ExePresCylindre(const double& dist,const Coordonnee& M)const;
// recherche près d'une sphere
void InitPresSphere(double& dist);
bool ExePresSphere(const double& dist,const Coordonnee& M)const;
// recherche d'un coté d'un plan
void InitCotePlan();
// ramène true si tous les points sont du même coté que t_poi(1) du plan
bool ExeCotePlan(const Tableau <Coordonnee> & t_M)const;
// condition entre plans //
void InitEntrePlan();
// ramène true si tous les points sont entre les deux plans
bool ExeEntrePlan(const Tableau <Coordonnee> & t_M)const;
// condition entre plans _avec_distance //
void InitEntrePlan_avec_distance();
// ramène true si tous les points sont entre les deux plans
bool ExeEntrePlan_avec_distance(const Tableau <Coordonnee> & t_M)const;
// condition dans ou dehors un cylindre
void InitDansCylindre();
// ramène true si tous les points sont dans le cylindre
bool ExeDansCylindre(const Tableau <Coordonnee> & t_M)const;
// ramène true si tous les points sont à l'extérieur du cylindre
bool ExeOutCylindre(const Tableau <Coordonnee> & t_M)const;
// condition entre deux cylindre
void InitEntreCylindre();
// ramène true si tous les points sont entre les deux cylindres
bool ExeEntreCylindre(const Tableau <Coordonnee> & t_M)const;
// condition dans ou dehors d'une sphére
void InitDansSphere();
// ramène true si tous les points sont dans la sphère
bool ExeDansSphere(const Tableau <Coordonnee> & t_M)const;
// ramène true si tous les points sont à l'extérieur de la sphère
bool ExeOutSpheres(const Tableau <Coordonnee> & t_M)const;
// condition entre deux spheres concentriques
void InitEntreSpheres();
// ramène true si tous les points sont entre les deux sphères
bool ExeEntreSpheres(const Tableau <Coordonnee> & t_M)const;
// condition du même coté d'une droite (en 2D seulement)
void InitCoteDroite();
// ramène true si tous les points sont du même coté que t_poi(1) de la droite (en 2D uniquement)
bool ExeCoteDroite(const Tableau <Coordonnee> & t_M)const;
// condition entre 2 droites (en 2D seulement)
void InitEntreDroite();
// ramène true si tous les points sont entre les 2 droites (en 2D uniquement)
bool ExeEntreDroite(const Tableau <Coordonnee> & t_M)const;
// condition entre 2 droites (en 2D seulement) _avec_distance
void InitEntreDroite_avec_distance();
// ramène true si tous les points sont entre les 2 droites (en 2D uniquement)
bool ExeEntreDroite_avec_distance(const Tableau <Coordonnee> & t_M)const;
// condition dans ou dehors un cercle (en 2D seulement)
void InitDansCercle();
// ramène true si tous les points sont dans le cercle
bool ExeDansCercle(const Tableau <Coordonnee> & t_M)const;
// ramène true si tous les points sont à l'extérieur du cercle
bool ExeOutCercle(const Tableau <Coordonnee> & t_M)const;
// condition entre cercles concentriques (en 2D seulement)
void InitEntreCercles();
// ramène true si tous les points sont entre les deux cercles concentriques
bool ExeEntreCercles (const Tableau <Coordonnee> & t_M)const;
// acquisition d'un plan
Plan Acquisition_interactive_plan();
// acquisition d'un point
Coordonnee Acquisition_interactive_point();
// acquisition d'une droite
Droite Acquisition_interactive_droite();
// acquisition d'un vecteur=direction
Coordonnee Acquisition_interactive_vecteur();
// condition d'appartenance à une référence existante
void InitInRef();
// condition d'exclusion à une référence existante
void InitOutRef();
// ---- mise en place de la condition d'appartenance ou d'exclusion à des références existantes
// contrairement aux autres conditions, cette condition est prise en compte au moment de la création finale
// de la référence dans la méthode : EnregRef, via les méthodes du 2)
// 1) une fonction qui ne fait rien, mais est là pour que le tout fonctionne normalement
bool Exe_In_out_avecRefExistantes(const Tableau <Coordonnee> & t_M)const; // ne fait rien
// 2) fonctions qui réellement font quelque chose: utilisées dans la méthode EnregRef
void Exe_In_out_avecRefExistantes_N(list <Noeud *>& list_noeud_restant);
void Exe_In_out_avecRefExistantes_E(list <Element *>& list_element_restant);
void Exe_In_out_avecRefExistantes_G(list <NBelemEtptInteg>& list_elemPtin_restant);
void Exe_In_out_avecRefExistantes_F(list <NBelemEtFace>& list_elemFace_restant);
void Exe_In_out_avecRefExistantes_A(list <NBelemEtArete>& list_elemArrete_restant);
// void InterOuDiff_avecRefExistantes(const Tableau <Coordonnee> & t_M)const;
//-------------------- méthodes particulières pour l'optimisation de largeur de bande ------------------------
// une classe intermédiaire pour pouvoir classer les noeuds en fonction du degré
class Noeud_degre
{ public: Noeud* noe; int degre;
Noeud_degre (): noe(NULL), degre(0) {};
Noeud_degre (Noeud* no,int deg): noe(no),degre(deg) {};
Noeud_degre (const Noeud_degre& no ): noe(no.noe), degre(no.degre) {};
~Noeud_degre() {};
bool operator > (const Noeud_degre& a) const { return (this->degre > a.degre);};
bool operator >= (const Noeud_degre& a) const { return (this->degre >= a.degre);};
bool operator < (const Noeud_degre& a) const { return (this->degre < a.degre);};
bool operator <= (const Noeud_degre& a) const { return (this->degre <= a.degre);};
Noeud_degre& operator= (const Noeud_degre& de) { degre = de.degre; noe = de.noe; return (*this);};
};
// 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
static Noeud* 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);
// méthode static: c-a-d indépendante des données du maillage (elle est générale)
// calcul des voisins de tous les noeuds du maillage en fonction des éléments et de conditions
// linéaires éventuelles,
// 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
static Tableau < LaLIST_io <Noeud* > >& 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);
// 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
static list < list < Noeud_degre > > & Descendance (const int& taille_tabnoeud
,Noeud * noeu, Tableau < LaLIST_io <Noeud* > >& t_voisin
, list < list < Noeud_degre > > & lient,bool& calcul_ok);
// 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 noeu, qui va être modifié dans le processus
// ramène une nouvelle numérotation (mais les numéros internes des noeuds ne sont pas changé
static Tableau <Noeud* > Cuthill_Mac_Kee(const int& taille_tabnoeud,Noeud * noeu
,Tableau < LaLIST_io <Noeud* > >& t_voisin
, list < list < Noeud_degre > >& lis_descent);
// 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
static int LargeurBandeEnNoeuds(const Tableau<Element *>& tab_elem);
// on s'occupe de mettre à jour les types de pb et les ddl types associés
void Mise_a_jour_type_pb_type_associe_ddl();
};
/// @} // end of group
#endif
Reference in a new issue Copy permalink