// fichier: Base.h


// 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-2021 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/>.

/************************************************************************
*     DATE:        23/01/97                                            *
*                                                                $     *
*     AUTEUR:      G RIO                                               *
*                                                                $     *
*     PROJET:      Herezh++                                            *
*                                                                $     *
************************************************************************
* BUT: Les classes Base servent à définir des bases en 1D 2D 3D
*      qui  permettent d'exprimer des coordonnées, en absolue ou en locale.
*      Ces bases correspondent à des bases naturelles ou des bases duales.
*                                                                $     *
*     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
*     MODIFICATIONS:                                                   *
*     !  date  !   auteur   !       but                          !     *
*     ------------------------------------------------------------     *
*                                                                $     *
************************************************************************/

#ifndef BASE_H
#define BASE_H

#include "Tableau_T.h"
#include "Coordonnee1.h"
#include "Mat_pleine.h"


/** @defgroup Les_classes_Base
*
* BUT: Les classes Base servent à définir des bases en 1D 2D 3D
*      qui  permettent d'exprimer des coordonnées, en absolue ou en locale.
*      Ces bases correspondent à des bases naturelles ou des bases duales.
* \author    Gérard Rio
* \version   1.0
* \date       23/01/97
* \brief       Définition des bases naturelles ou  absolues,
*  ou des bases duales.
*
*/



/// @addtogroup Les_classes_Base
///  @{
///

class BaseH;
class Util;

//===============================================================
//! Les base covariantes et absolus
//===============================================================
class   BaseB
{  /// surcharge de l'operator de lecture  avec le type
   friend istream & operator >> (istream &, BaseB &);
   /// surcharge de l'operator d'ecriture
   friend ostream & operator << (ostream &, const BaseB &);
     
  public :
    // VARIABLES PUBLIQUES :
    
    // CONSTRUCTEURS :
    
    /*! \brief
    // constructeur par defaut, defini la Base absolu en dimension 3
    // les vecteurs sont unitaires, ex en dim 2 ->
    // la base : 1,0 et 0,1 */
    BaseB () ;
    
    /// defini la Base absolu en dimension dim
    BaseB (int dim);
    
    /*! \brief
    // defini une Base relative v1(dim)
    // c-a-d differente de la base triviale absolu */
    BaseB (int dim, const Tableau<CoordonneeB > & v1);
    
    /*! \brief
    // defini une Base locale absolue (triviale) de n vecteurs
    // de dimension dim */
    BaseB (int dim,int n);
    
    /// idem dessus mais avec toutes les composantes = s
    BaseB (int dim,int n,double s);
    
    /*! \brief
    // defini une Base locale relative v1(dim)
    // de n vecteurs de dimension dim */
    BaseB (int dim,int n,const Tableau<CoordonneeB > & v1);
                                                  
    /// constructeur de copie
    BaseB (const BaseB &) ;
    
    /// DESTRUCTEUR :
    ~BaseB ();
    // METHODES PUBLIQUES :
    
    /// surcharge de l'affectation
    BaseB & operator = (const BaseB & aB);
    
    // retourne la dimension des vecteurs
    inline const int Dimension ()  const
      {return dimension; };
      
    /// retourne le nombre de vecteurs de la base
    inline const int NbVecteur ()  const
      {return nb_vecteur; };
    /// retourne  le i ieme vecteurs en lecture only
    const CoordonneeB & operator () (int i) const;
    /// retourne  le i ieme vecteurs en I/O
    CoordonneeB&  CoordoB(int i)  ;
    /// acces directe contrôlé à des vecteurs sans variance: uniquement en lecture
    const Coordonnee & Coordo(int i) const ;
 
    /// affichage à l'écran des infos
    void Affiche() const;
 
    /*! \brief
    // affectation trans_variance: utile pour une recopie de mêmes valeurs
    // mais ici l'appel est explicite donc a priori on sait ce que l'on fait
    // il n'y a pas de redimensionnement, donc la dimension et le nombre des vecteurs
    // doivent être identiques */
    void Affectation_trans_variance(const BaseH& aH);
 
    /*! \brief
    // changement de base
    // on suppose que this(i) correspond aux coordonnées dans un premier repère I_a
    // IpH correspond aux coordonnées dans I_a d'un nouveau repère
    // en sortie: apB(i) correspond aux coordonnées dans ipB de this(i) */
    void Change_repere(const BaseH& IpH, BaseB& apB);
 
    /*! \brief
    // la méthode qui suit a pour objectif de calculer les vecteurs de la base naturelle finale
    // associée à un paramétrage cartésien initial */
    
    /// donc soit  connue une base naturelle \hat g_i associée à un paramétrage theta^i
    /// \hat g_i est représenté par les vecteurs de this, et représente la situation déformée
    /// soit la base duale de g_i : gammaH^i = g^i c-à-d la base duale en situation non déformée
    /// maintenant: si on considère les coordonnées initiales X^i on cherche
    /// les vecteurs des bases naturelles associées à X^i avant g'_i et après déformation \hat g'_i
    /// \n on a (cf. annexe dans le document théorique d'Herezh)
    /// \n g'_i = I_i par définition et
    /// \n \hat g'_i =  (\vec I_i . \vec g^j) ~\hat g_j c-a-d
    /// \n \hat g'_i = gammaH^j(i) * (*this)(j)
    /// \n c'est le résultat de la méthode qui suit
 
    /// \n changement de base: retourne apB(a) = (*this)(j) . gamma^j_a
    /// il faut que le nombre de vecteur de apB soit identique à la dimension de gammaH
    /// et que le nombre de vecteur de gammaH soit identique au nombre de vecteur de this
    /// et que la dimension de apB soit identique à la dimension de this
    void ChangeBase_theta_vers_Xi(BaseB& apB, const BaseH& gammaH);
 
    /*! \brief
    // la méthode calcule à partir de this qui correspond à g_alpha dans I_a:
    //   apB :  g_alpha dans I'^alpha
    //   apH :  g^alpha dans I'^alpha
    //   IpB :  I'_beta dans I_a  */

    /// soient une base globale orthonormée : I_a et une base locale orthonormée I'_alpha
    /// pour l'instant: I_a est en 3 dimensions et alpha varie de 1 à 2
    /// soient une base naturelle g_alpha et duale associée g^beta
    /// telles que : I'_alpha appartient à l'espace des g_alpha ou g^beta
    /// \n A) on a:
    /// g^alpha = gamma(alpha,beta) * I'^beta  c-a-d : gamma^alpha_beta
    /// \n NB: 1) comme I'est orthonormée: I'^beta = I'_beta
    /// \n     2) chaque ligne de gamma représente un g^alpha
    /// \n B) dans ce contexte on a:
    /// inverse de gamma -> une matrice beta et chaque ligne de beta représente
    /// les coordonnées de g_alpha dans I'^alpha
    /// c-a-d g_alpha = alpha (delta,alpha) * I'_delta
    /// \n C) on peut également calculer les coordonnées de I'_beta dans le repère globale
    /// \n I'_beta = gamma(alpha,beta) * g_alpha
    //
    void ChangeBase_curviligne( const Mat_pleine& gamma, BaseB& apB , BaseH& apH, BaseB& IpB ) const;
 
    /*! \brief
    // calcul des composantes de coordonnées locales  dans la base absolue
    // en argument : A -> une reference sur les coordonnées résultat qui peut avoir une dimension
    // différente des coordonnées locale,  retour d'une reference sur A */
    Coordonnee & BaseAbsolue(Coordonnee & A,const CoordonneeH & B)  const;
	 
    /*! \brief
    // une partie des vecteurs de B est affectée à this,
    // si this contient plus de vecteur que B, les autres vecteurs sont mis à 0 ou non
    // suivant la valeur de  plusZero: = false: les autres vecteurs  sont inchangées, 
    // plusZero = true: les autres vecteurs sont mis à 0 */
    void Affectation_partielle(int nb_vecteur_a_affecter, const BaseB & B,bool plusZero);  

  private :  
    // VARIABLES PROTEGEES :
    int dimension; // dimension des vecteurs de la Base
    int nb_vecteur; // nombre de vecteur de la base
    Tableau<CoordonneeB > v ; // pointeur des vecteurs covariants de la Base
    Tableau<Coordonnee > v_sans ; // pointeur des vecteurs sans variance de la Base
    
    /// on met à la même place les v_sans que les v
    void Meme_place_coordonnee();
 };
 /// @}  // end of group

/// @addtogroup Les_classes_Base
///  @{
///

//===============================================================
//! Les base duales
//===============================================================

class   BaseH
{  /// surcharge de l'operator de lecture  avec le type
   friend istream & operator >> (istream &, BaseH &);
   /// surcharge de l'operator d'ecriture
   friend ostream & operator << (ostream &, const BaseH &);

  public :
    // VARIABLES PUBLIQUES :
    
    // CONSTRUCTEURS :
    /*! \brief
    // par defaut, defini une Base absolu en dimension 3
    // les vecteurs sont unitaires, ex en dim 2 ->
    // la base : 1,0 et 0,1 */
    BaseH () ;
    /// defini une Base absolu en dimension dim
    BaseH (int dim);
    /*! \brief
    // defini une Base relative v1(dim)
    // c-a-d differente de la base triviale absolue */
    BaseH (int dim, const Tableau<CoordonneeH > & v1);
    /*! \brief
    // defini une Base locale absolue (triviale) de n vecteurs
    // de dimension dim */
    BaseH (int dim,int n);
   /// idem dessus mais avec toutes les composantes = s
    BaseH (int dim,int n,double s);
    /// defini une Base locale relative v1(dim) de n vecteurs de dimension dim
    BaseH (int dim,int n,const Tableau<CoordonneeH >&  v1);
    /// constructeur de copie
    BaseH (const BaseH &) ;
    /// DESTRUCTEUR :
    ~BaseH ();
    // METHODES PUBLIQUES :
    
    /// surcharge de l'affectation
    BaseH & operator = (const BaseH & aB);
    /// retourne la dimension des vecteurs
    inline const int Dimension () const
      {return dimension; };
    /// retourne le nombre de vecteurs de la base
    inline const int NbVecteur () const
      {return nb_vecteur; };
    /// retourne  le i ieme vecteurs en lecture only
    const CoordonneeH & operator () (int i) const;
    /// retourne  le i ieme vecteurs en I/O
    CoordonneeH&  CoordoH(int i) ;
    /// acces directe contrôlé à des vecteurs sans variance: uniquement en lecture
    const Coordonnee & Coordo(int i) const ;
 
    /// affichage à l'écran des infos
    void Affiche() const;
 
    /*! \brief
    // affectation trans_variance: utile pour une recopie de mêmes valeurs
    // mais ici l'appel est explicite donc a priori on sait ce que l'on fait
    // il n'y a pas de redimensionnement, donc la dimension et le nombre des vecteurs
    // doivent être identiques */
    void Affectation_trans_variance(const BaseB& aB);
 
    /*! \brief
    // changement de base
    // on suppose que this(i) correspond aux coordonnées dans un premier repère I_a
    // IpB correspond aux coordonnées dans I_a d'un nouveau repère
    // en sortie: apH(i) correspond aux coordonnées dans ipH de this(i) */
    void Change_repere(const BaseB& IpB, BaseH& apH);
 
    /*! \brief
    // la méthode qui suit a pour objectif de calcul les vecteurs de la base naturelle finale
    // associée à un paramétrage cartésien initiale */
    
    /// donc soit  connue une base duale \hat g^i associée à un paramétrage theta^i
    /// \hat g^i est représenté par les vecteurs de this, et représente la situation déformée
    /// soit la base naturel de g_i : betaB_i = g_i c-à-d la base naturelle en situation non déformée
    /// maintenant: si on considère les coordonnées initiales X^i on cherche
    /// les vecteurs des bases duales associées à X^i avant g'^i et après déformation \hat g'^i
    /// on a (cf. annexe dans le document théorique d'Herezh)
    /// \n g'^i = g'_i =  I_i = I^i par définition et
    /// \n \hat g'^i =  (\vec I_i . \vec g_j) ~\hat g^j c-a-d
    /// \n \hat g'^i = betaB^j(i) * (*this)(j)
    /// \n c'est le résultat de la méthode qui suit

    /// \n changement de base: retourne apH(a) = (*this)(j) . beta_j^a
    /// il faut que le nombre de vecteur de apH soit identique à la dimension de betaB
    /// et que le nombre de vecteur de betaB soit identique au nombre de vecteur de this
    /// et que la dimension de apB soit identique à la dimension de this
    void ChangeBase_theta_vers_Xi(BaseH& apH, const BaseB& betaB);
 
    /*! \brief
    // la méthode calcule à partir de this qui correspond à g^alpha dans I_a:
    //   apB :  g_alpha dans I'^alpha
    //   apH :  g^alpha dans I'^alpha
    //   IpH :  I'^beta dans I_a */

    /// soient une base globale orthonormée : I_a et une base locale orthonormée I'_alpha
    /// pour l'instant: I_a est en 3 dimensions et alpha varie de 1 à 2
    /// soient une base naturelle g_alpha et duale associée g^beta
    /// telles que : I'_alpha appartient à l'espace des g_alpha ou g^beta
    /// \n A) on a:
    /// g^alpha = gamma(alpha,beta) * I'^beta  c-a-d : gamma^alpha_beta
    /// \n NB: 1) comme I'est orthonormée: I'^beta = I'_beta
    ///     2) chaque ligne de gamma représente un g^alpha
    /// \n B) dans ce contexte on a:
    /// inverse de gamma -> une matrice beta et chaque ligne de beta représente
    /// les coordonnées de g_alpha dans I'^alpha
    /// c-a-d g_alpha = alpha (delta,alpha) * I'_delta
    /// \n C) on peut également calculer les coordonnées de I'_beta dans le repère globale
    /// \n I'_beta = gamma(alpha,beta) * g_alpha
    //
    void ChangeBase_curviligne( const Mat_pleine& gamma, BaseB& apB , BaseH& apH, BaseH& IpH ) const;
 
    /*! \brief
    // calcul des composantes de coordonnées locales  dans la base absolue
    // en argument : A -> une reference sur les coordonnées résultat qui peut avoir une dimension
    // différente des coordonnées locale,  retour d'une reference sur A */
    Coordonnee & BaseAbsolue(Coordonnee & A,const CoordonneeB & B)  const;
	
    /*! \brief
    // une partie des vecteurs de B est affectée à this,
    // si this contient plus de vecteur que B, les autres vecteurs sont mis à 0 ou non
    // suivant la valeur de  plusZero: = false: les autres vecteurs  sont inchangées, 
    // plusZero = true: les autres vecteurs sont mis à 0  */
    void Affectation_partielle(int nb_vecteur_a_affecter, const BaseH & B,bool plusZero);  
 
  private :  
    // VARIABLES PROTEGEES :
    int dimension; // dimension des vecteurs de la Base
    int nb_vecteur; // nombre de vecteur de la base
    Tableau<CoordonneeH > v ; // pointeur des vecteurs contravariant de la Base
    Tableau<Coordonnee > v_sans ; // pointeur des vecteurs sans variance de la Base
    
    // on met à la même place les v_sans que les v
    void Meme_place_coordonnee();
 };
/// @}  // end of group

/// @addtogroup Les_classes_Base
///  @{

//=========================================================================
//! un groupe de 3  bases covariantes et absolus à 0, t et tdt
//=========================================================================
/// il s'agit ici essentiellement d'un conteneur pour optimiser le stockage
//=========================================================================

 class BaseB_0_t_tdt
 { /// surcharge de l'operator de lecture  avec le type
   friend istream & operator >> (istream &, BaseB_0_t_tdt &);
   /// surcharge de l'operator d'ecriture
   friend ostream & operator << (ostream &, const BaseB_0_t_tdt &);
     
  public :
    // VARIABLES PUBLIQUES :
    
    // CONSTRUCTEURS :
    
    /// par defaut, defini les Bases en absolu en dimension 3
    /// les vecteurs sont unitaires, ex en dim 2 ->
    /// la base : 1,0 et 0,1
    BaseB_0_t_tdt () :
      baseB_0(),baseB_t(), baseB() {};
    /// defini les Bases en absolu en dimension dim
    BaseB_0_t_tdt (int dim) :
      baseB_0(dim),baseB_t(dim), baseB(dim) {};
    /// defini 3 Bases relatives v1(dim)
    /// c-a-d differente de la base triviale absolu
    BaseB_0_t_tdt (int dim, const Tableau<CoordonneeB > & v1) :
      baseB_0(dim,v1),baseB_t(dim,v1), baseB(dim,v1) {};
    /// defini les Bases locale absolue (triviale) de n vecteurs
    /// de dimension dim
    BaseB_0_t_tdt (int dim,int n) :
      baseB_0(dim,n),baseB_t(dim,n), baseB(dim,n) {};
    /// idem dessus mais avec toutes les composantes = s
    BaseB_0_t_tdt (int dim,int n,double s) :
       baseB_0(dim,n,s),baseB_t(dim,n,s), baseB(dim,n,s) {};
    /// defini les Bases locale relative v1(dim)
    /// de n vecteurs de dimension dim
    BaseB_0_t_tdt (int dim,int n,const Tableau<CoordonneeB > & v1) :
       baseB_0(dim,n,v1),baseB_t(dim,n,v1), baseB(dim,n,v1) {};
    /// constructeur de copie
    BaseB_0_t_tdt (const BaseB_0_t_tdt & b):
     baseB_0(b.baseB_0),baseB_t(b.baseB_t), baseB(b.baseB) {};
 
    /// DESTRUCTEUR :
    ~BaseB_0_t_tdt () {};
    // METHODES PUBLIQUES :
    /// surcharge de l'affectation
    BaseB_0_t_tdt & operator = (const BaseB_0_t_tdt & b)
     {baseB_0 = b.baseB_0; baseB_t = b.baseB_t; baseB = b.baseB;
     };
  
    /// récupération de la base,
    ///  a) en constant, la base actuelle
    const BaseB& Const_BaseB_Noeud() const {return baseB;};
    ///  b) en constant, la base à t
    const BaseB& Const_BaseB_Noeud_t() const {return baseB_t;};
    ///  c) en constant, la base initiale
    const BaseB& Const_BaseB_Noeud_0() const {return baseB_0;};

    ///  d) en lecture écriture, la base actuelle
    BaseB& BaseB_Noeud()  {return baseB;};
    ///  e) en lecture écriture, la base à t
    BaseB& BaseB_Noeud_t() {return baseB_t;};
    ///  f) en lecture écriture, la base à 0
    BaseB& BaseB_Noeud_0()  {return baseB_0;};
  
  
    private :
        BaseB  baseB_0;   // à 0
        BaseB  baseB_t;   // à t
        BaseB  baseB;     // actuelle
 };
/// @}  // end of group

/// @addtogroup Les_classes_Base
///  @{
///


//=========================================================================
//! un groupe de 3  bases contravariant et absolus à 0, t et tdt
//=========================================================================
/// il s'agit ici essentiellement d'un conteneur pour optimiser le stockage
//=========================================================================

 class BaseH_0_t_tdt
 { /// surcharge de l'operator de lecture  avec le type
   friend istream & operator >> (istream & ent, BaseH_0_t_tdt &)
     {
     
     };
   /// surcharge de l'operator d'ecriture
   friend ostream & operator << (ostream & sort, const BaseH_0_t_tdt &);
  
  public :
    // VARIABLES PUBLIQUES :
  
    /// CONSTRUCTEURS :
    /// par defaut, defini les Bases en absolu en dimension 3
    /// les vecteurs sont unitaires, ex en dim 2 ->
    /// la base : 1,0 et 0,1
    BaseH_0_t_tdt () :
      baseH_0(),baseH_t(), baseH() {};
    /// defini les Bases en absolu en dimension dim
    BaseH_0_t_tdt (int dim) :
      baseH_0(dim),baseH_t(dim), baseH(dim) {};
    /// defini 3 Bases relatives v1(dim)
    /// c-a-d differente de la base triviale absolu
    BaseH_0_t_tdt (int dim, const Tableau<CoordonneeH > & v1) :
      baseH_0(dim,v1),baseH_t(dim,v1), baseH(dim,v1) {};
    /// defini les Bases locale absolue (triviale) de n vecteurs
    /// de dimension dim
    BaseH_0_t_tdt (int dim,int n) :
      baseH_0(dim,n),baseH_t(dim,n), baseH(dim,n) {};
    /// idem dessus mais avec toutes les composantes = s
    BaseH_0_t_tdt (int dim,int n,double s) :
       baseH_0(dim,n,s),baseH_t(dim,n,s), baseH(dim,n,s) {};
    /// defini les Bases locale relative v1(dim)
    /// de n vecteurs de dimension dim
    BaseH_0_t_tdt (int dim,int n,const Tableau<CoordonneeH > & v1) :
       baseH_0(dim,n,v1),baseH_t(dim,n,v1), baseH(dim,n,v1) {};
    /// constructeur de copie
    BaseH_0_t_tdt (const BaseH_0_t_tdt & b):
     baseH_0(b.baseH_0),baseH_t(b.baseH_t), baseH(b.baseH) {};
 
    /// DESTRUCTEUR :
    ~BaseH_0_t_tdt () {};
    // METHODES PUBLIQUES :
    /// surcharge de l'affectation
    BaseH_0_t_tdt & operator = (const BaseH_0_t_tdt & b)
     {baseH_0 = b.baseH_0; baseH_t = b.baseH_t; baseH = b.baseH; return *this;
     };
  
    /// récupération de la base,
    ///  a) en constant, la base actuelle
    const BaseH& Const_BaseH_Noeud() const {return baseH;};
    ///  b) en constant, la base à t
    const BaseH& Const_BaseH_Noeud_t() const {return baseH_t;};
    ///  c) en constant, la base initiale
    const BaseH& Const_BaseH_Noeud_0() const {return baseH_0;};

    ///  d) en lecture écriture, la base actuelle
    BaseH& BaseH_Noeud()  {return baseH;};
    ///  e) en lecture écriture, la base à t
    BaseH& BaseH_Noeud_t() {return baseH_t;};
    ///  f) en lecture écriture, la base à 0
    BaseH& BaseH_Noeud_0()  {return baseH_0;};
  
  
    private :
        BaseH  baseH_0;   // à 0
        BaseH  baseH_t;   // à t
        BaseH  baseH;     // actuelle
 };
/// @}  // end of group

 
#ifndef MISE_AU_POINT
  #include "Base.cc"
  #define  BASE_HetB_deja_inclus
#endif
 
#endif  
