rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Elements/Geometrie/Frontiere/Ligne/FrontSegLine.cc
Gérard Rio 0460624e94 mise à jour 7.010
2023-05-03 17:23:49 +02:00

405 lines
16 KiB
C++
Raw Blame History

// 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 "FrontSegLine.h"
#include "FrontPointF.h"
#include "Met_biellette.h"
#include "MetAxisymetrique2D.h"
#include "Util.h"
//----------------------------------------------------------------
// def des donnees commune a tous les elements
//----------------------------------------------------------------
GeomSeg FrontSegLine::segment(1,2);
Met_abstraite * FrontSegLine::met = NULL;
Vecteur FrontSegLine::phi(2);
Mat_pleine FrontSegLine::dphi(1,2);
BaseB FrontSegLine::giB;
BaseH FrontSegLine::giH;
// CONSTRUCTEURS :
FrontSegLine::FrontSegLine () : // par defaut
ElFrontiere(),refP(),droite(),Mp(),theta()
{ cout << "\n erreur, ce constructeur ne doit pas etre utilise "
<< "\nFrontSegLine::FrontSegLine ()" << endl;
Sortie(1);
};
// fonction du tableau de 2 noeuds sommets
FrontSegLine::FrontSegLine ( const Tableau <Noeud *>& tab, const DdlElement& ddlElem) :
ElFrontiere(tab,ddlElem,2),
refP(tab(1)->Dimension()),droite (tab(1)->Dimension()),Mp(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 = 2 * tab(1)->Coord0().Dimension();
d_T.Change_taille(nb_ddl);
};
// de copie
FrontSegLine::FrontSegLine( const FrontSegLine& a) :
ElFrontiere(a), refP(a.refP),droite (a.droite),Mp(a.Mp),theta(a.theta)
,theta_repere(a.theta_repere)
,d_T(a.d_T)
{};
// DESTRUCTEUR :
FrontSegLine::~FrontSegLine ()
{};
// surcharge de l'affectation
ElFrontiere& FrontSegLine::operator = ( const ElFrontiere& a)
{ if (this->TypeFrontiere() == a.TypeFrontiere())
{ this->ElFrontiere::operator=(a);
const FrontSegLine* b = (const FrontSegLine*) &a;
refP = Ref(); droite = b->DR(); Mp = b->MP(); 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 ElFrontiere& FrontSegLine::operator = (ElFrontiere& a) " << endl;
Sortie (1);
return *this;
};
};
// retourne le type de l'element frontiere
string FrontSegLine::TypeFrontiere() const
{ return string("FrontSegLine");};
// creation d'un nouvelle element frontiere du type FrontSegLine
ElFrontiere * FrontSegLine::NevezElemFront() const
{ ElFrontiere * pt;
pt = new FrontSegLine(*this);
return pt;
};
// creation d'un nouvelle element frontiere du type FrontSegLine
// avec des donnees differentes
ElFrontiere * FrontSegLine::NevezElemFront
( const Tableau <Noeud *>& tab, const DdlElement& ddlElem ) const
{ ElFrontiere * pt;
pt = new FrontSegLine(tab,ddlElem);
return pt;
};
// ramene et calcul les coordonnees du point de reference de l'element
Coordonnee FrontSegLine::Ref()
{ // le point de ref en coordonnees locale
Coordonnee A0(0.);
// appel de la routine de metrique
if (tabNoeud(1)->ExisteCoord2())
{refP = met->PointM_tdt(tabNoeud,segment.Phi_point(A0));}
else if (tabNoeud(1)->ExisteCoord1())
{refP = met->PointM_t(tabNoeud,segment.Phi_point(A0));}
else
{refP = met->PointM_0(tabNoeud,segment.Phi_point(A0));};
return refP;
};
// ramene une droite tangente au point de reference
// ici indic = 1 -> une droite
// ces infos sont stocke et sauvegardees dans l'element
void FrontSegLine::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;
// };
{ indic = 1;
// on sait ici que le point de référence est à mi-chemin entre les deux extrémités
// d'où un calcul simplifié
droite.Change_ptref(0.5*(tabNoeud(1)->Coord2()+tabNoeud(2)->Coord2()));
droite.Change_vect( tabNoeud(2)->Coord2() - tabNoeud(1)->Coord2());
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
// indic = 1 -> une droite
// ces infos sont stocke et sauvegardees dans l'element
void FrontSegLine::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_point(theta_repere),segment.Phi_point(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, ici on ne limite pas le repère de calcul
// car il n'y a jamais de pb
theta_repere = theta;
phi = segment.Phi_point(theta_repere); // fonctions d'interpolation au point
met->BaseND_tdt(tabNoeud,segment.Dphi_point(theta_repere),phi,giB,giH);
M1 = met->PointM_tdt(tabNoeud,phi);
droite.Change_ptref(M1);
droite.Change_vect(giB(1).Coor());
// retour
dr = droite;
indic = 1;
Mp=M; // sauvegarde
};
/* { M1 = M ;
Mp = M ;
dr = droite;
indic = 1;
// calcul des coordonnees local
double L = (tabNoeud(2)->Coord2() - tabNoeud(1)->Coord2()).Norme() / 2.; // demi longueur du segment
Coordonnee loc = (Mp - refP);
Coordonnee thet(1);
if (L < ConstMath::trespetit)
{ // procédure d'urgence
if (loc.Norme() < ConstMath::trespetit)
{ thet(1) = 0.; }
else
{ thet(1) = ConstMath::grand; }
}
else
// cas normal
// thet(1) = loc.Norme() / L;
// double alpha = loc * droite.VecDroite();
// if (alpha < 0.)
// theta = -thet;
// else
// theta = thet;
// plus simple:
// normalement la droite est orienté selon les noeuds croissants, et le vecteur de la droite est unitaire
{thet(1) = loc * droite.VecDroite() / L; };
};*/
// ramene une autre droite tangente genere de maniere pseudo aleatoire
// ici indic = 1 -> la droite elle meme,
// ces infos sont stocke et sauvegardees dans l'element
void FrontSegLine::AutreTangent(Droite& dr, Plan& , int& indic)
{ indic = 1;
dr = droite;
};
// ramene true si le dernier point M1 est dans l'element sinon false
// le calcul est fait à eps relatif près
bool FrontSegLine::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 >* FrontSegLine::DernierTangent(Droite& dr, Plan& , int& indic,bool avec_var)
{ indic = 1;
theta_repere = theta; // normalement ici theta_repere est toujours = theta
phi = segment.Phi_point(theta_repere); // fonctions d'interpolation au point
met->BaseND_tdt(tabNoeud,segment.Dphi_point(theta_repere),phi,giB,giH);
// calcul du point correspondant au theta_i
Coordonnee M1 = met->PointM_tdt(tabNoeud,phi);
droite.Change_ptref(M1);
droite.Change_vect(giB(1).Coor());
// droite.Change_ptref(0.5*(tabNoeud(1)->Coord2()+tabNoeud(2)->Coord2()));
// droite.Change_vect( tabNoeud(2)->Coord2() - tabNoeud(1)->Coord2());
// cout << "\n debug FrontSegLine::DernierTangent nbn1=" << tabNoeud(2)->Num_noeud() << " nbn2= " << tabNoeud(1)->Num_noeud()
// << "\n tabNoeud(2)->Coord2(): " << tabNoeud(2)->Coord2() << " tabNoeud(1)->Coord2(): " << tabNoeud(1)->Coord2() << endl;
dr = droite;
// dans le cas où l'on veut la variation du vecteur normal
Tableau <Coordonnee >* pt_varT = NULL; // par défaut
if (avec_var)
{ // 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);
// 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_point(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& FrontSegLine::Phi()
{ return segment.Phi_point(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 FrontSegLine::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();
Coordonnee M1 = (tabNoeud(2)->Coord1() + tabNoeud(1)->Coord1())/2.;
Coordonnee giB = (tabNoeud(2)->Coord1() - tabNoeud(1)->Coord1())/2.;
// calcul d'un vecteur proportionnel à la normale bien oriente: c-a-d vers l'extérieur du solide
Coordonnee Nor(dim); Nor(1) = giB(2);Nor(2) = -giB(1); // si axi, suivant z c'est nulle
r = (M1 - A) * 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 FrontSegLine::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
{
// devrait également marcher pour l'axisymétrie en 3D
int dim = ParaGlob::Dimension();
// calcul d'un vecteur proportionnel à la normale bien oriente: c-a-d vers l'extérieur du solide
// si axi, suivant z c'est nulle
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 FrontSegLine::Affiche(Enum_dure temp) const
{ cout << "\n element frontiere de type FrontSegLine , de noeuds sommets : ";
int nbn = 2;
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*>& FrontSegLine::Frontiere()
{if (tabfront.Taille() == 0)
{tabfront.Change_taille(2);
for (int i=1; i<= 2; i++)
{ Tableau <Noeud *> tab(1); tab(1) = tabNoeud(i);
DdlElement ddlE(1);
ddlE.Change_un_ddlNoeudElement(1,ddlElem(i));
// ddlE(1) = ddlElem(i);
tabfront(i) = 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 FrontSegLine::LongueurApprox()
{ double longueur = 0.;
if (tabNoeud(1)->ExisteCoord2())
{longueur = (tabNoeud(1)->Coord2() - tabNoeud(2)->Coord2()).Norme();
}
else if(tabNoeud(1)->ExisteCoord1())
{longueur = (tabNoeud(1)->Coord1() - tabNoeud(2)->Coord1()).Norme();
}
else
{longueur = (tabNoeud(1)->Coord0() - tabNoeud(2)->Coord0()).Norme();
}
return longueur;
};
//----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques
void FrontSegLine::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent)
{ string toto;
ent >> toto >> toto >> droite >> toto >> Mp >> toto >> theta;
};
void FrontSegLine::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort)
{ sort << " FrontSL " ;
sort << " dr_tg " << droite << " Mp " << Mp << " theta " << theta ;
};
//----------- METHODES PROTEGEES : ------------------------------------
// definition de la metrique
void FrontSegLine::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,2);
}
else
{met = new Met_biellette(dim_base,ddlElem,tab,2);};
};
Reference in a new issue View git blame Copy permalink