1784 lines
84 KiB
C++
Executable file
1784 lines
84 KiB
C++
Executable file
// FICHIER : Maillage.cp
|
|
// CLASSE : Maillage
|
|
|
|
// This file is part of the Herezh++ application.
|
|
//
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
// of mechanics for large transformations of solid structures.
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
//
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
//
|
|
// Copyright (C) 1997-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/>.
|
|
|
|
|
|
#include "Maillage.h"
|
|
# include <iostream>
|
|
using namespace std; //introduces namespace std
|
|
#include <stdlib.h>
|
|
#include "Sortie.h"
|
|
#include <stdio.h>
|
|
#include <vector>
|
|
#include "List_io.h"
|
|
#include "CharUtil.h"
|
|
#ifndef SYSTEM_MAC_OS_X_unix
|
|
#include "Frontier.h"
|
|
#endif
|
|
#include "ConstMath.h"
|
|
#include "ReferenceNE.h"
|
|
#include "ReferenceAF.h"
|
|
#include "Util.h"
|
|
#include "MvtSolide.h"
|
|
|
|
|
|
// --------- utilitaires de manipulation de maillage
|
|
// test pour savoir si le maillage contiend des éléments à interpolation linéaire
|
|
bool Maillage::Contient_lineaire()
|
|
{ // on balaie les éléments
|
|
int taille_elem = tab_element.Taille();
|
|
for (int i=1; i<=taille_elem;i++)
|
|
{ Enum_interpol eninter = tab_element(i)->Id_interpolation();
|
|
// LINEAIRE indique que l'on a une interpolation linéaire
|
|
if (eninter == LINEAIRE) return true;
|
|
}
|
|
// sinon pas d'élément incomplet quadratique
|
|
return false;
|
|
};
|
|
bool Maillage::Contient_quadratique_incomplet()
|
|
{ // on balaie les éléments
|
|
int taille_elem = tab_element.Taille();
|
|
for (int i=1; i<=taille_elem;i++)
|
|
{ Enum_interpol eninter = tab_element(i)->Id_interpolation();
|
|
// QUADRATIQUE indique que l'on a une interpolation quadratique incomplète
|
|
// alors que QUADRACOMPL indique que c'est quadratique complet
|
|
if (eninter == QUADRATIQUE) return true;
|
|
}
|
|
// sinon pas d'élément incomplet quadratique
|
|
return false;
|
|
};
|
|
|
|
// 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 Maillage::Transfo_lin_quadraIncomp(LesReferences &lesRef)
|
|
{list <Element *> nv_remplace;
|
|
list <Maillage::PosiEtNoeud> li_nv_noeud;
|
|
list <DeuxEntiers> li_bornes;
|
|
// 1) on balaie les éléments
|
|
int nbnt=tab_noeud.Taille(); // le nombre de noeud total (évolue pendant la transformation)
|
|
// nbnt permet à Construct_from_imcomplet de donner des numéros de noeud licite, en particulier
|
|
// permet d'éviter que deux noeuds aient le même numéro
|
|
int taille_elem = tab_element.Taille();
|
|
for (int i=1; i<=taille_elem;i++)
|
|
{ Enum_interpol eninter = tab_element(i)->Id_interpolation();
|
|
// LINEAIRE indique que l'on a une interpolation linéaire
|
|
if (eninter == LINEAIRE)
|
|
{// 2) on a trouvé un linéaire
|
|
// on crée un quadratique incomplet de même type
|
|
Element * elem = tab_element(i); // pour simplifier
|
|
Element::Signature signa = elem->Signature_element();
|
|
// on change l'interpolation
|
|
signa.id_interpol=QUADRATIQUE;
|
|
// on crée le nouvel élément quadratique avec le même numéro que le linéaire (car il le remplacera
|
|
// par la suite)
|
|
Element* elem2= Element::Choix_element(elem->Num_maillage(),elem->Num_elt(),signa);
|
|
if (elem2 == NULL)
|
|
{ cout << "\n erreur de creation d'un element quadratique incomplet a partir d'un lineaire"
|
|
<< "\n signature du lineaire: interpolation " << Nom_interpol(signa.id_interpol)
|
|
<< " geometrie: " << Nom_geom(signa.id_geom) << " problem: " << NomElemTypeProblem(signa.id_problem)
|
|
<< " infos_annexes: " << signa.infos_annexes
|
|
<< "\n Maillage::Transfo_lin_quadraIncomp(...";
|
|
Sortie(1);
|
|
}
|
|
// 3) on demande à l'élément de définir ses noeuds, d'une part à partir des noeuds
|
|
// déjà existants de l'élément linéaire, et d'autre part à partir de nouveaux noeuds
|
|
// construit à partir de l'interpolation initiale linéaire.
|
|
// on fournit également le premier numéro -1 du nouveau noeud
|
|
list <DeuxEntiers> li_bo; // les bornes pour la renumérotation
|
|
list <Noeud *> l_nv_noe = elem2->Construct_from_lineaire(*elem,li_bo,nbnt);
|
|
nbnt += l_nv_noe.size();
|
|
// 4) on ajoute les nouveaux noeuds
|
|
list <Noeud *>::iterator lni,lnifin=l_nv_noe.end();
|
|
for (lni=l_nv_noe.begin();lni!=lnifin;lni++)
|
|
{li_nv_noeud.push_back(Maillage::PosiEtNoeud(*lni,elem2));
|
|
}
|
|
list <DeuxEntiers>::iterator pni,pnifin=li_bo.end();
|
|
for (pni=li_bo.begin();pni!=pnifin;pni++)
|
|
{li_bornes.push_back(*pni);
|
|
}
|
|
// 5) on enregistre l'élément linéaire et on le remplace par le quadratique dans
|
|
// la liste d'élément
|
|
nv_remplace.push_back(elem);
|
|
tab_element(i) = elem2;
|
|
}
|
|
}
|
|
|
|
// 6) on supprime les doublons dans la liste des noeuds en réaffectant les bons pointeurs dans les éléments
|
|
// li_nv_noeud.sort(); // ordonne la liste
|
|
// suppression des doublons et réaffectation des pointeurs de noeuds supprimés dans les éléments
|
|
if (li_nv_noeud.size() != 1)
|
|
{list <Maillage::PosiEtNoeud>::iterator lili,lilifin = li_nv_noeud.end();
|
|
list <Maillage::PosiEtNoeud>::iterator lila = li_nv_noeud.begin();lili=lila; lili++;
|
|
list <DeuxEntiers>::iterator pili,pilifin = li_bornes.end();
|
|
list <DeuxEntiers>::iterator pila = li_bornes.begin();pili=pila; pili++;
|
|
do
|
|
{ if (*lila == *lili)
|
|
{ //cas de deux noeuds identiques, on réaffecte le pointeur de noeud dans l'élément
|
|
(*lila).el->Reaffectation_pointeur_noeud((*lila).noe,(*lili).noe);
|
|
// on supprime le noeud doublon
|
|
delete (*lila).noe;
|
|
// on supprime les éléments de la liste
|
|
li_nv_noeud.erase(lila); li_bornes.erase(pila);
|
|
}
|
|
lila = lili; lili++;
|
|
pila = pili; pili++;
|
|
} while (lili!= lilifin);
|
|
}
|
|
// 7) insertion des nouveaux noeuds dans le tableau définitif et renumérotation
|
|
// a) on commence par définir une liste de noeud, équivalente au tableau tab_noeud
|
|
List_io <Noeud *> li_no;
|
|
int nbn = tab_noeud.Taille();
|
|
// petite vérif: il faut que le maillage contienne au moins un noeud
|
|
#ifdef MISE_AU_POINT
|
|
if (nbn == 0)
|
|
{ cout << "\n erreur le maillage contiend 0 noeud en propre, ce qui est insufisent pour la routine"
|
|
<< "\n list <Element *> Maillage::Transfo_quadraIncomp_quadraComp()";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
// b) on définit un tableau de listes de pointeurs de noeud
|
|
Tableau <List_io<Noeud*> > tab_ln(nbn);
|
|
// c) on remplit chaque liste des noeuds qu'il faudrait ajouter pour avoir une bonne numérotation
|
|
list <Maillage::PosiEtNoeud>::iterator lili,lilifin = li_nv_noeud.end();
|
|
list <DeuxEntiers>::iterator pilifin = li_bornes.end();
|
|
list <DeuxEntiers>::iterator pili = li_bornes.begin();
|
|
for (lili=li_nv_noeud.begin();lili != lilifin; lili++,pili++)
|
|
{ // récup de la position moyenne d'insertion et remplissage de la liste correspondante
|
|
// cout << "\n un= " << (*pili).un << "deux= " << (*pili).deux ;
|
|
int bi=( (*pili).un + (*pili).deux ) / 2; // division entière
|
|
// cout << " bi= " << bi << endl;
|
|
tab_ln(bi).push_back((*lili).noe);
|
|
}
|
|
// d) on définit un nouveau tableau de noeud qui comprend les anciens et les nouveaux noeuds, ordonnées
|
|
int nbn_nv = nbn+li_nv_noeud.size();
|
|
Tableau<Noeud *> tab_noe_nv(nbn_nv);
|
|
// définition également d'un tableau d'indiçage inverse
|
|
Tableau <int> indic(nbn);
|
|
int ino=0;
|
|
for (int ivo=1;ivo<= nbn;ivo++)
|
|
{ // tout d'abord le noeud ancien
|
|
ino++; tab_noe_nv(ino)=tab_noeud(ivo);
|
|
indic(ivo)=ino;
|
|
// puis éventuellement les noeuds à intercaler
|
|
List_io<Noeud*>& li_ln = tab_ln(ivo); // pour simplifier
|
|
if (li_ln.size() != 0)
|
|
{ List_io<Noeud*>::iterator iln,iln_end=li_ln.end();
|
|
for (iln=li_ln.begin(); iln != iln_end; iln++)
|
|
{ ino++; tab_noe_nv(ino)=*iln;};
|
|
}
|
|
}
|
|
tab_noeud = tab_noe_nv; // remplacement du tableau du maillage
|
|
// e) on renumérote les différents noeuds
|
|
for (int j=1;j<= nbn_nv;j++) tab_noeud(j)->Change_num_noeud(j);
|
|
// 7) modification des références sur les noeuds
|
|
// a) on passe en revue les références et on sélectionne les références relatives aux noeuds
|
|
// de l'ancien maillage
|
|
const Reference* ref1 = lesRef.Init_et_Premiere();
|
|
do { if((ref1->Nbmaille() == idmail) && (ref1->Indic() == 1))
|
|
// on a trouvé une référence de noeud à considérer
|
|
{ ReferenceNE * refNE = ( ReferenceNE *) ref1; // pour simplifier
|
|
int nb_num=refNE->Taille();
|
|
for (int it= 1;it<=nb_num;it++)
|
|
refNE->Change_num_dans_ref(it,indic(refNE->Numero(it)));
|
|
}
|
|
ref1 = lesRef.Reference_suivante(); // la référence suivante
|
|
} while (ref1 != NULL);
|
|
|
|
cout << "\n *** attention les references generes ici ne sont pas bonnes !! , seul le maillage est "
|
|
<< " actuellement correcte ";
|
|
|
|
// 8) suppression des éléments linéaires qui n'ont plus lieu d'être
|
|
list <Element *>::iterator lele,lelefin=nv_remplace.end();
|
|
for (lele=nv_remplace.begin();lele!=lelefin;lele++)
|
|
delete (*lele);
|
|
// 9) rien à faire sur les références d'élément, ou de face d'élément ou d'arrête d'élément
|
|
// car d'une part les nouveaux éléments ont le même numéro que les anciens, et d'autre part
|
|
// le fait de passer en élément complet ne modifie pas les arrêtes ou faces
|
|
};
|
|
|
|
// 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 Maillage::Transfo_quadraIncomp_quadraComp(LesReferences &lesRef)
|
|
{list <Element *> nv_remplace;
|
|
list <Maillage::PosiEtNoeud> li_nv_noeud;
|
|
list <DeuxEntiers> li_bornes;
|
|
// 1) on balaie les éléments
|
|
int nbnt=tab_noeud.Taille(); // le nombre de noeud total (évolue pendant la transformation)
|
|
// nbnt permet à Construct_from_imcomplet de donner des numéros de noeud licite, en particulier
|
|
// permet d'éviter que deux noeuds aient le même numéro
|
|
int taille_elem = tab_element.Taille();
|
|
for (int i=1; i<=taille_elem;i++)
|
|
{ Enum_interpol eninter = tab_element(i)->Id_interpolation();
|
|
// QUADRATIQUE indique que l'on a une interpolation quadratique incomplète
|
|
// alors que QUADRACOMPL indique que c'est quadratique complet
|
|
if (eninter == QUADRATIQUE)
|
|
{// 2) on a trouvé un quadratique incomplet
|
|
// on crée un quadratique complet de même type
|
|
Element * elem = tab_element(i); // pour simplifier
|
|
Element::Signature signa = elem->Signature_element();
|
|
// on change l'interpolation
|
|
signa.id_interpol=QUADRACOMPL;
|
|
// on crée le nouvel élément complet avec le même numéro que l'incomplet (car il le remplacera
|
|
// par la suite)
|
|
Element* elem2= Element::Choix_element(elem->Num_maillage(),elem->Num_elt(),signa);
|
|
if (elem2 == NULL)
|
|
{ cout << "\n erreur de creation d'un element quadratique complet a partir d'un incomplet"
|
|
<< "\n signature du quadratique incomplet: interpolation " << Nom_interpol(signa.id_interpol)
|
|
<< " geometrie: " << Nom_geom(signa.id_geom) << " problem: " << NomElemTypeProblem(signa.id_problem)
|
|
<< " infos_annexes: " << signa.infos_annexes
|
|
<< "\n Maillage::Transfo_quadraIncomp_quadraComp(...";
|
|
Sortie(1);
|
|
}
|
|
// 3) on demande à l'élément de définir ses noeuds, d'une part à partir des noeuds
|
|
// déjà existants de l'élément incomplet, et d'autre part à partir de nouveaux noeuds
|
|
// construit à partir de l'interpolation initiale incomplète.
|
|
// on fournit également le premier numéro -1 du nouveau noeud
|
|
list <DeuxEntiers> li_bo; // les bornes pour la renumérotation
|
|
list <Noeud *> l_nv_noe = elem2->Construct_from_imcomplet(*elem,li_bo,nbnt);
|
|
nbnt += l_nv_noe.size();
|
|
// 4) on ajoute les nouveaux noeuds
|
|
list <Noeud *>::iterator lni,lnifin=l_nv_noe.end();
|
|
for (lni=l_nv_noe.begin();lni!=lnifin;lni++)
|
|
{li_nv_noeud.push_back(Maillage::PosiEtNoeud(*lni,elem2));
|
|
}
|
|
list <DeuxEntiers>::iterator pni,pnifin=li_bo.end();
|
|
for (pni=li_bo.begin();pni!=pnifin;pni++)
|
|
{li_bornes.push_back(*pni);
|
|
}
|
|
// 5) on enregistre l'élément incomplet et on le remplace par le complet dans
|
|
// la liste d'élément
|
|
nv_remplace.push_back(elem);
|
|
tab_element(i) = elem2;
|
|
}
|
|
}
|
|
|
|
// 6) on supprime les doublons dans la liste des noeuds en réaffectant les bons pointeurs dans les éléments
|
|
// non car cela ne sert à rien et il faudrait également traiter li_bornes li_nv_noeud.sort(); // ordonne la liste
|
|
// suppression des doublons et réaffectation des pointeurs de noeuds supprimés dans les éléments
|
|
if (li_nv_noeud.size() != 1)
|
|
{list <Maillage::PosiEtNoeud>::iterator lili,lilifin = li_nv_noeud.end();
|
|
list <Maillage::PosiEtNoeud>::iterator lila = li_nv_noeud.begin();lili=lila; lili++;
|
|
list <DeuxEntiers>::iterator pili,pilifin = li_bornes.end();
|
|
list <DeuxEntiers>::iterator pila = li_bornes.begin();pili=pila; pili++;
|
|
do
|
|
{ if (*lila == *lili)
|
|
{ //cas de deux noeuds identiques, on réaffecte le pointeur de noeud dans l'élément
|
|
(*lila).el->Reaffectation_pointeur_noeud((*lila).noe,(*lili).noe);
|
|
// on supprime le noeud doublon
|
|
delete (*lila).noe;
|
|
// on supprime les éléments de la liste
|
|
li_nv_noeud.erase(lila); li_bornes.erase(pila);
|
|
}
|
|
lila = lili; lili++;
|
|
pila = pili; pili++;
|
|
} while (lili!= li_nv_noeud.end());
|
|
};
|
|
////------ debug
|
|
//{
|
|
//cout << "\n debug: Maillage::Transfo_quadraIncomp_quadraComp ";
|
|
//list <DeuxEntiers>::iterator pili = li_bornes.begin();
|
|
//int i=1;
|
|
//for (pili;pili != li_bornes.end();pili++,i++)
|
|
// cout << "\n borne "<< i <<": " << *pili;
|
|
//cout << endl;
|
|
//};
|
|
////----- fin debug
|
|
|
|
|
|
|
|
// 7) insertion des nouveaux noeuds dans le tableau définitif et renumérotation
|
|
// a) on commence par définir une liste de noeud, équivalente au tableau tab_noeud
|
|
List_io <Noeud *> li_no;
|
|
int nbn = tab_noeud.Taille();
|
|
// petite vérif: il faut que le maillage contienne au moins un noeud
|
|
#ifdef MISE_AU_POINT
|
|
if (nbn == 0)
|
|
{ cout << "\n erreur le maillage contiend 0 noeud en propre, ce qui est insufisent pour la routine"
|
|
<< "\n list <Element *> Maillage::Transfo_quadraIncomp_quadraComp()";
|
|
Sortie(1);
|
|
}
|
|
#endif
|
|
// b) on définit un tableau de listes de pointeurs de noeud
|
|
Tableau <List_io<Noeud*> > tab_ln(nbn);
|
|
// c) on remplit chaque liste des noeuds qu'il faudrait ajouter pour avoir une bonne numérotation
|
|
list <Maillage::PosiEtNoeud>::iterator lili,lilifin = li_nv_noeud.end();
|
|
list <DeuxEntiers>::iterator pilifin = li_bornes.end();
|
|
list <DeuxEntiers>::iterator pili = li_bornes.begin();
|
|
for (lili=li_nv_noeud.begin();lili != lilifin; lili++,pili++)
|
|
{ // récup de la position moyenne d'insertion et remplissage de la liste correspondante
|
|
int bi=( (*pili).un + (*pili).deux ) / 2; // division entière
|
|
////------ debug
|
|
//{
|
|
//cout << "\n debug: Maillage::Transfo_quadraIncomp_quadraComp ";
|
|
// cout << "\n bornes : " << *pili << endl;
|
|
//};
|
|
////----- fin debug
|
|
tab_ln(bi).push_back((*lili).noe);
|
|
};
|
|
// d) on définit un nouveau tableau de noeud qui comprend les anciens et les nouveaux noeuds, ordonnées
|
|
int nbn_nv = nbn+li_nv_noeud.size();
|
|
Tableau<Noeud *> tab_noe_nv(nbn_nv);
|
|
// définition également d'un tableau d'indiçage inverse
|
|
Tableau <int> indic(nbn);
|
|
int ino=0;
|
|
for (int ivo=1;ivo<= nbn;ivo++)
|
|
{ // tout d'abord le noeud ancien
|
|
ino++; tab_noe_nv(ino)=tab_noeud(ivo);
|
|
indic(ivo)=ino;
|
|
// puis éventuellement les noeuds à intercaler
|
|
List_io<Noeud*>& li_ln = tab_ln(ivo); // pour simplifier
|
|
if (li_ln.size() != 0)
|
|
{ List_io<Noeud*>::iterator iln,iln_end=li_ln.end();
|
|
for (iln=li_ln.begin(); iln != iln_end; iln++)
|
|
{ ino++; tab_noe_nv(ino)=*iln;};
|
|
}
|
|
}
|
|
tab_noeud = tab_noe_nv; // remplacement du tableau du maillage
|
|
// e) on renumérote les différents noeuds
|
|
for (int j=1;j<= nbn_nv;j++) tab_noeud(j)->Change_num_noeud(j);
|
|
// 7) modification des références sur les noeuds
|
|
// a) on passe en revue les références et on sélectionne les références relatives aux noeuds
|
|
// de l'ancien maillage
|
|
const Reference* ref1 = lesRef.Init_et_Premiere();
|
|
do { if((ref1->Nbmaille() == idmail) && (ref1->Indic() == 1))
|
|
// on a trouvé une référence de noeud à considérer
|
|
{ ReferenceNE * refNE = ( ReferenceNE *) ref1; // pour simplifier
|
|
int nb_num=refNE->Taille();
|
|
for (int it= 1;it<=nb_num;it++)
|
|
refNE->Change_num_dans_ref(it,indic(refNE->Numero(it)));
|
|
}
|
|
ref1 = lesRef.Reference_suivante(); // la référence suivante
|
|
} while (ref1 != NULL);
|
|
|
|
// 8) suppression des élément incomplet qui n'ont plus lieu d'être
|
|
list <Element *>::iterator lele,lelefin=nv_remplace.end();
|
|
for (lele=nv_remplace.begin();lele!=lelefin;lele++)
|
|
delete (*lele);
|
|
// 9) rien à faire sur les références d'élément, ou de face d'élément ou d'arrête d'élément
|
|
// car d'une part les nouveaux éléments ont le même numéro que les anciens, et d'autre part
|
|
// le fait de passer en élément complet ne modifie pas les arrêtes ou faces
|
|
};
|
|
|
|
// Affiche les donnees du maillage dans un fichier
|
|
// dont le nom est construit à partir du nom du maillage
|
|
// au format ".her" et ".lis"
|
|
void Maillage::Affiche_dans_her_lis(LesReferences &lesRef,Enum_dure temps)
|
|
{
|
|
//------------- écriture du .her -------------
|
|
// ouverture du fichier pour les noeuds
|
|
char nomm[132];
|
|
char*fileName = nomm;
|
|
strcpy(fileName, nomDuMaillage.c_str());
|
|
ofstream * sur_sort = new ofstream (strcat(fileName,".her"));
|
|
ofstream & sort = * sur_sort;
|
|
if(!(sort.is_open()))
|
|
// le fichier ne peut être ouvert, message d'erreur
|
|
{ cout << "\n erreur en ouverture pour l'ecriture du fichier " << fileName << "\n"
|
|
<< " Maillage::Affiche_dans_her_lis(.... " << endl;
|
|
Sortie(1);
|
|
};
|
|
// écriture de l'entete
|
|
sort << "\n ###########################################################################"
|
|
<< "\n # ecriture automatique d'un maillage au format .her, par Herezh++ #"
|
|
<< "\n ###########################################################################"
|
|
<< "\n # version: " << ParaGlob::NbVersion() << "\n \n \n ";
|
|
// écriture du nom du maillage
|
|
sort << "\n nom_maillage " << nomDuMaillage << " # nom du maillage"
|
|
<< "\n"
|
|
<< "\n noeuds ------------ # definition des noeuds";
|
|
int dimen = ParaGlob::Dimension();
|
|
// l'entete des noeuds
|
|
int nbn = tab_noeud.Taille();
|
|
sort << "\n "<< nbn << " NOEUDS # definition du nombre de noeuds"
|
|
<< "\n \n"
|
|
<< "\n#---------------------------------------------------------------"
|
|
<< "\n#|NO DU| X | Y | Z |"
|
|
<< "\n#|NOEUD| | | |"
|
|
<< "\n#---------------------------------------------------------------"
|
|
<< "\n";
|
|
// écriture des noeuds
|
|
double sero = 0.;
|
|
for (int ine=1;ine<=nbn; ine++)
|
|
{ sort << "\n" << setw (6) << ine <<" ";
|
|
Coordonnee co;
|
|
switch (temps)
|
|
{
|
|
case TEMPS_0 : co=tab_noeud(ine)->Coord0(); break;
|
|
// si les noeuds n'ont pas bougés on sort les coordonnées à 0
|
|
case TEMPS_t :
|
|
{ if (tab_noeud(ine)->ExisteCoord1())
|
|
{ co=tab_noeud(ine)->Coord1(); }
|
|
else co=tab_noeud(ine)->Coord0();
|
|
break;
|
|
}
|
|
case TEMPS_tdt :
|
|
{ if (tab_noeud(ine)->ExisteCoord2())
|
|
{ co=tab_noeud(ine)->Coord2(); }
|
|
else co=tab_noeud(ine)->Coord0();
|
|
break;
|
|
}
|
|
default :
|
|
cout << "\nErreur : valeur incorrecte du type Enum_dure !\n";
|
|
cout << "Maillage::Affiche_dans_her_lis(.. \n";
|
|
Sortie(1);
|
|
};
|
|
#ifndef ENLINUX_STREAM
|
|
sort.setf(ios_base::scientific);
|
|
#else
|
|
sort.setf(ios::scientific);
|
|
#endif
|
|
for (int j=1;j<=3;j++)
|
|
if (j<=dimen)
|
|
sort << setw (18) << setprecision(ParaGlob::NbdigdoCA()) <<co(j) << " ";
|
|
else
|
|
sort << setw (18) << setprecision(ParaGlob::NbdigdoCA()) << sero << " ";
|
|
}
|
|
sort << "\n \n";
|
|
// entête des éléments
|
|
int nbe=tab_element.Taille();
|
|
sort << "\n elements ---------- \n"
|
|
<< "\n " << nbe << " ELEMENTS # definition du nombre d'elements"
|
|
<< "\n #----------------------------------------------------------------------"
|
|
<< "\n #| NO | | |"
|
|
<< "\n #|ELTS | type element | Noeuds |"
|
|
<< "\n #----------------------------------------------------------------------"
|
|
<< "\n";
|
|
// écriture des éléments
|
|
for (int ie=1;ie<=nbe;ie++)
|
|
{ sort << "\n" << setw (6) << ie <<" ";
|
|
Element::Signature sign = tab_element(ie)->Signature_element();
|
|
sort << Nom_geom(sign.id_geom) << " " << Nom_interpol(sign.id_interpol)
|
|
<< " " << sign.infos_annexes << " ";
|
|
Tableau<Noeud *>& tab_n = tab_element(ie)->Tab_noeud();
|
|
int taille_tab_n = tab_n.Taille();
|
|
for (int ite=1;ite<=taille_tab_n;ite++)
|
|
sort << tab_n(ite)->Num_noeud() << " ";
|
|
}
|
|
// quelques lignes blanches à la fin du fichier
|
|
sort << "\n \n \n";
|
|
// fermeture du fichier
|
|
delete sur_sort;
|
|
|
|
//------------- écriture du .lis -------------
|
|
|
|
// Affiche les donnees des références pour le maillage imail dans un fichier
|
|
// dont le nom est construit à partir du nom du maillage au format ".lis"
|
|
lesRef.Affiche_dans_lis(nomDuMaillage,idmail);
|
|
|
|
};
|
|
|
|
|
|
//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 Maillage::Restreint_sous_maillage(LesReferences* lesRef, string nom_ref)
|
|
{ // on définit un tableau d'indicateur donnant les éléments non référencés
|
|
Tableau <bool> tab_el_non_referencer(tab_element.Taille(),true); // par défaut on ne conserve pas
|
|
// on définit un tableau d'indicateur donnant les noeuds non référencés
|
|
Tableau <bool> tab_noe_non_referencer(tab_noeud.Taille(),true);
|
|
// récup de la référence des éléments
|
|
const ReferenceNE & ref =((ReferenceNE &) lesRef->Trouve(nom_ref,idmail));
|
|
if (ref.Indic() != 2)
|
|
{cout << "\n *** erreur: la reference "<<nom_ref<<" n'est pas une ref d'element "
|
|
<< " on ne peut pas continuer ";
|
|
if (ParaGlob::NiveauImpression() > 2)
|
|
cout << "\n Maillage::Restreint_sous_maillage(... ";
|
|
Sortie(1);
|
|
};
|
|
// récup du tableau d'éléments de la référence
|
|
const Tableau<int>& tab_E_ref = ref.Tab_num();
|
|
// on marque les éléments à conserver ainsi que les noeuds
|
|
// qui appartiennent à des éléments à conserver
|
|
int nb_el = tab_E_ref.Taille();
|
|
for (int i=1;i<=nb_el;i++)
|
|
{tab_el_non_referencer(tab_E_ref(i)) = false;
|
|
Element * el = tab_element(tab_E_ref(i));
|
|
const Tableau<Noeud *>& tab_noeu = el->Tab_noeud_const();
|
|
int nb_noe = tab_noeu.Taille();
|
|
for (int noe = 1;noe <= nb_noe; noe++)
|
|
tab_noe_non_referencer(tab_noeu(noe)->Num_noeud())=false;
|
|
};
|
|
// suppression des éléments non référencés
|
|
int NBE=tab_element.Taille();
|
|
for (int i=1;i<=NBE;i++)
|
|
if (tab_el_non_referencer(i))
|
|
delete tab_element(i);
|
|
// suppression des noeuds non référencés
|
|
int NBN = tab_noeud.Taille();
|
|
int nb_noeud_final = 0; // init
|
|
for (int i=1;i<= NBN;i++)
|
|
if (tab_noe_non_referencer(i))
|
|
{delete tab_noeud(i);}
|
|
else {nb_noeud_final++;}; // sinon on compte
|
|
|
|
// on redimentionne et réafecte le tableau de noeuds
|
|
Tableau<Noeud *> tab_old_noe = tab_noeud; // sauvegarde de l'ancien tableau
|
|
// nv_tab est tel que : nv_tab_noe(i) est le nouveau numéro qui avait auparavant le numéro "i"
|
|
Tableau <int > nv_tab_noe(NBN);
|
|
tab_noeud.Change_taille(nb_noeud_final);
|
|
int indice_noeu=1; // pour parcourir le tableau final de noeud
|
|
for (int i=1;i<=NBN;i++)
|
|
if (!tab_noe_non_referencer(i))
|
|
{tab_noeud(indice_noeu) = tab_old_noe(i);
|
|
nv_tab_noe(i)=indice_noeu;
|
|
tab_noeud(indice_noeu)->Change_num_noeud(indice_noeu);
|
|
indice_noeu++;
|
|
};
|
|
|
|
|
|
// on redimentionne et réafecte le tableau d'élément
|
|
Tableau<Element *> tab_old_El = tab_element; // sauvegarde de l'ancien tableau
|
|
// nv_tab est tel que : nv_tab_ele(i) est le nouveau numéro qui avait auparavant le numéro "i"
|
|
Tableau <int > nv_tab_ele(NBE);
|
|
tab_element.Change_taille(nb_el);
|
|
int indice_ele=1; // pour parcourir le tableau final d'élément
|
|
for (int i=1;i<=NBE;i++)
|
|
if (!tab_el_non_referencer(i))
|
|
{tab_element(indice_ele) = tab_old_El(i);
|
|
nv_tab_ele(i)=indice_ele;
|
|
tab_element(indice_ele)->Change_num_elt(indice_ele);
|
|
indice_ele++;
|
|
};
|
|
|
|
// on s'occupe maintenant des références
|
|
lesRef->Mise_a_jour_ref_element(nv_tab_ele,idmail,tab_el_non_referencer);
|
|
lesRef->Mise_a_jour_ref_noeud(nv_tab_noe,idmail,tab_noe_non_referencer);
|
|
// toilettage final
|
|
listFrontiere.clear();tab_noeud_front.Change_taille(0);indice.Change_taille(0);
|
|
mitoyen_de_chaque_element.Change_taille(0);
|
|
};
|
|
|
|
|
|
// relocalisation des points milieux des arrêtes des éléments quadratiques
|
|
void Maillage::RelocPtMilieuMailleQuadra()
|
|
{ // on passe en revue les différents éléments pour voir s'il ont une arrête quadratique
|
|
int nbe = tab_element.Taille();
|
|
for (int ne=1;ne<=nbe;ne++)
|
|
{ // récup de l'élément géométrique
|
|
const ElemGeomC0& elgeom = tab_element(ne)->ElementGeometrique_const();
|
|
// récup du nombre de segment
|
|
int nbse= elgeom.NbSe();
|
|
// on boucle sur les segments pour voir s'il y a un quadratique
|
|
for (int iseg=1;iseg<=nbse;iseg++)
|
|
{ ElemGeomC0 const & elseg = elgeom.ElemSeg(iseg);
|
|
if (elseg.TypeInterpolation() == QUADRACOMPL)
|
|
{ // récup de la connection des noeuds des arêtes par rapport a ceux de l'element
|
|
Tableau<Tableau<int> > const & nonStout = elgeom.NonS();
|
|
Tableau <int> const & nonS = nonStout(iseg);
|
|
Tableau<Noeud *>& t_noeud = tab_element(ne)->Tab_noeud();
|
|
Noeud & N1=*t_noeud(nonS(1));Noeud & N2=*t_noeud(nonS(2));Noeud & N3=*t_noeud(nonS(3));
|
|
// ------------- étape de modification du noeud milieu -----------------------
|
|
Coordonnee M01= N1.Coord0();Coordonnee M02= N2.Coord0();Coordonnee M03= N3.Coord0();
|
|
Coordonnee M1M3=(M03-M01);Coordonnee M1M2=(M02-M01);Coordonnee M2M3=(M03-M02);
|
|
double d12=M1M2.Norme();double d13=M1M3.Norme();double d23=M2M3.Norme();
|
|
if ((d12 < ConstMath::unpeupetit) || (d13 < ConstMath::unpeupetit) || (d23 < ConstMath::unpeupetit))
|
|
{ cout << "\n erreur deux des trois points du segment quadratique sont confondu a l'instant 0"
|
|
<< "\n il n'est pas possible d'effectuer la relocalisation du noeud milieu pour ce segment"
|
|
<< "\n Maillage::RelocPtMilieuMailleQuadra()";
|
|
N1.Affiche(); N2.Affiche(); N3.Affiche();
|
|
break;
|
|
}
|
|
Coordonnee U=M1M3/d13;
|
|
// le vecteur normal à U
|
|
int dim = ParaGlob::Dimension(); Coordonnee V(dim);
|
|
double sinusangle;
|
|
switch (dim)
|
|
{ case 1: // ici il suffit de prendre le point milieu
|
|
{ sinusangle=0.; break;}
|
|
case 2 : {V(1) = -U(2); V(2)=U(1);sinusangle = Util::Determinant(U,M1M2);break;}
|
|
case 3 : {Coordonnee W = Util::ProdVec_coor(U,M1M2); sinusangle = Util::Determinant(U,M1M2);
|
|
if (sinusangle > ConstMath::unpeupetit)
|
|
{ W.Normer(); V = Util::ProdVec_coor(W,U);}
|
|
break;
|
|
}
|
|
};
|
|
// on vérifie que les 3 points ne sont pas naturellement alignés
|
|
if (sinusangle > ConstMath::unpeupetit)
|
|
// cas où l'on peut considérer une base locale
|
|
{
|
|
double N1H = M1M2*U; double HN2 = M1M2*V;
|
|
double p1 = d13/2.; double p2 = d13*d13*HN2/(4.*N1H*(d13-N1H));
|
|
Coordonnee P = M01 + p1 * U + p2 * V;;
|
|
N2.Change_coord0(P); break;
|
|
}
|
|
else
|
|
// cas où les 3 points sont originalement alignés
|
|
{ Coordonnee milieu = (M01+M03)/2.;
|
|
N2.Change_coord0(milieu); break;
|
|
}
|
|
// +++++++ si les coordonnées à t existent, même traitement
|
|
if (N1.ExisteCoord1())
|
|
{ M01= N1.Coord1();M02= N2.Coord1();M03= N3.Coord1();
|
|
M1M3=(M03-M01); M1M2=(M02-M01); M2M3=(M03-M02);
|
|
d12=M1M2.Norme(); d13=M1M3.Norme(); d23=M2M3.Norme();
|
|
if ((d12 < ConstMath::unpeupetit) || (d13 < ConstMath::unpeupetit) || (d23 < ConstMath::unpeupetit))
|
|
{ cout << "\n erreur deux des trois points du segment quadratique sont confondu a l'instant t"
|
|
<< "\n il n'est pas possible d'effectuer la relocalisation du noeud milieu pour ce segment"
|
|
<< "\n Maillage::RelocPtMilieuMailleQuadra()";
|
|
N1.Affiche(); N2.Affiche(); N3.Affiche();
|
|
break;
|
|
}
|
|
U=M1M3/d13;
|
|
// le vecteur normal à U
|
|
switch (dim)
|
|
{ case 1: // ici il suffit de prendre le point milieu
|
|
{ sinusangle=0.; break;}
|
|
case 2 : {V(1) = -U(2); V(2)=U(1);sinusangle = Util::Determinant(U,M1M2);break;}
|
|
case 3 : {Coordonnee W = Util::ProdVec_coor(U,M1M2); sinusangle = Util::Determinant(U,M1M2);
|
|
if (sinusangle > ConstMath::unpeupetit)
|
|
{ W.Normer(); V = Util::ProdVec_coor(W,U);}
|
|
break;
|
|
}
|
|
};
|
|
// on vérifie que les 3 points ne sont pas naturellement alignés
|
|
if (sinusangle > ConstMath::unpeupetit)
|
|
// cas où l'on peut considérer une base locale
|
|
{
|
|
double N1H = M1M2*U; double HN2 = M1M2*V;
|
|
double p1 = d13/2.; double p2 = d13*d13*HN2/(4.*N1H*(d13-N1H));
|
|
Coordonnee P = M01 + p1 * U + p2 * V;;
|
|
N2.Change_coord1(P); break;
|
|
}
|
|
else
|
|
// cas où les 3 points sont originalement alignés
|
|
{ Coordonnee milieu = (M01+M03)/2.;
|
|
N2.Change_coord1(milieu); break;
|
|
}
|
|
}
|
|
// +++++ si les coordonnées à t existent, même traitement
|
|
if (N1.ExisteCoord2())
|
|
{ M01= N1.Coord2();M02= N2.Coord2();M03= N3.Coord2();
|
|
M1M3=(M03-M01); M1M2=(M02-M01); M2M3=(M03-M02);
|
|
d12=M1M2.Norme(); d13=M1M3.Norme(); d23=M2M3.Norme();
|
|
if ((d12 < ConstMath::unpeupetit) || (d13 < ConstMath::unpeupetit) || (d23 < ConstMath::unpeupetit))
|
|
{ cout << "\n erreur deux des trois points du segment quadratique sont confondu a l'instant tdt"
|
|
<< "\n il n'est pas possible d'effectuer la relocalisation du noeud milieu pour ce segment"
|
|
<< "\n Maillage::RelocPtMilieuMailleQuadra()";
|
|
N1.Affiche(); N2.Affiche(); N3.Affiche();
|
|
break;
|
|
}
|
|
U=M1M3/d13;
|
|
// le vecteur normal à U
|
|
switch (dim)
|
|
{ case 1: // ici il suffit de prendre le point milieu
|
|
{ sinusangle=0.; break;}
|
|
case 2 : {V(1) = -U(2); V(2)=U(1);sinusangle = Util::Determinant(U,M1M2);break;}
|
|
case 3 : {Coordonnee W = Util::ProdVec_coor(U,M1M2); sinusangle = Util::Determinant(U,M1M2);
|
|
if (sinusangle > ConstMath::unpeupetit)
|
|
{ W.Normer(); V = Util::ProdVec_coor(W,U);}
|
|
break;
|
|
}
|
|
};
|
|
// on vérifie que les 3 points ne sont pas naturellement alignés
|
|
if (sinusangle > ConstMath::unpeupetit)
|
|
// cas où l'on peut considérer une base locale
|
|
{
|
|
double N1H = M1M2*U; double HN2 = M1M2*V;
|
|
double p1 = d13/2.; double p2 = d13*d13*HN2/(4.*N1H*(d13-N1H));
|
|
Coordonnee P = M01 + p1 * U + p2 * V;;
|
|
N2.Change_coord2(P); break;
|
|
}
|
|
else
|
|
// cas où les 3 points sont originalement alignés
|
|
{ Coordonnee milieu = (M01+M03)/2.;
|
|
N2.Change_coord2(milieu); break;
|
|
}
|
|
}
|
|
// ------------- fin de l'étape de modification du noeud milieu - --------------
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// sortie du schemaXML: en fonction de enu
|
|
void Maillage::SchemaXML_Maillages(ofstream& sort,const Enum_IO_XML enu)
|
|
{ switch (enu)
|
|
{case XML_TYPE_GLOBAUX:
|
|
{// on définit des types pour un maillage
|
|
Noeud::SchemaXML_Noeud(sort,enu);
|
|
// def du type maillage
|
|
sort << "\n <xs:complexType name=\"Maillage\" >"
|
|
<< "\n <xs:annotation>"
|
|
<< "\n <xs:documentation> un nom de maillage, des noeuds, des references de noeuds,"
|
|
<< "\n des elements, des references d'elements "
|
|
<< "\n </xs:documentation>"
|
|
<< "\n </xs:annotation>"
|
|
<< "\n <xs:sequence>"
|
|
<< "\n <xs:element name=\"nom_du_maillage\" type=\"xs:string\" />"
|
|
<< "\n <xs:element name=\"Noeud\" type=\"Noeud\" "
|
|
<< "\n minOccurs=\"1\" maxOccurs=\"unbounded\" />";
|
|
|
|
|
|
|
|
/* << "\n <xs:complexType>"
|
|
<< "\n <xs:element name=\"****les_maillages:_nombre=\" type=\"xs:positiveInteger\" "
|
|
<< "\n use=\"required\" minOccurs=\"1\" maxOccurs=\"unbounded\" />"
|
|
<< "\n <xs:element name=\"defMaillages\" type=\"Maillage\" use=\"required\" />" */
|
|
|
|
sort << "\n </xs:sequence>"
|
|
<< "\n </xs:complexType>";
|
|
break;
|
|
}
|
|
case XML_IO_POINT_INFO:
|
|
{// cas de la définition d'un maillage
|
|
/* sort << "\n <xs:element name=\"Maillages\" minOccurs=\"1\" maxOccurs=\"unbounded\" >"
|
|
<< "\n <xs:complexType>"
|
|
<< "\n <xs:annotation>"
|
|
<< "\n <xs:documentation> un nom de maillage, des noeuds, des references de noeuds,"
|
|
<< "\n des elements, des references d'elements "
|
|
<< "\n </xs:documentation>"
|
|
<< "\n </xs:annotation>"
|
|
<< "\n <xs:sequence>"
|
|
<< "\n <xs:element name=\"nom_du_maillage\" type=\"xs:string\" />"
|
|
<< "\n <xs:element name=\"les_noeuds\" type=\"Noeud\" "
|
|
<< "\n minOccurs=\"1\" maxOccurs=\"unbounded\" />"*/
|
|
|
|
|
|
|
|
/* << "\n <xs:complexType>"
|
|
<< "\n <xs:element name=\"****les_maillages:_nombre=\" type=\"xs:positiveInteger\" "
|
|
<< "\n use=\"required\" minOccurs=\"1\" maxOccurs=\"unbounded\" />"
|
|
<< "\n <xs:element name=\"defMaillages\" type=\"Maillage\" use=\"required\" />" */
|
|
|
|
/* sort << "\n </xs:sequence>"
|
|
<< "\n </xs:complexType>"
|
|
<< "\n </xs:element>";*/
|
|
// def de Maillage
|
|
// SchemaXML_Maillage(sort,niveau);
|
|
break;
|
|
}
|
|
};
|
|
};
|
|
|
|
//---------------------- class de travail ---------------------------
|
|
|
|
// 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
|
|
|
|
Maillage::PosiEtNoeud& Maillage::PosiEtNoeud::operator= (const Maillage::PosiEtNoeud& po) // affectation
|
|
{ noe=po.noe; return *this;};
|
|
|
|
bool Maillage::PosiEtNoeud::operator == (const Maillage::PosiEtNoeud& po) const // test d'égalité
|
|
{ if ((noe->Coord0()-po.noe->Coord0()).Norme() <= ConstMath::unpeupetit) return true; else return false; };
|
|
|
|
bool Maillage::PosiEtNoeud::operator != (const Maillage::PosiEtNoeud& po) const // test d'inégalité
|
|
{ if (noe->Coord0() != po.noe->Coord0()) return true; else return false; };
|
|
|
|
bool Maillage::PosiEtNoeud::operator < (const Maillage::PosiEtNoeud& po) const // relation d'ordre
|
|
{ Coordonnee co1=noe->Coord0(); Coordonnee co2=po.noe->Coord0();
|
|
switch (co1.Dimension())
|
|
{ case 1: return (co1(1) < co2(1));break;
|
|
case 2: {if (co1(1) < co2(1)) return true;
|
|
else if (co1(1) == co2(1))
|
|
{ return (co1(2) < co2(2));}
|
|
else return false;
|
|
break;}
|
|
case 3: {if (co1(1) < co2(1)) return true;
|
|
else if (co1(1) == co2(1))
|
|
{ if (co1(2) < co2(2)) return true;
|
|
else if (co1(2) == co2(2))
|
|
{ return (co1(3) < co2(3));}
|
|
else false;
|
|
}
|
|
return false;
|
|
break;
|
|
}
|
|
default:
|
|
{ cout << "\n erreur le cas différent de 1 2 3 n'est pas admissible ici= " << co1.Dimension()
|
|
<< "\n bool Maillage::PosiEtNoeud::operator < (co... ";
|
|
Sortie(1);
|
|
}
|
|
};
|
|
Sortie(1); // ne doit jamais passer ici !!
|
|
return false;
|
|
};
|
|
|
|
bool Maillage::PosiEtNoeud::operator <= (const Maillage::PosiEtNoeud& po) const // relation d'ordre
|
|
{ Coordonnee co1=noe->Coord0(); Coordonnee co2=po.noe->Coord0();
|
|
switch (co1.Dimension())
|
|
{ case 1: return (co1(1) <= co2(1));break;
|
|
case 2: {if (co1(1) < co2(1)) return true;
|
|
else if (co1(1) == co2(1))
|
|
{ return (co1(2) <= co2(2));}
|
|
else return false;
|
|
break;}
|
|
case 3: {if (co1(1) < co2(1)) return true;
|
|
else if (co1(1) == co2(1))
|
|
{ if (co1(2) < co2(2)) return true;
|
|
else if (co1(2) == co2(2))
|
|
{ return (co1(3) <= co2(3));}
|
|
else false;
|
|
}
|
|
return false;
|
|
break;
|
|
}
|
|
default:
|
|
{ cout << "\n erreur le cas différent de 1 2 3 n'est pas admissible ici= " << co1.Dimension()
|
|
<< "\n bool Maillage::PosiEtNoeud::operator <= (co... ";
|
|
Sortie(1);
|
|
}
|
|
};
|
|
Sortie(1); // ne doit jamais passer ici !!
|
|
return false;
|
|
};
|
|
|
|
bool Maillage::PosiEtNoeud::operator > (const Maillage::PosiEtNoeud& po) const // relation d'ordre
|
|
{ return !(*this <= po);};
|
|
|
|
bool Maillage::PosiEtNoeud::operator >= (const Maillage::PosiEtNoeud& po) const // relation d'ordre
|
|
{ return !(*this < po);};
|
|
|
|
// transfert de grandeurs des points d'intégration aux noeuds
|
|
// 1- en entrée les type évolués et quelconques 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 3 é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 Maillage::AjoutConteneurAuNoeud(const List_io < Ddl_enum_etendu >& lienu
|
|
,const Tableau <List_io < TypeQuelconque > * >& tabQ)
|
|
{ // on crée des tableaux pour optimiser le nombre d'appel aux fonctions d'ajout de grandeur aux noeuds
|
|
// 1) cas des Ddl_enum_etendu
|
|
Tableau <Ddl_enum_etendu > tab_ddlEnuEtendu(lienu.size());
|
|
{List_io < Ddl_enum_etendu >::const_iterator ilienu,ilienufin = lienu.end();
|
|
int indice = 1;
|
|
for (ilienu = lienu.begin();ilienu != ilienufin; ilienu++,indice++)
|
|
tab_ddlEnuEtendu(indice) = (*ilienu);
|
|
};
|
|
// 2) cas des grandeurs quelconques
|
|
Tableau < TypeQuelconque > tabglobQ;
|
|
int ttai = 0;
|
|
if (tabQ(1) != NULL) ttai += tabQ(1)->size();
|
|
if (tabQ(2) != NULL) ttai += tabQ(2)->size();
|
|
tabglobQ.Change_taille(ttai);
|
|
int indice = 1;
|
|
if (tabQ(1) != NULL)
|
|
{List_io < TypeQuelconque >::const_iterator itabQ,itabQfin = tabQ(1)->end();
|
|
for (itabQ = tabQ(1)->begin();itabQ != itabQfin; itabQ++,indice++)
|
|
{tabglobQ(indice).ChangeGrandeur(*itabQ); // on commence par changer la grandeur
|
|
tabglobQ(indice) = (*itabQ); // et on affecte
|
|
};
|
|
};
|
|
if (tabQ(2) != NULL)
|
|
{List_io < TypeQuelconque >::const_iterator itabQ,itabQfin = tabQ(2)->end();
|
|
for (itabQ = tabQ(2)->begin();itabQ != itabQfin; itabQ++,indice++)
|
|
{tabglobQ(indice).ChangeGrandeur(*itabQ); // on commence par changer la grandeur
|
|
tabglobQ(indice) = (*itabQ); // et on affecte
|
|
};
|
|
};
|
|
|
|
int nbN=tab_noeud.Taille();
|
|
// on met à jour les noeuds
|
|
for(int i=1;i<=nbN;i++)
|
|
{ // Pour les grandeurs ddl étendu on les ajoutes aux noeuds si ce n'est pas déjà fait
|
|
tab_noeud(i)->AjoutTabDdl_etendu(tab_ddlEnuEtendu);
|
|
// on ajoute également les différents types quelconques aux noeuds
|
|
tab_noeud(i)->AjoutTabTypeQuelconque(tabglobQ);
|
|
// on met à jour le tableau d'indice de noeud, qui donne le nombre de fois où chaque noeud à été updaté
|
|
tab_noeud(i)->Mise_non_update_Ddl_etendu();
|
|
tab_noeud(i)->Mise_non_update_grandeurs_quelconques();
|
|
};
|
|
};
|
|
|
|
// B) initialisation des updates sur les noeuds
|
|
void Maillage::InitUpdateAuNoeud(const List_io < Ddl_enum_etendu >& lienetendu
|
|
,const Tableau <List_io < TypeQuelconque > * >& tabQ, int )
|
|
{int nbN=tab_noeud.Taille();
|
|
List_io <Ddl_enum_etendu>::const_iterator iliet,ilietfin = lienetendu.end();
|
|
List_io <TypeQuelconque>::const_iterator iliGQ,iliGQfin;
|
|
// on met à jour tous les noeuds
|
|
for(int inoeud=1;inoeud<=nbN;inoeud++)
|
|
{for (iliet = lienetendu.begin();iliet != ilietfin; iliet++)
|
|
{Ddl_etendu& dd = tab_noeud(inoeud)->ModifDdl_etendu(*iliet);
|
|
// on initialise la grandeur pointée:
|
|
dd.Valeur()=0.;
|
|
// mise à 0 du nombre d'appel
|
|
tab_noeud(inoeud)->Mise_non_update_Ddl_etendu(*iliet);
|
|
};
|
|
for (int iQu=1;iQu<=tabQ.Taille();iQu++)
|
|
{if (tabQ(iQu) != NULL)
|
|
{iliGQfin = tabQ(iQu)->end();
|
|
for (iliGQ = tabQ(iQu)->begin();iliGQ != iliGQfin; iliGQ++)
|
|
{TypeQuelconque& tq = tab_noeud(inoeud)->ModifGrandeur_quelconque((*iliGQ).EnuTypeQuelconque());
|
|
TypeQuelconque::Grandeur & grandeur = *(tq.Grandeur_pointee());
|
|
// on initialise la grandeur pointée:
|
|
grandeur *= 0.;
|
|
// mise à 0 du nombre d'appel
|
|
tab_noeud(inoeud)->Mise_non_update_grandeurs_quelconques((*iliGQ).EnuTypeQuelconque());
|
|
};
|
|
}
|
|
};
|
|
};
|
|
};
|
|
|
|
// D) dernière étape: (par exemple calcul des moyennes en chaque noeuds)
|
|
void Maillage::FinTransfertPtIntegAuNoeud
|
|
(const List_io < Ddl_enum_etendu >& lienetendu,const Tableau <List_io < TypeQuelconque > * >& tabQ,int cas)
|
|
{switch(cas)
|
|
{ case 1: // cas du transfert par moyennage
|
|
{ int nbN=tab_noeud.Taille();
|
|
List_io <Ddl_enum_etendu>::const_iterator iliet,ilietfin = lienetendu.end();
|
|
List_io <TypeQuelconque>::const_iterator iliGQ,iliGQfin;
|
|
// on passe en revue les grandeurs aux noeuds, et on les moyennes
|
|
for(int inoeud=1;inoeud<=nbN;inoeud++)
|
|
{ // .. pour les ddl étendus ..
|
|
for (iliet = lienetendu.begin();iliet != ilietfin; iliet++)
|
|
{Ddl_etendu& dd = tab_noeud(inoeud)->ModifDdl_etendu(*iliet);
|
|
// on modifie la grandeur pointée: -1 car ici on vient d'appeler
|
|
// ModifDdl_etendu qui comptabilise un appel de +
|
|
// dd.Valeur()/=(tab_noeud(inoeud)->DdlEtendue_update(*iliet)-1);
|
|
int nbappel = MaX((tab_noeud(inoeud)->DdlEtendue_update(*iliet)-1),1);
|
|
dd.Valeur()/=nbappel;
|
|
};
|
|
// .. pour les grandeurs quelconques ..
|
|
for (int iQu=1;iQu<=tabQ.Taille();iQu++)
|
|
{if (tabQ(iQu) != NULL)
|
|
{iliGQfin = tabQ(iQu)->end();
|
|
for (iliGQ = tabQ(iQu)->begin();iliGQ != iliGQfin; iliGQ++)
|
|
{TypeQuelconque_enum_etendu enuQ = (*iliGQ).EnuTypeQuelconque();
|
|
TypeQuelconque& tq = tab_noeud(inoeud)->ModifGrandeur_quelconque(enuQ);
|
|
TypeQuelconque::Grandeur & grandeur = *(tq.Grandeur_pointee());
|
|
// on modifie les grandeurs pointées: -1 car ici on vient d'appeler
|
|
// ModifGrandeur_quelconque qui comptabilise un appel de +
|
|
grandeur /= MaX((tab_noeud(inoeud)->Grandeur_quelconque_update(enuQ)-1),1);
|
|
//--- debug
|
|
//if (iliGQ == tabQ(iQu)->begin())
|
|
// cout << " noeud " << inoeud << " grandeur " << grandeur << endl;
|
|
//--- fin debug
|
|
};
|
|
}
|
|
};
|
|
};
|
|
break;
|
|
}
|
|
default :
|
|
cout << "\n *** cas non implante, cas = " << cas
|
|
<< "\n FinTransfertPtIntegAuNoeud(... ";
|
|
Sortie(1);
|
|
};
|
|
|
|
};
|
|
|
|
// fonctions utilitaires du même genre
|
|
|
|
// ajout sur le maillage d'un conteneur particulier quelconque
|
|
void Maillage::AjoutConteneurAuNoeud(TypeQuelconque& tQ)
|
|
{ int nbN=tab_noeud.Taille();
|
|
// on met à jour les noeuds
|
|
for(int i=1;i<=nbN;i++)
|
|
{ // on ajoute le type quelconque au noeud
|
|
tab_noeud(i)->AjoutUnTypeQuelconque(tQ);
|
|
// on met à jour le tableau d'indice de noeud, qui donne le nombre de fois où chaque noeud à été updaté
|
|
tab_noeud(i)->Mise_non_update_grandeurs_quelconques();
|
|
};
|
|
};
|
|
|
|
// ajout sur le maillage d'un ou plusieur ddl_enum_etendu comme conteneur
|
|
void Maillage::AjoutConteneurAuNoeud(const List_io < Ddl_enum_etendu >& lienu)
|
|
{ // on crée des tableaux pour optimiser le nombre d'appel aux fonctions d'ajout de grandeur aux noeuds
|
|
// 1) cas des Ddl_enum_etendu
|
|
Tableau <Ddl_enum_etendu > tab_ddlEnuEtendu(lienu.size());
|
|
{List_io < Ddl_enum_etendu >::const_iterator ilienu,ilienufin = lienu.end();
|
|
int indice = 1;
|
|
for (ilienu = lienu.begin();ilienu != ilienufin; ilienu++,indice++)
|
|
tab_ddlEnuEtendu(indice) = (*ilienu);
|
|
};
|
|
|
|
int nbN=tab_noeud.Taille();
|
|
int nb_ienu = lienu.size();
|
|
// on met à jour les noeuds
|
|
for(int i=1;i<=nbN;i++)
|
|
{ // Pour les grandeurs ddl étendu on les ajoutes aux noeuds si ce n'est pas déjà fait
|
|
tab_noeud(i)->AjoutTabDdl_etendu(tab_ddlEnuEtendu);
|
|
// on met à jour le tableau d'indice de noeud, qui donne le nombre de fois où chaque noeud à été updaté
|
|
for (int idee=1; idee <= nb_ienu; idee++)
|
|
tab_noeud(i)->Mise_non_update_Ddl_etendu(tab_ddlEnuEtendu(idee));
|
|
};
|
|
};
|
|
|
|
// 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 Maillage::InitUpdateAuNoeud(const List_io < Ddl_enum_etendu >& lienetendu)
|
|
{int nbN=tab_noeud.Taille();
|
|
List_io <Ddl_enum_etendu>::const_iterator iliet,ilietfin = lienetendu.end();
|
|
// on met à jour tous les noeuds
|
|
for(int inoeud=1;inoeud<=nbN;inoeud++)
|
|
{for (iliet = lienetendu.begin();iliet != ilietfin; iliet++)
|
|
{Ddl_etendu& dd = tab_noeud(inoeud)->ModifDdl_etendu(*iliet);
|
|
// on initialise la grandeur pointée:
|
|
dd.Valeur()=0.;
|
|
};
|
|
// on met à 0 le tableau d'indice de noeud, qui donne le nombre de fois où chaque noeud à été updaté
|
|
tab_noeud(inoeud)->Mise_non_update_Ddl_etendu();
|
|
};
|
|
};
|
|
|
|
// initialisation des updates d'un seul ddl_étendu uniquement sur les noeuds: on met à 0 le ddl_etendu correspondant,
|
|
// le compteur, comptant le nombre de fois où le noeud est modifié, est mis à 0
|
|
void Maillage::InitUpdateAuNoeud(const Ddl_enum_etendu & enetendu)
|
|
{int nbN=tab_noeud.Taille();
|
|
// on met à jour tous les noeuds
|
|
for(int inoeud=1;inoeud<=nbN;inoeud++)
|
|
{ // on initialise la grandeur pointée:
|
|
(tab_noeud(inoeud)->ModifDdl_etendu(enetendu)).Valeur()=0.;
|
|
// on met à 0 le tableau d'indice de noeud, qui donne le nombre de fois où chaque noeud à été updaté
|
|
tab_noeud(inoeud)->Mise_non_update_Ddl_etendu();
|
|
};
|
|
};
|
|
|
|
// moyenne des valeurs aux noeuds (en fonction du nombre ou le noeud a été modifié)
|
|
void Maillage::MoyenneCompteurAuNoeud(const Ddl_enum_etendu & enu)
|
|
{ int nbN=tab_noeud.Taille();
|
|
// on passe en revue les grandeurs aux noeuds, et on les moyennes
|
|
for(int inoeud=1;inoeud<=nbN;inoeud++)
|
|
{ Ddl_etendu& dd = tab_noeud(inoeud)->ModifDdl_etendu(enu);
|
|
// on modifie la grandeur pointée: -1 car ici on vient d'appeler
|
|
// ModifDdl_etendu qui comptabilise un appel de +
|
|
int nbappel = (tab_noeud(inoeud)->DdlEtendue_update(enu)-1);
|
|
dd.Valeur()/=nbappel;
|
|
};
|
|
};
|
|
|
|
// 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 Maillage::Init_Xi_t_et_tdt_de_0()
|
|
{ int nbN=tab_noeud.Taille();
|
|
// on passe en revue les grandeurs aux noeuds, et on les moyennes
|
|
for(int inoeud=1;inoeud<=nbN;inoeud++)
|
|
{ Noeud & noe = *tab_noeud(inoeud);
|
|
const Coordonnee& co1 = noe.Coord0();
|
|
noe.Change_coord1(co1);
|
|
noe.Change_coord2(co1);
|
|
};
|
|
};
|
|
|
|
// lecture des mouvements solides si nécessaire
|
|
void Maillage::Lecture_des_mouvements_solides(UtilLecture * entreePrinc)
|
|
{ // on définit un mouvement solide (vide par défaut)
|
|
MvtSolide mvtsolide;
|
|
if (strstr(entreePrinc->tablcar,"def_mouvement_solide_initiaux_")!=NULL) // cas de mouvements initiaux initiaux
|
|
{ if (ParaGlob::NiveauImpression() >= 6) cout << " lecture des mouvements solides initiaux " << endl ;
|
|
entreePrinc->NouvelleDonnee(); // on passe le mot clé
|
|
};
|
|
// lecture éventuelle des mouvements solides
|
|
mvtsolide.Lecture_mouvements_solides(entreePrinc);
|
|
// traitement au cas où il y a eu lecture de mouvements non nul
|
|
if (mvtsolide.ExisteMvtSolide())
|
|
{ if (ParaGlob::NiveauImpression() >= 6)
|
|
cout << " traitement des mouvements solides initiaux sur le maillage " << endl ;
|
|
// on passe le mot clé de fin de mouvement solides pour les lectures suivantes
|
|
entreePrinc->NouvelleDonnee();
|
|
|
|
// --- dans le cas où il y a des centres de rotation qui sont des positions de noeud, on renseigne
|
|
// a) récupération des centres de rotation noeud, éventuellement
|
|
const list <String_et_entier>& lis_centre_noeud = mvtsolide.Liste_ident_centreNoeud();
|
|
if (lis_centre_noeud.size() != 0)
|
|
{ list <String_et_entier>::const_iterator ict,ictfin=lis_centre_noeud.end();
|
|
list <Coordonnee> list_coor; // liste des coordonnées des noeuds centre de rotation
|
|
for (ict = lis_centre_noeud.begin();ict!=ictfin;ict++)
|
|
{ // a priori ne concerne que le maillage en question
|
|
if (((*ict).nom == "")|| ((*ict).nom == nomDuMaillage))
|
|
// cas normal
|
|
{ int num_noeud = (*ict).n;
|
|
if ((num_noeud < 0) || (num_noeud > tab_noeud.Taille()))
|
|
{ cout << "\n *** erreur sur le numero de noeud de centre de rotation = "<< num_noeud
|
|
<< " on ne peut pas appliquer la rotation " << endl;
|
|
if (ParaGlob::NiveauImpression() >= 6) cout << " lecture des mouvements solides initiaux " << endl ;
|
|
};
|
|
list_coor.push_back(tab_noeud(num_noeud)->Coord0()); // on récupère les coordonnées initiales
|
|
}
|
|
else // cas où il s'agit d'un autre maillage, pour l'instant non pris en compte
|
|
{ cout << "\n *** erreur sur le numero de noeud concerne un autre maillage = "<< (*ict).nom
|
|
<< " cette option n'est pas prise en compte " << endl;
|
|
if (ParaGlob::NiveauImpression() >= 6) cout << " lecture des mouvements solides initiaux " << endl ;
|
|
};
|
|
};
|
|
// b) maintenant on passe l'info au mouvement solide
|
|
mvtsolide.RenseigneCentreNoeud(list_coor);
|
|
};
|
|
int nbnoeud = tab_noeud.Taille();
|
|
Coordonnee point_inter;
|
|
for (int ne=1;ne<=nbnoeud;ne++)
|
|
{ point_inter = tab_noeud(ne)->Coord0(); // récupération des coordonnées initiales
|
|
mvtsolide.AppliqueMvtSolide(point_inter); // on applique le mouvement solide
|
|
tab_noeud(ne)->Change_coord0(point_inter); // on met à jour les nouvelles coordonnées
|
|
};
|
|
};
|
|
};
|
|
|
|
// 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 Maillage::Ajout_de_Noeuds(const list <Noeud *> & lisN, list <const Reference*>* lref,LesReferences* lesRef )
|
|
{ // on change de taille du tableau de noeud et on ajoute les noeuds passés en paramètre
|
|
int nbN = tab_noeud.Taille();
|
|
int nb_lisN = lisN.size();
|
|
tab_noeud.Change_taille(nbN+nb_lisN);
|
|
list<Noeud*>::const_iterator il,ilfin=lisN.end();
|
|
// on définit un tableau indiquant les nouveaux numéros indicés par les anciens
|
|
// t_new_num(i) : = le numéro du nouveau noeud correspondant au noeud initial i
|
|
int taille_maxi = 0;
|
|
for(il=lisN.begin();il!=ilfin;il++) // un premier passage pour avoir la dimension maxi du tableau
|
|
if ((*il)->Num_noeud() > taille_maxi)
|
|
taille_maxi = (*il)->Num_noeud();
|
|
Tableau<int> t_new_num(taille_maxi,0); // les données du tableau sont initialisées à 0
|
|
|
|
int i=1;
|
|
for(il=lisN.begin();il!=ilfin;il++,i++)
|
|
{ int ancien_num = (*il)->Num_noeud();
|
|
if (((*il)->Num_Mail() != 0) && ((*il)->Num_Mail() != idmail))
|
|
{ // on crée un nouveau noeud identique
|
|
Noeud* new_noe = new Noeud(*(*il));
|
|
// on change les numéros de noeud et de maillage
|
|
new_noe->Change_num_noeud(i+nbN);
|
|
new_noe->Change_num_Mail(idmail);
|
|
// affectation
|
|
tab_noeud(i+nbN) = new_noe;
|
|
}
|
|
else // sinon cela signifie que le noeud n'appartient pas pour l'instant à un maillage
|
|
{ // on change les numéros de noeud et de maillage
|
|
(*il)->Change_num_noeud(i+nbN);
|
|
(*il)->Change_num_Mail(idmail);
|
|
// affectation
|
|
tab_noeud(i+nbN) = (*il);
|
|
};
|
|
// on enregistre le nouveau num que si l'ancien est non nul
|
|
if (ancien_num != 0)
|
|
t_new_num(ancien_num) = i+nbN;
|
|
};
|
|
// cas de la présence d'une liste de référence éventuellement à ajouter
|
|
if (lref != NULL)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if (lesRef == NULL)
|
|
{ cout << "\n erreur le conteneur de reference n'est pas defini "
|
|
<< "\n Maillage::Ajout_de_Noeuds(... ";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// on va passer en revue la liste des références à ajouter
|
|
list<const Reference*>::const_iterator im,imfin = lref->end();
|
|
for (im=lref->begin();im!=imfin;im++)
|
|
{ if ((*im)->Indic() == 1)
|
|
{const ReferenceNE & refN = *((ReferenceNE *) (*im));
|
|
// on va contruire une nouvelle référence ad hoc:
|
|
string nouveau_nom = (refN.Nom());
|
|
// on regarde s'il y a déjà une ref avec le même nom dans le maillage
|
|
// si oui on change le nom de la ref à ajouter
|
|
string ajout="";int num=0;
|
|
while (lesRef->Existe((refN.Nom()+ajout),idmail))
|
|
{num++;ajout = "_"+ChangeEntierSTring(num);};
|
|
if (ajout != "")
|
|
{ nouveau_nom += ajout;
|
|
if (ParaGlob::NiveauImpression() > 0)
|
|
cout << "\n >>> attention la reference "<<refN.Nom()<<" a ajouter au maillage "
|
|
<< nomDuMaillage << " a un nouveau nom "<< (refN.Nom()+ajout);
|
|
};
|
|
Tableau<int> tt = refN.Tab_num(); // on récupère une copie du tableau de ref
|
|
// on le met à jour / aux nouveaux numéros
|
|
int tai = tt.Taille();int kn=0; // kn c'est le pointeur dans la nouvelle ref
|
|
for (int k=1;k<= tai; k++)
|
|
{if (t_new_num(k) != 0)
|
|
{ kn++;
|
|
tt(kn) = t_new_num(k); // cas où effectivement on a rajouté un noeud qui était déjà référencé
|
|
// dans l'ancienne référence
|
|
}
|
|
else
|
|
{if (ParaGlob::NiveauImpression() > 0)
|
|
cout << "\n le noeud "<<k<<" de la ref "<<refN.Nom()
|
|
<<" n'existe plus dans le nouveau maillage "<<nomDuMaillage;
|
|
};
|
|
};
|
|
// on redimentionne le tableau au maxi d'élément
|
|
tt.Change_taille(kn);
|
|
// on crée la nouvelle référence si le tableau n'est pas nul
|
|
if (tt.Taille() != 0)
|
|
{ ReferenceNE* newref = new ReferenceNE(tt,idmail,1,nouveau_nom);
|
|
// ajout de la référence
|
|
lesRef->Ajout_reference(newref);
|
|
};
|
|
};
|
|
|
|
};
|
|
};
|
|
};
|
|
|
|
// 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 lisE, doivent faire partie : soit de lisN, soit du maillage this
|
|
void Maillage::Ajout_elements_et_noeuds
|
|
(const list <Noeud *> & lisN, const list <Element *> & lisE,list <const Reference*>* lref,LesReferences* lesRef )
|
|
{ // -- on commence par ajouter les noeuds en gardant une trace du type d'ajout
|
|
|
|
// on change de taille du tableau de noeud et on ajoute les noeuds passés en paramètre
|
|
int nbN = tab_noeud.Taille();
|
|
int nb_lisN = lisN.size();
|
|
tab_noeud.Change_taille(nbN+nb_lisN);
|
|
list<Noeud*>::const_iterator il,ilfin=lisN.end();
|
|
// on définit un tableau indiquant les nouveaux numéros indicés par les anciens
|
|
// t_new_num(i) : = le numéro du nouveau noeud correspondant au noeud initial i
|
|
int taille_maxi = 0;
|
|
for(il=lisN.begin();il!=ilfin;il++) // un premier passage pour avoir la dimension maxi du tableau
|
|
if ((*il)->Num_noeud() > taille_maxi)
|
|
taille_maxi = (*il)->Num_noeud();
|
|
Tableau<int> t_new_num(taille_maxi,0); // les données du tableau sont initialisées à 0
|
|
|
|
list<Noeud*> li_nevez_noeud; // la liste des nouvelles positions de noeuds
|
|
int i=1;
|
|
for(il=lisN.begin();il!=ilfin;il++,i++)
|
|
{ int ancien_num = (*il)->Num_noeud();
|
|
if (((*il)->Num_Mail() != 0) && ((*il)->Num_Mail() != idmail))
|
|
{ // on crée un nouveau noeud identique
|
|
Noeud* new_noe = new Noeud(*(*il));
|
|
// on change les numéros de noeud et de maillage
|
|
new_noe->Change_num_noeud(i+nbN);
|
|
new_noe->Change_num_Mail(idmail);
|
|
// affectation
|
|
tab_noeud(i+nbN) = new_noe;
|
|
li_nevez_noeud.push_back(new_noe);
|
|
}
|
|
else // sinon cela signifie que le noeud n'appartient pas pour l'instant à un maillage
|
|
{ // on change les numéros de noeud et de maillage
|
|
(*il)->Change_num_noeud(i+nbN);
|
|
(*il)->Change_num_Mail(idmail);
|
|
// affectation
|
|
tab_noeud(i+nbN) = (*il);
|
|
li_nevez_noeud.push_back((*il));
|
|
};
|
|
// on enregistre le nouveau num que si l'ancien est non nul
|
|
// sinon
|
|
if (ancien_num != 0)
|
|
t_new_num(ancien_num) = i+nbN;
|
|
};
|
|
|
|
// -- puis on s'occupe des éléments
|
|
|
|
|
|
// on change de taille du tableau d'éléments et on ajoute les éléments passés en paramètre
|
|
int nbE = tab_element.Taille();
|
|
int nb_lisE = lisE.size();
|
|
tab_element.Change_taille(nbE+nb_lisE);
|
|
list<Element*>::const_iterator ie,iefin=lisE.end();
|
|
// on définit un tableau indiquant les nouveaux numéros indicés par les anciens
|
|
// t_new_num_elem(i) : = le numéro du nouvel élément correspondant à l'élément initial i
|
|
taille_maxi = 0;
|
|
for(ie=lisE.begin();ie!=iefin;ie++) // un premier passage pour avoir la dimension maxi du tableau
|
|
if ((*ie)->Num_elt_const() > taille_maxi)
|
|
taille_maxi = (*ie)->Num_elt_const();
|
|
Tableau<int> t_new_num_elem(taille_maxi,0); // les données du tableau sont initialisées à 0
|
|
|
|
i=1;
|
|
for(ie=lisE.begin();ie!=iefin;ie++,i++)
|
|
{ int num_elt = i+nbE; // numéro interne de l'élément
|
|
int ancien_num = (*ie)->Num_elt_const();
|
|
Element* new_elem = NULL; // sera affecté dans le if qui suit
|
|
if (((*ie)->Num_maillage() != 0) && ((*ie)->Num_maillage() != idmail))
|
|
{ Element::Signature signa = (*ie)->Signature_element(); // récupération de la signature de l'élément
|
|
// on crée un nouveau element identique
|
|
new_elem = Element::Choix_element(idmail,num_elt,signa);
|
|
if (new_elem == NULL)
|
|
{ // l'operation a echouee
|
|
cout << "\n Erreur dans la creation d'un nouvel element ****** ";
|
|
cout << "\n element : " << Nom_interpol(signa.id_interpol)
|
|
<< " " << Nom_geom(signa.id_geom)
|
|
<< "\n Maillage::Ajout_elements_et_noeuds(... " << endl;
|
|
Sortie (1);
|
|
};
|
|
// on affecte les données internes
|
|
(*new_elem) = (*(*ie));
|
|
// il faut de nouveau définir les numéros de maillage et d'élément
|
|
new_elem->Change_num_elt(num_elt);
|
|
new_elem->Change_num_maillage(idmail);
|
|
}
|
|
else // sinon cela signifie que l'éléments n'appartient pas pour l'instant à un maillage
|
|
{ // on change les numéros d'élément et de maillage, et peut directement l'affecté
|
|
(*ie)->Change_num_elt(num_elt);
|
|
(*ie)->Change_num_maillage(idmail);
|
|
new_elem = (*ie);
|
|
};
|
|
|
|
// maintenant on va s'occuper de la connexion
|
|
Tableau<Noeud *>& t_n_elem = new_elem->Tab_noeud();
|
|
int nbnoe = t_n_elem.Taille();
|
|
for (int inoe = 1; inoe <= nbnoe; inoe++)
|
|
{// on regarde si le noeud fait partie de la liste des noeuds en entrée
|
|
// ou alors, qu'il utilise les noeuds existants
|
|
bool fait_partie = false;
|
|
list<Noeud*>::iterator it=li_nevez_noeud.begin();
|
|
for(il=lisN.begin();il!=ilfin;il++,it++)
|
|
if ((*il) == t_n_elem(inoe))
|
|
{ fait_partie = true; break;};
|
|
// deux cas
|
|
if (fait_partie)
|
|
// on réaffecte
|
|
{t_n_elem(inoe)=(*it);}
|
|
else // sinon cela signifie que l'on utilise les noeuds existants
|
|
// on vérifie qu'il s'agit bien de noeud existant
|
|
{ bool verif = false;
|
|
for (int j=1;j<= nbN;j++) // on boucle jusqu'à nbN = le nombre initial de noeud
|
|
if (tab_noeud(j) == t_n_elem(inoe))
|
|
{verif = true; break;};
|
|
if (!verif)
|
|
{ cout << "\n erreur, la connexion de l'element a ajouter n'est pas recevable "
|
|
<< " le noeud "<<t_n_elem(inoe)->Num_noeud()<< " de l'element "
|
|
<< new_elem->Num_elt() << " n'existe pas dans le maillage initial "
|
|
<< "\n Maillage::Ajout_elements_et_noeuds(... " << endl;
|
|
Sortie (1);
|
|
};
|
|
}
|
|
};
|
|
// arrivée ici c'est que tout est ok, on ajoute l'élément
|
|
tab_element(nbE+i)=new_elem;
|
|
// on enregistre le nouveau num que si l'ancien est non nul
|
|
if (ancien_num != 0)
|
|
t_new_num_elem(ancien_num) = nbE+i;
|
|
};
|
|
|
|
|
|
// cas de la présence d'une liste de référence éventuellement à ajouter
|
|
if (lref != NULL)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if (lesRef == NULL)
|
|
{ cout << "\n erreur le conteneur de reference n'est pas defini "
|
|
<< "\n Maillage::Ajout_de_Noeuds(... ";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// on va passer en revue la liste des références à ajouter
|
|
list<const Reference*>::const_iterator im,imfin = lref->end();
|
|
for (im=lref->begin();im!=imfin;im++)
|
|
{int indic = (*im)->Indic(); // pour simplifier
|
|
switch (indic)
|
|
{case 1: // cas d'une ref de noeuds
|
|
{const ReferenceNE & refN = *((ReferenceNE *) (*im));
|
|
// on va contruire une nouvelle référence ad hoc:
|
|
string nouveau_nom = (refN.Nom());
|
|
// on regarde s'il y a déjà une ref avec le même nom dans le maillage
|
|
// si oui on change le nom de la ref à ajouter
|
|
string ajout="";int num=0;
|
|
while (lesRef->Existe((refN.Nom()+ajout),idmail))
|
|
{num++;ajout = "_"+ChangeEntierSTring(num);};
|
|
if (ajout != "")
|
|
{ nouveau_nom += ajout;
|
|
if (ParaGlob::NiveauImpression() > 0)
|
|
cout << "\n >>> attention la reference "<<refN.Nom()<<" a ajouter au maillage "
|
|
<< nomDuMaillage << " a un nouveau nom "<< (refN.Nom()+ajout);
|
|
};
|
|
Tableau<int> tt = refN.Tab_num(); // on récupère une copie du tableau de ref
|
|
Tableau<int> tt_new = tt; // le nouveau tableau
|
|
// on le met à jour / aux nouveaux numéros
|
|
int tai = tt.Taille();int kn=0; // kn c'est le pointeur dans la nouvelle ref
|
|
for (int k=1;k<= tai; k++)
|
|
{if (t_new_num(tt(k)) != 0)
|
|
{ kn++;
|
|
tt_new(kn) = t_new_num(tt(k)); // cas où effectivement on a rajouté un noeud qui était déjà référencé
|
|
// dans l'ancienne référence
|
|
}
|
|
else
|
|
{if (ParaGlob::NiveauImpression() > 0)
|
|
cout << "\n le noeud "<<tt(k)<<" de la ref "<<refN.Nom()
|
|
<<" n'existe plus dans le nouveau maillage "<<nomDuMaillage;
|
|
};
|
|
};
|
|
// on redimentionne le tableau au maxi d'élément
|
|
tt_new.Change_taille(kn);
|
|
// on crée la nouvelle référence si le tableau n'est pas nul
|
|
if (tt_new.Taille() != 0)
|
|
{ReferenceNE* newref = new ReferenceNE(tt_new,idmail,indic,nouveau_nom);
|
|
// ajout de la référence
|
|
lesRef->Ajout_reference(newref);
|
|
};
|
|
break;
|
|
}
|
|
case 2: // cas d'une ref d'éléments
|
|
{const ReferenceNE & refE = *((ReferenceNE *) (*im));
|
|
// on va contruire une nouvelle référence ad hoc:
|
|
string nouveau_nom = (refE.Nom());
|
|
// on regarde s'il y a déjà une ref avec le même nom dans le maillage
|
|
// si oui on change le nom de la ref à ajouter
|
|
string ajout="";int num=0;
|
|
while (lesRef->Existe((refE.Nom()+ajout),idmail))
|
|
{num++;ajout = "_"+ChangeEntierSTring(num);};
|
|
if (ajout != "")
|
|
{ nouveau_nom += ajout;
|
|
if (ParaGlob::NiveauImpression() > 0)
|
|
cout << "\n >>> attention la reference "<<refE.Nom()<<" a ajouter au maillage "
|
|
<< nomDuMaillage << " a un nouveau nom "<< (refE.Nom()+ajout);
|
|
};
|
|
Tableau<int> tt = refE.Tab_num(); // on récupère une copie du tableau de ref
|
|
// on le met à jour / aux nouveaux numéros
|
|
int tai = tt.Taille();int kn=0; // kn c'est le pointeur dans la nouvelle ref
|
|
Tableau<int> tt_new = tt; // le nouveau tableau
|
|
for (int k=1;k<= tai; k++)
|
|
{if (t_new_num_elem(tt(k)) != 0)
|
|
{ kn++;
|
|
tt_new(kn) = t_new_num_elem(tt(k)); // cas où effectivement on a rajouté un élément qui était déjà référencé
|
|
// dans l'ancienne référence
|
|
}
|
|
else
|
|
{if (ParaGlob::NiveauImpression() > 0)
|
|
cout << "\n l'element "<<tt(k)<<" de la ref "<<refE.Nom()
|
|
<<" n'existe plus dans le nouveau maillage "<<nomDuMaillage;
|
|
};
|
|
};
|
|
// on redimentionne le tableau au maxi d'élément
|
|
tt_new.Change_taille(kn);
|
|
// on crée la nouvelle référence si le tableau n'est pas nul
|
|
if (tt_new.Taille() != 0)
|
|
{ReferenceNE* newref = new ReferenceNE(tt_new,idmail,indic,nouveau_nom);
|
|
// ajout de la référence
|
|
lesRef->Ajout_reference(newref);
|
|
};
|
|
break;
|
|
}
|
|
case 3: case 4: case 5: case 6:// cas des autres refs: exemple surfaces
|
|
{const ReferenceAF & refAF = *((ReferenceAF *) (*im));
|
|
// on va contruire une nouvelle référence ad hoc:
|
|
string nouveau_nom = (refAF.Nom());
|
|
// on regarde s'il y a déjà une ref avec le même nom dans le maillage
|
|
// si oui on change le nom de la ref à ajouter
|
|
string ajout="";int num=0;
|
|
while (lesRef->Existe((refAF.Nom()+ajout),idmail))
|
|
{num++;ajout = "_"+ChangeEntierSTring(num);};
|
|
if (ajout != "")
|
|
{ nouveau_nom += ajout;
|
|
if (ParaGlob::NiveauImpression() > 0)
|
|
cout << "\n >>> attention la reference "<<refAF.Nom()<<" a ajouter au maillage "
|
|
<< nomDuMaillage << " a un nouveau nom "<< (refAF.Nom()+ajout);
|
|
};
|
|
Tableau<int> te = refAF.Tab_Elem(); // on récupère une copie du tableau des éléments
|
|
Tableau<int> te_new = te; // le nouveau tableau
|
|
// apriori seules les numéros d'élément sont succeptible d'avoir changé, les numéros
|
|
// locaux: surface, arête, noeuds relatifs à l'éléments, et pti restent inchangé
|
|
// par contre ils peuvent être supprimés si le num d'élément est supprimé
|
|
Tableau<int> tl = refAF.Tab_FA(); // on récupère une copie du tableau des num locaux
|
|
|
|
// on met à jour le tableau de d'éléments / aux nouveaux numéros
|
|
int tai = te.Taille();int kn=0; // kn c'est le pointeur dans la nouvelle ref
|
|
for (int k=1;k<= tai; k++)
|
|
{if (t_new_num_elem(te(k)) != 0)
|
|
{ kn++;
|
|
te_new(kn) = t_new_num_elem(te(k)); // cas où effectivement on a rajouté un élément qui était déjà référencé
|
|
// dans l'ancienne référence
|
|
tl(kn) = tl(k); // normalement k est > kn, donc cela revient à décaler
|
|
// en ne gardant que les termes viables
|
|
}
|
|
else
|
|
{if (ParaGlob::NiveauImpression() > 0)
|
|
cout << "\n l'element "<<te(k)<<" de la ref "<<refAF.Nom()
|
|
<<" n'existe plus dans le nouveau maillage "<<nomDuMaillage;
|
|
};
|
|
};
|
|
// on redimentionne le tableau au maxi d'élément
|
|
te_new.Change_taille(kn);tl.Change_taille(kn);
|
|
// on crée la nouvelle référence si le tableau n'est pas nul
|
|
if (te_new.Taille() != 0)
|
|
{ReferenceAF* newref = new ReferenceAF(te_new,tl,idmail,indic,nouveau_nom);
|
|
// ajout de la référence
|
|
lesRef->Ajout_reference(newref);
|
|
};
|
|
break;
|
|
}
|
|
};
|
|
};
|
|
};
|
|
// -------------- ajout de références globales si elles n'existent pas ---------------------
|
|
// ---- mise à jour de la référence de tous les éléments si elle n'existe pas déjà
|
|
int nbElement = tab_element.Taille();
|
|
string etout("E_tout");
|
|
if (lesRef->Existe(etout,idmail))
|
|
lesRef->SupprimeReference("E_tout",idmail); // on supprime la référence E_tout
|
|
// on construit le tableau des numéros des éléments
|
|
Tableau <int> tabE(nbElement); for (int i=1;i<=nbElement;i++) tabE(i)=i;
|
|
ReferenceNE* retout = new ReferenceNE(tabE,idmail,2,etout);// construction de la référence
|
|
lesRef->Ajout_reference(retout); // ajout de la ref, qui est maintenant géré par lesRef
|
|
|
|
// ---- dans tous les cas on ajoute ou modifie la référence de tous les noeuds
|
|
string ntout("N_tout");
|
|
int nbNoeud = tab_noeud.Taille();
|
|
if (lesRef->Existe(ntout,idmail))
|
|
lesRef->SupprimeReference("N_tout",idmail); // on supprime la référence N_tout
|
|
// on construit le tableau des numéros de noeuds
|
|
Tableau <int> tabN(nbNoeud); for (int i=1;i<=nbNoeud;i++) tabN(i)=i;
|
|
ReferenceNE* rtout = new ReferenceNE(tabN,idmail,1,ntout);// construction de la référence
|
|
lesRef->Ajout_reference(rtout); // ajout de la ref, qui est maintenant géré par lesRef
|
|
//debug
|
|
//cout << "\n nbElement " << nbElement << ", nbNoeud "<< nbNoeud << endl;
|
|
// fin debug
|
|
|
|
|
|
};
|
|
|
|
|
|
// 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 Maillage::Force_Ddl_aux_noeuds_a_une_valeur(Enum_ddl enu, const double& val,Enum_dure temps, bool fonction_de_la_dimension)
|
|
{
|
|
int nbnoeud = tab_noeud.Taille();
|
|
int dima = ParaGlob::Dimension();
|
|
switch (temps)
|
|
{case TEMPS_0:
|
|
{ if (!(fonction_de_la_dimension) || !FoncDim(enu))
|
|
{for (int i=1;i<= nbnoeud;i++)
|
|
{ Noeud& noe = *tab_noeud(i); // pour simplifier
|
|
if (noe.Existe_ici(enu)) // on intervient que si le ddl existe
|
|
noe.Change_val_0(enu,val);
|
|
};
|
|
}
|
|
else
|
|
{for (int i=1;i<= nbnoeud;i++)
|
|
{ Noeud& noe = *tab_noeud(i); // pour simplifier
|
|
if (noe.Existe_ici(enu)) // on intervient que si le ddl existe
|
|
{ switch (dima)
|
|
{ case 3: noe.Change_val_0(Enum_ddl(enu+2),val);
|
|
case 2: noe.Change_val_0(Enum_ddl(enu+1),val);
|
|
case 1: noe.Change_val_0(Enum_ddl(enu),val);
|
|
};
|
|
};
|
|
};
|
|
};
|
|
break;
|
|
}
|
|
case TEMPS_t:
|
|
{ if (!(fonction_de_la_dimension) || !FoncDim(enu))
|
|
{for (int i=1;i<= nbnoeud;i++)
|
|
{ Noeud& noe = *tab_noeud(i); // pour simplifier
|
|
if (noe.Existe_ici(enu)) // on intervient que si le ddl existe
|
|
noe.Change_val_t(enu,val);
|
|
};
|
|
}
|
|
else
|
|
{for (int i=1;i<= nbnoeud;i++)
|
|
{ Noeud& noe = *tab_noeud(i); // pour simplifier
|
|
if (noe.Existe_ici(enu)) // on intervient que si le ddl existe
|
|
{ switch (dima)
|
|
{ case 3: noe.Change_val_t(Enum_ddl(enu+2),val);
|
|
case 2: noe.Change_val_t(Enum_ddl(enu+1),val);
|
|
case 1: noe.Change_val_t(Enum_ddl(enu),val);
|
|
};
|
|
};
|
|
};
|
|
};
|
|
break;
|
|
}
|
|
case TEMPS_tdt:
|
|
{ if (!(fonction_de_la_dimension) || !FoncDim(enu))
|
|
{for (int i=1;i<= nbnoeud;i++)
|
|
{ Noeud& noe = *tab_noeud(i); // pour simplifier
|
|
if (noe.Existe_ici(enu)) // on intervient que si le ddl existe
|
|
noe.Change_val_tdt(enu,val);
|
|
};
|
|
}
|
|
else
|
|
{for (int i=1;i<= nbnoeud;i++)
|
|
{ Noeud& noe = *tab_noeud(i); // pour simplifier
|
|
if (noe.Existe_ici(enu)) // on intervient que si le ddl existe
|
|
{ switch (dima)
|
|
{ case 3: noe.Change_val_tdt(Enum_ddl(enu+2),val);
|
|
case 2: noe.Change_val_tdt(Enum_ddl(enu+1),val);
|
|
case 1: noe.Change_val_tdt(Enum_ddl(enu),val);
|
|
};
|
|
};
|
|
};
|
|
};
|
|
break;
|
|
}
|
|
};
|
|
|
|
};
|
|
|
|
|
|
// mise à zéro de dd_enum_etendu aux noeuds : force la mise à une valeur à 0
|
|
void Maillage::Force_Ddl_etendu_aux_noeuds_a_zero(const Tableau<Ddl_enum_etendu>& tab_enu)
|
|
{
|
|
int nbnoeud = tab_noeud.Taille();
|
|
int nb_enu = tab_enu.Taille();
|
|
for (int i=1;i<=nb_enu;i++)
|
|
{const Ddl_enum_etendu& enu = tab_enu(i);
|
|
for (int i=1;i<= nbnoeud;i++)
|
|
{ Noeud& noe = *tab_noeud(i); // pour simplifier
|
|
if (noe.Existe_ici_ddlEtendu(enu)) // on intervient que si le ddl existe
|
|
noe.ModifDdl_etendu(enu).Valeur() = 0.;
|
|
};
|
|
};
|
|
|
|
};
|
|
|
|
|
|
// on s'occupe de mettre à jour les types de pb et les ddl types associés
|
|
void Maillage::Mise_a_jour_type_pb_type_associe_ddl()
|
|
{ //types_de_problemes.clear();
|
|
//ddl_representatifs_des_physiques.clear();
|
|
// types_de_problemes.Libere();ddl_representatifs_des_physiques.Libere();
|
|
// int nbElement = tab_element.Taille();
|
|
//string titi;
|
|
//cout << "\n nbElement "<<nbElement << " une valeur ? ";
|
|
//cin >> titi;
|
|
// // on définit un tableau intermédiaire
|
|
// int nombre_de_EnumElemTypeProblem = Nombre_de_EnumElemTypeProblem();
|
|
//cout << "\n nombre_de_EnumElemTypeProblem "<<nombre_de_EnumElemTypeProblem << " une valeur ? ";
|
|
//cin >> titi;
|
|
// Tableau < int> types_de_problemes_actif(nombre_de_EnumElemTypeProblem,0);
|
|
// types_de_problemes_actif(1)=1;
|
|
//cout << "\n taill "<<types_de_problemes_actif.Taille() << " une valeur ? ";
|
|
//cin >> titi;
|
|
//cout << "\n types_de_problemes_actif(1) "<<types_de_problemes_actif(1) << " une valeur ? ";
|
|
//cin >> titi;
|
|
//
|
|
// for (int i;i<=nbElement;i++)
|
|
// {Element& ele = *tab_element(i);
|
|
//cout << "\n i"<<i <<"ele "<<ele.Num_elt() << " une valeur ? ";
|
|
//cin >> titi;
|
|
//ele.Affiche();
|
|
//cout << "\n i"<<i <<"ele "<<ele.Num_elt() << " une valeur ? ";
|
|
//cin >> titi;
|
|
// EnumElemTypeProblem enu = ele.Id_TypeProblem();
|
|
//cout << "\n i"<<i <<"ele "<<ele.Num_elt() << " une valeur ? ";
|
|
//cin >> titi;
|
|
//int truc =enu;
|
|
//cout << "\n enu= "<<enu<<" truc "<< truc<< " une valeur ? ";
|
|
//cin >> titi;
|
|
//cout << "\n types_de_problemes_actif(1) "<<types_de_problemes_actif(1) << " une valeur ? ";
|
|
//cin >> titi;
|
|
//types_de_problemes_actif(1) = 1;
|
|
//cout << "\n types_de_problemes_actif(1) "<<types_de_problemes_actif(1) << " une valeur ? ";
|
|
//cin >> titi;
|
|
//types_de_problemes_actif(int(enu)) = 1;
|
|
//cout << "\n types_de_problemes_actif(1) "<<types_de_problemes_actif(1) << " une valeur ? ";
|
|
//cin >> titi;
|
|
// // types_de_problemes_actif(truc) = 1; // on rend actif l'élément du tableau
|
|
// };
|
|
//cout << "\n une valeur ? ";
|
|
//cin >> titi;
|
|
// // maintenant on regarde le nombre de pb actif
|
|
// int nb_pb = 0; // init
|
|
// for (int i=1;i<=nombre_de_EnumElemTypeProblem;i++)
|
|
// if (types_de_problemes_actif(i)) nb_pb++;
|
|
//cout << "\n une valeur ? ";
|
|
//cin >> titi;
|
|
// // on redimentionne et on rempli
|
|
// types_de_problemes.Change_taille(nb_pb);
|
|
//cout << "\n une valeur ? ";
|
|
//cin >> titi;
|
|
// nb_pb = 0; // init
|
|
// for (int i=1;i<=nombre_de_EnumElemTypeProblem;i++)
|
|
// if (types_de_problemes_actif(i))
|
|
// {nb_pb++;types_de_problemes(nb_pb)=EnumElemTypeProblem(i);};
|
|
//cout << "\n une valeur ? ";
|
|
//cin >> titi;
|
|
//
|
|
//
|
|
////cout << "\n enu"<<enu << " une valeur ? ";
|
|
////cin >> titi;
|
|
//// bool trouve = false;
|
|
//// list <EnumElemTypeProblem>::iterator il,ilfin=types_de_problemes.end();
|
|
////if (!types_de_problemes.empty())
|
|
////cout << "\n ilfin il begin " << (*types_de_problemes.begin())<< " une valeur ? ";
|
|
////cin >> titi;
|
|
//// for (il=types_de_problemes.begin();il != ilfin; il++)
|
|
//// {cout << "\n "<<NomElemTypeProblem(*il) << " une valeur ? ";
|
|
//// cin >> titi;
|
|
////
|
|
//// if ((*il)==enu) {trouve = true; break;};
|
|
//// };
|
|
//// if (find(types_de_problemes.begin(),types_de_problemes.end(),enu) == types_de_problemes.end())
|
|
//// if (!trouve)
|
|
////EnumElemTypeProblem tutu = MECA_SOLIDE_DEFORMABLE;
|
|
// // { types_de_problemes.push_back(tutu);};
|
|
////
|
|
//// int taill = types_de_problemes.Taille();
|
|
//// for (int j=1;j<=taill;j++)
|
|
//// if (types_de_problemes(j) == enu)
|
|
//// { types_de_problemes.Change_taille(taill+1);
|
|
//// types_de_problemes(taill+1)=enu;
|
|
//// break;
|
|
//// };
|
|
//// };
|
|
//// inter.sort(); inter.unique();
|
|
//// types_de_problemes = inter;
|
|
// // on parcours les types de pb pour attribuer les types de ddl
|
|
//// list <EnumElemTypeProblem>::iterator il,ilfin=types_de_problemes.end();
|
|
//// for (il=types_de_problemes.begin();il != ilfin;il++)
|
|
////
|
|
//// { switch (types_de_problemes(j))
|
|
//// {case MECA_SOLIDE_DEFORMABLE :
|
|
//// ddl_representatifs_des_physiques.push_back(X1);break;
|
|
//// case THERMIQUE :
|
|
//// ddl_representatifs_des_physiques.push_back(TEMP);break;
|
|
//// default :
|
|
//// cout << "\n***Erreur : pour l'instant le type de probleme: "<<NomElemTypeProblem(*il)
|
|
//// << "n'est pas pris en compte !\n";
|
|
//// cout << "\n Maillage::LectureMaillage(... \n";
|
|
//// Sortie(1);
|
|
//// };
|
|
//// };
|
|
//// types_de_problemes.sort(); types_de_problemes.unique();
|
|
//// ddl_representatifs_des_physiques.sort(); ddl_representatifs_des_physiques.unique();
|
|
//
|
|
// ddl_representatifs_des_physiques.Change_taille(nb_pb);
|
|
// for (int j=1;j<=nb_pb;j++)
|
|
// { switch (types_de_problemes(j))
|
|
// {case MECA_SOLIDE_DEFORMABLE :
|
|
// ddl_representatifs_des_physiques(j)=X1;break;
|
|
// case THERMIQUE :
|
|
// ddl_representatifs_des_physiques(j)=TEMP;break;
|
|
// default :
|
|
// cout << "\n***Erreur : pour l'instant le type de probleme: "
|
|
// <<NomElemTypeProblem(types_de_problemes(j))
|
|
// << "n'est pas pris en compte !\n";
|
|
// cout << "\n Maillage::LectureMaillage(... \n";
|
|
// Sortie(1);
|
|
// };
|
|
// };
|
|
|
|
};
|
|
|