// 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:        1/10/98                                             *
 *                                                                $     *
 *     AUTEUR:      G RIO   (mailto:gerardrio56@free.fr)                *
 *                                                                $     *
 *     PROJET:      Herezh++                                            *
 *                                                                $     *
 ************************************************************************
 *     BUT: Classe générale des potentiels hyperélastiques isotropes,   *
 *     tels que définis par Denis Favier.                               *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/
#ifndef HYPERD_H
#define HYPERD_H

#include "Loi_comp_abstraite.h"
#include "Tenseur.h"
#include "Tenseur3.h"
#include "TenseurQ-3.h"
#include "TenseurQ3gene.h" 
#include "TypeConsTens.h"

/** @defgroup Les_lois_hyperelastiques
*
*     BUT:   groupe des lois hyperelastiques
*
*
* \author    Gérard Rio
* \version   1.0
* \date       11/06/2019
* \brief       groupe des lois hyperelastiques
*
*/

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


//template <class TensHH,class TensBB,class TensBH,class TensHB>
class HyperD : public Loi_comp_abstraite
{
  public :
		// CONSTRUCTEURS :
		
  HyperD (); // Constructeur par defaut
  // Constructeur utile si l'identificateur du nom de la loi
  // de comportement,  le paramètre phase sont connus
  HyperD (Enum_comp id_compor,Enum_categorie_loi_comp categorie_comp,int dimension, bool avec_ph)  ;
  // Constructeur utile si l'identificateur du nom de la loi
  // de comportement,  le paramètre phase sont connus		
  HyperD (char* nom,Enum_categorie_loi_comp categorie_comp,int dimension,bool avec_ph) ;	
  // DESTRUCTEUR :
  ~HyperD (); 
  // constructeur de copie
  HyperD (const HyperD & a) ;
	  
		

  // classe permettant le stockage de grandeurs de post-traitement
  class Invariantpost3D
   { public :
     Invariantpost3D() : V(0.),Qeps(0.),cos3phi(0.),potentiel(0.) {}; // constructeur par défaut
     Invariantpost3D(const double& V1,const double& Qe, const double& cos3p,const double& potent)
        : V(V1),Qeps(Qe),cos3phi(cos3p),potentiel(potent) {};
     Invariantpost3D(const Invariantpost3D & a)
        : V(a.V),Qeps(a.Qeps),cos3phi(a.cos3phi),potentiel(a.potentiel) {};
     // Surcharge de l'operateur = : realise l'affectation
     Invariantpost3D& operator= (const Invariantpost3D& a)
        {V=a.V;Qeps=a.Qeps;cos3phi=a.cos3phi;potentiel=a.potentiel;return (*this);};
     // surcharge de l'operator de lecture
     friend  istream & operator >> (istream & ent, Invariantpost3D  & a)
      { string toto;
        ent >> toto >>  a.V >> toto >>  a.Qeps >> toto >>  a.cos3phi
            >> toto >>  a.potentiel; return ent;
      };
     // surcharge de l'operator d'ecriture
     friend  ostream & operator << (ostream & sort , const Invariantpost3D & a)
      { sort << "  V= " << a.V << " Qeps= "<< a.Qeps << " cos3phi= "<< a.cos3phi
             << " potent= "<< a.potentiel << " "; return sort;
      };
     // data
     double V,Qeps,cos3phi,potentiel;
   };

  class SaveResulHyperD : public Loi_comp_abstraite::SaveResul//HyperD
   { public : 
        // constructeur 
        SaveResulHyperD(); // par défaut
        SaveResulHyperD(int sortie_post); // avec init ou pas
        SaveResulHyperD(const SaveResulHyperD& sav); // de copie
        virtual ~SaveResulHyperD(); // destructeur
    
        // définition d'une nouvelle instance identique
        // appelle du constructeur via new 
        SaveResul * Nevez_SaveResul() const {return (new SaveResulHyperD(*this));};
        // affectation
        virtual SaveResul & operator = ( const SaveResul & a);
        //============= 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& ,const int ) ;
        // 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& ,const int ) ;
           
        // mise à jour des informations transitoires 
        void TdtversT()  ;
        void TversTdt()  ;
    
        // affichage à l'écran des infos
        void Affiche() const  ;
    
        //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) {};

        // des grandeurs qui sont éventuellement crééent si on le demande
        HyperD::Invariantpost3D * invP, * invP_t;
    
        // --- gestion d'une map de grandeurs quelconques éventuelles ---

        // une map de grandeurs quelconques particulière qui peut servir aux classes appelantes
        // il s'agit ici d'une map interne qui a priori ne doit servir qu'aux class loi de comportement
        // un exemple d'utilisation est une loi combinée qui a besoin de grandeurs spéciales définies
        // -> n'est pas sauvegardé, car a priori il s'agit de grandeurs redondantes
        map <  EnumTypeQuelconque , TypeQuelconque, std::less < EnumTypeQuelconque> > map_type_quelconque;

        // récupération des type quelconque sous forme d'un arbre pour faciliter la recherche
        const map <  EnumTypeQuelconque , TypeQuelconque, std::less < EnumTypeQuelconque> >* Map_type_quelconque()
              const {return &map_type_quelconque;};
       private:
         void Mise_a_jour_map_type_quelconque();
    
         // ---- fin gestion d'une liste de grandeurs quelconques éventuelles ---
   };

  // création d'une nouvelle instance de SaveResul
  SaveResul * New_et_Initialise();
 
  // récupération des grandeurs particulière (hors ddl )
  // correspondant à liTQ
  // absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
  virtual void Grandeur_particuliere
        (bool absolue,List_io<TypeQuelconque>& liTQ,Loi_comp_abstraite::SaveResul * saveDon,list<int>& decal) const;
  // récupération de la liste de tous les grandeurs particulières
  // ces grandeurs sont ajoutées à la liste passées en paramètres
  // absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
  virtual void ListeGrandeurs_particulieres(bool absolue,List_io<TypeQuelconque>& liTQ) const;
        
// 1) definition d'une classe dérivée de SaveResul pour stocker le
// jacobien initial

//class SaveResulHyperD : public Loi_comp_abstraite::SaveResul
// { public : 
//      // constructeur 
//      SaveResulHyperD() : jacobien_0(0) {};
//      SaveResulHyperD(const double & jacob) : jacobien_0(jacob) {};
//      
//      // définition d'une nouvelle instance identique
//      // appelle du constructeur via new 
//      SaveResul * Nevez_SaveResul() const {return (new SaveResulHyperD(*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& ,const int ) {};
//      // 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& ,const int ) {};
//			  
//      // affichage à l'écran des infos
//      void Affiche() const { cout << "\n SaveResulHyperD: jacobien_0= " << jacobien_0 << " "; };
//
//      double jacobien_0;
//  
// };
//
// SaveResul * New_et_Initialise() { return (new SaveResulHyperD(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 {};
 
  // activation du stockage de grandeurs quelconques qui pourront ensuite être récupéré
  // via le conteneur SaveResul, si la grandeur n'existe pas ici, aucune action
		virtual void Activation_stockage_grandeurs_quelconques(list <EnumTypeQuelconque >& listEnuQuelc);
 
  // insertion des conteneurs ad hoc concernant le stockage de grandeurs quelconques
  // passée en paramètre, dans le save result: ces conteneurs doivent être valides
  // c-a-d faire partie de listdeTouslesQuelc_dispo_localement
  virtual void Insertion_conteneur_dans_save_result(SaveResul * saveResul);
 
 
//----------------------------------------------------------------------------------------------------------- 		
// on définit des classes conteneurs pour le passage sécurisé d'information au niveau des potentiels etc ..
//----------------------------------------------------------------------------------------------------------- 		
  public : 
  
  class PotenSansPhaseSansVar
   { public :
     PotenSansPhaseSansVar() : E(0.),EV(0.),EbIIb(0.),Ks(0) {};
     PotenSansPhaseSansVar(const PotenSansPhaseSansVar& a ) : E(a.E),EV(a.EV),EbIIb(a.EbIIb),Ks(a.Ks) {};
     PotenSansPhaseSansVar& operator = (const PotenSansPhaseSansVar& a)
        {E=a.E;EV=a.EV;EbIIb=a.EbIIb;Ks=a.Ks;return *this;};
     double E; // valeur du potentiel
     double EV; // variation du potentiel par rapport à V
     double EbIIb; // variation du potentiel par rapport à bIIb
     double Ks; // module de compressibilité sécant par rapport à log(V)
   };
  class PotenSansPhaseAvecVar : public PotenSansPhaseSansVar
   { public :
     PotenSansPhaseAvecVar() : PotenSansPhaseSansVar(),EVV(0.),EbIIbV(0.),EbIIb2(0.) {};
     PotenSansPhaseAvecVar(const PotenSansPhaseAvecVar& a) : 
        PotenSansPhaseSansVar(a),EVV(a.EVV),EbIIbV(a.EbIIbV),EbIIb2(a.EbIIb2) {};
     PotenSansPhaseAvecVar& operator = (const PotenSansPhaseAvecVar& a)
        {this->PotenSansPhaseSansVar::operator = (a);
         EVV=a.EVV;EbIIbV=a.EbIIbV;EbIIb2=a.EbIIb2;return *this;};
     double EVV;   // variation seconde par rapport à V
     double EbIIbV; // variation seconde par rapport à bIIb et V
     double EbIIb2; // variation seconde par rapport à bIIb
   };
  class Invariant           
   { public :
      Invariant () : Ieps(0.),V(0.),bIIb(0.),bIIIb(0.) {}; 
      Invariant (const double& I_n,const double& V_n,const double& bIIb_n,const double& bIIIb_n) : 
         Ieps(I_n),V(V_n),bIIb(bIIb_n),bIIIb(bIIIb_n) {}; 
      Invariant (const Invariant& a) :
         Ieps(a.Ieps),V(a.V),bIIb(a.bIIb),bIIIb(a.bIIIb) {};
      Invariant& operator = (const Invariant& a)
        {Ieps=a.Ieps;V=a.V;bIIb=a.bIIb;bIIIb=a.bIIIb;return *this; }
      double Ieps; // trace du tenseur de déformation
      double V;    // variation relative de volume
      double bIIb; // second invariant barre du déviateur de déformation
      double bIIIb; // troisième invariant barre du déviateur de déformation
   };
  class InvariantVarDdl : public Invariant           
   { public :
      InvariantVarDdl (int nddl = 0) :
         Invariant(),dIeps(nddl),dV(nddl),dbIIb(nddl),dbIIIb(nddl) {};
      InvariantVarDdl (const InvariantVarDdl& a) :
         Invariant(a),dIeps(a.dIeps),dV(a.dV),dbIIb(a.dbIIb),dbIIIb(a.dbIIIb) {};
      InvariantVarDdl& operator = (const InvariantVarDdl& a)
        {this->Invariant::operator = (a);
         dIeps=a.dIeps;dV=a.dV;dbIIb=a.dbIIb;dbIIIb=a.dbIIIb;return *this; }
      // données      
      Tableau<double>  dIeps; // variation de Ieps par rapport au ddl
      Tableau<double>  dV; // variation de V par rapport au ddl 
      Tableau<double>  dbIIb; // variation de bIIb par rapport au ddl
      Tableau<double>  dbIIIb; // variation de bIIIb par rapport au ddl
   };
    
  class InvariantVarEps : public Invariant // utilisable uniquement en 3D (ce qui est a priori les cas voulus)         
   { public :
      InvariantVarEps () :
         Invariant(),dIeps_deps_HH(),dV_deps_HH(),dbIIb_deps_HH(),dbIIIb_deps_HH() {};
      InvariantVarEps (const InvariantVarEps& a) :
         Invariant(a),dIeps_deps_HH(a.dIeps_deps_HH)
         ,dV_deps_HH(a.dV_deps_HH),dbIIb_deps_HH(a.dbIIb_deps_HH),dbIIIb_deps_HH(a.dbIIIb_deps_HH) {};
      InvariantVarEps& operator = (const InvariantVarEps& a)
        {this->Invariant::operator = (a);dIeps_deps_HH=a.dIeps_deps_HH;
         dV_deps_HH=a.dV_deps_HH;dbIIb_deps_HH=a.dbIIb_deps_HH;dbIIIb_deps_HH=a.dbIIIb_deps_HH;
         return *this; }
      // données      
      Tenseur3HH  dIeps_deps_HH; // variation de Ieps par rapport à epsBB
      Tenseur3HH  dV_deps_HH; // variation de V par rapport à epsBB 
      Tenseur3HH  dbIIb_deps_HH; // variation de bIIb par rapport à epsBB
      Tenseur3HH  dbIIIb_deps_HH; // variation de bIIIb par rapport à epsBB
   };
    
  class PotenAvecPhaseSansVar
   { public :
     PotenAvecPhaseSansVar() : E(0.),EV(0.),EbIIb(0.),EIeps(0.),Ks(0) {};
     PotenAvecPhaseSansVar (const PotenAvecPhaseSansVar& a) :
           E(a.E),EV(a.EV),EbIIb(a.EbIIb),EIeps(a.EIeps),Ks(a.Ks) {};
     PotenAvecPhaseSansVar& operator = (const PotenAvecPhaseSansVar& a)
        {E=a.E;EV=a.EV;EbIIb=a.EbIIb;EIeps=a.EIeps;Ks=a.Ks;return *this; }
     double E; // valeur du potentiel
     double EV; // variation du potentiel par rapport à V
     double EbIIb; // variation du potentiel par rapport à bIIb
     double EIeps; // variation du potentiel par rapport à Ieps
     double Ks; // module de compressibilité sécant par rapport à log(V)
   };
  class PotenAvecPhaseAvecVar : public PotenAvecPhaseSansVar
   { public :
     PotenAvecPhaseAvecVar() : PotenAvecPhaseSansVar()
        ,EVV(0.),EbIIb2(0.),EIeps2(0.),EbIIbV(0.),EIepsV(0.),EbIIbIeps(0.),Ks(0) {};
     PotenAvecPhaseAvecVar (const PotenAvecPhaseAvecVar& a) :
         PotenAvecPhaseSansVar(a)
         ,EVV(a.EVV),EbIIb2(a.EbIIb2),EIeps2(a.EIeps2),EbIIbV(a.EbIIbV)
         ,EIepsV(a.EIepsV),EbIIbIeps(a.EbIIbIeps),Ks(a.Ks) {};
     PotenAvecPhaseAvecVar& operator = (const PotenAvecPhaseAvecVar& a)
        {this->PotenAvecPhaseSansVar::operator = (a);
         EVV=a.EVV;EbIIb2=a.EbIIb2;EIeps2=a.EIeps2;EbIIbV=a.EbIIbV;
         EIepsV=a.EIepsV;EbIIbIeps=a.EbIIbIeps;Ks=a.Ks;return *this; }

     double EVV;   // variation seconde par rapport à V
     double EbIIb2; // variation seconde par rapport à bIIb
     double EIeps2; // variation seconde par rapport à Ieps
     double EbIIbV; // variation seconde par rapport à bIIb et V
     double EIepsV; //variation seconde par rapport à Ieps et V
     double EbIIbIeps; //variation seconde par rapport à bIIb et Ieps
     double Ks; // module de compressibilité sécant par rapport à log(V)
   };
   
  class A_i
   { public :
     A_i() : a_0(0.),a_1(0.),a_2(0.) {};
     A_i (const A_i& a) :
        a_0(a.a_0),a_1(a.a_1),a_2(a.a_2) {};
     A_i& operator = (const A_i& a)
       {a_0=a.a_0;a_1=a.a_1;a_2=a.a_2;return *this; }
     double a_0,a_1,a_2; // coeff ai pour le calcul de la contrainte
   };
  class A_iAvecVarDdl : public A_i
   { public :
     A_iAvecVarDdl (int nddl = 0) : 
         A_i(),da_0(nddl),da_1(nddl),da_2(nddl) {};
     A_iAvecVarDdl (const A_iAvecVarDdl& a) : 
         A_i(a),da_0(a.da_0),da_1(a.da_1),da_2(a.da_2) {};
     A_iAvecVarDdl& operator = (const A_iAvecVarDdl& a) 
         {this->A_i::operator = (a);
          da_0=a.da_0;da_1=a.da_1;da_2=a.da_2;return *this;};
     // données   
     Tableau<double> da_0; // variation de a_0 par rapport au ddl
     Tableau<double> da_1; // variation de a_1 par rapport au ddl
     Tableau<double> da_2; // variation de a_2 par rapport au ddl
   };
  class A_iAvecVarEps : public A_i
   { public :
     A_iAvecVarEps () : 
         A_i(),da_0_deps_HH(),da_1_deps_HH(),da_2_deps_HH() {};
     A_iAvecVarEps (const A_iAvecVarEps& a) : 
         A_i(a),da_0_deps_HH(a.da_0_deps_HH)
         ,da_1_deps_HH(a.da_1_deps_HH),da_2_deps_HH(a.da_2_deps_HH) {};
     A_iAvecVarEps& operator = (const A_iAvecVarEps& a) 
         {this->A_i::operator = (a);da_0_deps_HH=a.da_0_deps_HH;
          da_1_deps_HH=a.da_1_deps_HH;da_2_deps_HH=a.da_2_deps_HH;return *this;};
     // données   
     Tenseur3HH da_0_deps_HH; // variation de a_0 par rapport à epsBB
     Tenseur3HH da_1_deps_HH; // variation de a_1 par rapport à epsBB
     Tenseur3HH da_2_deps_HH; // variation de a_2 par rapport à epsBB
   };


	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);
		  	
        // calcul des contraintes et ses variations  par rapport aux déformations a t+dt
        // en_base_orthonormee:  le tenseur de contrainte en entrée est  en orthonormee
        //                  le tenseur de déformation et son incrémentsont également en orthonormees
        //                 si = false: les bases transmises sont utilisées
        // ex: contient les éléments de métrique relativement au paramétrage matériel = X_(0)^a
 void Calcul_dsigma_deps (bool en_base_orthonormee, TenseurHH & sigHH_t,TenseurBB& DepsBB
     ,TenseurBB & epsBB_tdt,TenseurBB & delta_epsBB,double& jacobien_0,double& jacobien
		  	,TenseurHH& sigHH,TenseurHHHH& d_sigma_deps
		  	,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double&  module_cisaillement
		  	,const Met_abstraite::Umat_cont& ex) ; //= 0;

 // calcul de grandeurs de travail aux points d'intégration via la def
 // 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 hyper10 pour le calcul des invariants
 
 // Calcul des invariants et, de epsBH, 
 // retour de IdGBH qui pointe sur le bon tenseur
 //++ virtual TensBH * Invariants (TenseurBB&  epsBB_t,TenseurBB& gijBB_t,
 virtual TenseurBH * Invariants (const TenseurBB&  epsBB_t,const TenseurBB& gijBB_t,
           const TenseurHH & gijHH_t,const  double& jacobien_0,const double& jacobien_t,
//++           Invariant & invariant,TensBH & epsBH) = 0;
           Invariant & invariant,TenseurBH & epsBH) = 0;
 // calcul des invariants et de leurs variations par rapport au ddl, de epsBH,
 // et de sa variation, puis  retour de IdGBH qui pointe sur le bon tenseur 
//++ virtual TensBH *  Invariants_et_var (TenseurBB&  epsBB_tdt,
 virtual TenseurBH *  Invariants_et_var (const TenseurBB&  epsBB_tdt,
           const TenseurBB& gijBB_tdt,const Tableau <TenseurBB *>& d_gijBB_tdt,
           const TenseurHH & gijHH_tdt,const Tableau <TenseurHH *>& d_gijHH_tdt,
           const double& jacobien_0,const double& jacobien_tdt,const Vecteur& d_jacobien_tdt,
           InvariantVarDdl& invariantVarDdl,
//++           TensBH & epsBH_tdt,Tableau<TensBH> & depsBH_tdt) = 0; 
           TenseurBH & epsBH_tdt,Tableau<TenseurBH*> & depsBH_tdt) = 0; 
           
 // calcul des invariants  et de leurs variations par rapport aux déformations
 virtual TenseurBH *  Invariants_et_varEps (const TenseurBB&  epsBB_tdt,
           const TenseurBB& gijBB_tdt,const TenseurHH & gijHH_tdt,
           const double& jacobien_0,const double& jacobien_tdt,
           InvariantVarEps& invariantVarEps,TenseurBH & epsBH_tdt) = 0; 
          
             
 // calcul du potentiel et de ses dérivées non compris la phase
 virtual PotenSansPhaseSansVar Potentiel
                 (const Invariant & invariant,const double& jacobien0) = 0;
 // calcul du potentiel et de ses dérivées avec la phase
 virtual PotenAvecPhaseSansVar PotentielPhase
                 (const Invariant& invariant,const double& jacobien0) = 0; 
 // calcul  du potentiel sans phase et dérivées avec  ses variations par rapport aux invariants
 virtual PotenSansPhaseAvecVar Potentiel_et_var
                 (const Invariant& invariant,const double& jacobien0) = 0;
 // calcul  du potentiel avec phase et dérivées avec  ses variations par rapport aux invariants
 virtual PotenAvecPhaseAvecVar PotentielPhase_et_var
                 (const Invariant& invariant,const double& jacobien0) = 0;
          

  protected  :  
    // VARIABLES PROTEGEES :
    bool avec_phase; // vrai quand on travail avec la phase
													 // ---utilisé par les potentiels Orgeas
//	 Invariant  invariant_t; //invariants à t donc au début du pas
    bool avec_regularisation; // si oui, on régularise les termes qui tendent vers 0
    double fact_regularisation; // spécifie le facteur de régularisation
 
    int sortie_post; // permet de stocker et ensuite d'accéder en post-traitement à certaines données
        // = 0 par défaut,
        // = 1 : on stocke toutes les grandeurs et elles sont disponibles en sortie
        // lecture dans les classes dérivées !!

    // Calcul_dsigma_deps, dans le cas où on n'est pas en orthonormee
    Tenseur3HHHH  I_xbarre_I_HHHH;
    
    // variables internmédiaire qui sont renseignées par
    // HyperD::Calcul_SigmaHH ou HyperD::Calcul_DsigmaHH_tdt ou HyperD::Calcul_dsigma_deps
    // et qui sont utilisées ensuite par les potentiels spécifiques pour les fct nD
    const Met_abstraite::Impli* ex_impli_hyper;
    const Met_abstraite::Expli_t_tdt* ex_expli_tdt_hyper;
    const Met_abstraite::Umat_cont* ex_umat_hyper;

	 
//    double scale_eps; // paramètre de scale d'eps, pour limiter les divisions par 0
    // la définition est faite dans les classes dérivées ainsi que la sauvegarde, lecture etc...
    
    // METHODES PROTEGEES :

    // affichage et definition interactive des commandes particulières ici = une partie générique
    // pour les lois hyper 3D, utilisée par les classes dérivées
    void Info_commande_LoisDeComp_hyper3D(UtilLecture& lec);

    // calcul des coefficients alpha dans le cas sans la phase
    inline void AAA_i (const PotenSansPhaseSansVar& potenSansPhaseSansVar,const Invariant& invariant
                       ,const double& jaco,A_i& a_i);
        
    // calcul des coefficients alpha dans le cas avec la phase
    inline void AAA_iPhase(const PotenAvecPhaseSansVar& potenAvecPhaseSansVar,const Invariant& invariant
                           ,const double& jaco,A_i& a_i);
           
    // calcul des coefficients alpha dans le cas sans la phase et de leurs variations / ddl
    inline void AAA_i_var(const PotenSansPhaseAvecVar& potenSansPhaseAvecVar,const double& jaco0
                          ,const InvariantVarDdl & invariantVarDdl
                          ,const double& jaco,const Vecteur& d_jacobien_tdt,A_iAvecVarDdl& a_iAvecVarDdl);

    // calcul des coefficients alpha dans le cas avec la phase et de leurs variations / ddl
    inline void AAA_iPhase_var (const PotenAvecPhaseAvecVar& potenAvecPhaseAvecVar,const double& jaco0 
                                ,const InvariantVarDdl & invariantVarDdl
                                ,const double& jaco,const Vecteur& d_jacobien_tdt,A_iAvecVarDdl& a_iAvecVarDdl); 

    // calcul des coefficients alpha dans le cas sans la phase et de leurs variations / eps
    inline void AAA_i_varEps(const PotenSansPhaseAvecVar& potenSansPhaseAvecVar,const double& jaco0
                          ,const InvariantVarEps & invariantVarEps
                          ,const double& jaco,A_iAvecVarEps& a_iAvecVarEps);

    // calcul des coefficients alpha dans le cas avec la phase et de leurs variations / eps
    inline void AAA_iPhase_varEps (const PotenAvecPhaseAvecVar& potenAvecPhaseAvecVar,const double& jaco0 
                                ,const InvariantVarEps & invariantVarEps
                                ,const double& jaco,A_iAvecVarEps& a_iAvecVarEps); 
 
 };
 /// @}  // end of group

//++#include "HyperD.cc"

 
#endif