// 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) .
//
// 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 .
//
// For more information, please consult: .
/************************************************************************
* DATE: 23/01/97 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: definir le groupe de maillage *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef LESMAILLAGES_H
#define LESMAILLAGES_H
#include "Maillage.h"
#include "Tableau_T.h"
#include "UtilLecture.h"
#include "ParaGlob.h"
#include "LesReferences.h"
// #include "bool.h"
#include "DiversStockage.h"
#include "LesLoisDeComp.h"
#include "Front.h"
#include "Enum_dure.h"
#include "Nb_assemb.h"
#include "Basiques.h"
#include "Enum_dure.h"
#include "TypeQuelconque.h"
#include "Enum_IO_XML.h"
/** @defgroup Les_Maillages Les_Maillages
*
* BUT: definir le groupe de maillage *
*
* \author Gérard Rio
* \version 1.0
* \date 23/01/97
* \brief Définition du groupe de maillage
*
*/
/// @addtogroup Les_Maillages
/// @{
///
//------------------------------------------------------------------
//! LesMaillages: l'ensemble des maillages
//------------------------------------------------------------------
/// \author Gérard Rio
/// \version 1.0
/// \date 23/01/97
class LesMaillages
{
public :
// VARIABLES PUBLIQUES :
// CONSTRUCTEURS : le pointeur sur UtilLecture permet d'avoir acces a la lecture
// le second pointe sur les variables globales
// le troisieme pointe sur l' instance des references
LesMaillages (UtilLecture * , ParaGlob *,LesReferences* lesRef);
// constructeur par défaut
LesMaillages();
// Constructeur de copie,
LesMaillages(const LesMaillages& lesmail);
// DESTRUCTEUR :
~LesMaillages();
// METHODES PUBLIQUES :
// lecture des maillages et des references s'y rapportant
void LectureLesMaillages();
// création et ajout d'un nouveau maillage en fonction d'un nom et d'une liste
// d'éléments
// *** 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éé
// >> ramène le numéro du nouveau maillage
int Creation_nouveau_maillage
(list & li_noeud,list & list_elem,const string& nom_maillage);
// suppression d'un maillage existant
// par défaut, tous les noeuds et éléments du maillage sont supprimés
// si sans_conservation_noeuds_elements est false: les noeuds et les éléments ne sont pas supprimés
// mais ils ne sont plus référencés dans ce maillage !
void Suppression_maillage( const string& nom_maillage,const bool sans_conservation_noeuds_elements = true);
// ajout d'un tableau de noeud à un maillage
void Ajout_de_Noeuds(const list & taN, int numMail)
{tabMaillage(numMail)->Ajout_de_Noeuds(taN);};
// -- ajout de noeuds, éléments et éventuellement de ref à un maillage
// 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 & taN, const list & taE,list * lref,LesReferences* lesRef, int numMail )
{tabMaillage(numMail)->Ajout_elements_et_noeuds(taN,taE,lref,lesRef);};
// affichage et definition interactive des commandes
void Info_commande_lesMaillages();
// Affiche les donnees du maillage
void Affiche () const ;
// Affiche les donnees du maillage dans le fichier de nom nom_fichier
// au format du fichier ".her"
void Affiche (char* nom_fichier) const ;
// test si toutes les informations des maillages sont completes
// = true -> complet
// = false -> incomplet
bool Complet();
// introduction des lois de comportement dans les elements qui le necessite
// des sections pour les biellettes etc c-a-d , completer les elements
// avec les donnees qui ont ete acquises apres la lecture du maillage
// def des tableaux de ddl dans les noeuds
// def des pointeurs d'assemblage dans les noeuds
void Completer(DiversStockage* divers,LesLoisDeComp* lesLois
,LesFonctions_nD* lesFonctionsnD);
// mise à jour des repères d'anisotropie
void Mise_a_jour_repere_anisotropie(DiversStockage* divers,LesFonctions_nD* lesFonctionsnD);
// ramene le nombre de maillage
inline int NbMaillage() const
{ return nbMaillageTotal;};
// ramene le nombre d'element du maillage i
inline int Nombre_element(int i) const
{ return tabMaillage(i)->Nombre_element();};
// ramene le nombre de noeud du maillage i
inline int Nombre_noeud(int i) const
{ return tabMaillage(i)->Nombre_noeud();};
// ramene l'element j du maillage i
inline Element& Element_LesMaille(int i, int j) const
{return tabMaillage(i)->Element_mail(j);};
// idem mais en version constant
inline const Element& Element_LesMaille_const(int i, int j) const
{return tabMaillage(i)->Element_mail_const(j);};
// ramene le noeud j du maillage i
inline Noeud& Noeud_LesMaille(int i, int j) const
{return tabMaillage(i)->Noeud_mail(j);};
// Retourne le tableau des noeuds du maillage i
inline Tableau& Tab_noeud (int i)
{ return tabMaillage(i)->Tab_noeud(); };
// Retourne le nom du maillage i
string NomMaillage(int i) const {return tabMaillage(i)->NomDuMaillage();};
// retourne le numéro du maillage de nom donné
// ou 0 si le nom ne correspond pas à un maillage
int NumMaillage(const string& nom) const
{map < string, int , std::less >::const_iterator itmap = mapNomMail.find(nom);
if (itmap!=mapNomMail.end()) {return (*itmap).second;}
else {return 0;};
};
// suppression éventuelle des noeuds, non référencés par les éléments et les références
// dans tous les maillages
void SuppressionNoeudNonReferencer(LesReferences& lesRef)
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->SuppressionNoeudNonReferencer(lesRef);};
// Affichage des noeuds, non référencés par les éléments
void AffichageNoeudNonReferencer()
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->AffichageNoeudNonReferencer();};
// renumérotation des noeuds de tous les maillagesen même temps, + prise en compte
// des conditions linéaires qui existent entre les noeuds
// ramène false si rien n'a changé (à cause d'un pb ou parce que la renumérotation n'est pas meilleure), vrai sinon
// si le pointeur d'assemblage est non nulle, cela veut dire que l'on veut également une mise à jour
// globale des pointeurs d'assemblages (ce qui est différent de la méthode : MiseAJourPointeurAssemblage(
// qui agit maillage après maillage)
// si le pointeur d'assemblage est non nulle et le drapeau: sans_changement_num_noeud = true
// cela signifie que l'on désire uniquement une renumérotation de pointeur sans les noeuds
// ramène dans tous les cas les nouvelles largeurs en ddl
// nouvelles_largeur_en_ddl.un = la largeur totale résultante
// nouvelles_largeur_en_ddl.deux = la demie largeur totale résultante
// nouvelles_largeur_en_ddl.trois = la demie largeur maximale pour la partie éléments finis
// uniquement (sans les CLL)
//
bool Renumerotation(LesReferences& lesRef,const Tableau >& condCLL
,TroisEntiers& nouvelles_largeur_en_ddl,const Nb_assemb* nb_casAssemb = NULL
,bool sans_changement_num_noeud = false);
// renumérotation des noeuds maillages par maillage,
// === sans prise en compte de conditions linéaires ===
// en sortie les maillages sont mis à jour si la nouvelle numérotation conduit à une largeur de bande
// plus faible que la largeur initiale: en noeuds
// 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);
// création éventuelle d'une référence sur les noeuds, non référencés par les éléments
// dans tous les maillages
void CreationRefNoeudNonReferencer(LesReferences& lesRef)
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->CreationRefNoeudNonReferencer(lesRef);};
// ramène le numéro du noeud le plus proche du point donné pour t=0,
// ceci pour le maillage i, par défaut i vaut 1
inline int Noeud_le_plus_proche_0(const Coordonnee& M,int i = 1)
{ return tabMaillage(i)->Noeud_le_plus_proche_0(M); };
// idem à t
inline int Noeud_le_plus_proche_t(const Coordonnee& M,int i = 1)
{ return tabMaillage(i)->Noeud_le_plus_proche_t(M); };
// idem à tdt
inline int Noeud_le_plus_proche_tdt(const Coordonnee& M,int i = 1)
{ return tabMaillage(i)->Noeud_le_plus_proche_tdt(M); };
// 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)
// ceci pour le maillage i, (par défaut i vaut 1)
// 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
// si pb ramène un numéro d'élément nulle
// enu_temps: dit si les coordonnées du point M sont à 0 ou t ou tdt
inline Maillage::NBelemEtptInteg Element_le_plus_proche
(Enum_dure enu_temps,const List_io & list_enu,const Coordonnee& M,int i = 1)
{ return tabMaillage(i)->Element_le_plus_proche(enu_temps,list_enu,M); };
// ramène la liste des problèmes physiques gérés par les éléments de tous les maillages
inline const list & 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 tous les 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
inline const list & Types_de_problemes() const
{return types_de_problemes;};
// ramene le nombre total de ddl actifs du pb
int NbTotalDdlActifs() const ;
// idem mais pour un type de ddl donné, dans le cas de type
// vectoriel on cumule les ddl de l'ensemble de la dimension
int NbTotalDdlActifs(Enum_ddl enum_ddl) const;
// ramene le nombre total de points d'intégration correspondant à un ddl donné
int NbTotalPtInteg(Enum_ddl enum_ddl) const ;
// ramene le nombre total de grandeurs génératrices, calculées aux points d'intégrations,
// correspondant à un ddl donné.
int NbTotalGrandeursGeneratrices(Enum_ddl enu) const ;
//récupération d'une grandeur vectoriel de dimension, la dimension
// de l'espace, défini au noeud et transféré dans un vecteur global
// qui cumule de manière séquentielle toutes les grandeurs
// en entrée : enum_ddl donne le type de la grandeur à récupérer
// en fait de la première composante
// duree : indique à quel temps doit s'effectuer le transfert, t=0 ou t ou tdt
// enum_actif : le transfert s'effectue que si le ddl enum_actif est actif
// ce qui permet la différentiation entre les différents ddl
// vect : est le vecteur global de stockage qui normalement a été
// au préalable dimensionné avec NbTotalDdlActifs(Enum_ddl enum_ddl)
// en retour : une référence sur vect
Vecteur & Vect_loc_vers_glob(Enum_dure duree,Enum_ddl enum_actif
,Vecteur& vect,Enum_ddl enum_ddl);
// fonction inverse de Vect_loc_vers_glob, il s'agit ici de passer
// de la grandeur globale aux grandeurs locale
void Vect_glob_vers_local(Enum_dure duree,Enum_ddl enum_actif
,const Vecteur& vect,Enum_ddl enum_ddl) ;
//récupération d'une grandeur vectoriel de dimension, la dimension
// de l'espace, défini au noeud et transféré dans un vecteur global
// qui cumule de manière séquentielle toutes les grandeurs
// en entrée : tab_enum_ddl donne le tableau des type de la grandeur à récupérer
// en fait de la première composante
// duree : indique à quel temps doit s'effectuer le transfert, t=0 ou t ou tdt
// tab_enum_actif : pour chaque élément tab_enum_ddl(i), le transfert s'effectue que si
// le ddl tab_enum_actif(i) est actif
// ce qui permet la différentiation entre les différents ddl
// vect : est le vecteur global de stockage qui normalement a été
// au préalable dimensionné avec somme des NbTotalDdlActifs(Enum_ddl enum_ddl), avec enum_ddl
// qui balaie l'ensemble des éléments de tab_enum_ddl
// Important: pour chaque famille de ddl, les ddl sont classés de manière croissante, ce qui signifie
// que c'est l'ordre des pointeurs d'assemblage si et seulement si, ces ddl ont été rangés dans les noeuds
// au préalable
// en retour : une référence sur vect
Vecteur & Vect_loc_vers_glob(Enum_dure duree,const Tableau & tab_enum_actif
,Vecteur& vect,const Tableau & tab_enum_ddl);
// fonction inverse de Vect_loc_vers_glob, il s'agit ici de passer
// de la grandeur globale aux grandeurs locale
void Vect_glob_vers_local(Enum_dure duree,const Tableau & tab_enum_actif
,const Vecteur& vect,const Tableau & tab_enum_ddl) ;
//récupération d'une grandeur scalaire
// défini au noeud et transféré dans un vecteur global
// qui cumule de manière séquentielle toutes les grandeurs
// en entrée : enum_ddl donne le type de la grandeur à récupérer
// duree : indique à quel temps doit s'effectuer le transfert, t=0 ou t ou tdt
// enum_actif : le transfert s'effectue que si le ddl enum_actif est actif
// ce qui permet la différentiation entre les différents ddl
// vect : est le vecteur global de stockage qui normalement a été
// au préalable dimensionné avec NbTotalDdlActifs(Enum_ddl enum_ddl)
// en retour : une référence sur vect
Vecteur & Scalaire_loc_vers_glob(Enum_dure duree,Enum_ddl enum_actif
,Vecteur& vect,Enum_ddl enum_ddl);
// fonction inverse de Scalaire_loc_vers_glob, il s'agit ici de passer
// de la grandeur globale à la grandeur locale
void Scalaire_glob_vers_local(Enum_dure duree,Enum_ddl enum_actif
,Vecteur& vect,Enum_ddl enum_ddl);
// deux fonctions idem que pour les ddl : mais pour un Ddl_etendu
Vecteur & Scalaire_loc_vers_glob(Enum_ddl enum_actif,Vecteur& vect,const Ddl_enum_etendu& enum_ddl_etend);
void Scalaire_glob_vers_local(Enum_ddl enum_actif,Vecteur& vect,const Ddl_enum_etendu& enum_ddl_etend);
// deux fonctions idem que pour les ddl_etendu : mais pour une grandeur quelconque
Vecteur & Quelconque_loc_vers_glob(Enum_ddl enum_actif,Vecteur& vect,const TypeQuelconque& type_generique);
void Quelconque_glob_vers_local(Enum_ddl enum_actif,Vecteur& vect,const TypeQuelconque& type_generique);
// retourne la liste des types de ddl principaux actuellement utilisé
// aux noeuds pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que le ddl en question soit présent
// pour tous les noeud du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
Tableau > Les_type_de_ddl_par_noeud(bool absolue);
// retourne la liste des types de ddl étendu actuellement utilisé
// aux noeuds pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que le ddl en question soit présent
// pour tous les noeud du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
Tableau > Les_type_de_ddl_etendu_par_noeud(bool absolue);
// retourne la liste des types quelconque actuellement utilisé
// aux noeuds pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que le ddl en question soit présent
// pour tous les noeud du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
Tableau > Les_type_de_TypeQuelconque_par_noeud(bool absolue);
// initialisation par défaut de tous les conteneurs aux noeuds
// de tous les maillages
// contenant li_restreinte_TQ
// ces conteneurs sont supposés déjà existés
// typiquement si le conteneurs est un scalaire, on met 0
void Init_par_defaut_conteneurs(List_io < TypeQuelconque >& li_restreinte_TQ);
// idem pour une seule grandeur
void Init_par_defaut_conteneurs(TypeQuelconque_enum_etendu enuTypeQuelconque);
// intro de certains conteneurs internes en relation par exemple avec les demandes de visualisation
// ou autre
// exemple: si VECT_REAC_N qui est un type quelconque, a été choisit
// il faut qu'il soit présent aux noeuds, alors qu'il est alimenter par les ddl pur ...
// on introduit donc le type quelconque associé
// NB: le conteneur passé en paramètre ne sert que pour localiser les grandeurs
void Intro_Conteneurs_internes_noeud_relier_auto_autres_grandeur
( const List_io < TypeQuelconque > & glob_noeud_evol_retenu);
// idem mais ciblé en fonction d'un tableau indicé sur les maillages
void Intro_Conteneurs_internes_noeud_relier_auto_autres_grandeur
( const Tableau < List_io < TypeQuelconque > > & tab_noeud_evol_retenu);
// retourne la liste des types de ddl actuellement utilisé
// aux éléments pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que le ddl en question soit présent
// pour tous les éléments du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
Tableau > Les_type_de_ddl_par_element(bool absolue);
// idem pour les grandeurs évoluées interne actuellement utilisés
// par les éléments, c'est-à-dire comme les ddl mais directement sous forme de vecteur, tenseurs ...
Tableau > Les_type_de_donnees_evolues_internes_par_element(bool absolue);
// idem pour les grandeurs particulières
Tableau > Les_type_de_donnees_particulieres_par_element(bool absolue);
// retourne la liste des types de grandeur quelconque actuellement utilisé
// aux faces élément pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que la grandeur en question soit présent
// pour tous les éléments du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
Tableau > Les_type_de_donnees_evolues_internes_par_face_element(bool absolue);
// idem pour les arêtes d'élément
Tableau > Les_type_de_donnees_evolues_internes_par_arete_element(bool absolue);
// Au niveau des noeuds: transfert des coordonnées de grandeurs vectorielles à des grandeurs évoluées
// stockée sous forme de grandeurs TypeQuelconque
// exemple: les réactions qui sont naturellement stockée en composantes
// le principe est que ce passage s'effectue si les conteneurs existent au niveau des noeuds
void PassageInterneDansNoeud_composantes_vers_vectorielles();
// ..... transfert de grandeurs des points d'intégration aux noeuds .....
// 1- en entrée les type évoluées et les types particuliers que l'on veut transférer
// 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 4 étapes pour éviter d'initialiser plusieurs fois lorque l'on refait à chaque fois
// le même transfert
// les méthodes: AjoutConteneurAuNoeud, InitUpdateAuNoeud, sont générales, peuvent être utilisés pour autres choses
// 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(int num_maillage,const List_io < Ddl_enum_etendu >& lienu
,const Tableau * >& tabQ)
{ tabMaillage(num_maillage)->AjoutConteneurAuNoeud(lienu,tabQ);};
// fonctions utilitaires du même genre pour tous les maillages
// ajout sur tous les maillages d'un ou plusieur ddl_enum_etendu comme conteneur
// 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 * >& tabQ)
{ for (int imail=1;imail<=nbMaillageTotal;imail++)
tabMaillage(imail)->AjoutConteneurAuNoeud(lienu,tabQ);};
// B) initialisation des updates sur les noeuds
// lorsque l'on a des listes différentes pour chaque maillage on peut directement utiliser la routine de Maillage
void InitUpdateAuNoeud(const List_io < Ddl_enum_etendu >& lienu
, const Tableau * >& tabQ,int cas)
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->InitUpdateAuNoeud(lienu,tabQ,cas);};
void InitUpdateAuNoeud(int numMail,const List_io < Ddl_enum_etendu >& lienu
, const Tableau * >& tabQ,int cas)
{ tabMaillage(numMail)->InitUpdateAuNoeud(lienu,tabQ,cas);};
// C) exécution du transfert
// transfert de ddl des points d'intégrations (de tous) 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(int numMail,Element& ele,const List_io < Ddl_enum_etendu >& lietendu
,const Tableau > & tab_val,int cas)
{ tabMaillage(numMail)->TransfertPtIntegAuNoeud(ele,lietendu,tab_val,cas);};
// idem pour des grandeurs quelconques
// les informations sont ici contenues dans les types quelconques
// liQ_travail: est une liste de travail qui sera utilisée dans le transfert
void TransfertPtIntegAuNoeud(int numMail,Element& ele,const Tableau >& tab_liQ
,List_io < TypeQuelconque > & liQ_travail,int cas)
{ tabMaillage(numMail)->TransfertPtIntegAuNoeud(ele,tab_liQ,liQ_travail,cas);};
// D) dernière étape: (par exemple calcul des moyennes en chaque noeuds)
void FinTransfertPtIntegAuNoeud(const List_io < Ddl_enum_etendu >& lienu
, const Tableau * >& tabQ,int cas)
{ for (int i=1;i<=nbMaillageTotal;i++) tabMaillage(i)->FinTransfertPtIntegAuNoeud(lienu,tabQ,cas);};
void FinTransfertPtIntegAuNoeud(int numMail,const List_io < Ddl_enum_etendu >& lienu
, const Tableau * >& tabQ,int cas)
{ tabMaillage(numMail)->FinTransfertPtIntegAuNoeud(lienu,tabQ,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) InitUpdateElementAuNoeud: avant le cumul, initialise les conteneurs
// initialise uniquement les grandeurs qui sont gérées par l'élément
// C) Accumul_aux_noeuds : balaie les éléments avec cumul aux noeuds, uniquement des grandeurs gérées par l'élement
// D) MoyenneCompteurAuNoeud : effectue les moyennes aux noeuds
// accumulation aux noeuds de grandeurs venant de tous les éléments vers ses 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(int numMail,const List_io < Ddl_enum_etendu >& lietendu
,List_io < TypeQuelconque > & liQ,int cas)
{ tabMaillage(numMail)->Accumul_aux_noeuds(lietendu,liQ,cas);};
// fonctions utilitaires du même genre pour tous les maillages
// ajout sur tous les maillages d'un conteneur particulier quelconque
void AjoutConteneurAuNoeud(TypeQuelconque& tQ)
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->AjoutConteneurAuNoeud(tQ);};
// ajout sur tous les maillages d'un ou plusieur ddl_enum_etendu comme conteneur
void AjoutConteneurAuNoeud(const List_io < Ddl_enum_etendu >& lienu)
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->AjoutConteneurAuNoeud(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)
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->InitUpdateAuNoeud(lienu);};
// idem pour un seul ddl_etendu
void InitUpdateAuNoeud(const Ddl_enum_etendu & enu)
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->InitUpdateAuNoeud(enu);};
// moyenne des valeurs aux noeuds (en fonction du nombre ou le noeud a été modifié)
void MoyenneCompteurAuNoeud(const Ddl_enum_etendu & enu)
{ for (int imail=1;imail<=nbMaillageTotal;imail++) tabMaillage(imail)->MoyenneCompteurAuNoeud(enu);};
// initialisation d'un ou de plusieurs nouveau cas d'assemblage
// ramène le numéro du premier nouveau cas d'assemblage
Nb_assemb InitNouveauCasAssemblage(int nb_cas);
// ramène le nombre total de cas d'assemblage actuellement pris en compte dans les
// maillages
int Nb_total_en_cours_de_cas_Assemblage() const {return tab_nb_assemb;};
// met a jour les pointeurs d'assemblage dans les noeuds pour un cas d'assemblage
// a effectuer si l'on a changer de nb de noeuds, de nb de ddl, de nb de maillage
// casAssemb : donne le cas d'assemblage qui est a considérer
void MiseAJourPointeurAssemblage(const Nb_assemb& nb_casAssemb);
// mise a zero de tous les ddl actifs autres que les deplacements
// si indic = false; pas de creation des tableaux a t+dt
// si indic = true; creation des tableaux a t+dt
// cas = true; les coordonnées à t et éventuellement à t+dt sont initialisées
// aux valeurs de t=0 (cas par défaut),
// sinon on ne les modifies pas.
void ZeroDdl(bool indic,bool cas = true);
// 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)
{ for (int imail=1;imail<=nbMaillageTotal;imail++)
tabMaillage(imail)->Force_Ddl_aux_noeuds_a_une_valeur(enu,val,temps,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& tab_enu)
{ for (int imail=1;imail<=nbMaillageTotal;imail++)
tabMaillage(imail)->Force_Ddl_etendu_aux_noeuds_a_zero(tab_enu);};
// ramene la demi largeur de bande en ddl et la largeur de bande
// casAssemb : donne le cas d'assemblage qui est a considérer
void Largeur_Bande(int& demi, int& total,const Nb_assemb& nb_casAssemb);
// méthode permettant le calcul des matrices de connexion pour chaque
// élément ceci par rapport à la numérotation absolu des ddl
// casAssemb : donne le cas d'assemblage qui est a considérer
void Table_connexion
(Tableau < Tableau >& petites_matricespetites_matrices
,const Nb_assemb& nb_casAssemb) const;
// actualisation des ddl et des grandeurs actives de t+dt vers t
void TdtversT();
// actualisation des ddl et des grandeurs actives de t vers tdt
void TversTdt();
// actualisation des ddl a t+dt, a partir du resultat de la resolution
// casAssemb : donne le cas d'assemblage qui est a considérer
void PlusDelta_tdt(Vecteur& sol,const Nb_assemb& nb_casAssemb);
// actualisation des ddl actifs a t, a partir du resultat de la resolution
// casAssemb : donne le cas d'assemblage qui est a considérer
void PlusDelta_t(Vecteur& sol,const Nb_assemb& nb_casAssemb);
// récupération du vecteur correspondant à l'incrément de ddl entre t et tdt
// en paramètre le vecteur vide et en sortie le vecteur rempli
// casAssemb : donne le cas d'assemblage qui est a considérer
Vecteur& RecupDepde_tatdt(Vecteur& sol,const Nb_assemb& nb_casAssemb);
// changement des ddl à tdt par ceux correspondant au vecteur passé en paramètre
// casAssemb : donne le cas d'assemblage qui est a considérer
void ChangeDdla_tdt(Vecteur& sol,const Nb_assemb& nb_casAssemb);
// retrouver le ddl correspondant a un pointeur de position
// d'assemblage, le nb du noeud et du maillage
// insol = le pointeur d'assemblage;
// ddl = le ddl en sortie; a t+dt si elle il existe
// sinon la valeur a t
// casAssemb : donne le cas d'assemblage qui est a considérer
Ddl NoeudIndice(int inSol,int& nbNoeud, int& nbMaillage
,const Nb_assemb& nb_casAssemb);
// idem en ramenant en plus la valeur du ddl a 0
// casAssemb : donne le cas d'assemblage qui est a considérer
Ddl NoeudIndice(int inSol,int& nbNoeud, int& nbMaillage, double& val0
,const Nb_assemb& nb_casAssemb);
// 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()
{ for (int imail=1;imail<=nbMaillageTotal;imail++)
tabMaillage(imail)->InitNormaleAuxNoeuds();};
// mise à jour -> mise à jour des normales à t
void MiseAjourNormaleAuxNoeuds()
{ for (int imail=1;imail<=nbMaillageTotal;imail++)
tabMaillage(imail)->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()
{ for (int imail=1;imail<=nbMaillageTotal;imail++)
tabMaillage(imail)->MiseAjourNormaleAuxNoeuds_de_tdt_vers_T();};
// ---------- particularité aux contacts ----------
// creation des elements frontiere: cela n'a lieu qu'une seule fois
// si les frontières existent déjà, --> aucune action, --> ramène 0
// sinon il y a réellement création, et --> ramène 1
int CreeElemFront();
// ramene le nombre de maillage esclave
inline int NbEsclave() { return domEsclave;};
// ramene le tableau des list des elements frontiere
inline Tableau *>& ListFrontiere() { return listFrontiere;};
// ramene un tableau des noeuds des frontières des maillages esclaves
Tableau < Tableau *> Tab_noeud_frontiere_esclave();
// ramene le tableau des noeuds des frontières des maillages
const Tableau *>& Tab_noeud_frontiere() {return tt_noeud_front;};
// calcul et ramene le tableau de tous les noeuds des maillages esclaves
// noeuds de la frontière et noeuds internes
// s'ils existent, sinon le tableau est vide
// le tableau n'est pas sauvegarde
const Tableau Esclave();
// mise à jour des boites d'encombrements des éléments, qui contiennent des éléments frontières
// et des éléments frontières eux-même
void Mise_a_jour_boite_encombrement_elem_front(Enum_dure temps);
// crée et ramene pour tous les maillages, la liste des éléments qui contiennent chaque noeud
// mis à jour lorsque lors de la création des frontières
const Tableau < const Tableau > *>& Indice() ;
// inactive tous les ddl et les données
void Inactive_ddl_et_donnees();
// inactive les ddl mais pas les données
void Inactive_ddl();
// inactive les ddl primaires
void Inactive_ddl_primaire();
// active les ddl primaires
void Active_ddl_primaire();
// introduction des ddl de contraintes si cela veut dire quelques chose
// pour l'élément
void Plus_ddl_Sigma();
// inactivation des ddls de contraintes si cela veut dire quelques chose
// pour l'élément
void Inactive_ddl_Sigma();
// activation des ddls de contraintes si cela veut dire quelques chose
// pour l'élément
void Active_ddl_Sigma();
// activation du premier ddl de contraintes si cela veut dire quelques chose
// pour l'élément
void Active_premier_ddl_Sigma();
// introduction des ddl d'erreur si cela veut dire quelques chose
// pour l'élément
void Plus_ddl_Erreur();
// inactivation des ddls d'erreur si cela veut dire quelques chose
// pour l'élément
void Inactive_ddl_Erreur();
// activation des ddls d'erreur si cela veut dire quelques chose
// pour l'élément
void Active_ddl_Erreur();
// d'une manière plus générique une fonction pour activer une série de ddl
// donnée par un identificateur, si c'est une grandeur vectoriel c'est l'ensemble
// des ddl du vecteur qui sont inactivé.
void Active_un_type_ddl_particulier(Enum_ddl en);
void Active_un_type_ddl_particulier(Tableau& tab_en); // idem mais pour un tableau
void Active_un_type_ddl_particulier(const list& list_en); // idem pour une liste
// idem la fonction Active_ddl_noeud mais ici pour l'inactivation
void Inactive_un_type_ddl_particulier(Enum_ddl en);
void Inactive_un_type_ddl_particulier(Tableau& tab_en); // idem mais pour un tableau
void Inactive_un_type_ddl_particulier(const list & list_en); // idem pour une liste
// -- encore plus générique
// changement de toutes les conditions données (service, variable, fixage ..)
// selon le tableau de ddl passé en paramètre
// par contre les valeurs de ta ne sont pas utilisé donc les valeurs actuelles restent inchangé
void ChangeToutesLesConditions(const Tableau& ta);
// changement de statu des ddl d'une combinaison, en fonction du statut
// de enuta dans chaque noeud, les ddl de la combinaison, prennent le même statut que celui
// de enuta dans chaque noeud.
// cas est la combinaison,
void ChangeStatut(int cas,Enum_ddl enuta);
// changement de statu des ddl d'une combinaison dans chaque noeud, en fonction
// de enubold, les ddl de la combinaison, prennent le même statut que enubold
// cas est la combinaison,
void ChangeStatut(int cas,Enum_boolddl enubold);
//change le statut de tous les ddl liés à la physique en cours
//par exemple: met à libre ou bloque les ddl liés à la physique en cours
void Libere_Ddl_representatifs_des_physiques(Enum_boolddl enubold);
// Calcul de l'erreur sur l'ensemble des éléments
// type indique le type d'erreur retenue
// type = 1 : cas d'un calcul aux moindres carrés
// et retour un tableau de tableau de grandeurs sur les maillages en cours
// ret(i) : concerne le maillage i
// ret(i)(1) : somme des erreurs sur l'ensemble des éléments: est homogêne à
// un |delta contrainte| * domaine
// ret(i)(2) : somme de la grandeur de ref du calcul d'erreur sur l'ensemble des
// éléments: est homogêne à une |contrainte| * domaine
// ret(i)(3) : le maxi pour les tous les éléments de |delta contrainte| * domaine
// ret(i)(4) : le maxi pour les tous les éléments de |contrainte| * domaine
Tableau > ErreurSurChaqueElement(int type);
// lecture de donnée en fonction d'un indicateur : type
// type = 1 , on lit les tenseurs de contraintes
void LectureDonneesExternes(const int type ,const string& nomMaillage);
// mise en place du travail à t sur les maillages
// indique que l'on va utiliser les ddl en 0, t
// si les grandeurs en tdt existaient, elles sont supprimées
void Travail_t();
// idem pour un maillage donné de numéro num
void Travail_t(int num);
// définition des coordonnées à t identiques à ceux à t=0,
void Insert_coord1();
// mise en place du travail à t tdt sur les maillages
// indique que l'on va utiliser les ddl en 0, t, tdt
void Travail_tdt();
// 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() { for (int imail=1;imail<=nbMaillageTotal;imail++)
tabMaillage(imail)->Init_Xi_t_et_tdt_de_0();};
// 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 pour tous les maillages
double Min_dist2Noeud_des_elements(Enum_dure temps) const ;
// indique aux éléments un niveau de précision de calcul désiré pour les prochains calculs
// precision = 0 : aucune précision demandée, precision >=0 : précision maximale demandée
void Drapeau_preparation_calcul_precis(int precision);
// --------- calcul dynamique ---------
// ajout des ddl de vitesse pour tous les maillages
// val_fixe indique si l'on veut des ddl libres ou pas
void Plus_Les_ddl_Vitesse(Enum_boolddl val_fixe);
// ajout des ddl d'accélération pour tous les maillages
// val_fixe indique si l'on veut des ddl libres ou pas
void Plus_Les_ddl_Acceleration(Enum_boolddl val_fixe);
// calcul de la longueur d'arrête d'élément minimal
// divisé par la célérité dans le matériau
double Longueur_arrete_mini_sur_c(Enum_dure temps);
// initialisation éventuelle du bulk viscosity
// choix peut-être égale à 0, 1 ou 2
void Init_bulk_viscosity(int choix,const DeuxDoubles & coef);
//----- lecture écriture de restart -----
// 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
void SchemaXML_LesMaillages(ofstream& sort,const Enum_IO_XML enu) const ;
// ------ informations utiles par exemples pour la visualisation
// retourne les dimensions minis et maxi suivant les axes du repère
// absolu du maillage numéro nbmail (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 Taille_boite(int nbmail);
// dans le cas ou aucun numéro de maillage n'est fournis
// c'est l'encombrement de tous les maillages qui est fourni
Tableau Taille_boite();
// -------- utilitaires de manipulation de maillage
// création de maillage quadratiques incomplets à partir de maillages linéaires.
// En fait il y création de maillages identiques aux maillages déjà existants, les éléments qui sont de types
// linéaires sont remplacés par des éléments quadratiques incomplets correspondants.
// Il y a création de références correspondantes
void CreeMaillagesQuadratiques_a_partir_des_lineaires(LesReferences* lesRef);
// création de maillage quadratiques complets. En fait il y création de maillages identiques aux maillages
// déjà existants, les éléments qui sont de types quadratiques incomplets sont remplacés par des éléments
// quadratiques complets correspondants.
// Il y a création de références correspondantes
void CreeMaillagesQuadratiquesComplets_a_partir_des_incomplets(LesReferences* lesRef);
// création de maillages par extrusion
// Il y a création de références correspondantes
void CreeMaillageExtrusion2D3D(LesReferences* lesRef);
// 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);
// 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);
// Collapse des éléments supperposés, c-a-d identiques, dans le cas où il en existe
void Collapse_element_supperpose(LesReferences* lesRef);
// création d'un nouveau maillage issue de la fusion de maillages existants
// nom_mails_a_fusionner : la liste des maillages à fusionner
// new_mail : le nom du nouveau maillage à construire
// NB: si new_mail correspond à un maillage déjà existant, il y a fusion de ce maillage
// avec les autres, sans création d'un nouveau maillage
void Fusion_maillages(List_io < string >& nom_mails_a_fusionner,const string& new_mail
,LesReferences* lesRef);
// création d'un nouveau maillage issue d'un maillages existants et d'une ref d'éléments
// le nouveau maillage = les éléments de la ref
void Cree_sous_maillage(int num_mail,LesReferences* lesRef, string nom_ref,const string& new_mail);
// création d'éléments SFE en fonction d'éléments classiques
// il y a création d'un nouveau maillage
void CreationMaillageSFE();
// Affiche les donnees des maillages dans des fichiers dont le nom est construit à partir du nom de
// chaque maillage au format ".her" et ".lis"
// le paramètre optionnel indique le numéro du maillage à afficher, s'il vaut -1, on affiche tous les maillages
void Affiche_maillage_dans_her_lis(Enum_dure temps,LesReferences &lesRef,int imail=-1);
// relocalisation des points milieux des arrêtes des éléments quadratiques
void RelocPtMilieuMailleQuadra();
// --- utilitaires pour calculs particuliers-------
// calcul des diverses intégrations: volume et volume + temps,
// alimentation des grandeurs globales associées
void Integration();
// calcul des diverses statistiques sur des ref de noeuds et avec éventuellement
// cumul sur le temps
// alimentation des grandeurs globales associées
void CalStatistique();
private :
// VARIABLES PROTEGEES :
Tableau tabMaillage ; // tableau de maillages
// liste des noms de maillages associée à un numéro sous forme d'un arbre pour faciliter la recherche
// cette liste est modifiée que par chaque maillage
map < string, int , std::less > mapNomMail;
// const int nbEnreg; // nb de maillage initiaux
int nbEnreg; // nb de maillage initiaux
int nbMaillageTotal; // nb de maillage effectivement en cours
int nbPortion ; // nbPortion = le nombre maxi de maillage enregistrable
// avant une nouvelle allocation dynamique de nbEnreg places supplementaires
UtilLecture * entreePrinc; // acces a la lecture du fichier principal
ParaGlob * paraGlob ; // parametres globaux
LesReferences* lesRef; // references
int domEsclave; // nombre de domaine esclave, lorsqu'il est different de zero
// il indique le nombre de maillage a partir de 1, qui sont esclave
// ---- stockage des intégrales de volumes sur des références d'éléments ----
// --- cas des intégrales volumiques: définition du conteneur, il peut également s'agir d'une intégration temporelle en +
// d'où la grandeur courante et celle à t
// 1) intégration de volume uniquement
Tableau integ_vol_typeQuel, integ_vol_typeQuel_t;
Tableau ref_integ_vol; // les références associées
// si la référence est nulle, cela signifie que l'intégrale est figée: sa valeur ne change pas
// 2) intégration de volume et en temps: donc on commule le delta
Tableau integ_vol_t_typeQuel, integ_vol_t_typeQuel_t;
Tableau ref_integ_vol_t; // les références associées
// si la référence est nulle, cela signifie que l'intégrale est figée: sa valeur ne change pas
// ---- stockage des statistiques sur des références de noeuds ----
// --- cas des statistique: définition du conteneur, il peut également s'agir d'un cumul temporelle en +
// d'où la grandeur courante et celle à t
// 1) statistique de ref de noeuds uniquement
Tableau statistique_typeQuel, statistique_typeQuel_t;
Tableau ref_statistique; // les références associées
// si la référence est nulle, cela signifie que la statistique
// est figée: sa valeur ne change pas
//pour_statistique_de_ddl a la même dimension que ref_statistique
// 1) Dans le cas où ref_statistique(i) est une statistique de Ddl_enum_etendu
// pour_statistique_de_ddl(i) == le Ddl_enum_etendu
// 2) sinon, pour_statistique_de_ddl(i) == NU_DDL
Tableau < Ddl_enum_etendu > pour_statistique_de_ddl;
// 2) statistique avec cumul en temps: donc on commule le delta
Tableau statistique_t_typeQuel, statistique_t_typeQuel_t;
Tableau ref_statistique_t; // les références associées
// si la référence est nulle, cela signifie que la statistique est figée: sa valeur ne change pas
//pour_statistique_t_de_ddl a la même dimension que ref_statistique_t
// 1) Dans le cas où ref_statistique_t(i) est une statistique de Ddl_enum_etendu
// pour_statistique_t_de_ddl(i) == le Ddl_enum_etendu
// 2) sinon, pour_statistique_de_ddl(i) == NU_DDL
Tableau < Ddl_enum_etendu > pour_statistique_t_de_ddl;
// cumule les 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 les 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)
list ddl_representatifs_des_physiques;
// idem au niveau des types de problèmes gérés par les éléments
list types_de_problemes;
// stockage des pointeurd de listes d'element frontiere
Tableau *> listFrontiere;
// idem pour les noeuds des frontières
Tableau *> tt_noeud_front;
// crée et ramene pour tous les maillages, la liste des éléments qui contiennent chaque noeud
// mis à jour lorsque lors de la création des frontières
Tableau < const Tableau > *> tous_indices;
// tableau d'indexage des ddl géré par les noeuds
// t_i_n (i)(j) -> donne les infos pour retrouver le ddl numéro j du cas de charge i
Tableau < Tableau > t_i_n;
// nombre actuellement de cas d'assemblage initialisé
int tab_nb_assemb;
// METHODES PROTEGEES :
// 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();
// met a jour les pointeurs d'assemblage dans les noeuds pour un cas d'assemblage
// a effectuer si l'on a changer de nb de noeuds, de nb de ddl, de nb de maillage
// casAssemb : donne le cas d'assemblage qui est a considérer
// ici, l'assemblage suit l'ordre du tableau de noeud passé en paramètre
// le tableau de noeuds rassemble tous les noeuds des maillages mais avec une numérotation propre
void MiseAJourPointeurAssemblage_interne(const Nb_assemb& nb_casAssemb,Tableau & tab_N_final);
// remise à jour des tableaux de pointeurs t_i_n uniquement, due à un changement de numéro de noeud
// en fonction d'un changement de num de noeud (mais pas de changement de pointeur d'assemblage
// pour chaque noeud, tab_N_final(i) correspond au noeud qui avait le numéro i ancien
// et qui a maintenant le numéro tab_N_final(i)->Num_noeud()
void MiseAJourTableau_t_i_n(const Nb_assemb& nb_casAssemb,Tableau & tab_N_final);
};
/// @} // end of group
#endif