
// 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 "GeomPentaCom.h"
#include <math.h>
#include "GeomSeg.h"
#include "GeomQuadrangle.h"
#include "GeomTriangle.h"
#include "MathUtil.h"

// constructeur
    // le constructeur par défaut ne doit pas être utilisé
GeomPentaCom::GeomPentaCom()
  {   cout << "\n erreur le constructeur par defaut ne doit pas être utilise " ;
        cout << "\nGeomPentaCom::GeomPentaCom()  " << endl;     
        Sortie(1);
   };
    
//  la dimension est 3, on a nbi pt d'integration, nbn noeuds et 5 faces, 9 aretes
GeomPentaCom::GeomPentaCom(int nbi , int nbn, Enum_interpol interpol) :
    ElemGeomC0(3,nbi,nbn,5,9,PENTAEDRE,interpol)
   { 
     // coordonnees des points d'integration
     // ceux-ci sont obtenues par assemblage des points de surface et ceux d'épaisseur
     int nbil,nbis;
     switch (nbi)
      { case 1 : nbil = 1; nbis = 1; break; 
        case 2 : nbil = 2; nbis = 1; break; 
        case 3 : nbil = 3; nbis = 1; break;
        case 6 : nbil = 2; nbis = 3; break;
        case 8 : nbil = 2; nbis = 4; break;
        case 9 : nbil = 3; nbis = 3; break;
        case 12 : nbil = 3; nbis = 4; break;
        case 18 : nbil = 3; nbis = 6; break;
        default :
         {cout << "\n erreur le pentaedre  de nombre de point d'integration = " << nbi
               << "\n n\'est pas implante !! ";
          cout << "\nGeomPentaCom::GeomPentaCom(int nbi) " << endl;     
          Sortie(1);
         }
       };
       
      // un segment de base avec  deux noeuds
      GeomSeg  segbase(nbil,2); 
      // un triangle de base avec 3 noeuds
      // dans le cas de 3 pt d'integ de surface, on choisit des pt d'integ près des noeuds
      // et non au milieu des arrêtes d'où nbis_tri pour ce choix 
      int nbis_tri(nbis); if (nbis == 3) nbis_tri = 1000+nbis; 
      GeomTriangle triabase(nbis_tri,3); 
      // on reconstitue les coordonnées en trois dimension
      // et on calcul les poids d'intégration
      int npi=1;
      for (int niil=1;niil<=nbil;niil++)
        for (int nis=1;nis<=nbis;nis++,npi++)
          { ptInteg(npi) = Coordonnee
                    ((triabase.CoorPtInteg(nis))(1)
                    ,(triabase.CoorPtInteg(nis))(2)
                    ,(segbase.CoorPtInteg(niil))(1));
           // les poids d'integration sont obtenus par produit de ceux de surface
           // et ceux de hauteur
           WI(npi)=triabase.Wi(nis) * segbase.Wi(niil);
          };
};

// destructeur
GeomPentaCom::~GeomPentaCom() 
  { 
   };
// constructeur de copie
GeomPentaCom::GeomPentaCom(const GeomPentaCom& a) :
  ElemGeomC0(a)
   {
   };    
   
// en fonction de coordonnees locales, retourne true si le point est a l'interieur
// de l'element, false sinon
bool GeomPentaCom::Interieur(const Coordonnee& M)
  { if ((seg(1)->Interieur(M(3))) &&(face(1)->Interieur(Coordonnee(M(1),M(2)))))
      return true;
     else
      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 GeomPentaCom::Maxi_Coor_dans_directionGM(const Coordonnee& M)
  { // on décompose la recherche en segment et facette
    double x=M(1); double y=M(2); double z=M(3);
    // tout d'abord on calcul le point maxi dans le plan 1 2 et dans z indépendemment
    Coordonnee XY(x,y); Coordonnee Z(z);
    Coordonnee Pxy= face(1)->Maxi_Coor_dans_directionGM(XY);
    Coordonnee Pz = seg(1)->Maxi_Coor_dans_directionGM(Z);
	 Coordonnee P(0.,0.,0.); // le retour
	 
	 // G le centre de gravité: il a la cote nulle et il est centre de gravité du triangle médian
	 double untiers = 1./3.;
	 Coordonnee G(untiers,untiers,0.);
	 Coordonnee Gxy(untiers,untiers); // en 2D xy

	 // le pb est de savoir si on sort sur une des faces triangulaires, ou sur une des faces rectangulaires
	 // Si le point maxi P sort par une face quadrangulaire, cela signifie que z_P est compris entre 1 et -1
	 // --- on va donc commencer par calculer le z_P
	 // on considère les points: G (z_G=0),  Pxy dont la côte est également nulle, M, et z_P ?
	 // soit un plan vertical (normale à Oxy) passant par G,M,Pxy. Il passe également par P. On note Mxy la projection
	 // de M sur le plan Oxy. Dans le plan verticale on peut faire une régle de trois: 
	 // on a z_P/z_M = GPxy/GMxy d'où z_P = z_M * (GPxy/GMxy)
	 // NB: si ||GMxy|| = 0, là c'est sur ça ne sort pas par un quadrangle
	 
	 
	 // 1)-----
	 Coordonnee GMxy(x-untiers,y-untiers); // en 2D xy
	 int fin_traitement = false; // par défaut
	 double gmxy = GMxy.Norme();
	 if (gmxy > ConstMath::trespetit)
	  { double z_P = z * ( (Pxy-Gxy).Norme()) / gmxy;
	    if (Abs(z_P) <= 1.) // là c'est ok on sort par un rectangle
		   {P(1)=Pxy(1); P(2)=Pxy(2); P(3)=z_P;
			 fin_traitement = true;// pour indiquer que c'est ok
			 };
		};
	 // 2)----	
	 // dans le cas où fin_traitement est toujours faux, cela signifie que le cas sortie par un quadrangle n'a pas marché
	 // donc cela signifie que le point P est sur la face sup ou inf. En fait cela dépend de z_M si c'est positif alors
	 // c'est la face sup donc z_P=1 sinon c'est la face inf donc z_P=-1
	 // on considère un plan vertical qui passe par G, M et P . On a GMxy/z_M = GPxy/z_P avec z_P connu
	 // d'où GPxy = z_P * GMxy/z_M = e (en module) d'où \vec{GPxy} = e * \vec{GMxy)/||GMxy|| = z_P / z_M * \vec{GMxy) d'où P
	 if (! fin_traitement)	
	  { if (z > ConstMath::trespetit)
	    { // cas d'une sortie par la facette supérieure, z_P = 1.
		   Coordonnee GPxy = GMxy / z;
			P(1) = untiers + GPxy(1); P(2) = untiers + GPxy(2); P(3) = 1.;
			 fin_traitement = true;// pour indiquer que c'est ok
		  }	 
	    else if (z < -ConstMath::trespetit)
	    { // cas d'une sortie par la facette inférieure, z_P = -1.
		   Coordonnee GPxy = (-1./z) * GMxy ;
			P(1) = untiers + GPxy(1); P(2) = untiers + GPxy(2); P(3) = -1.;
			 fin_traitement = true;// pour indiquer que c'est ok
		  }	 
       else
		  // arrivée ici, cela veut dire que z est quasiment nulle, et pourtant due au 1)--- 
		  // - soit Abs(z_P) est > 1 , ce qui n'est pas possible car on vient de trouver z quasiment nulle
		  // - soit gmxy est également quasiment nulle : dans ce cas on choisit arbitrairement P(0,0,0)
		  { P.Zero();}; 
		};
		 
    #ifdef MISE_AU_POINT
          if ((P(1) + P(2)) > (1. + ConstMath::petit))
		     { cout << "\n petit soucis, le point maxi calcule n'est pas correcte ";
			    P.Affiche(cout); 
			    cout << "\n GeomPentaCom::Maxi_Coor_dans_directionGM(.." << endl;
			   }; 
    #endif
/*	 
	 
// en fait il y a un pb, car la suite à l'air correcte si on cherche l'intersection de OM avec la frontière
// mais ce qu'il nous faut c'est GM avec la frontière, il faut donc quelques modifs !!
cout << "\n ***************** GeomPentaCom::Maxi_Coor_dans_directionGM( a revoir ******" << endl;	 
	 
    if ((Dabs(x) <= ConstMath::petit) && (Dabs(y) <= ConstMath::petit))
      { // cas où x et y transformées sont quasi nulles, il ne reste plus qu'à examiner le cas de z
        if (Dabs(z) <= ConstMath::petit)
         { // cas où toutes les coordonnées sont nulles, retour de M
			  // on met les coordonnées en x, y strictement à 0. pour éviter d'être légèrement à l'extérieur
           return Coordonnee (0.,0.,z);
          }
        else // cas où l'on modifie  suivant z (le point est sur le triangle sup ou inf)
         { return Coordonnee (0.,0.,Pz(1));
          }  
       }
    else // cas où x ou/et y sont non nulles
     {// on calcul de facteur de réduction suivant xy
      double facteurxy=0.;
      if (Dabs(x) <= ConstMath::petit) // donc y est non nulle
       {// cas donc où seule y a peut-être variée
        facteurxy = Pxy(2)/y;
        }
      else if (Dabs(y) <= ConstMath::petit) // donc x est non nulle
        {// cas donc où seule x a peut-être variée
         facteurxy = Pxy(1)/x; 
         }
      else // cas où x et y sont non nulles
        {// cas donc où x et  y x ont peut-être variées
         facteurxy = MiN(Pxy(1)/x,Pxy(2)/y);
         }   
      // on regarde maintenant du coté de z 
      if (Dabs(z) <= ConstMath::petit)
        { // z ne participe pas car nulle 
          return Coordonnee (Pxy(1),Pxy(2),z);
         }
      else // cas où la modification est possible suivant z
        { double facteurz= Pz(1)/z;
          // on prend le plus petit des deux facteurs
          if (facteurxy <= facteurz)
             { // c'est le facteur dans le plan qui agit
               return Coordonnee (Pxy(1),Pxy(2),facteurxy*z);
              }
          else
             { // c'est le facteur suivant z qui agit
               return Coordonnee (facteurz*x,facteurz*y,Pz(1));
              }
          }  
      } //-- fin du cas  où x ou/et y sont non nulles  
      // 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 GeomPentaCom::Maxi_Coor_dans_directionGM(..";
      Sortie(1);  */   
      return M; // pour éviter un warning
   }; 

  
  
  
  
    



