// ************************************************************************
// --- Logiciel MEF++
// ---
// --- Copyright 1996-2006 GIREF, Université Laval
// --- TOUS DROITS RÉSERVÉS
// --- ALL RIGHTS RESERVED
// ---
// --- Ce logiciel est couvert par la Loi sur le droit d'auteur.
// --- L'utilisation, ou la modification de ce logiciel sous toutes ses
// --- formes, que ce soit code source ou code compilé, à des fins
// --- personnelles et non commerciales sont autorisées sans frais pour
// --- autant que la présente notice de copyright ainsi que cette
// --- permission apparaissent dans toutes les copies ainsi que dans la
// --- documentation.
// --- Le GIREF et l'Université Laval ne prétendent en aucune façon que
// --- ce code convient à un emploi quelconque. Celui-ci est distribué
// --- sans aucune garantie implicite ou explicite.
// ************************************************************************

#ifndef GeorgesVisco_TFElastiqueViscoElastiqueMaxwellHPPEpsilonLin_INCLUS
#define GeorgesVisco_TFElastiqueViscoElastiqueMaxwellHPPEpsilonLin_INCLUS

// ***********************************************************************************************
//  Nom du fichier: GeorgesVisco_TFElastiqueViscoElastiqueMaxwellHPPEpsilonLin.h
//
//  Nom de la classe: GeorgesVisco_TFElastiqueViscoElastiqueMaxwellHPPEpsilonLin
//
//  Sommaire: Terme de formulation pour la composante purement élastique dans un modèle visco-élastique de Maxwell généralisé
//            avec élasticité linéaire 3D, l'hypothèse de linéarité en temps du tenseur des déformations !{!\epsilon!}!
//            et la possibilité de distinguer deux états du solide via un indicateur permettant d'utiliser deux variantes
//            de la loi de Hooke: la loi de Hooke ou la loi de Bazant.
//
//  Description: Terme de formulation calculant la contribution à la matrice et au résidu de la composante
//               purement élastique dans un modèle visco-élastique de Maxwell généralisé avec élasticité linéaire 3D.
//               Dans cette classe on permet de  distinguer deux états du solide via un indicateur et d'utiliser
//               deux variantes de la loi de Hooke: la loi de Hooke ou la loi de Bazant. L'hypothèse de linéarité
//               en temps du tenseur des déformations !{!\epsilon!}! permet d'avoir la forme suivante pour les
//               contributions au résidu et à la matrice:
//  <p>
//            Matrice = !{!\int \boldsymbol{S}_{n+1}\epsilon(\delta u):\epsilon(v) dx.!}!
//  <p>
//            Résidu = !{! - \int ( (\chi \le 0.) \boldsymbol{S}_{n+1}\epsilon(u_{p}) + (\chi > 0.) \sigma_p):\epsilon(v) dx.!}!<p>
//  <p>
//  où<p>
//!{!\epsilon_{ij}(v) = \frac{1}{2}(\frac{\partial v_i}{\partial x_j} +  \frac{\partial v_j}{\partial x_i})!}!
//                       le tenseur des déformations (ordre 2)<p>
//
//!{!\boldsymbol{S}_{n+1}!}!      le champ tensoriel O4 symétrique provenant l'integration du produit (termes à termes) du tenseur
//                                d'élasticité et du tenseur du temps de relaxation<p>
//!{!u = \delta u + u_p!}!        le champ vectoriel3d des déplacements<p>
//!{!v!}!                         le champ vectoriel3d des fonctions test<p>
//!{!        \chi \le 0\text{ si loi de Hooke : }\sigma_{ij}(t,x) = E_{ijkl}(t,x)\epsilon_{kl}(u(t,x))!}!<p>
//!{!        \chi > 0\text{ si loi de Bazant : }\frac{ \partial \sigma_{ij}(t,x)}{\partial t} = E_{ijkl}(t,x)\frac{\partial \epsilon_{kl}(u(t,x))}{\partial t}!}!<p>
//!{!\sigma_p!}!                  le champs des contraintes associées à la composante élastique au pas de temps précédent<p>
//
//  Attributs:
//   *aChampU                           Le champ de calcul
//   *aChampV                           Le champ associé aux fonctions test
//   *aChampUPrecedent:                 Le champ contenant les deplacements au pas precedent
//   *aChampSigmaPrecedent:             Le champ contenant le tenseur des contraintes au pas precedent
//   *aChampS:                          Le champ contenant le tenseur provenant l'integration du produit du tenseur
//                                      d'élasticité et du tenseur du temps de relaxation
//   *aVectInfoTransformation:          Le * au vecteur d'information de transformation de l'élément de
//                                      référence sur l'élément réel.
//   *aVectInfoInterpolationNU:         Le * au vecteur d'information d'interpolation du champ U.
//   *aVectInfoInterpolationNV:         Le * au vecteur d'information d'interpolation du champ V.
//   *aVectInfoChampU                   Le * au vecteur d'information des valeurs  du champ U.
//   *aVectInfoChampS                   Le * au vecteur d'information des valeurs  du champ S.
//   *aVectInfoChampIndicateurEtat:     Le * au vecteur d'information des valeurs  du champ I.
//   *aVectInfoChampSigmaPrecedent:     Le * au vecteur d'information des valeurs  du champ SigmaPrecedent.
//
// ***********************************************************************************************

#include "MEFPPUtil.h"
#include "TenseurO2Sym.h"
#include "TenseurO4Sym.h"
#include "TFGenerique.h"

class BlocVElem;
class BlocMElem;
class ChampGeometrique;
class ChampVectoriel3D;
class ChampTensorielO2Sym;
class ChampTensorielO4Sym;
class ChampTensorielO4SymMin;
class InfoLocalesTransformation;
class InfoLocalesInterpolation;
template <class PTTypeValeur> class InfoLocalesChamp;
template <class PTTypeValeur> class InfoLocales;
template <class PTType> class VectDyn;


class GeorgesVisco_TFElastiqueViscoElastiqueMaxwellHPPEpsilonLin: public TFGenerique
{
public:

  GeorgesVisco_TFElastiqueViscoElastiqueMaxwellHPPEpsilonLin();
  virtual ~GeorgesVisco_TFElastiqueViscoElastiqueMaxwellHPPEpsilonLin();

  virtual void ajouteEvaluationsAFaire        (bool                 pAssembleMatrice,
                                               bool                 pAssembleResidu);

  ERMsg        asgnChamps                     (ChampGeometrique&       pChampGeo,
                                               ChampVectoriel3D&       pChampU,
                                               ChampVectoriel3D&       pChampV,
                                               ChampVectoriel3D&       pChampUPrecedent,
                                               ChampTensorielO2Sym&    pChampSigma,
                                               ChampTensorielO4Sym&    pChampS,
                                               ChampScalaire&          pChampIndicateurEtat,
                                               const SchemaIntg&       pSchemaIntg);

  virtual void evalueIntegrale                (BlocMElem&           pBlocMElem,
                                               BlocVElem&           pBlocVElem);


private:

  GeorgesVisco_TFElastiqueViscoElastiqueMaxwellHPPEpsilonLin(const GeorgesVisco_TFElastiqueViscoElastiqueMaxwellHPPEpsilonLin&);
  GeorgesVisco_TFElastiqueViscoElastiqueMaxwellHPPEpsilonLin& operator= (const GeorgesVisco_TFElastiqueViscoElastiqueMaxwellHPPEpsilonLin&);

  ChampVectoriel3D                               *aChampU;
  ChampVectoriel3D                               *aChampV;
  ChampVectoriel3D                               *aChampUPrecedent;
  ChampTensorielO2Sym                            *aChampSigmaPrecedent;
  ChampTensorielO4Sym                            *aChampS;
  ChampScalaire                                  *aChampIndicateurEtat;
  const VectDyn<InfoLocalesTransformation>       *aVectInfoTransformation;
  const VectDyn<InfoLocalesInterpolation>        *aVectInfoInterpolationNU;
  const VectDyn<InfoLocalesInterpolation>        *aVectInfoInterpolationNV;
  const VectDyn<InfoLocalesChamp<Vecteur3D> >    *aVectInfoChampU;
  const VectDyn<InfoLocalesChamp<Vecteur3D> >    *aVectInfoChampUPrecedent;
  const VectDyn<InfoLocalesChamp<TenseurO2Sym> > *aVectInfoChampSigmaPrecedent;
  const VectDyn<InfoLocalesChamp<TenseurO4Sym> > *aVectInfoChampS;
  const VectDyn<InfoLocalesChamp<DReel> >        *aVectInfoChampIndicateurEtat;

  TenseurO2Sym aGamma_phi_i_0;
  TenseurO2Sym aGamma_phi_i_1;
  TenseurO2Sym aGamma_phi_i_2;

  _GIREF_DECLARE_INVARIANTS;

};

#endif // #ifndef GeorgesVisco_TFElastiqueViscoElastiqueMaxwellHPPEpsilonLin_INCLUS