
// 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
   }; 
      
 
  
  



