2021-09-27 12:42:13 +02:00
|
|
|
|
|
|
|
|
// 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.
|
|
|
|
|
//
|
2023-05-03 17:23:49 +02:00
|
|
|
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
2021-09-27 12:42:13 +02:00
|
|
|
// 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 "Debug.h"
|
|
|
|
|
|
|
|
|
|
#include "GeomPentaL.h"
|
|
|
|
|
#include <math.h>
|
|
|
|
|
#include "GeomSeg.h"
|
|
|
|
|
#include "GeomTriangle.h"
|
|
|
|
|
#include "GeomQuadrangle.h"
|
|
|
|
|
#include "MathUtil.h"
|
|
|
|
|
|
|
|
|
|
// constructeur
|
|
|
|
|
// la dimension est 3, on a nbi pt d'integration ( 2 par défaut), 6 noeuds et 5 faces, 9 aretes
|
|
|
|
|
GeomPentaL::GeomPentaL(int nbi) :
|
|
|
|
|
GeomPentaCom(nbi,6,LINEAIRE)
|
|
|
|
|
,phi_M(),dphi_M()
|
|
|
|
|
{ // coordonnees dans l'élément de référence des noeuds
|
|
|
|
|
ptelem(1) = Coordonnee(0,0,-1.); ptelem(2) = Coordonnee(1.,0,-1.);
|
|
|
|
|
ptelem(3) = Coordonnee(0,1.,-1.); ptelem(4) = Coordonnee(0,0,1.);
|
|
|
|
|
ptelem(5) = Coordonnee(1.,0,1.); ptelem(6) = Coordonnee(0,1.,1.);
|
|
|
|
|
// définition de la numérotation locale de l'élément de direction inverse
|
|
|
|
|
INVCONNEC(1) = 1;INVCONNEC(2) = 3; INVCONNEC(3) = 2;
|
|
|
|
|
INVCONNEC(4) = 4;INVCONNEC(5) = 6; INVCONNEC(6) = 5;
|
|
|
|
|
// le tableau des tranches
|
|
|
|
|
IND.Change_taille(1);
|
|
|
|
|
IND(1)=6; // les sommets
|
|
|
|
|
|
|
|
|
|
//--------------------------------
|
|
|
|
|
//def des arretes
|
|
|
|
|
//--------------------------------
|
|
|
|
|
int nbill =1; // nb de pt d'integ par ligne
|
|
|
|
|
int nbnel =2; // nb de noeud du segment
|
|
|
|
|
seg(1) = new GeomSeg(nbill,nbnel);
|
|
|
|
|
for (int il=2;il<= NBSE; il++) // ici NBSE = 9
|
|
|
|
|
seg(il) = seg(1);
|
|
|
|
|
// def des tableaux de connection des noeuds des aretes
|
|
|
|
|
for (int i =1;i<=NBSE;i++) NONS(i).Change_taille(2);
|
|
|
|
|
// la description est fait selon le fichier EIMail
|
|
|
|
|
NONS(1)(1) = 1;NONS(1)(2) = 2;NONS(2)(1) = 2;NONS(2)(2) = 3;
|
|
|
|
|
NONS(3)(1) = 3;NONS(3)(2) = 1;NONS(4)(1) = 1;NONS(4)(2) = 4;
|
|
|
|
|
NONS(5)(1) = 2;NONS(5)(2) = 5;NONS(6)(1) = 3;NONS(6)(2) = 6;
|
|
|
|
|
NONS(7)(1) = 4;NONS(7)(2) = 5;NONS(8)(1) = 5;NONS(8)(2) = 6;
|
|
|
|
|
NONS(9)(1) = 6;NONS(9)(2) = 4;
|
|
|
|
|
//--------------------------------
|
|
|
|
|
//def des faces
|
|
|
|
|
//--------------------------------
|
|
|
|
|
// 1) tout d'abord les faces verticales quadrangulaire
|
|
|
|
|
int nbqis =4; // nb de pt d'integ par facee
|
|
|
|
|
int nbqnes =4; // nb de noeud de la face
|
|
|
|
|
face(2) = new GeomQuadrangle(nbqis,nbqnes);
|
|
|
|
|
face(3) = face(2);
|
|
|
|
|
face(5) = face(2);
|
|
|
|
|
// 2) puis les faces haut et bas triangulairesv
|
|
|
|
|
int nbtis =1; // nb de pt d'integ par facee
|
|
|
|
|
int nbtnes =3; // nb de noeud de la face
|
|
|
|
|
face(1) = new GeomTriangle(nbtis,nbtnes);
|
|
|
|
|
face(4) = face(1);
|
|
|
|
|
// def des tableaux de connection des noeuds des faces
|
|
|
|
|
// 1) les quadrangles
|
|
|
|
|
NONF(2).Change_taille(nbqnes);NONF(3).Change_taille(nbqnes);
|
|
|
|
|
NONF(5).Change_taille(nbqnes);
|
|
|
|
|
// 2) les triangles
|
|
|
|
|
NONF(1).Change_taille(nbtnes);NONF(4).Change_taille(nbtnes);
|
|
|
|
|
|
|
|
|
|
// connection entre les noeuds des faces et les noeuds des elements
|
|
|
|
|
NONF(1)(1)= 1;NONF(1)(2)= 3;NONF(1)(3)= 2;
|
|
|
|
|
NONF(2)(1)= 1;NONF(2)(2)= 4;NONF(2)(3)= 6;NONF(2)(4)= 3;
|
|
|
|
|
NONF(3)(1)= 1;NONF(3)(2)= 2;NONF(3)(3)= 5;NONF(3)(4)= 4;
|
|
|
|
|
NONF(4)(1)= 4;NONF(4)(2)= 5;NONF(4)(3)= 6;
|
|
|
|
|
NONF(5)(1)= 2;NONF(5)(2)= 3;NONF(5)(3)= 6;NONF(5)(4)= 5;
|
|
|
|
|
|
|
|
|
|
// triangulation des différentes faces
|
|
|
|
|
// on se sert d'une part de l'élément de référence de chaque face
|
|
|
|
|
// puis de la connection les faces par rapport à celle de l'élément
|
|
|
|
|
// ici c'est le même élément pour toutes les faces
|
|
|
|
|
// on est obligé de boucler sur tous les indices et de faire
|
|
|
|
|
// de l'adressage indirecte
|
|
|
|
|
for (int isf=1;isf<= NBFE; isf++) // boucle sur les faces
|
|
|
|
|
{// 1) récup du tableau de l'élément de référence de la face
|
|
|
|
|
const Tableau<Tableau<Tableau<int> > > & tabi = face(isf)->Trian_lin();
|
|
|
|
|
int nbtria = tabi(1).Taille(); // nombre de triangle par face
|
|
|
|
|
NONFt(isf).Change_taille(nbtria);
|
|
|
|
|
for (int if1=1;if1<= nbtria; if1++) // boucle sur les triangles de la face
|
|
|
|
|
{ NONFt(isf)(if1).Change_taille(3);
|
|
|
|
|
for (int in1=1;in1<= 3; in1++) // boucle sur les noeuds du triangle
|
|
|
|
|
NONFt(isf)(if1)(in1) = NONF(isf)(tabi(1)(if1)(in1));
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
// fonctions d'interpolation globales aux points d'intégrations
|
|
|
|
|
for (int ptint=1;ptint<= nbi; ptint++)
|
2023-05-03 17:23:49 +02:00
|
|
|
tabPhi(ptint) = Phi_point( ptInteg(ptint));
|
2021-09-27 12:42:13 +02:00
|
|
|
// derivees des fonctions d'interpolations aux points d'intégrations
|
|
|
|
|
for (int ptint=1;ptint<= nbi; ptint++)
|
2023-05-03 17:23:49 +02:00
|
|
|
tabDPhi(ptint) = Dphi_point( ptInteg(ptint));
|
2021-09-27 12:42:13 +02:00
|
|
|
// ---- constitution du tableau Extrapol -----
|
|
|
|
|
Calcul_extrapol(nbi);
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// destructeur
|
|
|
|
|
GeomPentaL::~GeomPentaL()
|
|
|
|
|
{ delete seg(1);
|
|
|
|
|
delete face(1); delete face(2);
|
|
|
|
|
};
|
|
|
|
|
// constructeur de copie
|
|
|
|
|
GeomPentaL::GeomPentaL(const GeomPentaL& a) :
|
|
|
|
|
GeomPentaCom(a),phi_M(a.phi_M),dphi_M(a.dphi_M)
|
|
|
|
|
{ // la copie des parties pointées est à la charge de la classe spécifique
|
|
|
|
|
// definition des faces
|
|
|
|
|
face(1) = new GeomTriangle(*((GeomTriangle*)(a.face(1))));
|
|
|
|
|
face(4) = face(1);
|
|
|
|
|
face(2) = new GeomQuadrangle(*((GeomQuadrangle*)(a.face(2))));
|
|
|
|
|
face(3) = face(2);
|
|
|
|
|
face(5) = face(2);
|
|
|
|
|
// def des segments
|
|
|
|
|
seg(1) = new GeomSeg(*((GeomSeg*)(a.seg(1)))) ;
|
|
|
|
|
for (int il=2;il<= NBSE; il++)
|
|
|
|
|
seg(il) = seg(1);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// création d'élément identiques : cette fonction est analogue à la fonction new
|
|
|
|
|
// elle y fait d'ailleurs appel. l'implantation est spécifique dans chaque classe
|
|
|
|
|
// dérivée
|
|
|
|
|
// pt est le pointeur qui est affecté par la fonction
|
|
|
|
|
ElemGeomC0 * GeomPentaL::newElemGeomC0(ElemGeomC0 * pt)
|
|
|
|
|
{ pt = new GeomPentaL(*this);
|
|
|
|
|
return pt;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
//--------- cas de coordonnees locales quelconques ----------------
|
|
|
|
|
|
|
|
|
|
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
2023-05-03 17:23:49 +02:00
|
|
|
const Vecteur& GeomPentaL::Phi_point(const Coordonnee& M)
|
2021-09-27 12:42:13 +02:00
|
|
|
{
|
|
|
|
|
#ifdef MISE_AU_POINT
|
|
|
|
|
// verification de la dimension des coordonnees locales
|
|
|
|
|
if (M.Dimension() != 3)
|
|
|
|
|
{ cout << "\n erreur la dimension des coordonnees locales :" << M.Dimension()
|
|
|
|
|
<<"n\'est pas egale a 3 "
|
|
|
|
|
<< "\nGeomPentaL::Phi(Coordonnee& M)";
|
|
|
|
|
Sortie(1);
|
|
|
|
|
};
|
|
|
|
|
#endif
|
|
|
|
|
// Vecteur phi(NBNE); // tableau des fonctions d'interpolation
|
|
|
|
|
// dimentionnement éventuelle du tableau des fonctions d'interpolation
|
|
|
|
|
phi_M.Change_taille(NBNE); // si la taille est identique -> aucune action
|
|
|
|
|
|
|
|
|
|
int nbnes = 3; // nombre de noeud par faces
|
|
|
|
|
int nbnel = 2; // nombre de noeud par cotes
|
|
|
|
|
Coordonnee X(2),Z(1);
|
|
|
|
|
X(1) = M(1); X(2) = M(2); // coordonnées pour le triangle
|
|
|
|
|
Z(1) = M(3); // coordonnees pour le segment
|
|
|
|
|
// fonctions d'interpolation
|
|
|
|
|
int ne = 1;
|
|
|
|
|
for (int iz = 1;iz<= nbnel; iz++)
|
|
|
|
|
for (int ix = 1;ix<= nbnes; ix++)
|
2023-05-03 17:23:49 +02:00
|
|
|
{ phi_M(ne) = seg(1)->Phi_point(Z)(iz) * face(1)->Phi_point(X)(ix) ;
|
2021-09-27 12:42:13 +02:00
|
|
|
ne++;
|
|
|
|
|
};
|
|
|
|
|
// retour de phi_M
|
|
|
|
|
return phi_M;
|
|
|
|
|
};
|
|
|
|
|
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
2023-05-03 17:23:49 +02:00
|
|
|
const Mat_pleine& GeomPentaL::Dphi_point(const Coordonnee& M)
|
2021-09-27 12:42:13 +02:00
|
|
|
{
|
|
|
|
|
#ifdef MISE_AU_POINT
|
|
|
|
|
// verification de la dimension des coordonnees locales
|
|
|
|
|
if (M.Dimension() != 3)
|
|
|
|
|
{ cout << "\n erreur la dimension des coordonnees locales :" << M.Dimension()
|
|
|
|
|
<<"n\'est pas egale a 3 "
|
|
|
|
|
<< "\nGeomPentaL::Dphi(Coordonnee& M)";
|
|
|
|
|
Sortie(1);
|
|
|
|
|
};
|
|
|
|
|
#endif
|
|
|
|
|
// Mat_pleine dphi(3,NBNE); // le tableau des derivees
|
|
|
|
|
// le tableau des derivees: redimentionnement si nécessaire
|
|
|
|
|
if ((dphi_M.Nb_ligne() != 3)&&(dphi_M.Nb_colonne() != NBNE))
|
|
|
|
|
dphi_M.Initialise (3,NBNE,0.);
|
|
|
|
|
int nbnes = 3; // nombre de noeud par faces
|
|
|
|
|
int nbnel = 2; // nombre de noeud par cotes
|
|
|
|
|
Coordonnee X(2),Z(1);
|
|
|
|
|
X(1) = M(1); X(2) = M(2); // coordonnées pour le triangle
|
|
|
|
|
Z(1) = M(3); // coordonnees pour le segment
|
|
|
|
|
// derivee des fonctions d'interpolation
|
|
|
|
|
int ne = 1;
|
|
|
|
|
for (int iz = 1;iz<= nbnel; iz++)
|
|
|
|
|
for (int ix = 1;ix<= nbnes; ix++)
|
2023-05-03 17:23:49 +02:00
|
|
|
{ dphi_M(1,ne) = seg(1)->Phi_point(Z)(iz) * face(1)->Dphi_point(X)(1,ix) ;
|
|
|
|
|
dphi_M(2,ne) = seg(1)->Phi_point(Z)(iz) * face(1)->Dphi_point(X)(2,ix) ;
|
|
|
|
|
dphi_M(3,ne) = seg(1)->Dphi_point(Z)(1,iz) * face(1)->Phi_point(X)(ix) ;
|
2021-09-27 12:42:13 +02:00
|
|
|
ne++;
|
|
|
|
|
};
|
|
|
|
|
// retour des derivees
|
|
|
|
|
return dphi_M;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// constitution du tableau Extrapol
|
|
|
|
|
void GeomPentaL::Calcul_extrapol(int nbi)
|
|
|
|
|
{ // cas de l'extrapolation de grandeur des points d'intégrations aux noeuds
|
|
|
|
|
// def du tableau de pondération tab(i)(j) qu'il faut appliquer
|
|
|
|
|
// aux noeuds pour avoir la valeur aux noeuds
|
|
|
|
|
// val_au_noeud(i) = somme_(de j=indir(i)(1) à indir(i)(taille(indir(i)) )) {tab(i)(j) * val_pt_integ(j) }
|
|
|
|
|
// cas = 1: la valeur au noeud = la valeur au pt d'integ le plus près ou une moyenne des
|
|
|
|
|
// pt les plus près (si le nb de pt d'integ < nb noeud)
|
|
|
|
|
//--- changement: 13 avril 2021: on fait une extrapolation tri-linéaire via les pti les plus proches
|
|
|
|
|
Tableau<Tableau<int> > & indir = extrapol(1).indir; // pour simplifier
|
|
|
|
|
Tableau<Tableau<double > > & tab = extrapol(1).tab; // pour simplifier
|
|
|
|
|
Tableau <int> indirect(2); // tableau de travail
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
switch (nbi)
|
|
|
|
|
{ case 1:
|
|
|
|
|
{ // cas avec un point d'intégration,
|
|
|
|
|
// on reporte la valeur du pt d'integ, telle quelle aux noeuds du bas et du haut
|
|
|
|
|
for (int ne=1;ne<=6;ne++)
|
|
|
|
|
{tab(ne).Change_taille(nbi);
|
|
|
|
|
tab(ne)(1)=1.;
|
|
|
|
|
indir(ne).Change_taille(1); indir(ne)(1)=1;
|
|
|
|
|
};
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 2:
|
|
|
|
|
{ // cas avec deux points d'intégration,
|
|
|
|
|
|
|
|
|
|
// tab est supposé être initialisé à 0.
|
|
|
|
|
Tableau <Coordonnee> gi_B,gi_H; // bases naturelle et duale
|
|
|
|
|
// --- méthode 1 (par défaut), on utilise une extrapolation linéaire dans l'épaisseur
|
|
|
|
|
{Tableau<Tableau<int> > & indir = extrapol(1).indir; // pour simplifier
|
|
|
|
|
Tableau<Tableau<double > > & tab = extrapol(1).tab; // pour simplifier
|
|
|
|
|
Tableau <int> indirect(nbi); // tableau de travail: on a 2 pondérations
|
|
|
|
|
indirect(1)=1; indirect(2)=2;
|
|
|
|
|
tab.Change_taille(NBNE);indir.Change_taille(NBNE);
|
|
|
|
|
|
|
|
|
|
// tout d'abord on s'occupe des 3 premiers noeuds
|
|
|
|
|
{ // il nous faut calculer la coordonnée locale theta^3 des 3 noeuds
|
|
|
|
|
// c-a-d celle du centre de gravité par exemple ou du premier noeud.
|
|
|
|
|
// on retient le premier noeud
|
|
|
|
|
int ne1 = 1;
|
|
|
|
|
// les pti ici considérés, sont les extrémités d'un segment
|
|
|
|
|
Coordonnee theta(1); // la coordonnée que l'on cherche
|
|
|
|
|
Vecteur phi_z(2); // le conteneur pour les fonctions d'interpolation
|
|
|
|
|
// suivant z
|
|
|
|
|
{Bases_naturel_duales(indirect,gi_B,gi_H);
|
|
|
|
|
Coordonnee O(0.5*(ptInteg(indirect(1))+ptInteg(indirect(2)))); //
|
|
|
|
|
ElemGeomC0::Coor_phi(O,gi_H,ptelem(ne1),phi_z,theta);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// maintenant on va attribuer aux 3 noeuds de la facette la valeur extrapolée
|
|
|
|
|
for (int ne=1;ne<=3;ne++)
|
|
|
|
|
{indir(ne).Change_taille(nbi);
|
|
|
|
|
tab(ne).Change_taille(nbi); // ici nbi ==2
|
|
|
|
|
for (int i=1;i<=nbi;i++)
|
|
|
|
|
{tab(ne)(indirect(i))=phi_z(i);
|
|
|
|
|
indir(ne)(i)=indirect(i);
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
// idem pour mes 3 derniers noeuds
|
|
|
|
|
{ // il nous faut calculer la coordonnée locale theta^3 des 3 noeuds
|
|
|
|
|
// c-a-d celle du centre de gravité par exemple ou du 4ieme noeud.
|
|
|
|
|
// on retient le 4ieme noeud
|
|
|
|
|
int ne1 = 4;
|
|
|
|
|
// les pti ici considérés, sont les extrémités d'un segment
|
|
|
|
|
Coordonnee theta(1); // la coordonnée que l'on cherche
|
|
|
|
|
Vecteur phi_z(2); // le conteneur pour les fonctions d'interpolation
|
|
|
|
|
// suivant z
|
|
|
|
|
{Bases_naturel_duales(indirect,gi_B,gi_H);
|
|
|
|
|
Coordonnee O(0.5*(ptInteg(indirect(1))+ptInteg(indirect(2)))); //
|
|
|
|
|
ElemGeomC0::Coor_phi(O,gi_H,ptelem(ne1),phi_z,theta);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// maintenant on va attribuer aux 3 noeuds de la facette la valeur extrapolée
|
|
|
|
|
for (int ne=4;ne<=6;ne++)
|
|
|
|
|
{indir(ne).Change_taille(nbi);
|
|
|
|
|
tab(ne).Change_taille(nbi); // ici nbi ==2
|
|
|
|
|
for (int i=1;i<=nbi;i++)
|
|
|
|
|
{tab(ne)(indirect(i))=phi_z(i);
|
|
|
|
|
indir(ne)(i)=indirect(i);
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
// --- ancienne méthode
|
|
|
|
|
// // on reporte la valeur au premier pt d'integ, telle quelle aux noeuds du bas
|
|
|
|
|
// for (int ne=1;ne<=3;ne++)
|
|
|
|
|
// {tab(ne)(1)=1.;
|
|
|
|
|
// indir(ne).Change_taille(1); indir(ne)(1)=1;
|
|
|
|
|
// };
|
|
|
|
|
// // on reporte la valeur au second pt d'integ, telle quelle aux noeuds du haut
|
|
|
|
|
// for (int ne=4;ne<=6;ne++)
|
|
|
|
|
// {tab(ne)(2)=1.;
|
|
|
|
|
// indir(ne).Change_taille(1); indir(ne)(1)=2;
|
|
|
|
|
// };
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 3:
|
|
|
|
|
{ // cas avec 3 points d'intégration,
|
|
|
|
|
|
|
|
|
|
// tab est supposé être initialisé à 0.
|
|
|
|
|
Tableau <Coordonnee> gi_B,gi_H; // bases naturelle et duale
|
|
|
|
|
// --- méthode 1 (par défaut), on utilise une extrapolation linéaire dans l'épaisseur
|
|
|
|
|
{Tableau<Tableau<int> > & indir = extrapol(1).indir; // pour simplifier
|
|
|
|
|
Tableau<Tableau<double > > & tab = extrapol(1).tab; // pour simplifier
|
|
|
|
|
Tableau <int> indirect(nbi); // tableau de travail: on a 2 pondérations
|
|
|
|
|
tab.Change_taille(NBNE);indir.Change_taille(NBNE);
|
|
|
|
|
|
|
|
|
|
// tout d'abord on s'occupe des 3 premiers noeuds
|
|
|
|
|
{ // il nous faut calculer la coordonnée locale theta^3 des 3 noeuds
|
|
|
|
|
// c-a-d celle du centre de gravité par exemple ou du premier noeud.
|
|
|
|
|
// on retient le premier noeud
|
|
|
|
|
int ne1 = 1;
|
|
|
|
|
// les pti ici considérés, sont les extrémités d'un segment
|
|
|
|
|
Coordonnee theta(1); // la coordonnée que l'on cherche
|
|
|
|
|
Vecteur phi_z(2); // le conteneur pour les fonctions d'interpolation
|
|
|
|
|
indirect(1)=1; indirect(2)=2; // on utilise les 2 premiers pti pour l'extrapolation
|
|
|
|
|
// suivant z
|
|
|
|
|
{Bases_naturel_duales(indirect,gi_B,gi_H);
|
|
|
|
|
Coordonnee O(0.5*(ptInteg(indirect(1))+ptInteg(indirect(2)))); //
|
|
|
|
|
ElemGeomC0::Coor_phi(O,gi_H,ptelem(ne1),phi_z,theta);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// maintenant on va attribuer aux 3 noeuds de la facette la valeur extrapolée
|
|
|
|
|
for (int ne=1;ne<=3;ne++)
|
|
|
|
|
{indir(ne).Change_taille(nbi);
|
|
|
|
|
tab(ne).Change_taille(nbi); // ici nbi ==2
|
|
|
|
|
for (int i=1;i<=nbi;i++)
|
|
|
|
|
{tab(ne)(indirect(i))=phi_z(i);
|
|
|
|
|
indir(ne)(i)=indirect(i);
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
// idem pour mes 3 derniers noeuds
|
|
|
|
|
{ // il nous faut calculer la coordonnée locale theta^3 des 3 noeuds
|
|
|
|
|
// c-a-d celle du centre de gravité par exemple ou du 4ieme noeud.
|
|
|
|
|
// on retient le 4ieme noeud
|
|
|
|
|
int ne1 = 4;
|
|
|
|
|
// les pti ici considérés, sont les extrémités d'un segment
|
|
|
|
|
Coordonnee theta(1); // la coordonnée que l'on cherche
|
|
|
|
|
Vecteur phi_z(2); // le conteneur pour les fonctions d'interpolation
|
|
|
|
|
indirect(1)=2; indirect(2)=3; // on utilise les 2 derniers pti pour // suivant z
|
|
|
|
|
{Bases_naturel_duales(indirect,gi_B,gi_H);
|
|
|
|
|
Coordonnee O(0.5*(ptInteg(indirect(1))+ptInteg(indirect(2)))); //
|
|
|
|
|
ElemGeomC0::Coor_phi(O,gi_H,ptelem(ne1),phi_z,theta);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// maintenant on va attribuer aux 3 noeuds de la facette la valeur extrapolée
|
|
|
|
|
for (int ne=4;ne<=6;ne++)
|
|
|
|
|
{indir(ne).Change_taille(nbi);
|
|
|
|
|
tab(ne).Change_taille(nbi); // ici nbi ==2
|
|
|
|
|
for (int i=1;i<=nbi;i++)
|
|
|
|
|
{tab(ne)(indirect(i))=phi_z(i);
|
|
|
|
|
indir(ne)(i)=indirect(i);
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
// --- ancienne méthode
|
|
|
|
|
// // on reporte la valeur au premier pt d'integ, telle quelle aux noeuds du bas
|
|
|
|
|
// for (int ne=1;ne<=3;ne++)
|
|
|
|
|
// {tab(ne)(1)=1.;
|
|
|
|
|
// indir(ne).Change_taille(1); indir(ne)(1)=1;
|
|
|
|
|
// };
|
|
|
|
|
// // on reporte la valeur au pt d'integ 3, telle quelle aux noeuds du haut
|
|
|
|
|
// for (int ne=4;ne<=6;ne++)
|
|
|
|
|
// {tab(ne)(3)=1.;
|
|
|
|
|
// indir(ne).Change_taille(1); indir(ne)(1)=3;
|
|
|
|
|
// };
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 6: // 3 pt de surface en bas et en haut
|
|
|
|
|
{
|
|
|
|
|
// tab est supposé être initialisé à 0.
|
|
|
|
|
Tableau <Coordonnee> gi_B,gi_H; // bases naturelle et duale
|
|
|
|
|
// --- méthode 1 (par défaut), on utilise une extrapolation linéaire dans l'épaisseur
|
|
|
|
|
// et une extrapolation linéaire dans le plan du triangle
|
|
|
|
|
// donc en fait on extrapole via un pentaèdre linéaire dont les sommets sont au niveau
|
|
|
|
|
// des pti
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
{Tableau<Tableau<int> > & indir = extrapol(1).indir; // pour simplifier
|
|
|
|
|
Tableau<Tableau<double > > & tab = extrapol(1).tab; // pour simplifier
|
|
|
|
|
tab.Change_taille(NBNE);indir.Change_taille(NBNE);
|
|
|
|
|
|
|
|
|
|
Tableau <int> indirect(nbi); // tableau de travail: on a 6 pondérations
|
|
|
|
|
// même numérotation des pti
|
|
|
|
|
for (int i=1;i<=nbi;i++)
|
|
|
|
|
indirect(i) = i;
|
|
|
|
|
|
|
|
|
|
// tout d'abord on s'occupe des 3 premiers noeuds
|
|
|
|
|
for (int ne=1;ne<=3;ne++)
|
|
|
|
|
{// il nous faut calculer les coordonnées locales du noeud
|
|
|
|
|
// sachant que les pti ici considérés, sont aux sommets d'un pentaèdre linéaire orthogonal
|
|
|
|
|
// on peut traiter séparément les coordonnées dans le plan et la coordonnée z
|
|
|
|
|
|
|
|
|
|
Coordonnee theta(3); // les coordonnées que l'on cherche
|
|
|
|
|
|
|
|
|
|
// suivant x et y: calcul de theta^alpha
|
|
|
|
|
{Tableau <int> indirect_local(3); // tableau de travail
|
|
|
|
|
// on considère le triangle des 3 premiers pti
|
|
|
|
|
indirect_local(1) = indirect(1);indirect_local(2) = indirect(2);
|
|
|
|
|
indirect_local(3) = indirect(3);
|
|
|
|
|
Coordonnee theta_loc(2); // le conteneur pour les coordonnées locales en x y
|
|
|
|
|
Tableau <Coordonnee> gi_loc_B,gi_loc_H; // bases naturelle et duale
|
|
|
|
|
Bases_naturel_duales(indirect_local,gi_loc_B,gi_loc_H);
|
|
|
|
|
Coordonnee O(ptInteg(indirect(1))); //
|
|
|
|
|
Vecteur phi_xy(3); // le conteneur pour les fonctions
|
|
|
|
|
ElemGeomC0::Coor_phi(O,gi_loc_H,ptelem(ne),phi_xy,theta_loc);
|
|
|
|
|
theta(1)=theta_loc(1); // on enregistre
|
|
|
|
|
theta(2)=theta_loc(2); // on enregistre
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// suivant z: calcul de theta^3
|
|
|
|
|
{Tableau <int> indirect_local(2); // tableau de travail
|
|
|
|
|
// on considère la ligne du pti 1 -> pti 4
|
|
|
|
|
indirect_local(1) = indirect(1);indirect_local(2) = indirect(4);
|
|
|
|
|
Coordonnee theta_loc(1); // le conteneur pour les coordonnées locales
|
|
|
|
|
Tableau <Coordonnee> gi_loc_B,gi_loc_H; // bases naturelle et duale
|
|
|
|
|
Bases_naturel_duales(indirect_local,gi_loc_B,gi_loc_H);
|
|
|
|
|
Coordonnee O(0.5*(ptInteg(indirect(1))+ptInteg(indirect(2)))); //
|
|
|
|
|
Vecteur phi_z(2); // le conteneur pour les fonctions d'interpolation
|
|
|
|
|
ElemGeomC0::Coor_phi(O,gi_loc_H,ptelem(ne),phi_z,theta_loc);
|
|
|
|
|
theta(3)=theta_loc(1); // on enregistre
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// maintenant on va attribuer au noeud de la facette la valeur extrapolée
|
|
|
|
|
// maintenant on calcule les fct d'interpolation au noeud ne
|
|
|
|
|
// via ses coordonnées locales theta: on utilise le pentaèdre this
|
2023-05-03 17:23:49 +02:00
|
|
|
const Vecteur& phiphi = this->Phi_point(theta);
|
2021-09-27 12:42:13 +02:00
|
|
|
// et on enregistre
|
|
|
|
|
indir(ne).Change_taille(nbi);
|
|
|
|
|
tab(ne).Change_taille(nbi);
|
|
|
|
|
// on boucle sur les pti du pentaèdre linéaire d'interpolation
|
|
|
|
|
for (int i=1;i<7;i++)
|
|
|
|
|
{tab(ne)(indirect(i))=phiphi(i);
|
|
|
|
|
indir(ne)(i)=indirect(i);
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
// idem pour mes 3 derniers noeuds
|
|
|
|
|
for (int ne=4;ne<=6;ne++)
|
|
|
|
|
{// il nous faut calculer les coordonnées locales du noeud
|
|
|
|
|
// sachant que les pti ici considérés, sont aux sommets d'un pentaèdre linéaire orthogonal
|
|
|
|
|
// on peut traiter séparément les coordonnées dans le plan et la coordonnée z
|
|
|
|
|
|
|
|
|
|
Coordonnee theta(3); // les coordonnées que l'on cherche
|
|
|
|
|
|
|
|
|
|
// suivant x et y: calcul de theta^alpha
|
|
|
|
|
{Tableau <int> indirect_local(3); // tableau de travail
|
|
|
|
|
// on considère le triangle des 3 derniers pti
|
|
|
|
|
indirect_local(1) = indirect(4);indirect_local(2) = indirect(5);
|
|
|
|
|
indirect_local(3) = indirect(6);
|
|
|
|
|
Coordonnee theta_loc(2); // le conteneur pour les coordonnées locales en x y
|
|
|
|
|
Tableau <Coordonnee> gi_loc_B,gi_loc_H; // bases naturelle et duale
|
|
|
|
|
Bases_naturel_duales(indirect_local,gi_loc_B,gi_loc_H);
|
|
|
|
|
Coordonnee O(ptInteg(indirect(1))); //
|
|
|
|
|
Vecteur phi_xy(3); // le conteneur pour les fonctions
|
|
|
|
|
ElemGeomC0::Coor_phi(O,gi_loc_H,ptelem(ne),phi_xy,theta_loc);
|
|
|
|
|
theta(1)=theta_loc(1); // on enregistre
|
|
|
|
|
theta(2)=theta_loc(2); // on enregistre
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// suivant z: calcul de theta^3
|
|
|
|
|
{Tableau <int> indirect_local(2); // tableau de travail
|
|
|
|
|
// on considère la ligne du pti 1 -> pti 4
|
|
|
|
|
// on pourrait de la même manière choisir de 2 à 5 ou de 3 à 6
|
|
|
|
|
indirect_local(1) = indirect(1);indirect_local(2) = indirect(4);
|
|
|
|
|
Coordonnee theta_loc(1); // le conteneur pour les coordonnées locales
|
|
|
|
|
Tableau <Coordonnee> gi_loc_B,gi_loc_H; // bases naturelle et duale
|
|
|
|
|
Bases_naturel_duales(indirect_local,gi_loc_B,gi_loc_H);
|
|
|
|
|
Coordonnee O(0.5*(ptInteg(indirect(1))+ptInteg(indirect(2)))); //
|
|
|
|
|
Vecteur phi_z(2); // le conteneur pour les fonctions d'interpolation
|
|
|
|
|
ElemGeomC0::Coor_phi(O,gi_loc_H,ptelem(ne),phi_z,theta_loc);
|
|
|
|
|
theta(3)=theta_loc(1); // on enregistre
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// maintenant on va attribuer au noeud de la facette la valeur extrapolée
|
|
|
|
|
// maintenant on calcule les fct d'interpolation au noeud ne
|
|
|
|
|
// via ses coordonnées locales theta: on utilise le pentaèdre this
|
2023-05-03 17:23:49 +02:00
|
|
|
const Vecteur& phiphi = this->Phi_point(theta);
|
2021-09-27 12:42:13 +02:00
|
|
|
// et on enregistre
|
|
|
|
|
indir(ne).Change_taille(nbi);
|
|
|
|
|
tab(ne).Change_taille(nbi);
|
|
|
|
|
// on boucle sur les pti du pentaèdre linéaire d'interpolation
|
|
|
|
|
for (int i=1;i<7;i++)
|
|
|
|
|
{tab(ne)(indirect(i))=phiphi(i);
|
|
|
|
|
indir(ne)(i)=indirect(i);
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
// --- ancienne méthode
|
|
|
|
|
// on utilise systématiquement le pt d'integ le plus proche
|
|
|
|
|
// { int ne = 1; tab(ne)(1) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=1;
|
|
|
|
|
// ne = 2; tab(ne)(2) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=2;
|
|
|
|
|
// ne = 3; tab(ne)(3) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=3;
|
|
|
|
|
// ne = 4; tab(ne)(4) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=4;
|
|
|
|
|
// ne = 5; tab(ne)(5) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=5;
|
|
|
|
|
// ne = 6; tab(ne)(6) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=6;
|
|
|
|
|
break;
|
|
|
|
|
} // fin du cas avec 6 pt d'intégration
|
|
|
|
|
case 8: // 4 pt de surface en bas et en haut
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
// tab est supposé être initialisé à 0.
|
|
|
|
|
Tableau <Coordonnee> gi_B,gi_H; // bases naturelle et duale
|
|
|
|
|
/*
|
|
|
|
|
// --- méthode 1 (par défaut), on utilise une extrapolation linéaire dans l'épaisseur
|
|
|
|
|
// et une extrapolation linéaire dans le plan du triangle
|
|
|
|
|
// donc en fait on extrapole via un pentaèdre linéaire dont les sommets sont au niveau
|
|
|
|
|
// de 6 pti
|
|
|
|
|
// couche du bas couche du haut
|
|
|
|
|
// 4 points 4 points
|
|
|
|
|
// (3) (6)
|
|
|
|
|
// | \ | \
|
|
|
|
|
// | \ | \
|
|
|
|
|
// | 4 \ | 8 \
|
|
|
|
|
// | \ | \
|
|
|
|
|
// face 2 -> | \ <- face 5 | \
|
|
|
|
|
// | 1 \ | 5 \
|
|
|
|
|
// | \ | \
|
|
|
|
|
// | \ | \
|
|
|
|
|
// | 2 3 \ | 6 7 \
|
|
|
|
|
// |______________\ |______________\
|
|
|
|
|
// (1) (2) (4) (5)
|
|
|
|
|
// ^
|
|
|
|
|
// |
|
|
|
|
|
// face 3
|
|
|
|
|
|
|
|
|
|
// |zeta
|
|
|
|
|
// |
|
|
|
|
|
// 4---------6
|
|
|
|
|
// /| * |
|
|
|
|
|
// / | * |
|
|
|
|
|
// / | * |
|
|
|
|
|
// / |-*-------|----- eta
|
|
|
|
|
// / /| |
|
|
|
|
|
// / * | |
|
|
|
|
|
// / * / | |
|
|
|
|
|
// 5 / 1---------3
|
|
|
|
|
// | / / *
|
|
|
|
|
// | / / *
|
|
|
|
|
// |/ / *
|
|
|
|
|
// | / *
|
|
|
|
|
// /| / *
|
|
|
|
|
// xi | / *
|
|
|
|
|
// |/ *
|
|
|
|
|
// 2
|
|
|
|
|
//
|
|
|
|
|
//
|
|
|
|
|
//
|
|
|
|
|
// face 1 : noeud 1 3 2, face 2 : noeud 1 4 6 3,
|
|
|
|
|
// face 3 : noeud 1 2 5 4, face 4 : noeud 4 5 6,
|
|
|
|
|
// face 5 : noeud 2 3 6 5
|
|
|
|
|
*/
|
|
|
|
|
// on va utiliser un pentaèdre linéaire particulier par face verticale de l'élément
|
|
|
|
|
for (int iface = 1; iface <=3; iface++) // correspond aux faces 2 3 5 de l'élément
|
|
|
|
|
{// pour chaque face on définit les sommets du pentaèdre linéaire
|
|
|
|
|
Tableau <int> indirect(6); // pti concernés
|
|
|
|
|
Tableau <int> J(4); // les noeuds concernés
|
|
|
|
|
int nbn_concernes;
|
|
|
|
|
|
|
|
|
|
switch (iface)
|
|
|
|
|
{case 1: // face 2
|
|
|
|
|
{indirect(1)=4;indirect(2)=2;indirect(3)=1;
|
|
|
|
|
indirect(4)=8;indirect(5)=6;indirect(6)=5;
|
|
|
|
|
J(1)=1; J(2)=4; J(3)=6; J(4)=3;
|
|
|
|
|
nbn_concernes = 4;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 2: // face 3
|
|
|
|
|
{indirect(1)=1;indirect(2)=2;indirect(3)=3;
|
|
|
|
|
indirect(4)=5;indirect(5)=6;indirect(6)=7;
|
|
|
|
|
nbn_concernes = 2;
|
|
|
|
|
J(1)=2; J(2)=5;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 3: // face 5
|
|
|
|
|
{indirect(1)=1;indirect(2)=1;indirect(3)=3;
|
|
|
|
|
indirect(4)=5;indirect(5)=6;indirect(6)=7;
|
|
|
|
|
nbn_concernes = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
};
|
|
|
|
|
// on boucle sur les noeuds à traiter
|
|
|
|
|
for (int ine = 1;ine<= nbn_concernes; ine++)
|
|
|
|
|
{int ne = J(ine);
|
|
|
|
|
// il nous faut calculer les coordonnées locales du noeud
|
|
|
|
|
// sachant que les pti ici considérés, sont aux sommets d'un pentaèdre linéaire orthogonal
|
|
|
|
|
// on peut traiter séparément les coordonnées dans le plan et la coordonnée z
|
|
|
|
|
|
|
|
|
|
Coordonnee theta(3); // les coordonnées que l'on cherche
|
|
|
|
|
|
|
|
|
|
// suivant x et y: calcul de theta^alpha
|
|
|
|
|
{Tableau <int> indirect_local(3); // tableau de travail
|
|
|
|
|
// on considère le triangle des 3 premiers pti
|
|
|
|
|
indirect_local(1) = indirect(1);indirect_local(2) = indirect(2);
|
|
|
|
|
indirect_local(3) = indirect(3);
|
|
|
|
|
Coordonnee theta_loc(2); // le conteneur pour les coordonnées locales en x y
|
|
|
|
|
Tableau <Coordonnee> gi_loc_B,gi_loc_H; // bases naturelle et duale
|
|
|
|
|
Bases_naturel_duales(indirect_local,gi_loc_B,gi_loc_H);
|
|
|
|
|
Coordonnee O(ptInteg(indirect(1))); //
|
|
|
|
|
Vecteur phi_xy(3); // le conteneur pour les fonctions
|
|
|
|
|
ElemGeomC0::Coor_phi(O,gi_loc_H,ptelem(ne),phi_xy,theta_loc);
|
|
|
|
|
theta(1)=theta_loc(1); // on enregistre
|
|
|
|
|
theta(2)=theta_loc(2); // on enregistre
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// suivant z: calcul de theta^3
|
|
|
|
|
{Tableau <int> indirect_local(2); // tableau de travail
|
|
|
|
|
// on considère la ligne du pti 1 -> pti 5
|
|
|
|
|
indirect_local(1) = indirect(1);indirect_local(2) = indirect(4);
|
|
|
|
|
Coordonnee theta_loc(1); // le conteneur pour les coordonnées locales
|
|
|
|
|
Tableau <Coordonnee> gi_loc_B,gi_loc_H; // bases naturelle et duale
|
|
|
|
|
Bases_naturel_duales(indirect_local,gi_loc_B,gi_loc_H);
|
|
|
|
|
Coordonnee O(0.5*(ptInteg(indirect(1))+ptInteg(indirect(2)))); //
|
|
|
|
|
Vecteur phi_z(2); // le conteneur pour les fonctions d'interpolation
|
|
|
|
|
ElemGeomC0::Coor_phi(O,gi_loc_H,ptelem(ne),phi_z,theta_loc);
|
|
|
|
|
theta(3)=theta_loc(1); // on enregistre
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// maintenant on va attribuer au noeud la valeur extrapolée
|
|
|
|
|
// on calcule les fct d'interpolation au noeud ne
|
|
|
|
|
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
2023-05-03 17:23:49 +02:00
|
|
|
const Vecteur& phiphi = this->Phi_point(theta);
|
2021-09-27 12:42:13 +02:00
|
|
|
// et on enregistre
|
|
|
|
|
indir(ne).Change_taille(6);
|
|
|
|
|
tab(ne).Change_taille(nbi);
|
|
|
|
|
// on boucle sur les pti du pentaèdre linéaire d'interpolation
|
|
|
|
|
for (int i=1;i<7;i++)
|
|
|
|
|
{tab(ne)(indirect(i))=phiphi(i);
|
|
|
|
|
indir(ne)(i)=indirect(i);
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
// --- ancienne méthode
|
|
|
|
|
|
|
|
|
|
// // on utilise systématiquement le pt d'integ le plus proche
|
|
|
|
|
// { int ne = 1; tab(ne)(2) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=2;
|
|
|
|
|
// ne = 2; tab(ne)(3) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=3;
|
|
|
|
|
// ne = 3; tab(ne)(4) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=4;
|
|
|
|
|
// ne = 4; tab(ne)(6) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=6;
|
|
|
|
|
// ne = 5; tab(ne)(7) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=7;
|
|
|
|
|
// ne = 6; tab(ne)(8) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=8;
|
|
|
|
|
break;
|
|
|
|
|
} // fin du cas avec 8 pt d'intégration
|
|
|
|
|
case 9: // 3 * 3pt de surface de bas en haut
|
|
|
|
|
{ // tab est supposé être initialisé à 0.
|
|
|
|
|
Tableau <Coordonnee> gi_B,gi_H; // bases naturelle et duale
|
|
|
|
|
// --- méthode 1 (par défaut), on utilise une extrapolation linéaire dans l'épaisseur
|
|
|
|
|
// on va utiliser les 6 premiers pti pour définir un penta linéaire
|
|
|
|
|
// qui servira pour les noeuds du bas et du milieu
|
|
|
|
|
// NB: en fait pour les noeuds du milieu, compte tenu qu'ils sont
|
|
|
|
|
// exactement au même niveau que les pti 4 5 5, ce sera uniquement ceux là
|
|
|
|
|
// qui seront interpolé,
|
|
|
|
|
// puis avec les pti de 4 à 9 on définit le second penta linéaire
|
|
|
|
|
// pour interpoler les noeuds du haut
|
|
|
|
|
{Tableau<Tableau<int> > & indir = extrapol(1).indir; // pour simplifier
|
|
|
|
|
Tableau<Tableau<double > > & tab = extrapol(1).tab; // pour simplifier
|
|
|
|
|
tab.Change_taille(NBNE);indir.Change_taille(NBNE);
|
|
|
|
|
|
|
|
|
|
Tableau <int> indirect(nbi); // tableau de travail: on a 6 pondérations
|
|
|
|
|
for (int inappe = 1; inappe <=2; inappe++)
|
|
|
|
|
{Tableau <int> J(9); // les noeuds concernés
|
|
|
|
|
int nbn_concernes;
|
|
|
|
|
switch (inappe)
|
|
|
|
|
{case 1: // nappe de noeuds du bas
|
|
|
|
|
{nbn_concernes = 3;
|
|
|
|
|
J(1)=1; J(2)=2;
|
|
|
|
|
J(3)=3;
|
|
|
|
|
// même numérotation des pti pour les 6 premiers pti
|
|
|
|
|
for (int i=1;i<=6;i++)
|
|
|
|
|
indirect(i) = i;
|
|
|
|
|
};
|
|
|
|
|
break;
|
|
|
|
|
case 2: // nappe de noeuds du milieu
|
|
|
|
|
{nbn_concernes = 3;
|
|
|
|
|
J(1)=4; J(2)=5; J(3)=6;
|
|
|
|
|
// les pti pour le penta linéaire
|
|
|
|
|
for (int i=1;i<=6;i++)
|
|
|
|
|
indirect(i) = i+3;
|
|
|
|
|
};
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
};
|
|
|
|
|
// on traite tous les noeuds de la même manière
|
|
|
|
|
for (int ine = 1;ine<= nbn_concernes; ine++)
|
|
|
|
|
{int ne = J(ine);
|
|
|
|
|
// il nous faut calculer les coordonnées locales du noeud
|
|
|
|
|
// sachant que les pti ici considérés, sont aux sommets d'un pentaèdre linéaire orthogonal
|
|
|
|
|
// on peut traiter séparément les coordonnées dans le plan et la coordonnée z
|
|
|
|
|
|
|
|
|
|
Coordonnee theta(3); // les coordonnées que l'on cherche
|
|
|
|
|
|
|
|
|
|
// suivant x et y: calcul de theta^alpha
|
|
|
|
|
{Tableau <int> indirect_local(3); // tableau de travail
|
|
|
|
|
// on considère le triangle des 3 premiers pti
|
|
|
|
|
indirect_local(1) = indirect(1);indirect_local(2) = indirect(2);
|
|
|
|
|
indirect_local(3) = indirect(3);
|
|
|
|
|
Coordonnee theta_loc(2); // le conteneur pour les coordonnées locales en x y
|
|
|
|
|
Tableau <Coordonnee> gi_loc_B,gi_loc_H; // bases naturelle et duale
|
|
|
|
|
Bases_naturel_duales(indirect_local,gi_loc_B,gi_loc_H);
|
|
|
|
|
Coordonnee O(ptInteg(indirect(1))); //
|
|
|
|
|
Vecteur phi_xy(3); // le conteneur pour les fonctions
|
|
|
|
|
ElemGeomC0::Coor_phi(O,gi_loc_H,ptelem(ne),phi_xy,theta_loc);
|
|
|
|
|
theta(1)=theta_loc(1); // on enregistre
|
|
|
|
|
theta(2)=theta_loc(2); // on enregistre
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// suivant z: calcul de theta^3
|
|
|
|
|
{Tableau <int> indirect_local(2); // tableau de travail
|
|
|
|
|
// on considère la ligne du pti 1 -> pti 4
|
|
|
|
|
indirect_local(1) = indirect(1);indirect_local(2) = indirect(4);
|
|
|
|
|
Coordonnee theta_loc(1); // le conteneur pour les coordonnées locales
|
|
|
|
|
Tableau <Coordonnee> gi_loc_B,gi_loc_H; // bases naturelle et duale
|
|
|
|
|
Bases_naturel_duales(indirect_local,gi_loc_B,gi_loc_H);
|
|
|
|
|
Coordonnee O(0.5*(ptInteg(indirect(1))+ptInteg(indirect(2)))); //
|
|
|
|
|
Vecteur phi_z(2); // le conteneur pour les fonctions d'interpolation
|
|
|
|
|
ElemGeomC0::Coor_phi(O,gi_loc_H,ptelem(ne),phi_z,theta_loc);
|
|
|
|
|
theta(3)=theta_loc(1); // on enregistre
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// maintenant on va attribuer au noeud la valeur extrapolée
|
|
|
|
|
// on calcule les fct d'interpolation au noeud ne
|
|
|
|
|
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
2023-05-03 17:23:49 +02:00
|
|
|
const Vecteur& phiphi = this->Phi_point(theta);
|
2021-09-27 12:42:13 +02:00
|
|
|
// et on enregistre
|
|
|
|
|
indir(ne).Change_taille(nbi);
|
|
|
|
|
tab(ne).Change_taille(nbi);
|
|
|
|
|
// on boucle sur les pti du pentaèdre linéaire d'interpolation
|
|
|
|
|
for (int i=1;i<7;i++)
|
|
|
|
|
{tab(ne)(indirect(i))=phiphi(i);
|
|
|
|
|
indir(ne)(i)=indirect(i);
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// --- ancienne méthode
|
|
|
|
|
//
|
|
|
|
|
// // on utilise systématiquement le pt d'integ le plus proche
|
|
|
|
|
// { int ne = 1; tab(ne)(1) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=1;
|
|
|
|
|
// ne = 2; tab(ne)(2) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=2;
|
|
|
|
|
// ne = 3; tab(ne)(3) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=3;
|
|
|
|
|
// ne = 4; tab(ne)(7) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=7;
|
|
|
|
|
// ne = 5; tab(ne)(8) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=8;
|
|
|
|
|
// ne = 6; tab(ne)(9) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=9;
|
|
|
|
|
break;
|
|
|
|
|
} // fin du cas avec 9 pt d'intégration
|
|
|
|
|
case 12: // 3 * 4 pt de surface de bas en haut
|
|
|
|
|
{// rappel des pti pour une nappe triangle
|
|
|
|
|
// 4 pti
|
|
|
|
|
// (3)
|
|
|
|
|
// | \
|
|
|
|
|
// | \
|
|
|
|
|
// | 4 \ <- face 5 basse (2) -> (label 4)
|
|
|
|
|
// | \ hautes (2) -> (label 8)
|
|
|
|
|
// face 2 basse-> | \ <- face 5
|
|
|
|
|
// (label 1) | 1 \
|
|
|
|
|
// | \
|
|
|
|
|
// face 2 haute-> | \ <- face 5 basse (1) -> (label 3)
|
|
|
|
|
// (label 5) | 2 3 \ haute (1) -> (label 7)
|
|
|
|
|
// |______________\
|
|
|
|
|
// (1) (2)
|
|
|
|
|
// ^
|
|
|
|
|
// |
|
|
|
|
|
// face 3 basse (label 2), haute (label 6)
|
|
|
|
|
|
|
|
|
|
// tab est supposé être initialisé à 0.
|
|
|
|
|
Tableau <Coordonnee> gi_B,gi_H; // bases naturelle et duale
|
|
|
|
|
{Tableau<Tableau<int> > & indir = extrapol(1).indir; // pour simplifier
|
|
|
|
|
Tableau<Tableau<double > > & tab = extrapol(1).tab; // pour simplifier
|
|
|
|
|
tab.Change_taille(NBNE);indir.Change_taille(NBNE);
|
|
|
|
|
|
|
|
|
|
// on va utiliser un pentaèdre linéaire particulier par face verticale de l'élément
|
|
|
|
|
for (int ilabel = 1; ilabel <=8; ilabel++) // correspond aux 8 labels de l'élément
|
|
|
|
|
{// pour chaque label on définit les sommets du pentaèdre linéaire
|
|
|
|
|
Tableau <int> indirect(6); // pti concernés
|
|
|
|
|
int nbn_concernes;
|
|
|
|
|
|
|
|
|
|
Tableau <int> J(4); // les noeuds concernés
|
|
|
|
|
|
|
|
|
|
switch (ilabel)
|
|
|
|
|
{case 1: // sur la face 2 basse
|
|
|
|
|
{indirect(1)=4;indirect(2)=2;indirect(3)=1;
|
|
|
|
|
indirect(4)=8;indirect(5)=6;indirect(6)=5;
|
|
|
|
|
nbn_concernes = 2;
|
|
|
|
|
J(1)=1; J(2)=3;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 2: // sur la face 3 basse
|
|
|
|
|
{indirect(1)=1;indirect(2)=2;indirect(3)=3;
|
|
|
|
|
indirect(4)=5;indirect(5)=6;indirect(6)=7;
|
|
|
|
|
nbn_concernes = 1;
|
|
|
|
|
J(1)=2;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 3: // face 5 basse (1) -> (label 3)
|
|
|
|
|
{indirect(1)=1;indirect(2)=2;indirect(3)=3;
|
|
|
|
|
indirect(4)=5;indirect(5)=6;indirect(6)=7;
|
|
|
|
|
nbn_concernes = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 4: // face 5 basse (2) -> (label 4) : ne reste aucun noeud
|
|
|
|
|
{nbn_concernes = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 5: // sur la face 2 haute
|
|
|
|
|
{indirect(1)=8;indirect(2)=6;indirect(3)=5;
|
|
|
|
|
indirect(4)=12;indirect(5)=10;indirect(6)=9;
|
|
|
|
|
nbn_concernes = 2;
|
|
|
|
|
J(1)=4; J(2)=6;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 6: // sur la face 3 haute
|
|
|
|
|
{indirect(1)=5;indirect(2)=6;indirect(3)=7;
|
|
|
|
|
indirect(4)=9;indirect(5)=10;indirect(6)=11;
|
|
|
|
|
nbn_concernes = 1;
|
|
|
|
|
J(1)=5;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 7: // face 5 haute (1)
|
|
|
|
|
{indirect(1)=5;indirect(2)=6;indirect(3)=7;
|
|
|
|
|
indirect(4)=9;indirect(5)=10;indirect(6)=11;
|
|
|
|
|
nbn_concernes = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 8: // face 5 haute (2)
|
|
|
|
|
{nbn_concernes = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
};
|
|
|
|
|
// on traite tous les noeuds de la même manière
|
|
|
|
|
for (int ine = 1;ine<= nbn_concernes; ine++)
|
|
|
|
|
{int ne = J(ine);
|
|
|
|
|
// il nous faut calculer les coordonnées locales du noeud
|
|
|
|
|
// sachant que les pti ici considérés, sont aux sommets d'un pentaèdre linéaire orthogonal
|
|
|
|
|
// on peut traiter séparément les coordonnées dans le plan et la coordonnée z
|
|
|
|
|
|
|
|
|
|
Coordonnee theta(3); // les coordonnées que l'on cherche
|
|
|
|
|
|
|
|
|
|
// suivant x et y: calcul de theta^alpha
|
|
|
|
|
{Tableau <int> indirect_local(3); // tableau de travail
|
|
|
|
|
// on considère le triangle des 3 premiers pti
|
|
|
|
|
indirect_local(1) = indirect(1);indirect_local(2) = indirect(2);
|
|
|
|
|
indirect_local(3) = indirect(3);
|
|
|
|
|
Coordonnee theta_loc(2); // le conteneur pour les coordonnées locales en x y
|
|
|
|
|
Tableau <Coordonnee> gi_loc_B,gi_loc_H; // bases naturelle et duale
|
|
|
|
|
Bases_naturel_duales(indirect_local,gi_loc_B,gi_loc_H);
|
|
|
|
|
Coordonnee O(ptInteg(indirect(1))); //
|
|
|
|
|
Vecteur phi_xy(3); // le conteneur pour les fonctions
|
|
|
|
|
ElemGeomC0::Coor_phi(O,gi_loc_H,ptelem(ne),phi_xy,theta_loc);
|
|
|
|
|
theta(1)=theta_loc(1); // on enregistre
|
|
|
|
|
theta(2)=theta_loc(2); // on enregistre
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// suivant z: calcul de theta^3
|
|
|
|
|
{Tableau <int> indirect_local(2); // tableau de travail
|
|
|
|
|
// on considère la ligne du pti 1 -> pti 4
|
|
|
|
|
indirect_local(1) = indirect(1);indirect_local(2) = indirect(4);
|
|
|
|
|
Coordonnee theta_loc(1); // le conteneur pour les coordonnées locales
|
|
|
|
|
Tableau <Coordonnee> gi_loc_B,gi_loc_H; // bases naturelle et duale
|
|
|
|
|
Bases_naturel_duales(indirect_local,gi_loc_B,gi_loc_H);
|
|
|
|
|
Coordonnee O(0.5*(ptInteg(indirect(1))+ptInteg(indirect(2)))); //
|
|
|
|
|
Vecteur phi_z(2); // le conteneur pour les fonctions d'interpolation
|
|
|
|
|
ElemGeomC0::Coor_phi(O,gi_loc_H,ptelem(ne),phi_z,theta_loc);
|
|
|
|
|
theta(3)=theta_loc(1); // on enregistre
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// maintenant on va attribuer au noeud la valeur extrapolée
|
|
|
|
|
// on calcule les fct d'interpolation au noeud ne
|
|
|
|
|
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
2023-05-03 17:23:49 +02:00
|
|
|
const Vecteur& phiphi = this->Phi_point(theta);
|
2021-09-27 12:42:13 +02:00
|
|
|
// et on enregistre
|
|
|
|
|
indir(ne).Change_taille(nbi);
|
|
|
|
|
tab(ne).Change_taille(nbi);
|
|
|
|
|
// on boucle sur les pti du pentaèdre linéaire d'interpolation
|
|
|
|
|
for (int i=1;i<7;i++)
|
|
|
|
|
{tab(ne)(indirect(i))=phiphi(i);
|
|
|
|
|
indir(ne)(i)=indirect(i);
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// --- ancienne méthode
|
|
|
|
|
//
|
|
|
|
|
// // on utilise systématiquement le pt d'integ le plus proche
|
|
|
|
|
// { int ne = 1; tab(ne)(2) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=2;
|
|
|
|
|
// ne = 2; tab(ne)(3) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=3;
|
|
|
|
|
// ne = 3; tab(ne)(4) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=4;
|
|
|
|
|
// ne = 4; tab(ne)(10) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=10;
|
|
|
|
|
// ne = 5; tab(ne)(11) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=11;
|
|
|
|
|
// ne = 6; tab(ne)(12) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=12;
|
|
|
|
|
break;
|
|
|
|
|
} // fin du cas avec 12 pt d'intégration
|
|
|
|
|
case 18: // 3 * 6 pt de surface de bas en haut
|
|
|
|
|
{// rappel des pti pour une nappe triangle
|
|
|
|
|
// 6 pti
|
|
|
|
|
//
|
|
|
|
|
// (3)
|
|
|
|
|
// | \
|
|
|
|
|
// | \
|
|
|
|
|
// face 2 basse-> | 6 \ <- face 5 basse droite -> (label 6)
|
|
|
|
|
// gauche (1) | \ hautes droite -> (label 12)
|
|
|
|
|
// droite (2) | \ <- face 5
|
|
|
|
|
// face 2 haute-> | 2 1 \
|
|
|
|
|
// gauche (7) | \
|
|
|
|
|
// droite (8) | \ <- face 5 basse gauche -> (label 5)
|
|
|
|
|
// | 4 3 5 \ haute gauche -> (label 11)
|
|
|
|
|
// |______________\
|
|
|
|
|
// (1) (2)
|
|
|
|
|
// ^ ^
|
|
|
|
|
// | |
|
|
|
|
|
// face 3 basse gauche(3) droite (4)
|
|
|
|
|
// haute gauche(9) droite (10)
|
|
|
|
|
|
|
|
|
|
// tab est supposé être initialisé à 0.
|
|
|
|
|
Tableau <Coordonnee> gi_B,gi_H; // bases naturelle et duale
|
|
|
|
|
{Tableau<Tableau<int> > & indir = extrapol(1).indir; // pour simplifier
|
|
|
|
|
Tableau<Tableau<double > > & tab = extrapol(1).tab; // pour simplifier
|
|
|
|
|
tab.Change_taille(NBNE);indir.Change_taille(NBNE);
|
|
|
|
|
|
|
|
|
|
// on va utiliser un pentaèdre linéaire particulier par face verticale de l'élément
|
|
|
|
|
for (int ilabel = 1; ilabel <=12; ilabel++) // correspond aux 12 labels de l'élément
|
|
|
|
|
{// pour chaque label on définit les sommets du pentaèdre linéaire
|
|
|
|
|
Tableau <int> indirect(6); // pti concernés
|
|
|
|
|
int nbn_concernes;
|
|
|
|
|
|
|
|
|
|
Tableau <int> J(4); // les noeuds concernés
|
|
|
|
|
|
|
|
|
|
switch (ilabel)
|
|
|
|
|
{case 1: // sur la face 2 basse gauche
|
|
|
|
|
{indirect(1)=2;indirect(2)=1;indirect(3)=6;
|
|
|
|
|
indirect(4)=8;indirect(5)=7;indirect(6)=12;
|
|
|
|
|
nbn_concernes = 1;
|
|
|
|
|
J(1)=3;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 2: // sur la face 2 basse droite
|
|
|
|
|
{indirect(1)=2;indirect(2)=4;indirect(3)=3;
|
|
|
|
|
indirect(4)=8;indirect(5)=10;indirect(6)=9;
|
|
|
|
|
nbn_concernes = 1;
|
|
|
|
|
J(1)=1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 3: // face 3 basse gauche
|
|
|
|
|
{indirect(1)=2;indirect(2)=4;indirect(3)=3;
|
|
|
|
|
indirect(4)=8;indirect(5)=10;indirect(6)=9;
|
|
|
|
|
nbn_concernes = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 4: // face 3 basse droite
|
|
|
|
|
{indirect(1)=1;indirect(2)=3;indirect(3)=5;
|
|
|
|
|
indirect(4)=7;indirect(5)=9;indirect(6)=11;
|
|
|
|
|
nbn_concernes = 1;
|
|
|
|
|
J(1)=2;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 5: // face 5 basse gauche
|
|
|
|
|
{indirect(1)=1;indirect(2)=3;indirect(3)=5;
|
|
|
|
|
indirect(4)=7;indirect(5)=9;indirect(6)=11;
|
|
|
|
|
nbn_concernes = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 6: // face 5 basse droite
|
|
|
|
|
{indirect(1)=2;indirect(2)=1;indirect(3)=6;
|
|
|
|
|
indirect(4)=8;indirect(5)=7;indirect(6)=12;
|
|
|
|
|
nbn_concernes = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 7: // face 2 haute gauche
|
|
|
|
|
{indirect(1)=8;indirect(2)=7;indirect(3)=12;
|
|
|
|
|
indirect(4)=14;indirect(5)=13;indirect(6)=18;
|
|
|
|
|
nbn_concernes = 1;
|
|
|
|
|
J(1)=6;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 8: // face 2 haute droite
|
|
|
|
|
{indirect(1)=8;indirect(2)=10;indirect(3)=9;
|
|
|
|
|
indirect(4)=14;indirect(5)=16;indirect(6)=15;
|
|
|
|
|
nbn_concernes = 1;
|
|
|
|
|
J(1)=4;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 9: // face 3 haute gauche
|
|
|
|
|
{indirect(1)=8;indirect(2)=10;indirect(3)=9;
|
|
|
|
|
indirect(4)=14;indirect(5)=16;indirect(6)=15;
|
|
|
|
|
nbn_concernes = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 10: // face 3 haute droite
|
|
|
|
|
{indirect(1)=7;indirect(2)=9;indirect(3)=11;
|
|
|
|
|
indirect(4)=13;indirect(5)=15;indirect(6)=17;
|
|
|
|
|
nbn_concernes = 1;
|
|
|
|
|
J(1)=5;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 11: // face 5 haute gauche
|
|
|
|
|
{indirect(1)=8;indirect(2)=10;indirect(3)=9;
|
|
|
|
|
indirect(4)=14;indirect(5)=16;indirect(6)=15;
|
|
|
|
|
nbn_concernes = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case 12: // face 5 haute droite
|
|
|
|
|
{nbn_concernes = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
};
|
|
|
|
|
// on traite tous les noeuds de la même manière
|
|
|
|
|
for (int ine = 1;ine<= nbn_concernes; ine++)
|
|
|
|
|
{int ne = J(ine);
|
|
|
|
|
// il nous faut calculer les coordonnées locales du noeud
|
|
|
|
|
// sachant que les pti ici considérés, sont aux sommets d'un pentaèdre linéaire orthogonal
|
|
|
|
|
// on peut traiter séparément les coordonnées dans le plan et la coordonnée
|
|
|
|
|
Coordonnee theta(3); // les coordonnées que l'on cherche
|
|
|
|
|
|
|
|
|
|
// suivant x et y: calcul de theta^alpha
|
|
|
|
|
{Tableau <int> indirect_local(3); // tableau de travail
|
|
|
|
|
// on considère le triangle des 3 premiers pti
|
|
|
|
|
indirect_local(1) = indirect(1);indirect_local(2) = indirect(2);
|
|
|
|
|
indirect_local(3) = indirect(3);
|
|
|
|
|
Coordonnee theta_loc(2); // le conteneur pour les coordonnées locales en x y
|
|
|
|
|
Tableau <Coordonnee> gi_loc_B,gi_loc_H; // bases naturelle et duale
|
|
|
|
|
Bases_naturel_duales(indirect_local,gi_loc_B,gi_loc_H);
|
|
|
|
|
Coordonnee O(ptInteg(indirect(1))); //
|
|
|
|
|
Vecteur phi_xy(3); // le conteneur pour les fonctions
|
|
|
|
|
ElemGeomC0::Coor_phi(O,gi_loc_H,ptelem(ne),phi_xy,theta_loc);
|
|
|
|
|
theta(1)=theta_loc(1); // on enregistre
|
|
|
|
|
theta(2)=theta_loc(2); // on enregistre
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// suivant z: calcul de theta^3
|
|
|
|
|
{Tableau <int> indirect_local(2); // tableau de travail
|
|
|
|
|
// on considère la ligne du pti 1 -> pti 4
|
|
|
|
|
indirect_local(1) = indirect(1);indirect_local(2) = indirect(4);
|
|
|
|
|
Coordonnee theta_loc(1); // le conteneur pour les coordonnées locales
|
|
|
|
|
Tableau <Coordonnee> gi_loc_B,gi_loc_H; // bases naturelle et duale
|
|
|
|
|
Bases_naturel_duales(indirect_local,gi_loc_B,gi_loc_H);
|
|
|
|
|
Coordonnee O(0.5*(ptInteg(indirect(1))+ptInteg(indirect(2)))); //
|
|
|
|
|
Vecteur phi_z(2); // le conteneur pour les fonctions d'interpolation
|
|
|
|
|
ElemGeomC0::Coor_phi(O,gi_loc_H,ptelem(ne),phi_z,theta_loc);
|
|
|
|
|
theta(3)=theta_loc(1); // on enregistre
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// maintenant on va attribuer au noeud la valeur extrapolée
|
|
|
|
|
// on calcule les fct d'interpolation au noeud ne
|
|
|
|
|
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
2023-05-03 17:23:49 +02:00
|
|
|
const Vecteur& phiphi = this->Phi_point(theta);
|
2021-09-27 12:42:13 +02:00
|
|
|
// et on enregistre
|
|
|
|
|
indir(ne).Change_taille(nbi);
|
|
|
|
|
tab(ne).Change_taille(nbi);
|
|
|
|
|
// on boucle sur les pti du pentaèdre linéaire d'interpolation
|
|
|
|
|
for (int i=1;i<7;i++)
|
|
|
|
|
{tab(ne)(indirect(i))=phiphi(i);
|
|
|
|
|
indir(ne)(i)=indirect(i);
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// --- ancienne méthode
|
|
|
|
|
//
|
|
|
|
|
//
|
|
|
|
|
// // on utilise systématiquement le pt d'integ le plus proche
|
|
|
|
|
// { int ne = 1; tab(ne)(4) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=4;
|
|
|
|
|
// ne = 2; tab(ne)(5) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=5;
|
|
|
|
|
// ne = 3; tab(ne)(6) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=6;
|
|
|
|
|
// ne = 4; tab(ne)(16) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=16;
|
|
|
|
|
// ne = 5; tab(ne)(17) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=17;
|
|
|
|
|
// ne = 6; tab(ne)(18) = 1.;indir(ne).Change_taille(1); indir(ne)(1)=18;
|
|
|
|
|
break;
|
|
|
|
|
} // fin du cas avec 18 pt d'intégration
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
{ cout << "\n erreur le nombre de point d'integration demande : " << nbi <<" n\'est pas implante "
|
|
|
|
|
<< "\nGeomPentaL::Calcul_extrapol(int nbi)";
|
|
|
|
|
Sortie(1);
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
