// ************************************************************************
// --- 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 TFSigmaUEpsilonV3DIncrementalVieillissant_INCLUS
#define TFSigmaUEpsilonV3DIncrementalVieillissant_INCLUS

// ***********************************************************************************************
//  Nom du fichier: TFSigmaUEpsilonV3DIncrementalVieillissant.h
//
//  Nom de la classe: TFSigmaUEpsilonV3DIncrementalVieillissant
//
//  Sommaire: Terme de formulation d'un problème d'élasticité linéaire 3D pour un matériau dont les propriétés
//            varient avec le temps. On suppose que l'on applique les hypothèses de petites perturbations et que
//            l'on traite un probleme quasi-statique avec une formulation incrémentale la loi de comportement
//            s'écrivant:<p>
//                                  sigma(U,t) = E(t) (epsilon(U) - Beta(t)(M-M_0))          t_0 < t < t_F<p>
//            où on tient compte d'un couplage avec une fonction scalaire connue (generalement thermique/hydrique)
//<p>
//  Description:  Terme de formulation intégrant numériquement les entrées de la matrice élémentaire et du residu
//                issues d'un problème d'élasticité linéaire 3D (la rigidité) pour un matériau dont les propriétés
//                varient avec le temps. Construit à partir d'une formulation incrémentale (quasi statique) en petites
//                déformations menant à l'équation:<p>
//      - div(E(t+dt):epsilon(dU)) = div(dE:(epsilon(U) - Beta(t)(M(t)-M_0)) - div(E(t+dt):Beta(M(t+dt)-M(t)) - div(E(t+dt):dBeta(M(t)-M_0)))Construit à partir:<p>
//                On doit fournir:
//                  0) l'inconnue variationnelle: l'incrément des déplacements U
//                  1) les déplacements U au pas de temps courant (la classe calcule les déformations), <p>
//                  2) la rigidite E courante et précédentes,<p>
//                  3) le champ scalaire M de couplage (thermique/hydrique) au pas de temps courant, precedent et initial<p>
//                  4) le tenseur beta (dilatations) au pas de temps courant et precedent (si beta est vieillissant lui aussi)<p>
//  <p>
//            Matrice = !{!\int E_{ijkh}\epsilon_{kh}(\delta u):\epsilon_{ij}(v) dx.!}!
//  <p>
//            Résidu = !{!-\int E_{ijkh}\epsilon_{kh}(u):\epsilon_{ij}(v) \Delta E_{ijkh} (\epsilon_{kh}(U) - \beta_{kh}(M^p-M^0)) -
//                         E_{ijkh}\Delta\beta_{kh}(M^p-M^0) -E_{ijkh}\beta_{kh}(M-M^p)) :\epsilon_{ij}(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>
//
//!{!u = \delta u + u_p!}!        le champ vectoriel3d de l'increment des déplacements<p>
//!{!v!}!                         le champ vectoriel3d des fonctions test<p>
//!{!U!}!                         le champ vectoriel3d des déplacements<p>
//!{!E_{ijkh}  !}!                le champ du tenseur O4 de rigidite,<p>
//!{!\Delta E_{ijkh}  = E_{ijkh}-E_{ijkh}^p!}! le champ de la variation en temps du tenseur de rigidite,<p>
//!{!\beta_{ij}  !}!              les dilatations dues à M,<p>
//!{!M,M^p, M^0  !}!              la valeur courante, au pas precedent et initiale du champ M ,<p>
//!{!\Delta \beta^M_{ij}  !}!     la variation en temps du tenseur des dilatations hydriques,<p>
//<p>
//
//  Attributs:
//
// ***********************************************************************************************

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

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


class TFSigmaUEpsilonV3DIncrementalVieillissant: public TFGenerique
{
public:

  TFSigmaUEpsilonV3DIncrementalVieillissant();

  virtual ~TFSigmaUEpsilonV3DIncrementalVieillissant();

  virtual void ajouteEvaluationsAFaire        (bool                 pAssembleMatrice,
                                               bool                 pAssembleResidu);

  ERMsg        asgnChamps                     (ChampGeometrique&    pChampGeo,
                                               ChampVectoriel3D&    pChampU,
                                               ChampVectoriel3D&    pChampV,
                                               ChampVectoriel3D&    pChampDeplacements,
                                               ChampTensorielO4Sym& pChampE,
                                               const SchemaIntg&    pSchemaIntg);

  ERMsg        asgnChamps                     (ChampGeometrique&    pChampGeo,
                                               ChampVectoriel3D&    pChampU,
                                               ChampVectoriel3D&    pChampV,
                                               ChampVectoriel3D&    pChampDeplacements,
                                               ChampTensorielO4Sym& pChampE,
                                               ChampTensorielO4Sym& pChampEPrecedent,
                                               const SchemaIntg&    pSchemaIntg);

  void         asgnCouplageFctConnue          (ChampScalaire&       pChampM,
                                               ChampScalaire&       pChampMPrecedent,
                                               ChampScalaire&       pChampMInitial,
                                               ChampTensorielO2Sym& pChampBeta);

  void         asgnCouplageFctConnue          (ChampScalaire&       pChampM,
                                               ChampScalaire&       pChampMPrecedent,
                                               ChampScalaire&       pChampMInitial,
                                               ChampTensorielO2Sym& pChampBeta,
                                               ChampTensorielO2Sym& pChampBetaPrecedent);

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


private:

  TFSigmaUEpsilonV3DIncrementalVieillissant(const TFSigmaUEpsilonV3DIncrementalVieillissant&);
  TFSigmaUEpsilonV3DIncrementalVieillissant& operator= (const TFSigmaUEpsilonV3DIncrementalVieillissant&);

  ChampVectoriel3D                               *aChampU;
  ChampVectoriel3D                               *aChampV;
  ChampVectoriel3D                               *aChampDeplacements;
  ChampTensorielO4Sym                            *aChampE;
  ChampTensorielO4Sym                            *aChampEPrecedent;
  ChampScalaire                                  *aChampM;
  ChampScalaire                                  *aChampMPrecedent;
  ChampScalaire                                  *aChampMInitial;
  ChampTensorielO2Sym                            *aChampBeta;
  ChampTensorielO2Sym                            *aChampBetaPrecedent;

  const VectDyn<InfoLocalesTransformation>       *aVectInfoTransformation;
  const VectDyn<InfoLocalesInterpolation>        *aVectInfoInterpolationNV;
  const VectDyn<InfoLocalesInterpolation>        *aVectInfoInterpolationNU;
  const VectDyn<InfoLocalesChamp<Vecteur3D> >    *aVectInfoChampU;
  const VectDyn<InfoLocalesChamp<Vecteur3D> >    *aVectInfoChampDeplacements;
  const VectDyn<InfoLocalesChamp<TenseurO4Sym> > *aVectInfoChampE;
  const VectDyn<InfoLocalesChamp<TenseurO4Sym> > *aVectInfoChampEPrecedent;
  const VectDyn<InfoLocalesChamp<DReel> >        *aVectInfoChampM;
  const VectDyn<InfoLocalesChamp<DReel> >        *aVectInfoChampMPrecedent;
  const VectDyn<InfoLocalesChamp<DReel> >        *aVectInfoChampMInitial;
  const VectDyn<InfoLocalesChamp<TenseurO2Sym> > *aVectInfoChampBeta;
  const VectDyn<InfoLocalesChamp<TenseurO2Sym> > *aVectInfoChampBetaPrecedent;

  bool aMatriceElementaireSymetrique;

  TenseurO2Sym aGamma_phi_i_0;
  TenseurO2Sym aGamma_phi_i_1;
  TenseurO2Sym aGamma_phi_i_2;

  _GIREF_DECLARE_INVARIANTS;

};

#endif // #ifndef TFSigmaUEpsilonV3DIncrementalVieillissant