243 lines
11 KiB
C++
243 lines
11 KiB
C++
|
|
// This file is part of the Herezh++ application.
|
|
//
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
// of mechanics for large transformations of solid structures.
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
//
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
//
|
|
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
|
// AUTHOR : Gérard Rio
|
|
// E-MAIL : gerardrio56@free.fr
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License,
|
|
// or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
//
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
|
|
|
//#include "Debug.h"
|
|
|
|
#include "GeomTetraCom.h"
|
|
#include <math.h>
|
|
#include "GeomSeg.h"
|
|
#include "GeomQuadrangle.h"
|
|
#include "MathUtil.h"
|
|
|
|
// constructeur
|
|
// le constructeur par défaut ne doit pas être utilisé
|
|
GeomTetraCom::GeomTetraCom()
|
|
{ cout << "\n erreur le constructeur par défaut ne doit pas être utilisé " ;
|
|
cout << "\nGeomTetraCom::GeomTetraCom() " << endl;
|
|
Sortie(1);
|
|
};
|
|
// il y a 1 points d'integration par défaut
|
|
// nbi : le nombre de point d'intégration voulu
|
|
// dimension de l'espace : 3, 4 faces, 6 arêtes
|
|
GeomTetraCom::GeomTetraCom(int nbi, int nbe, Enum_interpol interpol) :
|
|
ElemGeomC0(3,nbi,nbe,4,6,TETRAEDRE,interpol)
|
|
{// coordonnees des points et poids d'integration
|
|
switch (nbi)
|
|
{case 1 :
|
|
{ // 1 point : (ordre 1)
|
|
double a = 1./4.;
|
|
ptInteg(1) = Coordonnee(a,a,a);
|
|
WI(1)= 1./6.;
|
|
break;
|
|
}
|
|
case 4 :
|
|
{ // 4 points : (ordre 2)
|
|
double a = (5. - sqrt(5.))/20.; double b = (5.+3.*sqrt(5.))/20.;
|
|
ptInteg(1) = Coordonnee(a,a,a);
|
|
ptInteg(2) = Coordonnee(a,a,b);
|
|
ptInteg(3) = Coordonnee(a,b,a);
|
|
ptInteg(4) = Coordonnee(b,a,a);
|
|
for (int i =1;i<=nbi;i++)
|
|
WI(i)= 1./24.;
|
|
break;
|
|
}
|
|
case 5 :
|
|
{ // 5 points : (ordre 3)
|
|
double a = 1./4.; double b=1./6.; double c = 1./2.;
|
|
ptInteg(1) = Coordonnee(a,a,a);
|
|
ptInteg(2) = Coordonnee(b,b,b);
|
|
ptInteg(3) = Coordonnee(b,b,c);
|
|
ptInteg(4) = Coordonnee(b,c,b);
|
|
ptInteg(5) = Coordonnee(c,b,b);
|
|
WI(1)= -2./15.;
|
|
for (int i =2;i<=Nbi();i++)
|
|
WI(i)= 3./40.;
|
|
break;
|
|
}
|
|
case 15 : // formule page 371 de Dhatt et Touzot en tenant compte d'une modif (dans les i !),
|
|
{ // 15 points : (ordre 5)
|
|
double a = 1./4.; double b1=(7.+sqrt(15.))/34.;
|
|
double b2=(7.-sqrt(15.))/34.;double c1=(13.+3.*sqrt(15.))/34.;
|
|
double c2=(13.-3.*sqrt(15.))/34.;double d=(5.-sqrt(15.))/20.;
|
|
double e=(5.+sqrt(15.))/20.;
|
|
ptInteg(1) = Coordonnee(a,a,a);
|
|
ptInteg(2) = Coordonnee(b2,b2,b2);
|
|
ptInteg(3) = Coordonnee(c1,b2,b2);
|
|
ptInteg(4) = Coordonnee(b2,c1,b2);
|
|
ptInteg(5) = Coordonnee(b2,b2,c1);
|
|
ptInteg(6) = Coordonnee(b1,b1,b1);
|
|
ptInteg(7) = Coordonnee(c2,b1,b1);
|
|
ptInteg(8) = Coordonnee(b1,c2,b1);
|
|
ptInteg(9) = Coordonnee(b1,b1,c2);
|
|
ptInteg(10) = Coordonnee(d,d,e);
|
|
ptInteg(11) = Coordonnee(d,e,d);
|
|
ptInteg(12) = Coordonnee(e,d,d);
|
|
ptInteg(13) = Coordonnee(d,e,e);
|
|
ptInteg(14) = Coordonnee(e,d,e);
|
|
ptInteg(15) = Coordonnee(e,e,d);
|
|
WI(1)= 8./405.;
|
|
WI(2)= (2665.+ 14.)/226800.;
|
|
WI(3)= (2665.- 14.)/226800.;
|
|
for (int i =4;i<=Nbi();i++)
|
|
WI(i)= 5./567.;
|
|
break;
|
|
}
|
|
default :
|
|
{ cout << "\nErreur : valeur incorrecte du nombre de points d'intégration demandé ! nbi = \n"
|
|
<< nbi << '\n';
|
|
cout << "GeomTetraCom::GeomTetraCom(int nbi, int nbe)" << endl;
|
|
Sortie(1);
|
|
}
|
|
};
|
|
};
|
|
|
|
|
|
// destructeur
|
|
GeomTetraCom::~GeomTetraCom()
|
|
{
|
|
};
|
|
// constructeur de copie
|
|
GeomTetraCom::GeomTetraCom(const GeomTetraCom& a) :
|
|
ElemGeomC0(a)
|
|
{
|
|
};
|
|
|
|
|
|
|
|
// en fonction de coordonnees locales, retourne true si le point est a l'interieur
|
|
// de l'element, false sinon
|
|
bool GeomTetraCom::Interieur(const Coordonnee& M)
|
|
{ if (Dabs(M(3)) <= 1.)
|
|
// tout d'abord il faut que la troisième coordonnée soit comprise entre 0 et 1
|
|
// si oui le triangle horizontale équivalent a des maxi qui vont de 0 à 0.- M(3)
|
|
{if (Dabs(M(2)) <= 1.-M(3))
|
|
// deuxième condition il faut que le y soit compris entre 0 et 1.-z
|
|
// d'où un x qui doit être compris entre 0 et 1.-y-z
|
|
{if (Dabs(M(1)) <= 1.-M(3)-M(2))
|
|
return true;
|
|
};
|
|
};
|
|
return false;
|
|
};
|
|
|
|
// en fonction de coordonnees locales, retourne le point local P, maximum intérieur à l'élément, donc sur la frontière
|
|
// dont les coordonnées sont sur la droite GM: c-a-d GP = alpha GM, avec apha maxi et P appartenant à la frontière
|
|
// de l'élément, G étant le centre de gravité, sauf si GM est nul, dans ce cas retour de M
|
|
Coordonnee GeomTetraCom::Maxi_Coor_dans_directionGM(const Coordonnee& M)
|
|
{ // le principe est de faire un traitement en fonction du secteur dans lequel se trouve le point
|
|
double x=M(1); double y=M(2); double z=M(3);
|
|
// on appelle G le centre de gravité, A(1,0,0), B(0,1,0), C(0,0,0), D(0,0,1)
|
|
double unquart = 0.25;
|
|
Coordonnee G(unquart,unquart,unquart);
|
|
//
|
|
if ((x+y+2.*z-1. >=0.) && (2.*x + y +z -1 >=0.) && (x+2.*y+z-1. >= 0))
|
|
{ // cas où l'on est dans le secteur limité par les demies droites ]A,G] et ]B,G] et ]D,G]
|
|
// méthodologie:
|
|
//1) on calcul la normale au plan: GAB->proportionnelle à (1,1,2), on doit être à l'avant de ce plan: AM.N >= 0 -> x+y+2z-1 >=0
|
|
//2) on calcul la normale au plan: GBD->proportionnelle à (2,1,1), on doit être à l'avant de ce plan: BM.N >= 0 -> 2x+y+z-1 >=0
|
|
//3) on calcul la normale au plan: GDA->proportionnelle à (1,2,1), on doit être à l'avant de ce plan: DM.N >= 0 -> x+2y+z-1 >= 0
|
|
// si les 3 conditions sont ok => on doit prolonger la doite GM en un point M' appartenant au plan qui passe par ABD, de normale prop à (1,1,1)
|
|
// GM'. N = alpha * GM . N = GA . N = 0.25<3,-1,-1>(1;1;1) = 0.25 = alpha * (x+y+z - 3/4) d'où alpha et M'
|
|
|
|
double unsSurAlpha = (x+y+z-0.75)/0.25;
|
|
// on utilise un sur alpha au lieu d'alpha pour éviter d'avoir une division par 0 au niveau du calcul d'alpha
|
|
if (Dabs(unsSurAlpha) >= ConstMath::grand)
|
|
//si alpha est trop petit cela signifie que M est près de G,
|
|
{ return M;}
|
|
else
|
|
{ return (Coordonnee((M-G)/unsSurAlpha + G));}
|
|
}
|
|
|
|
else if ((2.*x+y+z-1. <= 0.) && (-x + z >= 0.) && (-x + y >= 0))
|
|
{// cas où l'on est dans le secteur limité par les demies droites ]C,G], ]B,G], ]D,G]
|
|
// méthodologie:
|
|
//1) on calcul la normale au plan: GCD->proportionnelle à (-1,1,0), on doit être à l'avant de ce plan: CM.N >= 0 -> -x + y >= 0
|
|
//2) on calcul la normale au plan: GBC->proportionnelle à (-1,0,1), on doit être à l'avant de ce plan: CM.N >= 0 -> -x + z >= 0.
|
|
//3) on calcul la normale au plan: BGD->proportionnelle à (-2,-1,-1), on doit être à l'avant de ce plan: BM.N >= 0 -> 2x+y+z-1. <= 0.
|
|
// si les 3 conditions sont ok => on doit prolonger la doite GM en un point M' appartenant au plan qui passe par BCD, de normale prop à (1,0,0)
|
|
// GM'. N = alpha * GM . N = GC . N = -0.25 = alpha * (x-0.25) d'où alpha et M'
|
|
|
|
double unsSurAlpha = (0.25-x)/0.25;
|
|
// on utilise un sur alpha au lieu d'alpha pour éviter d'avoir une division par 0 au niveau du calcul d'alpha
|
|
if (Dabs(unsSurAlpha) >= ConstMath::grand)
|
|
//si alpha est trop petit cela signifie que M est près de G,
|
|
{ return M;}
|
|
else
|
|
{ return (Coordonnee((M-G)/unsSurAlpha + G));}
|
|
}
|
|
else if ((x-y >= 0.) && (x+2.*y+z -1. <= 0.) && (-y + z >= 0))
|
|
{// cas où l'on est dans le secteur limité par les demies droites ]C,G], ]A,G], ]D,G]
|
|
// méthodologie:
|
|
//1) on calcul la normale au plan: CGD->proportionnelle à (1,-1,0), on doit être à l'avant de ce plan: CM.N >= 0 -> x - y >= 0
|
|
//2) on calcul la normale au plan: AGD->proportionnelle à (-1,-2,-1), on doit être à l'avant de ce plan: CM.N >= 0 -> x+2.*y+z <== 0.
|
|
//3) on calcul la normale au plan: AGC->proportionnelle à (0,-1,1), on doit être à l'avant de ce plan: BM.N >= 0 -> -y+z >= 0.
|
|
// si les 3 conditions sont ok => on doit prolonger la doite GM en un point M' appartenant au plan qui passe par ACD, de normale prop à (0,1,0)
|
|
// GM'. N = alpha * GM . N = GC . N = -0.25 = alpha * (y-0.25) d'où alpha et M'
|
|
|
|
double unsSurAlpha = (0.25-y)/0.25;
|
|
// on utilise un sur alpha au lieu d'alpha pour éviter d'avoir une division par 0 au niveau du calcul d'alpha
|
|
if (Dabs(unsSurAlpha) >= ConstMath::grand)
|
|
//si alpha est trop petit cela signifie que M est près de G,
|
|
{ return M;}
|
|
else
|
|
{ return (Coordonnee((M-G)/unsSurAlpha + G));}
|
|
}
|
|
|
|
else if ((x+y+2.*z -1. <= 0.) && (x-z >= 0.) && (y-z >= 0.))
|
|
{// cas où l'on est dans le secteur limité par les demies droites ]A,G], ]B,G], ]C,G]
|
|
// méthodologie:
|
|
//1) on calcul la normale au plan: AGB->proportionnelle à (-1,-1,-2), on doit être à l'avant de ce plan: CM.N >= x+y+2.*z <= 0.
|
|
//2) on calcul la normale au plan: BGC->proportionnelle à (1,0,-1), on doit être à l'avant de ce plan: CM.N >= 0 -> x-z >= 0.
|
|
//3) on calcul la normale au plan: CGA->proportionnelle à (0,1,-1), on doit être à l'avant de ce plan: BM.N >= 0 -> y-z >= 0.
|
|
// si les 3 conditions sont ok => on doit prolonger la doite GM en un point M' appartenant au plan qui passe par ABC, de normale prop à (0,0,1)
|
|
// GM'. N = alpha * GM . N = GC . N = 0.25 = alpha * (z-0.25) d'où alpha et M'
|
|
|
|
double unsSurAlpha = (z-0.25)/0.25;
|
|
// on utilise un sur alpha au lieu d'alpha pour éviter d'avoir une division par 0 au niveau du calcul d'alpha
|
|
if (Dabs(unsSurAlpha) >= ConstMath::grand)
|
|
//si alpha est trop petit cela signifie que M est près de G,
|
|
{ return M;}
|
|
else
|
|
{ return (Coordonnee((M-G)/unsSurAlpha + G));}
|
|
}
|
|
|
|
// cas qui ne doit jamais arriver car on se situe forcément dans un des trois secteurs
|
|
// précédemment étudiés
|
|
cout << "\n erreur inconnue !!"
|
|
<< "\n GeomTetraCom::Maxi_Coor_dans_directionGM(..";
|
|
Sortie(1);
|
|
return M; // pour éviter un warning
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|