// 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 "FrontQuadQC.h"
#include "Util.h"
#include "MathUtil.h"
#include "FrontSegQuad.h"
//----------------------------------------------------------------
// def des donnees commune a tous les elements
// représente des conteneurs de travail
//----------------------------------------------------------------
// 4 points d'integration et 9 noeuds
GeomQuadrangle FrontQuadQC::quadrangle(4,9);
Met_abstraite * FrontQuadQC::met = NULL;
Vecteur FrontQuadQC::phi(9);
Mat_pleine FrontQuadQC::dphi(2,9);
BaseB FrontQuadQC::giB;
BaseH FrontQuadQC::giH;
// CONSTRUCTEURS :
FrontQuadQC::FrontQuadQC () : // par defaut
ElFrontiere()
{ cout << "\n erreur, ce constructeur ne doit pas etre utilise "
<< "\nFrontQuadQC::FrontQuadQC ()" << endl;
Sortie(1);};
// fonction du tableau des noeuds sommets
FrontQuadQC::FrontQuadQC ( const Tableau <Noeud *>& tab, const DdlElement& ddlElem) :
ElFrontiere(tab,ddlElem,9),
ref(tab(1)->Dimension()),plan(tab(1)->Dimension()),theta(2),theta_repere(2)
,d_N(),D_pasnormale()
{ // au premier appel on construit la metrique associee
if ( met == NULL)
DefMetrique();
// définition de d_N
int nb_ddl = 9 * tab(1)->Coord0().Dimension();
d_N.Change_taille(nb_ddl);
D_pasnormale.Change_taille(nb_ddl);
};
// de copie
FrontQuadQC::FrontQuadQC( const FrontQuadQC& a) :
ElFrontiere(a),ref(a.ref),plan(a.plan),theta(a.theta),theta_repere(a.theta_repere)
,d_N(a.d_N)
{};
// DESTRUCTEUR :
FrontQuadQC::~FrontQuadQC ()
{};
// surcharge de l'affectation
ElFrontiere& FrontQuadQC::operator = ( const ElFrontiere& a)
{ if (this->TypeFrontiere() == a.TypeFrontiere())
{ this->ElFrontiere::operator=(a);
const FrontQuadQC* b = (const FrontQuadQC*) &a;
ref = Ref(); plan = b->PL(); theta = b->theta;
theta_repere = b->theta_repere;
d_N = b->d_N;
return *this;
}
else
{ cout << "\n erreur d\'affectation, le deux membres non pas le meme type ";
cout << "\n FrontQuadQC& ElFrontiere::operator = (ElFrontiere& a) " << endl;
Sortie (1);
return *this;
}
};
// retourne le type de l'element frontiere
string FrontQuadQC::TypeFrontiere() const
{ return string("FrontQuadQC");};
// creation d'un nouvelle element frontiere du type FrontQuadQC
ElFrontiere * FrontQuadQC::NevezElemFront() const
{ ElFrontiere * pt;
pt = new FrontQuadQC(*this);
return pt;
};
// creation d'un nouvelle element frontiere du type FrontQuadQC
// avec des donnees differentes
ElFrontiere * FrontQuadQC::NevezElemFront
( const Tableau <Noeud *>& tab, const DdlElement& ddlElem ) const
{ ElFrontiere * pt;
pt = new FrontQuadQC(tab,ddlElem);
return pt;
};
// ramene et calcul les coordonnees du point de reference de l'element
Coordonnee FrontQuadQC::Ref()
{ // le point de ref en coordonnees locale
Coordonnee A0(0.,0.);
// appel de la routine de metrique, 9 noeuds
if (tabNoeud(1)->ExisteCoord2())
{ref = met->PointM_tdt(tabNoeud,quadrangle.Phi_point(A0));}
else if (tabNoeud(1)->ExisteCoord1())
{ref = met->PointM_t(tabNoeud,quadrangle.Phi_point(A0));}
else
{ref = met->PointM_0(tabNoeud,quadrangle.Phi_point(A0));};
return ref;
};
// ramene un plan tangent au point de reference
// si indic = 2 -> un plan
// ces infos sont stocke et sauvegardees dans l'element
void FrontQuadQC::TangentRef(Droite& , Plan& pl, int& indic)
{ indic = 2;
// le point de ref en coordonnees locale
Coordonnee A0(0.,0.);
// calcul des bases et du plan tangent et de giH
met->BaseND_tdt(tabNoeud,quadrangle.Dphi_point(A0),quadrangle.Phi_point(A0),giB,giH);
plan.Change_ptref(Ref());
Coordonnee Normal = Util::ProdVec_coorBN(giB(1),giB(2));
plan.Change_normal(Normal);
theta(1) = 0.;theta(2) = 0.;theta_repere=theta;
pl = plan;
};
// M est un point du dernier plan tangent sauvegarde dans l'element
// - calcul du point M1 correspondant sur la surface, M1 est stocke
// _ calul et retour du plan tangent au point M1
// si indic = 2 -> un plan
// ces infos sont stocke et sauvegardees dans l'element
void FrontQuadQC::Tangent(const Coordonnee& M,Coordonnee& M1, Droite& , Plan& pl, int& indic)
{ // récup des bases au point courant projeté
met->BaseND_tdt(tabNoeud,quadrangle.Dphi_point(theta_repere),quadrangle.Phi_point(theta_repere),giB,giH);
// on incremente la coordonnee curviligne
Coordonnee M1M = M - plan.PointPlan();
theta(1) += M1M * giH.Coordo(1);
theta(2) += M1M * giH.Coordo(2);
// 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 (!(quadrangle.Interieur(theta)))
// calcul d'un point extreme de l'élément dans le sens de M
{ theta_repere = quadrangle.Maxi_Coor_dans_directionGM(theta);
// on recalcule le repère local
phi = quadrangle.Phi_point(theta_repere); // fonctions d'interpolation au point limite dans l'élément
met->BaseND_tdt(tabNoeud,quadrangle.Dphi_point(theta_repere),phi,giB,giH);
// on recalcule les coodonnées locales
theta(1) += M1M * giH.Coordo(1);
theta(2) += M1M * giH.Coordo(2);
}
else
// sinon le point est correcte, on peut y calculer le nouveau repère
{ theta_repere = theta;
phi = quadrangle.Phi_point(theta_repere); // fonctions d'interpolation au point
met->BaseND_tdt(tabNoeud,quadrangle.Dphi_point(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) + delta_theta(2) * giB.Coordo(2);
plan.Change_ptref(M1);
Coordonnee Normal = Util::ProdVec_coorBN(giB(1),giB(2));
plan.Change_normal(Normal);
// retour
pl = plan;
indic = 2;
};
// ramene un autre plan tangent genere de maniere pseudo aleatoire
// si indic = 2 -> un plan
// ces infos sont stocke et sauvegardees dans l'element
void FrontQuadQC::AutreTangent(Droite& , Plan& pl, 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;
nrand++; // pour avoir un nombre different
srand(nrand);
theta(2) = -1. + 2.*((double) rand())/RAND_MAX;
if (!(quadrangle.Interieur(theta)))
// calcul d'un point extreme de l'élément dans le sens de M
{ theta_repere = quadrangle.Maxi_Coor_dans_directionGM(theta);
// on recalcule le repère local
phi = quadrangle.Phi_point(theta_repere); // fonctions d'interpolation au point limite dans l'élément
met->BaseND_tdt(tabNoeud,quadrangle.Dphi_point(theta_repere),phi,giB,giH);
}
else
// sinon le point est correcte, on peut y calculer le nouveau repère
{ theta_repere = theta;
phi = quadrangle.Phi_point(theta_repere); // fonctions d'interpolation au point
// calcul des bases et du plan tangent et de giH
met->BaseND_tdt(tabNoeud,quadrangle.Dphi_point(theta_repere),phi,giB,giH);
};
// calcul du point correspondant
Coordonnee delta_theta = theta - theta_repere;
Coordonnee M1 = met->PointM_tdt(tabNoeud,phi) + delta_theta(1) * giB.Coordo(1) + delta_theta(2) * giB.Coordo(2);
plan.Change_ptref(M1);
Coordonnee Normal = Util::ProdVec_coorBN(giB(1),giB(2));
plan.Change_normal(Normal);
// retour
pl = plan;
indic = 2;
};
// ramene true si le dernier point M1 est dans l'element sinon false
// le calcul est fait à eps relatif près
bool FrontQuadQC::InSurf(const double& eps) const
{
if ((Dabs(theta(1)) <= 1.+eps) && (Dabs(theta(2)) <= 1.+eps))
// le point est sur la surface
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 >* FrontQuadQC::DernierTangent(Droite& , Plan& pl, int& indic,bool avec_var)
{
if (!(quadrangle.Interieur(theta)))
// calcul d'un point extreme de l'élément dans le sens de M
{ theta_repere = quadrangle.Maxi_Coor_dans_directionGM(theta);
// on recalcule le repère local
phi = quadrangle.Phi_point(theta_repere); // fonctions d'interpolation au point limite dans l'élément
met->BaseND_tdt(tabNoeud,quadrangle.Dphi_point(theta_repere),phi,giB,giH);
}
else
// sinon le point est correcte, on peut y calculer le nouveau repère
{ theta_repere = theta;
phi = quadrangle.Phi_point(theta_repere); // fonctions d'interpolation au point
// calcul des bases et du plan tangent et de giH
met->BaseND_tdt(tabNoeud,quadrangle.Dphi_point(theta_repere),phi,giB,giH);
};
// calcul du point correspondant aux coordonnees theta
Coordonnee delta_theta = theta - theta_repere;
Coordonnee M1 = met->PointM_tdt(tabNoeud,phi) + delta_theta(1) * giB.Coordo(1) + delta_theta(2) * giB.Coordo(2);
plan.Change_ptref(M1);
Coordonnee Normal = Util::ProdVec_coorBN(giB(1),giB(2));
plan.Change_normal(Normal);
// prépa retour
pl = plan;
indic = 2;
// dans le cas où l'on veut la variation du vecteur normal
Tableau <Coordonnee >* pt_varN = NULL; // par défaut
if (avec_var)
{ // calcul de la variation des vecteurs de base
const Tableau <BaseB>& d_giB_tdt = met->d_BaseNat_tdt(tabNoeud,quadrangle.Dphi_point(theta_repere),phi);
// calcul de la variation de la normale
// 1) variation du produit vectoriel qui a servi pour le calcul de la normale
Util::VarProdVect_coorBN( giB(1),giB(2),d_giB_tdt,D_pasnormale);
// 2) de la normale
Util::VarUnVect_coor(Normal,D_pasnormale,Normal.Norme(),d_N);
pt_varN = &d_N;
};
// retour
return pt_varN;
};
// calcul les fonctions d'interpolation au dernier point de projection sauvegarde
const Vecteur& FrontQuadQC::Phi()
{ return quadrangle.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 FrontQuadQC::BonCote_t( const Coordonnee& a,double& r) const // cas ou on utilise la frontiere a t
{ // def des infos du plan tangent a t en theta
phi = quadrangle.Phi_point(theta_repere); // fonctions d'interpolation au point
// calcul des bases et du plan tangent et de giH
met->BaseND_tdt(tabNoeud,quadrangle.Dphi_point(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) + delta_theta(2) * giB.Coordo(2);
Coordonnee Normal = Util::ProdVec_coorBN(giB(1),giB(2));
if (ref.Dimension() == 3)
// on regarde si a est du bon cote de la frontiere
{r = (M1 - a) * Normal ;
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 2D , la normale ne veut rien dire
return true;
};
bool FrontQuadQC::BonCote_tdt( const Coordonnee& a,double& r) const // cas ou on utilise la frontiere a tdt
{ if (ref.Dimension() == 3)
// on regarde si a est du bon cote de la frontiere a l'instant precedent
{ r = (plan.PointPlan() - a) * plan.Vecplan() ;
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 2D , la normale ne veut rien dire
return true;
};
// 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*>& FrontQuadQC::Frontiere()
{if (tabfront.Taille() == 0)
{tabfront.Change_taille(4);
// premiere ligne
Tableau <Noeud *> tab(3);
tab(1) = tabNoeud(1);tab(2) = tabNoeud(5);tab(3) = tabNoeud(2);
DdlElement ddlE(3);
ddlE.Change_un_ddlNoeudElement(1,ddlElem(1));
ddlE.Change_un_ddlNoeudElement(2,ddlElem(5));
ddlE.Change_un_ddlNoeudElement(3,ddlElem(2));
// ddlE(1) = ddlElem(1);ddlE(2) = ddlElem(5);ddlE(3) = ddlElem(2);
tabfront(1) = new FrontSegQuad(tab,ddlE);
// deuxieme ligne
tab(1) = tabNoeud(2);tab(2) = tabNoeud(6);tab(3) = tabNoeud(3);
ddlE.Change_un_ddlNoeudElement(1,ddlElem(2));
ddlE.Change_un_ddlNoeudElement(2,ddlElem(6));
ddlE.Change_un_ddlNoeudElement(3,ddlElem(3));
// ddlE(1) = ddlElem(2);ddlE(2) = ddlElem(6);ddlE(3) = ddlElem(3);
tabfront(2) = new FrontSegQuad(tab,ddlE);
// troisieme ligne
tab(1) = tabNoeud(3);tab(2) = tabNoeud(7);tab(3) = tabNoeud(4);
ddlE.Change_un_ddlNoeudElement(1,ddlElem(3));
ddlE.Change_un_ddlNoeudElement(2,ddlElem(7));
ddlE.Change_un_ddlNoeudElement(3,ddlElem(4));
// ddlE(1) = ddlElem(3);ddlE(2) = ddlElem(7);ddlE(3) = ddlElem(4);
tabfront(3) = new FrontSegQuad(tab,ddlE);
// quatrieme ligne
tab(1) = tabNoeud(4);tab(2) = tabNoeud(8);tab(3) = tabNoeud(1);
ddlE.Change_un_ddlNoeudElement(1,ddlElem(4));
ddlE.Change_un_ddlNoeudElement(2,ddlElem(8));
ddlE.Change_un_ddlNoeudElement(3,ddlElem(1));
// ddlE(1) = ddlElem(4);ddlE(2) = ddlElem(8);ddlE(3) = ddlElem(1);
tabfront(4) = new FrontSegQuad(tab,ddlE);
}
return tabfront;
};
// affichage des infos de l'elements
void FrontQuadQC::Affiche(Enum_dure temp) const
{ cout << "\n element frontiere de type FrontQuadQC , de noeuds sommets : \n ";
int nbn = 9;
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;
};
};
//----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques
void FrontQuadQC::Lecture_base_info_ElFrontiere_pour_projection(istream& ent)
{ string toto;
ent >> toto >> toto >> plan >> toto >> theta;
};
void FrontQuadQC::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort)
{ sort << " FrontQC " ;
sort << " pl_tg " << plan << " theta " << theta ;
};
//----------- METHODES PROTEGEES : ------------------------------------
// definition de la metrique
void FrontQuadQC::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;
met = new Met_abstraite(dim_base,2,ddlElem,tab,9);
};