425 lines
17 KiB
C++
425 lines
17 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-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 "FrontSegQuad.h"
|
||
|
|
#include "Base.h"
|
||
|
|
#include "MathUtil.h"
|
||
|
|
#include "FrontPointF.h"
|
||
|
|
#include "Met_biellette.h"
|
||
|
|
#include "MetAxisymetrique2D.h"
|
||
|
|
#include "Util.h"
|
||
|
|
|
||
|
|
//----------------------------------------------------------------
|
||
|
|
// def des donnees commune a tous les elements
|
||
|
|
//----------------------------------------------------------------
|
||
|
|
// 2 points d'integration et 3 noeuds
|
||
|
|
GeomSeg FrontSegQuad::segment(2,3);
|
||
|
|
Met_abstraite * FrontSegQuad::met = NULL;
|
||
|
|
Vecteur FrontSegQuad::phi(3);
|
||
|
|
Mat_pleine FrontSegQuad::dphi(1,3);
|
||
|
|
BaseB FrontSegQuad::giB;
|
||
|
|
BaseH FrontSegQuad::giH;
|
||
|
|
|
||
|
|
// CONSTRUCTEURS :
|
||
|
|
FrontSegQuad::FrontSegQuad () : // par defaut
|
||
|
|
ElFrontiere()
|
||
|
|
{ cout << "\n erreur, ce constructeur ne doit pas etre utilise "
|
||
|
|
<< "\nFrontSegQuad::FrontSegQuad ()" << endl;
|
||
|
|
Sortie(1);
|
||
|
|
};
|
||
|
|
// fonction du tableau des noeuds sommets
|
||
|
|
FrontSegQuad::FrontSegQuad ( const Tableau <Noeud *>& tab, const DdlElement& ddlElem) :
|
||
|
|
ElFrontiere(tab,ddlElem,3),
|
||
|
|
refP(tab(1)->Dimension()),droite (tab(1)->Dimension()),theta(1),theta_repere(1)
|
||
|
|
,d_T()
|
||
|
|
{ // au premier appel on construit la metrique associee
|
||
|
|
if ( met == NULL)
|
||
|
|
DefMetrique();
|
||
|
|
// définition de d_T
|
||
|
|
int nb_ddl = 3 * tab(1)->Coord0().Dimension();
|
||
|
|
d_T.Change_taille(nb_ddl);
|
||
|
|
};
|
||
|
|
// de copie
|
||
|
|
FrontSegQuad::FrontSegQuad( const FrontSegQuad& a) :
|
||
|
|
ElFrontiere(a),refP(a.refP),droite(a.droite),theta(a.theta),theta_repere(a.theta_repere)
|
||
|
|
,d_T(a.d_T)
|
||
|
|
{};
|
||
|
|
|
||
|
|
// DESTRUCTEUR :
|
||
|
|
FrontSegQuad::~FrontSegQuad ()
|
||
|
|
{};
|
||
|
|
// surcharge de l'affectation
|
||
|
|
ElFrontiere& FrontSegQuad::operator = ( const ElFrontiere& a)
|
||
|
|
{ if (this->TypeFrontiere() == a.TypeFrontiere())
|
||
|
|
{ this->ElFrontiere::operator=(a);
|
||
|
|
const FrontSegQuad* b = (const FrontSegQuad*) &a;
|
||
|
|
refP = Ref(); droite = b->DR(); theta = b->Theta();
|
||
|
|
theta_repere = b->theta_repere;
|
||
|
|
d_T=b->d_T;
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ cout << "\n erreur d\'affectation, le deux membres non pas le meme type ";
|
||
|
|
cout << "\n FrontSegQuad& ElFrontiere::operator = (ElFrontiere& a) " << endl;
|
||
|
|
Sortie (1);
|
||
|
|
return *this;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// retourne le type de l'element frontiere
|
||
|
|
string FrontSegQuad::TypeFrontiere() const
|
||
|
|
{ return string("FrontSegQuad");};
|
||
|
|
|
||
|
|
// creation d'un nouvelle element frontiere du type FrontSegQuad
|
||
|
|
ElFrontiere * FrontSegQuad::NevezElemFront() const
|
||
|
|
{ ElFrontiere * pt;
|
||
|
|
pt = new FrontSegQuad(*this);
|
||
|
|
return pt;
|
||
|
|
};
|
||
|
|
// creation d'un nouvelle element frontiere du type FrontSegQuad
|
||
|
|
// avec des donnees differentes
|
||
|
|
ElFrontiere * FrontSegQuad::NevezElemFront
|
||
|
|
( const Tableau <Noeud *>& tab, const DdlElement& ddlElem ) const
|
||
|
|
{ ElFrontiere * pt;
|
||
|
|
pt = new FrontSegQuad(tab,ddlElem);
|
||
|
|
return pt;
|
||
|
|
};
|
||
|
|
// ramene et calcul les coordonnees du point de reference de l'element
|
||
|
|
Coordonnee FrontSegQuad::Ref()
|
||
|
|
{ // le point de ref en coordonnees locale
|
||
|
|
Coordonnee A0(0.);
|
||
|
|
// appel de la routine de metrique, 3 noeuds
|
||
|
|
refP = met->PointM_tdt(tabNoeud,segment.Phi(A0));
|
||
|
|
return refP;
|
||
|
|
};
|
||
|
|
// ramene une droite tangente au point de reference
|
||
|
|
// si indic = 1 -> une droite
|
||
|
|
// ces infos sont stocke et sauvegardees dans l'element
|
||
|
|
void FrontSegQuad::TangentRef(Droite& dr, Plan& , int& indic)
|
||
|
|
{ indic = 1;
|
||
|
|
// le point de ref en coordonnees locale
|
||
|
|
Coordonnee A0(0.);
|
||
|
|
BaseB giB;
|
||
|
|
met->BaseND_tdt(tabNoeud,segment.Dphi(A0),segment.Phi(A0),giB,giH);
|
||
|
|
droite.Change_ptref(Ref());
|
||
|
|
droite.Change_vect(giB(1).Coor());
|
||
|
|
theta(1) = 0.;theta_repere=theta;
|
||
|
|
dr = droite;
|
||
|
|
};
|
||
|
|
// M est un point de la derniere droite tangente sauvegarde dans l'element
|
||
|
|
// - calcul du point M1 correspondant sur la courbe , M1 est stocke
|
||
|
|
// _ calcul et retour de la droite tangente au point M1
|
||
|
|
// si indic = 1 -> une droite
|
||
|
|
// ces infos sont stocke et sauvegardees dans l'element
|
||
|
|
void FrontSegQuad::Tangent(const Coordonnee& M,Coordonnee& M1, Droite& dr, Plan& , int& indic)
|
||
|
|
{ // récup des bases au point courant projeté
|
||
|
|
met->BaseND_tdt(tabNoeud,segment.Dphi(theta_repere),segment.Phi(theta_repere),giB,giH);
|
||
|
|
// on incremente la coordonnee curviligne
|
||
|
|
Coordonnee M1M = M - droite.PointDroite();
|
||
|
|
theta(1) += M1M * giH.Coordo(1);
|
||
|
|
|
||
|
|
|
||
|
|
// dans le cas où le point est externe à l'élément, on limite le repère de calcul au point externe
|
||
|
|
// de l'élément dans la direction de theta
|
||
|
|
if (!(segment.Interieur(theta)))
|
||
|
|
// calcul d'un point extreme de l'élément dans le sens de M
|
||
|
|
{ theta_repere = segment.Maxi_Coor_dans_directionGM(theta);
|
||
|
|
// on recalcule le repère local
|
||
|
|
phi = segment.Phi(theta_repere); // fonctions d'interpolation au point limite dans l'élément
|
||
|
|
met->BaseND_tdt(tabNoeud,segment.Dphi(theta_repere),phi,giB,giH);
|
||
|
|
// on recalcule les coodonnées locales
|
||
|
|
theta(1) += M1M * giH.Coordo(1);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
// sinon le point est correcte, on peut y calculer le nouveau repère
|
||
|
|
{ theta_repere = theta;
|
||
|
|
phi = segment.Phi(theta_repere); // fonctions d'interpolation au point
|
||
|
|
met->BaseND_tdt(tabNoeud,segment.Dphi(theta_repere),phi,giB,giH);
|
||
|
|
};
|
||
|
|
|
||
|
|
// calcul du point correspondant au theta_i
|
||
|
|
Coordonnee delta_theta = theta - theta_repere;
|
||
|
|
M1 = met->PointM_tdt(tabNoeud,phi) + delta_theta(1) * giB.Coordo(1);
|
||
|
|
|
||
|
|
droite.Change_ptref(M1);
|
||
|
|
droite.Change_vect(giB(1).Coor());
|
||
|
|
// retour
|
||
|
|
dr = droite;
|
||
|
|
indic = 1;
|
||
|
|
};
|
||
|
|
|
||
|
|
// ramene une autre droite tangente genere de maniere pseudo aleatoire
|
||
|
|
// si indic = 1 -> une droite,
|
||
|
|
// ces infos sont stocke et sauvegardees dans l'element
|
||
|
|
void FrontSegQuad::AutreTangent(Droite& dr, Plan& , int& indic)
|
||
|
|
{ // on genere un nombre entre -1 et 1
|
||
|
|
nrand++; // pour avoir un nombre different
|
||
|
|
srand(nrand);
|
||
|
|
theta(1) = -1. + 2.*((double) rand())/RAND_MAX;
|
||
|
|
// dans le cas où le point est externe à l'élément, on limite le repère de calcul au point externe
|
||
|
|
// de l'élément dans la direction de theta
|
||
|
|
if (!(segment.Interieur(theta)))
|
||
|
|
// calcul d'un point extreme de l'élément dans le sens de M
|
||
|
|
{ theta_repere = segment.Maxi_Coor_dans_directionGM(theta);
|
||
|
|
// on recalcule le repère local
|
||
|
|
phi = segment.Phi(theta_repere); // fonctions d'interpolation au point limite dans l'élément
|
||
|
|
met->BaseND_tdt(tabNoeud,segment.Dphi(theta_repere),phi,giB,giH);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
// sinon le point est correcte, on peut y calculer le nouveau repère
|
||
|
|
{ theta_repere = theta;
|
||
|
|
phi = segment.Phi(theta_repere); // fonctions d'interpolation au point
|
||
|
|
met->BaseND_tdt(tabNoeud,segment.Dphi(theta_repere),phi,giB,giH);
|
||
|
|
};
|
||
|
|
|
||
|
|
// calcul du point correspondant au theta_i
|
||
|
|
Coordonnee delta_theta = theta - theta_repere;
|
||
|
|
Coordonnee M1 = met->PointM_tdt(tabNoeud,phi) + delta_theta(1) * giB.Coordo(1);
|
||
|
|
|
||
|
|
droite.Change_ptref(M1);
|
||
|
|
droite.Change_vect(giB(1).Coor());
|
||
|
|
// retour
|
||
|
|
dr = droite;
|
||
|
|
indic = 1;
|
||
|
|
};
|
||
|
|
// ramene true si le dernier point M1 est dans l'element sinon false
|
||
|
|
// le calcul est fait à eps relatif près
|
||
|
|
bool FrontSegQuad::InSurf(const double& eps) const
|
||
|
|
{
|
||
|
|
if (Dabs(theta(1)) <= 1.+eps)
|
||
|
|
return true;
|
||
|
|
else
|
||
|
|
return false;
|
||
|
|
};
|
||
|
|
// actualise et ramene le dernier plan tangent (ou droite tangente) calcule
|
||
|
|
// si indic = 1 -> une droite, =2 -> un plan
|
||
|
|
// ramène éventuellement la variation du vecteur normale pour un plan en 3D ou une ligne en 2D
|
||
|
|
// dans le cas d'une ligne en 3D ramène la variation du vecteur tangent: si var_normale = true, sinon ramène NULL
|
||
|
|
Tableau <Coordonnee >* FrontSegQuad::DernierTangent(Droite& dr, Plan& , int& indic,bool avec_var)
|
||
|
|
{
|
||
|
|
// dans le cas où le point est externe à l'élément, on limite le repère de calcul au point externe
|
||
|
|
// de l'élément dans la direction de theta
|
||
|
|
if (!(segment.Interieur(theta)))
|
||
|
|
// calcul d'un point extreme de l'élément dans le sens de M
|
||
|
|
{ theta_repere = segment.Maxi_Coor_dans_directionGM(theta);
|
||
|
|
// on recalcule le repère local
|
||
|
|
phi = segment.Phi(theta_repere); // fonctions d'interpolation au point limite dans l'élément
|
||
|
|
met->BaseND_tdt(tabNoeud,segment.Dphi(theta_repere),phi,giB,giH);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
// sinon le point est correcte, on peut y calculer le nouveau repère
|
||
|
|
{ theta_repere = theta;
|
||
|
|
phi = segment.Phi(theta_repere); // fonctions d'interpolation au point
|
||
|
|
met->BaseND_tdt(tabNoeud,segment.Dphi(theta_repere),phi,giB,giH);
|
||
|
|
};
|
||
|
|
|
||
|
|
// calcul du point correspondant au theta_i
|
||
|
|
Coordonnee delta_theta = theta - theta_repere;
|
||
|
|
Coordonnee M1 = met->PointM_tdt(tabNoeud,phi) + delta_theta(1) * giB.Coordo(1);
|
||
|
|
|
||
|
|
droite.Change_ptref(M1);
|
||
|
|
droite.Change_vect(giB(1).Coor());
|
||
|
|
// prépa retour
|
||
|
|
dr = droite;
|
||
|
|
indic = 1;
|
||
|
|
// dans le cas où l'on veut la variation du vecteur normal
|
||
|
|
Tableau <Coordonnee >* pt_varT = NULL; // par défaut
|
||
|
|
if (avec_var)
|
||
|
|
{ // calcul de la variation des vecteurs de base: donc ici d'un seul vecteur
|
||
|
|
const Tableau <BaseB>& d_giB_tdt = met->d_BaseNat_tdt(tabNoeud,segment.Dphi(theta_repere),phi);
|
||
|
|
// calcul de la variation de la tangente normée
|
||
|
|
Util::VarUnVect_coorBN( giB(1),d_giB_tdt,giB(1).Coor().Norme(),d_T);
|
||
|
|
if (ParaGlob::Dimension() == 2)
|
||
|
|
{ // dans le cas 2D on peut calculer la normale, on le fait donc
|
||
|
|
int taille = d_T.Taille();
|
||
|
|
for (int i=1;i<=taille;i++)
|
||
|
|
{ Coordonnee& dT = d_T(i); // par simplicité
|
||
|
|
double inter = dT(1);
|
||
|
|
dT(1) = -dT(2);
|
||
|
|
dT(2) = inter;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
pt_varT = &d_T;
|
||
|
|
};
|
||
|
|
// retour
|
||
|
|
return pt_varT;
|
||
|
|
};
|
||
|
|
|
||
|
|
// calcul les fonctions d'interpolation au dernier point de projection sauvegarde
|
||
|
|
const Vecteur& FrontSegQuad::Phi()
|
||
|
|
{ return segment.Phi(theta);};
|
||
|
|
|
||
|
|
// test si la position d'un point est du bon cote ( c-a-d hors matiere) ou non
|
||
|
|
// si le point est sur la surface, ramène false
|
||
|
|
// ramene true si hors matiere, sinon false
|
||
|
|
// le test sur a est executer uniquement dans les cas suivants :
|
||
|
|
// dimension 3D et frontiere 2D
|
||
|
|
// dimension 3D axi et frontière 1D
|
||
|
|
// dimension 2D et frontiere 1D
|
||
|
|
// ->>> dimension 3D et frontiere 1D, pas de verif
|
||
|
|
// ->>> autre cas ne doivent pas arriver normalement !!
|
||
|
|
// retour de r = distance du point à la surface, ligne
|
||
|
|
bool FrontSegQuad::BonCote_t( const Coordonnee& a,double& r) const // cas ou on utilise la frontiere a t
|
||
|
|
{ if ((refP.Dimension() == 2)|| (ParaGlob::AxiSymetrie()))
|
||
|
|
{ // def des infos de la droite tangente a t en theta
|
||
|
|
// devrait également marcher pour l'axisymétrie en 3D
|
||
|
|
int dim = ParaGlob::Dimension();
|
||
|
|
phi = segment.Phi(theta_repere); // fonctions d'interpolation au point
|
||
|
|
// calcul des bases et du plan tangent et de giH
|
||
|
|
met->BaseND_tdt(tabNoeud,segment.Dphi(theta_repere),phi,giB,giH);
|
||
|
|
// def des infos du plan tangent a t en theta
|
||
|
|
Coordonnee delta_theta = theta - theta_repere;
|
||
|
|
Coordonnee M1 = met->PointM_t(tabNoeud,phi) + delta_theta(1) * giB.Coordo(1);
|
||
|
|
// calcul d'un vecteur proportionnel à la normale bien oriente: c-a-d vers l'extérieur du solide
|
||
|
|
Vecteur Nor(dim); Nor(1) = giB(1)(2);Nor(2) = - giB(1)(1);
|
||
|
|
r = (M1 - a).Vect() * Nor ;
|
||
|
|
if (r < 0.)
|
||
|
|
{return true;}
|
||
|
|
else // le cas = 0 signifie que le point etait deja sur la facette donc pas hors matière
|
||
|
|
{return false;};
|
||
|
|
}
|
||
|
|
else // cas du 3D , la normale ne veut rien dire
|
||
|
|
return true;
|
||
|
|
};
|
||
|
|
|
||
|
|
bool FrontSegQuad::BonCote_tdt( const Coordonnee& a,double& r) const // cas ou on utilise la frontiere a tdt
|
||
|
|
{ if ((refP.Dimension() == 2)|| (ParaGlob::AxiSymetrie()))
|
||
|
|
// on regarde si a est du bon cote de la frontiere
|
||
|
|
{ // calcul d'un vecteur proportionnel à la normale bien oriente: c-a-d vers l'extérieur du solide
|
||
|
|
// devrait également marcher pour l'axisymétrie en 3D
|
||
|
|
int dim = ParaGlob::Dimension();
|
||
|
|
Vecteur Nor(dim); Nor(1) = droite.VecDroite()(2);Nor(2) = - droite.VecDroite()(1);
|
||
|
|
r = (droite.PointDroite() - a).Vect() * Nor ;
|
||
|
|
if (r < 0.)
|
||
|
|
{return true;}
|
||
|
|
else // le cas = 0 signifie que le point etait deja sur la facette donc pas hors matière
|
||
|
|
{return false;};
|
||
|
|
}
|
||
|
|
else // cas du 3D , la normale ne veut rien dire
|
||
|
|
return true;
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
// affichage des infos de l'elements
|
||
|
|
void FrontSegQuad::Affiche(Enum_dure temp) const
|
||
|
|
{ cout << "\n element frontiere de type FrontSegQuad , de noeuds sommets : ";
|
||
|
|
|
||
|
|
int nbn = 3;
|
||
|
|
switch (temp)
|
||
|
|
{case TEMPS_tdt: for (int i =1;i<=nbn;i++)
|
||
|
|
cout <<" noe: " << tabNoeud(i)->Num_noeud() << " "
|
||
|
|
<< tabNoeud(i)->Coord2() << ", " ; break;
|
||
|
|
case TEMPS_t : for (int i =1;i<=nbn;i++)
|
||
|
|
cout <<" noe: " << tabNoeud(i)->Num_noeud() << " "
|
||
|
|
<< tabNoeud(i)->Coord1() << ", " ; break;
|
||
|
|
case TEMPS_0 : for (int i =1;i<=nbn;i++)
|
||
|
|
cout <<" noe: " << tabNoeud(i)->Num_noeud() << " "
|
||
|
|
<< tabNoeud(i)->Coord0() << ", " ; break;
|
||
|
|
default: break;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
// creation et ramene des pointeurs sur les frontieres de l'element frontiere
|
||
|
|
// au premier appel il y a construction, ensuite on ne fait que ramener le tableau
|
||
|
|
// à moins qu'il soit effacé
|
||
|
|
Tableau <ElFrontiere*>& FrontSegQuad::Frontiere()
|
||
|
|
{if (tabfront.Taille() == 0)
|
||
|
|
{tabfront.Change_taille(3);
|
||
|
|
Tableau <Noeud *> tab(1); tab(1) = tabNoeud(1);
|
||
|
|
DdlElement ddlE(1);
|
||
|
|
ddlE.Change_un_ddlNoeudElement(1,ddlElem(1));
|
||
|
|
// ddlE(1) = ddlElem(1);
|
||
|
|
tabfront(1) = new FrontPointF(tab,ddlE);
|
||
|
|
tab(1) = tabNoeud(2);
|
||
|
|
ddlE.Change_un_ddlNoeudElement(1,ddlElem(2));
|
||
|
|
// ddlE(1) = ddlElem(2);
|
||
|
|
tabfront(2) = new FrontPointF(tab,ddlE);
|
||
|
|
tab(1) = tabNoeud(3);
|
||
|
|
ddlE.Change_un_ddlNoeudElement(1,ddlElem(3));
|
||
|
|
// ddlE(1) = ddlElem(3);
|
||
|
|
tabfront(3) = new FrontPointF(tab,ddlE);
|
||
|
|
}
|
||
|
|
return tabfront;
|
||
|
|
};
|
||
|
|
|
||
|
|
// cas d'un élément frontière ligne:
|
||
|
|
// ramène, une longueur approximative de l'élément (toujours > 0) : calculée à l'aide
|
||
|
|
// de la ligne représentée par une suite de segments rejoignants les noeuds
|
||
|
|
// ramène une valeur nulle, s'il n'y a pas de ligne
|
||
|
|
double FrontSegQuad::LongueurApprox()
|
||
|
|
{ double longueur = 0.;
|
||
|
|
if (tabNoeud(1)->ExisteCoord2())
|
||
|
|
{longueur = (tabNoeud(1)->Coord2() - tabNoeud(2)->Coord2()).Norme()
|
||
|
|
+ (tabNoeud(2)->Coord2() - tabNoeud(3)->Coord2()).Norme();
|
||
|
|
}
|
||
|
|
else if(tabNoeud(1)->ExisteCoord1())
|
||
|
|
{longueur = (tabNoeud(1)->Coord1() - tabNoeud(2)->Coord1()).Norme()
|
||
|
|
+ (tabNoeud(2)->Coord1() - tabNoeud(3)->Coord1()).Norme();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{longueur = (tabNoeud(1)->Coord0() - tabNoeud(2)->Coord0()).Norme()
|
||
|
|
+ (tabNoeud(2)->Coord0() - tabNoeud(3)->Coord0()).Norme();
|
||
|
|
};
|
||
|
|
return longueur;
|
||
|
|
};
|
||
|
|
|
||
|
|
//----- lecture écriture de restart -----
|
||
|
|
// ceci concerne uniquement les informations spécifiques
|
||
|
|
void FrontSegQuad::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent)
|
||
|
|
{ string toto;
|
||
|
|
ent >> toto >> toto >> droite >> toto >> theta;
|
||
|
|
};
|
||
|
|
void FrontSegQuad::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort)
|
||
|
|
{ sort << " FrontSQ " ;
|
||
|
|
sort << " dr_tg " << droite << " theta " << theta ;
|
||
|
|
};
|
||
|
|
|
||
|
|
//----------- METHODES PROTEGEES : ------------------------------------
|
||
|
|
// definition de la metrique
|
||
|
|
void FrontSegQuad::DefMetrique()
|
||
|
|
{ // dimension d'un des noeuds
|
||
|
|
int dim_base = ((*tabNoeud(1)).Coord0()).Dimension();
|
||
|
|
// def des variables dont on se servira
|
||
|
|
Tableau<Enum_variable_metrique> tab(17);
|
||
|
|
tab(1) = iM0; tab(2) = iMt; tab(3) = iMtdt ;
|
||
|
|
tab(4)=igiB_0;tab(5)=igiB_t;tab(6)=igiB_tdt;
|
||
|
|
tab(7)=igiH_0;tab(8)=igiH_t;tab(9)=igiH_tdt ;
|
||
|
|
tab(10)=igijBB_0;tab(11)=igijBB_t;tab(12)=igijBB_tdt;
|
||
|
|
tab(13)=igijHH_0;tab(14)=igijHH_t;tab(15)=igijHH_tdt ;
|
||
|
|
tab(16) = igradVBB_tdt;tab(17) = id_giB_tdt;
|
||
|
|
// la définition de la métrique dépend du type d'espace
|
||
|
|
if (ParaGlob::AxiSymetrie())
|
||
|
|
{// cas d'un espace de travail axisymétrique
|
||
|
|
met = new MetAxisymetrique2D(dim_base,ddlElem,tab,3);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{met = new Met_biellette(dim_base,ddlElem,tab,3);};
|
||
|
|
};
|