

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

/************************************************************************
 *     DATE:        1/10/98                                             *
 *                                                                $     *
 *     AUTEUR:      G RIO   (mailto:gerardrio56@free.fr)                *
 *                                                                $     *
 *     PROJET:      Herezh++                                            *
 *                                                                $     *
 ************************************************************************
 *     BUT: Classe générale des potentiels hyperélastiques isotropes,   *
 *     définis à partir des invariants :                                *
 *      - V  : variation relative de volume,                            *
 *      - Ieps  : trace du tenseur de déformation d'Almansi,            *
 *      - bIIb  : deuxième invariant barre, du déviateur des            *
 *                déformations.                                         *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/
#ifndef HYPERDN_H
#define HYPERDN_H

#include "Loi_comp_abstraite.h"



/// @addtogroup Les_lois_hyperelastiques
///  @{
///

template <class TensHH,class TensBB,class TensBH,class TensHB,
          class Tens_nHH,class Tens_nBB>
class HyperDN : public Loi_comp_abstraite
{
  public :
		// CONSTRUCTEURS :
		
    HyperDN (); // Constructeur par defaut
    // Constructeur utile si l'identificateur du nom de la loi
    // de comportement et la dimension  sont connus
    HyperDN (Enum_comp id_compor,Enum_categorie_loi_comp categorie_comp,int dimension)  ;
    // Constructeur utile si l'identificateur du nom de la loi
    // de comportement et la dimension  sont connus
    HyperDN (char* nom,Enum_categorie_loi_comp categorie_comp,int dimension) ;
    // DESTRUCTEUR :
    ~HyperDN ();
    // constructeur de copie
    HyperDN (const HyperDN & a) ;
	  
    // 1) definition d'une classe dérivée de SaveResul pour stocker le
    // jacobien initial

    class SaveResulHyperDN : public Loi_comp_abstraite::SaveResul
     { public :
          // constructeur
          SaveResulHyperDN(const double & jacob) : jacobien_0(jacob) {};
          // destructeur
          ~SaveResulHyperDN() {};
          
          // définition d'une nouvelle instance identique
          // appelle du constructeur via new
          SaveResul * Nevez_SaveResul() const {return (new SaveResulHyperDN(*this));};
          // affectation
          virtual SaveResul & operator = ( const SaveResul & a)
            { SaveResulHyperDN& sav = *((SaveResulHyperDN*) &a);
              jacobien_0=sav.jacobien_0;
              return *this;
            };
          //============= lecture écriture dans base info ==========
             // cas donne le niveau de la récupération
             // = 1 : on récupère tout
             // = 2 : on récupère uniquement les données variables (supposées comme telles)
          virtual void Lecture_base_info (ifstream& ent,const int cas) {};
             // cas donne le niveau de sauvegarde
             // = 1 : on sauvegarde tout
             // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
          virtual void Ecriture_base_info(ofstream& sort,const int cas) {};
          
          // affichage à l'écran des infos
          void Affiche() const { cout << "\n SaveResulHyperDN: jacobien_0= " << jacobien_0 << " ";};
        
          //changement de base de toutes les grandeurs internes tensorielles stockées
          // beta(i,j) represente les coordonnees de la nouvelle base naturelle gpB dans l'ancienne gB
          // gpB(i) = beta(i,j) * gB(j), i indice de ligne, j indice de colonne
          // ici il ne s'agit que de grandeurs scalaires donc rien n'a faire
          // gpH(i) = gamma(i,j) * gH(j)
          virtual void ChBase_des_grandeurs(const Mat_pleine& beta,const Mat_pleine& gamma){};
      
          // procedure permettant de completer éventuellement les données particulières
          // de la loi stockées
          // au niveau du point d'intégration par exemple: exemple: un repère d'anisotropie
          // completer est appelé apres sa creation avec les donnees du bloc transmis
          // peut etre appeler plusieurs fois
          SaveResul* Complete_SaveResul(const BlocGen & bloc, const Tableau <Coordonnee>& tab_coor
                                           ,const Loi_comp_abstraite* loi) {return NULL;};
                                           

          double jacobien_0;
      };

     SaveResul * New_et_Initialise() { return (new SaveResulHyperDN(0.));};
 
     // 2) METHODES public découlant de méthodes virtuelles :
       
      // affichage des donnees particulieres a l'elements
      // de matiere traite ( c-a-dire au pt calcule)
      void AfficheDataSpecif(ofstream& ,SaveResul * ) const {};

            
      protected :
      
     // 3) METHODES  protegees découlant de virtuelles pures:
      // calcul des contraintes a t+dt
             // calcul des contraintes
      void Calcul_SigmaHH (TenseurHH & sigHH_t,TenseurBB& DepsBB,DdlElement & tab_ddl
          ,TenseurBB & gijBB_t,TenseurHH & gijHH_t,BaseB& giB,BaseH& gi_H, TenseurBB & epsBB_
          ,TenseurBB & delta_epsBB_
          ,TenseurBB & gijBB_,TenseurHH & gijHH_,Tableau <TenseurBB *>& d_gijBB_
          ,double& jacobien_0,double& jacobien,TenseurHH & sigHH
          ,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double&  module_cisaillement
          ,const Met_abstraite::Expli_t_tdt& ex);

            // calcul des contraintes et de ses variations  a t+dt
      void Calcul_DsigmaHH_tdt (TenseurHH & sigHH_t,TenseurBB& DepsBB,DdlElement & tab_ddl
          ,BaseB& giB_t,TenseurBB & gijBB_t,TenseurHH & gijHH_t
          ,BaseB& giB_tdt,Tableau <BaseB> & d_giB_tdt,BaseH& giH_tdt,Tableau <BaseH> & d_giH_tdt
          ,TenseurBB & epsBB_tdt,Tableau <TenseurBB *>& d_epsBB
          ,TenseurBB & delta_epsBB,TenseurBB & gijBB_tdt,TenseurHH & gijHH_tdt
          ,Tableau <TenseurBB *>& d_gijBB_tdt
          ,Tableau <TenseurHH *>& d_gijHH_tdt,double& jacobien_0,double& jacobien
          ,Vecteur& d_jacobien_tdt,TenseurHH& sigHH,Tableau <TenseurHH *>& d_sigHH
          ,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double&  module_cisaillement
          ,const Met_abstraite::Impli& ex);
          

      // fonction surchargée dans les classes dérivée si besoin est
      virtual void CalculGrandeurTravail
                      (const PtIntegMecaInterne& ,const Deformation &
                       ,Enum_dure,const ThermoDonnee&
                       ,const Met_abstraite::Impli* ex_impli
                       ,const Met_abstraite::Expli_t_tdt* ex_expli_tdt
                       ,const Met_abstraite::Umat_cont* ex_umat
                       ,const List_io<Ddl_etendu>* exclure_dd_etend
                       ,const List_io<const TypeQuelconque *>* exclure_Q
                       ) {};

      // 4) METHODES internes spécifiques à l'hyperélasticité isotrope

      // par exemple, regarder dans hyper10N pour le calcul des invariants
      
      // Calcul des trois invariants ,de epsBH,
       // retour de IdGBH qui pointe sur le bon tenseur
      virtual TensBH *  Invariants (TenseurBB&  epsBB_t,TenseurBB& gijBB_t,
                TenseurHH & gijHH_t, double& jacobien_0,double& jacobien_t,
                double & Ieps,double & V,double& bIIb,TensBH & epsBH) = 0;
      // calcul des trois invariants et de leurs variations, de epsBH,
       // et de sa variation, puis retour de IdGBH qui pointe sur le bon tenseur
      virtual TensBH *  Invariants_et_var
               (TenseurBB&  epsBB_tdt,
                TenseurBB& gijBB_tdt,Tableau <TenseurBB *>& d_gijBB_tdt,
                TenseurHH & gijHH_tdt,Tableau <TenseurHH *>& d_gijHH_tdt,
                double& jacobien_0,double& jacobien_tdt,Vecteur& d_jacobien_tdt,
                double & Ieps,Tableau<double> & dIeps,
                double & V,Tableau<double> & dV,double& bIIb,Tableau<double> & dbIIb,
                TensBH & epsBH,Tableau<TensBH> & depsBH) = 0;
                  
      // calcul du potentiel et de ses dérivées premières
      virtual void Potentiel(double& jacobien_0, double& Ieps,double& V,double& bIIb,
                  double& E,double& EV,double& EbIIb,double& EIeps) = 0;
      // calcul  du potentiel et de ses dérivées premières et secondes
      virtual void Potentiel_et_var(double& jacobien_0,double&  Ieps,double&  V,double& bIIb,
               double& E,double& EV,double& EbIIb,double& EIeps ,
               double& EVV,double& EbIIb2,double& EIeps2,
               double& EVbIIb,double& EVIeps,double& EbIIbIeps ) = 0;
          
       protected  :
         // VARIABLES PROTEGEES :

         // METHODES PROTEGEES :
      // calcul des coefficients alpha
      inline void Alpha (double& E,double& EV,double& EbIIb,double& EIeps,
             double& jacobien_0,double&  Ieps,double&  V,double& bIIb,
             double&  alpha_0,double&  alpha_1,double&  alpha_2);
          

      // calcul des coefficients alpha  et de leurs variations par rapport aux degrés de libertés
      inline void Alpha_var (double& E,double& EV,double& EbIIb,double& EIeps,
             double& EVV,double& EbIIb2,double& EIeps2,
             double& EVbIIb,double& EVIeps,double& EbIIbIeps,
             double& jacobien_0,double&  Ieps,Tableau<double> & dIeps,double&  V,Tableau<double> & dV,
             double& bIIb,Tableau<double> & dbIIb,
             double&  alpha_0,Tableau<double> & dalpha_0,
             double&  alpha_1,Tableau<double> & dalpha_1,
             double&  alpha_2,Tableau<double> & dalpha_2);

   };
 /// @}  // end of group

 #include "HyperDN.cc"

 
#endif  
