Herezh_dev/Elements/Geometrie/Frontiere/Surface/FrontQuadLine.cc

// 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 "FrontQuadLine.h"
#include "Util.h"
#include "MathUtil.h"
#include "FrontSegLine.h"

//----------------------------------------------------------------
// def des donnees commune a tous les elements
//----------------------------------------------------------------
// 4 points d'integration et 4 noeuds
GeomQuadrangle FrontQuadLine::quadrangle(4,4);                                     
Met_abstraite * FrontQuadLine::met = NULL;
Vecteur FrontQuadLine::phi(4);
Mat_pleine FrontQuadLine::dphi(2,4);
BaseB FrontQuadLine::giB;  
BaseH FrontQuadLine::giH;  

    // CONSTRUCTEURS :
FrontQuadLine::FrontQuadLine () : // par defaut
  ElFrontiere()
   { cout << "\n erreur, ce constructeur ne doit pas etre utilise "
           << "\nFrontQuadLine::FrontQuadLine ()" << endl;
     Sortie(1);};
    // fonction du tableau des noeuds  sommets 
FrontQuadLine::FrontQuadLine ( const Tableau <Noeud *>& tab, const DdlElement& ddlElem) :
  ElFrontiere(tab,ddlElem,4),
  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 = 4 * tab(1)->Coord0().Dimension();
	 d_N.Change_taille(nb_ddl);
	 D_pasnormale.Change_taille(nb_ddl);	
   };
// de copie   
FrontQuadLine::FrontQuadLine( const FrontQuadLine& a) :
  ElFrontiere(a),ref(a.ref),plan(a.plan),theta(a.theta),theta_repere(a.theta_repere)
  ,d_N(a.d_N)
  {};

    // DESTRUCTEUR :
FrontQuadLine::~FrontQuadLine ()
 {};
// surcharge de l'affectation
ElFrontiere& FrontQuadLine::operator = ( const ElFrontiere& a)
   { if (this->TypeFrontiere() == a.TypeFrontiere())
       { this->ElFrontiere::operator=(a);
         const FrontQuadLine* b = (const FrontQuadLine*) &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 FrontQuadLine& ElFrontiere::operator = (ElFrontiere& a) " << endl;
         Sortie (1);
         return *this;
        } 
     };
     
// retourne le type de l'element frontiere
string FrontQuadLine::TypeFrontiere() const 
  { return string("FrontQuadLine");};
  
// creation d'un nouvelle element frontiere du type FrontQuadLine
ElFrontiere * FrontQuadLine::NevezElemFront() const 
  { ElFrontiere * pt;
    pt = new FrontQuadLine(*this);
    return pt; 
   };  
// creation d'un nouvelle element frontiere du type FrontQuadLine
// avec des donnees differentes
ElFrontiere * FrontQuadLine::NevezElemFront
     ( const Tableau <Noeud *>& tab, const DdlElement& ddlElem ) const
  { ElFrontiere * pt;
    pt = new FrontQuadLine(tab,ddlElem);
    return pt; 
   };  
    
// ramene les coordonnees du point de reference de l'element
Coordonnee FrontQuadLine::Ref()  
  { // le point de ref en coordonnees locale
    const Coordonnee A0(0.,0.);
    // appel de la routine de metrique, 4 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 FrontQuadLine::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
    BaseB giB;
    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 FrontQuadLine::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 FrontQuadLine::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 FrontQuadLine::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 >* FrontQuadLine::DernierTangent(Droite& , Plan& pl, int& indic,bool avec_var)
  {
//cout << "\n theta "; theta.Affiche(); cout <<"\n *** debug FrontQuadLine::DernierTangent( "<< endl;
    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;
//cout << "\n delta_theta "; delta_theta.Affiche(); cout <<"\n *** debug FrontQuadLine::DernierTangent( "<< endl;
    Coordonnee M1 = met->PointM_tdt(tabNoeud,phi) + delta_theta(1) * giB.Coordo(1) + delta_theta(2) * giB.Coordo(2);
//cout << "\n M1 "; M1.Affiche(); cout <<"\n *** debug FrontQuadLine::DernierTangent( "<< endl;
    plan.Change_ptref(M1);
    Coordonnee Normal = Util::ProdVec_coorBN(giB(1),giB(2));
    plan.Change_normal(Normal);
//cout << "\n Normal "; Normal.Affiche(); cout <<"\n *** debug FrontQuadLine::DernierTangent( "<< endl;
    // 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& FrontQuadLine::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 FrontQuadLine::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 FrontQuadLine::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*>& FrontQuadLine::Frontiere()
 {if (tabfront.Taille() == 0)
   {tabfront.Change_taille(4);
    // premiere ligne
    Tableau <Noeud *> tab(2); tab(1) = tabNoeud(1);tab(2) = tabNoeud(2);
    DdlElement ddlE(2); 
    ddlE.Change_un_ddlNoeudElement(1,ddlElem(1));
    ddlE.Change_un_ddlNoeudElement(2,ddlElem(2));
//    ddlE(1) = ddlElem(1);ddlE(2) = ddlElem(2);
    tabfront(1) = new FrontSegLine(tab,ddlE);
    // deuxieme ligne
    tab(1) = tabNoeud(2);tab(2) = tabNoeud(3);
    ddlE.Change_un_ddlNoeudElement(1,ddlElem(2));
    ddlE.Change_un_ddlNoeudElement(2,ddlElem(3));
//    ddlE(1) = ddlElem(2);ddlE(2) = ddlElem(3);
    tabfront(2) = new FrontSegLine(tab,ddlE);
    // troisieme ligne
    tab(1) = tabNoeud(3);tab(2) = tabNoeud(4);
    ddlE.Change_un_ddlNoeudElement(1,ddlElem(3));
    ddlE.Change_un_ddlNoeudElement(2,ddlElem(4));
//    ddlE(1) = ddlElem(3);ddlE(2) = ddlElem(4);
    tabfront(3) = new FrontSegLine(tab,ddlE);
    // quatrieme ligne
    tab(1) = tabNoeud(4);tab(2) = tabNoeud(1);
    ddlE.Change_un_ddlNoeudElement(1,ddlElem(4));
    ddlE.Change_un_ddlNoeudElement(2,ddlElem(1));
//    ddlE(1) = ddlElem(4);ddlE(2) = ddlElem(1);
    tabfront(4) = new FrontSegLine(tab,ddlE);
    }
    return tabfront;          
  };
       
    // affichage des infos de l'elements
void FrontQuadLine::Affiche(Enum_dure temp) const 
  { cout << "\n element frontiere de type FrontQuadLine , de noeuds sommets : \n "; 
    int nbn = 4;
    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 FrontQuadLine::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent)
{ string toto; 
  ent >> toto >> toto >> plan >>  toto >> theta; 	
};
void FrontQuadLine::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort)
{ sort << " FrontQL " ;
  sort << " pl_tg " << plan <<  " theta " << theta ;
};  
   
//----------- METHODES PROTEGEES : ------------------------------------
    // definition de la metrique
void FrontQuadLine::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,4);
  };