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


// *******************************************************************
//  Nom du fichier:   ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas.cc
//
//  Nom de la classe: ChampCelluleViscoElastiqueFormulationThetaSchemasMaxwellHPP
//
// *******************************************************************

#include "ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas.h"
#include "ChampScalContinu.h"
#include "ChampTensO4SymDiscParElement.h"
#include "ChampTensO4SymMinDiscParElement.h"
#include "ChampTensorielO4Sym.h"
#include "ChampTensorielO4SymMin.h"
#include "ChampVect3DContinu.h"
#include "UtilPersistance.h"
#include "fonctionsTenseurs.h"

// *******************************************************************
//
//  Description: Constructeur par défaut.
//
//  Entrée: Aucune
//
//  Sortie: Aucune
//
// *******************************************************************
ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas(const std::string& pNom)
  :aChampDeplacements(0),
   aChampDeplacementsPrecedents(0),
   aChampFonctionElasticiteViscosite(0),
   aChampYijklPrecedentes(0),
   aChampFonctionVieillisementRessort(0),
   aChampDeriveeFonctionVieillisementRessort(0),
   aChampFonctionVieillisementLambda(0),
   aChampFonctionVieilLambdaPrecedent(0),
   aChampFonctionVieilRessortPrecedent(0),
   aChampDeriveeFonctionVieilRessortPrecedent(0),
   aChampIndicateurEtat(0),
   aPasDeTemps(0),
   aThetaSchema(0),
   aAppelRecursifComposante(false)
{
  _GIREF_CONSTRUCTEUR_INVARIANTS;

  for (Entier i = 0; i < 36; ++i) {
    aComposantes[i].asgnParametres(*this, i);
  }

  asgnNom(pNom);

  _GIREF_TEST_INVARIANTS;
}

// *******************************************************************
//
//  Description: Constructeur par copie.
//
//  Entrée: pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas: l'objet à copier
//
//  Sortie: Aucune
//
// *******************************************************************
ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas(const ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas& pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas)
  : ChampAnalytiqueBaseDiscParElement<ChampTensO4SymMinDiscParElement>(),
    aAppelRecursifComposante(false)
{
  _GIREF_APPEL_TEST_INVARIANTS(pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas);
  _GIREF_CONSTRUCTEUR_INVARIANTS;

  for (Entier i = 0; i < 36; ++i) {
    aComposantes[i].asgnParametres(*this, i);
  }

  asgnNom(pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas.reqNom());

  *this = pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas;

  _GIREF_TEST_INVARIANTS;
}

// *******************************************************************
//
//  Description: Destructeur.
//
//  Entrée: Aucune
//
//  Sortie: Aucune
//
// *******************************************************************
ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::~ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas()
{
  _GIREF_TEST_INVARIANTS;

  _GIREF_DESTRUCTEUR_INVARIANTS;
}

// *******************************************************************
//
//  Description: Opérateur d'assignation.
//
//  Entrée: pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas: l'objet à copier
//
//  Sortie: Une référence sur l'objet courant
//
// *******************************************************************
ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas& ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::operator= (const ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas& pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas)
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_APPEL_TEST_INVARIANTS(pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas);

  ChampAnalytiqueBaseDiscParElement<ChampTensO4SymMinDiscParElement>::operator=(pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas);

  if (this != &pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas) {
    aChampDeplacements                 = pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas.aChampDeplacements;
    aChampDeplacementsPrecedents       = pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas.aChampDeplacementsPrecedents;
    aChampFonctionElasticiteViscosite  = pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas.aChampFonctionElasticiteViscosite;
    aChampYijklPrecedentes             = pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas.aChampYijklPrecedentes;
    aChampFonctionVieillisementRessort = pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas.aChampFonctionVieillisementRessort;
    aChampDeriveeFonctionVieillisementRessort = pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas.aChampDeriveeFonctionVieillisementRessort;
    aChampFonctionVieillisementLambda  = pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas.aChampFonctionVieillisementLambda;
    aChampFonctionVieilLambdaPrecedent = pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas.aChampFonctionVieilLambdaPrecedent;
    aChampFonctionVieilRessortPrecedent=pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas.aChampFonctionVieilRessortPrecedent;
    aChampDeriveeFonctionVieilRessortPrecedent =pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas.aChampDeriveeFonctionVieilRessortPrecedent;
    aChampIndicateurEtat               = pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas.aChampIndicateurEtat;
    aPasDeTemps                        = pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas.aPasDeTemps;
    aThetaSchema                       = pChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas.aThetaSchema;
  }

  _GIREF_TEST_INVARIANTS;
  return *this;
}

// *******************************************************************
//
//  Description:
//
//  Entrée:
//
//  Sortie: ERMsg: Message d'erreur
//
// *******************************************************************
void ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::asgnChampsSansVieillissement(ChampVect3DContinu  &pChampDeplacements,
                                                        ChampVect3DContinu  &pChampDeplacementsPrecedents,
                                                        ChampTensorielO4Sym &pChampFonctionElasticiteViscosite,
                                                        ChampTensorielO4SymMin &pChampYijklPrecedentes,
                                                        DReel              &pPasDeTemps,
                                                        const DReel        & pThetaSchema)
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION(0!= &pChampDeplacements,                       "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampDeplacementsPrecedents,             "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampFonctionElasticiteViscosite,        "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampYijklPrecedentes,                   "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pPasDeTemps,                              "Pointeur nul!");
//  _GIREF_PRECONDITION(0!= &pThetaSchema,                             "Pointeur nul!");

  aChampDeplacements                        = &pChampDeplacements;
  aChampDeplacementsPrecedents              = &pChampDeplacementsPrecedents;
  aChampFonctionElasticiteViscosite         = &pChampFonctionElasticiteViscosite;
  aChampYijklPrecedentes                    = &pChampYijklPrecedentes;
  aPasDeTemps                               = &pPasDeTemps;
  aThetaSchema                              = pThetaSchema;

  aChampFonctionVieillisementRessort        = 0;
  aChampDeriveeFonctionVieillisementRessort = 0;
  aChampFonctionVieillisementLambda         = 0;
  aChampFonctionVieilLambdaPrecedent        = 0;
  aChampFonctionVieilRessortPrecedent       = 0;
  aChampDeriveeFonctionVieilRessortPrecedent= 0;
  aChampIndicateurEtat                      = 0;
  _GIREF_TEST_INVARIANTS;
}

// *******************************************************************
//
//  Description:
//
//  Entrée:
//
//  Sortie: ERMsg: Message d'erreur
//
// *******************************************************************
void ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::asgnChampsAvecVieillissement(ChampVect3DContinu  &pChampDeplacements,
                                                        ChampVect3DContinu  &pChampDeplacementsPrecedents,
                                                        ChampTensorielO4Sym &pChampFonctionElasticiteViscosite,
                                                        ChampTensorielO4SymMin &pChampYijklPrecedentes,
                                                        ChampScalaire &pChampFonctionVieillisementRessort,
                                                        ChampScalaire &pChampDeriveeFonctionVieillisementRessort,
                                                        ChampScalaire &pChampFonctionVieillisementLambda,
                                                        ChampScalaire &pChampFonctionVieilLambdaPrecedent,
                                                        ChampScalaire &pChampFonctionVieilRessortPrecedent,
                                                        ChampScalaire &pChampDeriveeFonctionVieilRessortPrecedent,
                                                        ChampScalaire      &pChampIndicateurEtat,
                                                        DReel              &pPasDeTemps,
                                                        const DReel        &pThetaSchema)
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION(0!= &pChampDeplacements,                       "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampDeplacementsPrecedents,             "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampFonctionElasticiteViscosite,        "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampYijklPrecedentes,                   "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampFonctionVieillisementLambda,        "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampDeriveeFonctionVieillisementRessort,"Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampFonctionVieillisementRessort,       "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampFonctionVieilRessortPrecedent,      "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampFonctionVieilLambdaPrecedent,       "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampDeriveeFonctionVieilRessortPrecedent,"Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampIndicateurEtat,                     "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pPasDeTemps,                              "Pointeur nul!");
  // _GIREF_PRECONDITION(0!= &pThetaSchema,                             "Pointeur nul!");

  aChampDeplacements                        = &pChampDeplacements;
  aChampDeplacementsPrecedents              = &pChampDeplacementsPrecedents;
  aChampFonctionElasticiteViscosite         = &pChampFonctionElasticiteViscosite;
  aChampYijklPrecedentes                    = &pChampYijklPrecedentes;
  aChampFonctionVieillisementRessort        = &pChampFonctionVieillisementRessort;
  aChampDeriveeFonctionVieillisementRessort = &pChampDeriveeFonctionVieillisementRessort;
  aChampFonctionVieillisementLambda         = &pChampFonctionVieillisementLambda;
  aChampFonctionVieilLambdaPrecedent        = &pChampFonctionVieilLambdaPrecedent;
  aChampFonctionVieilRessortPrecedent       = &pChampFonctionVieilRessortPrecedent;
  aChampDeriveeFonctionVieilRessortPrecedent= &pChampDeriveeFonctionVieilRessortPrecedent;
  aChampIndicateurEtat                      = &pChampIndicateurEtat;
  aPasDeTemps                               = &pPasDeTemps;
  aThetaSchema                              = pThetaSchema;

  _GIREF_TEST_INVARIANTS;
}

// *******************************************************************
//
//  Description: Méthode permettant d'assigner un nouveau temps
//  au Champ. Les évaluations subséquentes utiliseront
//  cette valeur, si elles en ont besoin.  On appelle la méthode sur
//  chacune des composantes du champ
//
//  Entrée: pTemps, le nouveau temps à utiliser.
//
//  Sortie: Aucune
//
// *******************************************************************
void ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::asgnTemps(const DReel& pTemps)
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION(0 != aChampDeplacements, "Le champ des déplacements n'est pas assigné");

  if (!aAppelRecursifComposante) {
    aAppelRecursifComposante = true;
    ChampAnalytiqueBaseDiscParElement<ChampTensO4SymMinDiscParElement>::asgnTemps(pTemps);

    aChampDeplacements                        ->asgnTemps(pTemps);
    aChampDeplacementsPrecedents              ->asgnTemps(pTemps);
    aChampFonctionElasticiteViscosite         ->asgnTemps(pTemps);
    aChampYijklPrecedentes                    ->asgnTemps(pTemps);
    if(aChampIndicateurEtat){
      aChampFonctionVieillisementRessort        ->asgnTemps(pTemps);
      aChampDeriveeFonctionVieillisementRessort ->asgnTemps(pTemps);
      aChampFonctionVieillisementLambda         ->asgnTemps(pTemps);
      aChampFonctionVieilLambdaPrecedent        ->asgnTemps(pTemps);
      aChampFonctionVieilRessortPrecedent       ->asgnTemps(pTemps);
      aChampDeriveeFonctionVieilRessortPrecedent->asgnTemps(pTemps);
      aChampIndicateurEtat                      ->asgnTemps(pTemps);
     }

    aAppelRecursifComposante = false;
  }

  _GIREF_TEST_INVARIANTS;
}

// *******************************************************************
//
//  Description:  evalue(X,Y,Z,T) = evaluation de   l'ExpressionAlgebrique
//
//  Entrée: pCoor, la coordonnee a laquelle evaluer la fonction
//              pTemps, le temps de l'evaluation de la fonction
//
//  Sortie: L'evaluation de la fonction
//
// *******************************************************************
void ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::evalue(const Vecteur3D& /*pCoor*/, const DReel& /*pTemps*/, TenseurO4SymMin& /*pValeur*/) const
{
  _GIREF_TEST_INVARIANTS;

  _GIREF_ASSERTION(false, "Pas implanté");

  _GIREF_TEST_INVARIANTS;
}

// *******************************************************************
//
//  Description: Crée un champ du même type
//
//  Entrée: Aucune
//
//  Sortie: Un pointeur vers l'objet créé
//
// *******************************************************************
ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas* ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::newChamp() const
{
  _GIREF_TEST_INVARIANTS;

  return new ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas();
}

// *******************************************************************
//
//  Description: Crée un champ du même type en se copiant soi-même
//
//  Entrée: Aucune
//
//  Sortie: Un pointeur vers l'objet créé
//
// *******************************************************************
ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas* ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::newChampCopie() const
{
  _GIREF_TEST_INVARIANTS;

  return new ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas(*this);
}

// *******************************************************************
//
//  Description: Retourne le ChampScalContinu representant la
//  composante X du Champ courant.
//
//  Entrée: Aucune
//
//  Sortie: Une reference sur la composante X
//
// *******************************************************************
ChampScalaire& ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::reqComposante(const Entier pIndice)
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION(36 > pIndice && 0<= pIndice, "Indice trop grand ou trop petit");

  return aComposantes[pIndice];
}

// *******************************************************************
//
//  Description: Retourne le ChampScalContinu representant la
//  composante X du Champ courant.
//
//  Entrée: Aucune
//
//  Sortie: Une reference sur la composante X
//
// *******************************************************************
const ChampScalaire& ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::reqComposante(const Entier pIndice) const
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION(36 > pIndice && 0<= pIndice, "Indice trop grand ou trop petit");

  return aComposantes[pIndice];
}

// *******************************************************************
//
//  Description: Methode de lecture du Champ
//
//  Entrée: pEntree, un "Input Stream".
//
//  Sortie: Un message d'erreur s'il y a un probleme a la lecture.
//
// *******************************************************************
ERMsg ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::importeVersion0(std::istream& /*pEntree*/)
{
  _GIREF_TEST_INVARIANTS;
  ERMsg lMsg;

  lMsg = ERMsg(ERMsg::ERREUR,"ERR_FORMAT_FICHIER");
  lMsg.ajoute("ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas");

  _GIREF_TEST_INVARIANTS;
  return lMsg;
}


// *******************************************************************
//
//  Description: Methode d'ecriture du Champ
//
//  Entrée: pSortie, un "Output Stream".
//
//  Sortie: Un message d'erreur s'il y a un probleme a l'ecriture.
//
// *******************************************************************
ERMsg ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::exporteVersion0(std::ostream& _GIREF_PARAM_DEBUG(pSortie)) const
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION((pSortie), "Le ostream pSortie est en erreur");
  ERMsg lMsg;

  _GIREF_ASSERTION(false,"Operation non supportee (nouveau format)");

  _GIREF_TEST_INVARIANTS;
  return lMsg;
}

// *******************************************************************
//
//  Description: Assignation des évaluations à faire sur le champ.
//
//  Entrée: Entier pChoixEvaluations: Les évaluations à faire.
//
//  Sortie: Aucune
//
// *******************************************************************
void ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::ajouteEvaluationsAFaire(Entier pChoixEvaluations,
                                                                     const SchemaIntg& pSchemaIntg)
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION(!EvalsChampLocal::reqChoixPourChampComporteEvaluationsAutresQueChamp(pChoixEvaluations), "Pas supporté");

  if (!aAppelRecursifComposante && pChoixEvaluations & EvalsChampLocal::EvalueChamp) {
    aAppelRecursifComposante = true;

    ChampAnalytiqueBaseDiscParElement<ChampTensO4SymMinDiscParElement>::ajouteEvaluationsAFaire(pChoixEvaluations, pSchemaIntg);

    aAppelRecursifComposante = false;

    Entier lEvaluationChamp = EvalsChampLocal::EvalueChamp;

    aChampFonctionElasticiteViscosite          ->ajouteEvaluationsAFaire(lEvaluationChamp,pSchemaIntg);
    aChampYijklPrecedentes                     ->ajouteEvaluationsAFaire(lEvaluationChamp,pSchemaIntg);
    if(aChampIndicateurEtat){
      aChampFonctionVieillisementRessort         ->ajouteEvaluationsAFaire(lEvaluationChamp,pSchemaIntg);
      aChampDeriveeFonctionVieillisementRessort  ->ajouteEvaluationsAFaire(lEvaluationChamp,pSchemaIntg);
      aChampFonctionVieillisementLambda          ->ajouteEvaluationsAFaire(lEvaluationChamp,pSchemaIntg);
      aChampFonctionVieilLambdaPrecedent         ->ajouteEvaluationsAFaire(lEvaluationChamp,pSchemaIntg);
      aChampFonctionVieilRessortPrecedent        ->ajouteEvaluationsAFaire(lEvaluationChamp,pSchemaIntg);
      aChampDeriveeFonctionVieilRessortPrecedent ->ajouteEvaluationsAFaire(lEvaluationChamp,pSchemaIntg);
      aChampIndicateurEtat                       ->ajouteEvaluationsAFaire(lEvaluationChamp,pSchemaIntg);
    }

    Entier lEvaluationDeplacement = EvalsChampLocal::EvalueDeriveesPremieresChamp;

    aChampDeplacements           ->ajouteEvaluationsAFaire(lEvaluationDeplacement,pSchemaIntg);
    aChampDeplacementsPrecedents ->ajouteEvaluationsAFaire(lEvaluationDeplacement,pSchemaIntg);

  }

  _GIREF_TEST_INVARIANTS;
}

// *******************************************************************
//
//  Description: On remet à zéro les évaluations à faire.
//
//  Entrée: Aucune
//
//  Sortie: Aucune
//
// *******************************************************************
void ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::remetAZeroEvaluationsAFaire(const SchemaIntg& pSchemaIntg)
{

  _GIREF_TEST_INVARIANTS;

  if (!aAppelRecursifComposante) {
    aAppelRecursifComposante = true;

    ChampAnalytiqueBaseDiscParElement<ChampTensO4SymMinDiscParElement>::remetAZeroEvaluationsAFaire(pSchemaIntg);

    aAppelRecursifComposante = false;

    aChampDeplacements                         ->remetAZeroEvaluationsAFaire(pSchemaIntg);
    aChampDeplacementsPrecedents               ->remetAZeroEvaluationsAFaire(pSchemaIntg);
    aChampFonctionElasticiteViscosite          ->remetAZeroEvaluationsAFaire(pSchemaIntg);
    aChampYijklPrecedentes                     ->remetAZeroEvaluationsAFaire(pSchemaIntg);
    if(aChampIndicateurEtat){
      aChampFonctionVieillisementRessort         ->remetAZeroEvaluationsAFaire(pSchemaIntg);
      aChampDeriveeFonctionVieillisementRessort  ->remetAZeroEvaluationsAFaire(pSchemaIntg);
      aChampFonctionVieillisementLambda          ->remetAZeroEvaluationsAFaire(pSchemaIntg);
      aChampFonctionVieilLambdaPrecedent         ->remetAZeroEvaluationsAFaire(pSchemaIntg);
      aChampFonctionVieilRessortPrecedent        ->remetAZeroEvaluationsAFaire(pSchemaIntg);
      aChampDeriveeFonctionVieilRessortPrecedent ->remetAZeroEvaluationsAFaire(pSchemaIntg);
      aChampIndicateurEtat                       ->remetAZeroEvaluationsAFaire(pSchemaIntg);
     }

  }

  _GIREF_TEST_INVARIANTS;

}

// *******************************************************************
//
//  Description: Méthode qui ajoute un schéma d'intégration afin que les
//        fonctions de bases soient précalculées et les calculs
//        de "transfert" sur un éléments soient stockés.
//
//  Entrée: const SchemaIntg& pSchemaIntg: Le schéma à assigner
//
//  Sortie: Aucune
//
// *******************************************************************
void ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::ajouteSchemaIntegration(const SchemaIntg& pSchemaIntg)
{
  _GIREF_TEST_INVARIANTS;

  if (!aAppelRecursifComposante) {
    aAppelRecursifComposante = true;

    ChampAnalytiqueBaseDiscParElement<ChampTensO4SymMinDiscParElement>::ajouteSchemaIntegration(pSchemaIntg);

    aAppelRecursifComposante = false;

    aChampDeplacements                         ->ajouteSchemaIntegration(pSchemaIntg);
    aChampDeplacementsPrecedents               ->ajouteSchemaIntegration(pSchemaIntg);
    aChampFonctionElasticiteViscosite          ->ajouteSchemaIntegration(pSchemaIntg);
    aChampYijklPrecedentes                     ->ajouteSchemaIntegration(pSchemaIntg);

    if(aChampIndicateurEtat){
      aChampFonctionVieillisementRessort         ->ajouteSchemaIntegration(pSchemaIntg);
      aChampDeriveeFonctionVieillisementRessort  ->ajouteSchemaIntegration(pSchemaIntg);
      aChampFonctionVieillisementLambda          ->ajouteSchemaIntegration(pSchemaIntg);
      aChampFonctionVieilRessortPrecedent        ->ajouteSchemaIntegration(pSchemaIntg);
      aChampFonctionVieilLambdaPrecedent         ->ajouteSchemaIntegration(pSchemaIntg);
      aChampDeriveeFonctionVieilRessortPrecedent ->ajouteSchemaIntegration(pSchemaIntg);
      aChampIndicateurEtat                       ->ajouteSchemaIntegration(pSchemaIntg);
    }

  }

  _GIREF_TEST_INVARIANTS;
}

// *******************************************************************
//
//  Description: Méthode qui efface toutes les mémoires de fonctions de bases
//         précalculées.
//
//  Entrée: Aucune
//
//  Sortie: Aucune
//
// *******************************************************************
void ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::enleveToutSchemaIntegrations()
{
  _GIREF_TEST_INVARIANTS;

  if (!aAppelRecursifComposante) {
    aAppelRecursifComposante = true;

    ChampAnalytiqueBaseDiscParElement<ChampTensO4SymMinDiscParElement>::enleveToutSchemaIntegrations();

    aAppelRecursifComposante = false;

    aChampDeplacements                         ->enleveToutSchemaIntegrations();
    aChampDeplacementsPrecedents               ->enleveToutSchemaIntegrations();
    aChampFonctionElasticiteViscosite          ->enleveToutSchemaIntegrations();
    aChampYijklPrecedentes                     ->enleveToutSchemaIntegrations();

    if(aChampIndicateurEtat){
      aChampFonctionVieillisementRessort         ->enleveToutSchemaIntegrations();
      aChampDeriveeFonctionVieillisementRessort  ->enleveToutSchemaIntegrations();
      aChampFonctionVieillisementLambda          ->enleveToutSchemaIntegrations();
      aChampFonctionVieilLambdaPrecedent         ->enleveToutSchemaIntegrations();
      aChampFonctionVieilRessortPrecedent        ->enleveToutSchemaIntegrations();
      aChampDeriveeFonctionVieilRessortPrecedent ->enleveToutSchemaIntegrations();
      aChampIndicateurEtat                       ->enleveToutSchemaIntegrations();
    }

  }

  _GIREF_TEST_INVARIANTS;
}

// *******************************************************************
//
//  Description: Méthode qui transfert les informations d'interpolation
//     sur un élément.  Si elles sont pré-calculées, on trasnfert simplement
//     le pointeur.
//
//  Entrée: Aucune
//
//  Sortie: Aucune
//
// *******************************************************************
template <class PTTypeObjet>
const VectDyn<InfoLocalesChamp<TenseurO4SymMin> >&
ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::transfertChampSurGenerique(const PTTypeObjet& pObjet,
                                                                   const SchemaIntg& pSchemaIntg,
                                                                   const VectDyn<InfoLocalesTransformation>& pVectInfoLocalesTransformation) const
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION(aConteneurMemoireChamp[pSchemaIntg.reqIndiceSchemaAjoute()].reqSchemaIntg() == pSchemaIntg, "Mauvais Schéma d'intégration dans la mémoire");
  _GIREF_PRECONDITION(!EvalsChampLocal::reqChoixPourChampComporteEvaluationsAutresQueChamp(aConteneurMemoireChamp[pSchemaIntg.reqIndiceSchemaAjoute()].reqEvaluationsAFaire()), "Pas supporté");

  const Entier lNoIndiceSchema = pSchemaIntg.reqIndiceSchemaAjoute();

  // Ici on transfert l'information calculée sur l'élément par pointeur.
  VectDyn<InfoLocalesChamp<TenseurO4SymMin> >& lVectInfoLocalesChamp = aConteneurMemoireChamp[lNoIndiceSchema].reqVectInfoLocalesChamp();

  //Est-ce que la mémoire contient l'information sur le bon élément?
  if (Champ::reqMemoireChampDesactivee() ||
      TraitMemoireChamp<PTTypeObjet>::reqDernierObjetEvalue(aConteneurMemoireChamp[lNoIndiceSchema]) != &pObjet) {

    const Entier lChoixEvaluations = aConteneurMemoireChamp[lNoIndiceSchema].reqEvaluationsAFaire();
    const bool lFlagEvalueChamp = lChoixEvaluations & EvalsChampLocal::EvalueChamp;

    // Valeurs de l'evaluation
    const EntierN lNbPtIntg = pVectInfoLocalesTransformation.reqLongueur();
    lVectInfoLocalesChamp.asgnLongueur(lNbPtIntg);

    if (lFlagEvalueChamp) {
      const VectDyn<InfoLocalesChamp<Vecteur3D> >&    lVectInfoU = aChampDeplacements->transfertChampSur(pObjet,
                                                                                                         pSchemaIntg,
                                                                                                         pVectInfoLocalesTransformation);

      const VectDyn<InfoLocalesChamp<Vecteur3D> >&    lVectInfoUPrecedent = aChampDeplacementsPrecedents->transfertChampSur(pObjet,
                                                                                                                            pSchemaIntg,
                                                                                                                            pVectInfoLocalesTransformation);

      const VectDyn<InfoLocalesChamp<TenseurO4Sym> >& lVectInfoFonctElasVis = aChampFonctionElasticiteViscosite->transfertChampSur(pObjet,
                                                                                                                                   pSchemaIntg,
                                                                                                                                   pVectInfoLocalesTransformation);
      const VectDyn<InfoLocalesChamp<TenseurO4SymMin> >& lVectInfoYijklPrec = aChampYijklPrecedentes->transfertChampSur(pObjet,
                                                                                                                        pSchemaIntg,
                                                                                                                        pVectInfoLocalesTransformation);
      const VectDyn<InfoLocalesChamp<DReel> >*  lVectInfoFonctVielRes=0;
      const VectDyn<InfoLocalesChamp<DReel> >*  lVectInfoDeriveeFonctVielRes =0;
      const VectDyn<InfoLocalesChamp<DReel> >*  lVectInfoDeriveeFonctVielResPrec =0;
      const VectDyn<InfoLocalesChamp<DReel> >*  lVectInfoFonctVielLambda =0;
      const VectDyn<InfoLocalesChamp<DReel> >*  lVectInfoFonctVielLambdaPrecedent = 0;
      const VectDyn<InfoLocalesChamp<DReel> >*  lVectInfoFonctVielResPrecedent =0;
      const VectDyn<InfoLocalesChamp<DReel> >*  lVectInfoEtat =0;

      if(aChampIndicateurEtat){
        lVectInfoFonctVielRes = &aChampFonctionVieillisementRessort->transfertChampSur(pObjet,
                                                                                       pSchemaIntg,
                                                                                       pVectInfoLocalesTransformation);

        lVectInfoDeriveeFonctVielRes = &aChampDeriveeFonctionVieillisementRessort->transfertChampSur(pObjet,
                                                                                                     pSchemaIntg,
                                                                                                     pVectInfoLocalesTransformation);
        lVectInfoDeriveeFonctVielResPrec = &aChampDeriveeFonctionVieilRessortPrecedent->transfertChampSur(pObjet,
                                                                                                          pSchemaIntg,
                                                                                                          pVectInfoLocalesTransformation);

        lVectInfoFonctVielLambda = &aChampFonctionVieillisementLambda->transfertChampSur(pObjet,
                                                                                         pSchemaIntg,
                                                                                         pVectInfoLocalesTransformation);

        lVectInfoFonctVielLambdaPrecedent = &aChampFonctionVieilLambdaPrecedent->transfertChampSur(pObjet,
                                                                                                   pSchemaIntg,
                                                                                                   pVectInfoLocalesTransformation);


        lVectInfoFonctVielResPrecedent = &aChampFonctionVieilRessortPrecedent->transfertChampSur(pObjet,
                                                                                                 pSchemaIntg,
                                                                                                 pVectInfoLocalesTransformation);


        lVectInfoEtat = &aChampIndicateurEtat->transfertChampSur(pObjet,
                                                                 pSchemaIntg,
                                                                 pVectInfoLocalesTransformation);
      }



      for(EntierN lPt=0;lPt<lNbPtIntg;lPt++) {

        bool lHookeen(true);

        if(aChampIndicateurEtat) {
          lHookeen =((*lVectInfoEtat)[lPt].reqValeurChamp() <= 0.);
        }

        // On calcule le tenseur des deformations
        const Vecteur3D& ldUdX = lVectInfoU[lPt].reqValeurDeriveeXChamp();
        const Vecteur3D& ldUdY = lVectInfoU[lPt].reqValeurDeriveeYChamp();
        const Vecteur3D& ldUdZ = lVectInfoU[lPt].reqValeurDeriveeZChamp();

        TenseurO2Sym lEpsilonU(ldUdX.reqX(),ldUdY.reqY(),ldUdZ.reqZ(),
                               0.5*(ldUdX.reqY() +ldUdY.reqX()), 0.5*(ldUdY.reqZ() +ldUdZ.reqY()),0.5*(ldUdX.reqZ() +ldUdZ.reqX()) );
        const Vecteur3D& ldUPrecdX = lVectInfoUPrecedent[lPt].reqValeurDeriveeXChamp();
        const Vecteur3D& ldUPrecdY = lVectInfoUPrecedent[lPt].reqValeurDeriveeYChamp();
        const Vecteur3D& ldUPrecdZ = lVectInfoUPrecedent[lPt].reqValeurDeriveeZChamp();

        const TenseurO2Sym lEpsilonUPrecedent(ldUPrecdX.reqX(),ldUPrecdY.reqY(),ldUPrecdZ.reqZ(),
                                              0.5*(ldUPrecdX.reqY() +ldUPrecdY.reqX()), 0.5*(ldUPrecdY.reqZ() +ldUPrecdZ.reqY()),0.5*(ldUPrecdX.reqZ() +ldUPrecdZ.reqX()) );

        DReel lB             = 1.;
        DReel lBPrec         = 1.;
        DReel lLambda        = 1.;
        DReel lLambdaPrec    = 1.;
        DReel lDivise        = 0.;
        DReel lDivisePrec    = 0.;
        DReel lDeriveeB      = 0.;
        DReel lDeriveeBPrec  = 0.;

        DReel lCoef1         = (1.-aThetaSchema)*(*aPasDeTemps);
        DReel lCoef2         = (aThetaSchema)*(*aPasDeTemps);

        if(aChampIndicateurEtat) {
          lB             = (*lVectInfoFonctVielRes)[lPt].reqValeurChamp();
          lBPrec         = (*lVectInfoFonctVielResPrecedent)[lPt].reqValeurChamp();
          lLambda        = (*lVectInfoFonctVielLambda)[lPt].reqValeurChamp();
          lLambdaPrec    = (*lVectInfoFonctVielLambdaPrecedent)[lPt].reqValeurChamp();
        }

        const DReel lMoisUn  = -1.0;
        TenseurO4Sym lUniteO4(1.);
        TenseurO4Sym lMoinsUniteO4(-1.);
        TenseurO4Sym lMoinsUnitePrecO4(-1.);
        TenseurO4Sym lUniteIntO4(1.);
        TenseurO4Sym lUniteIntPrecO4(1.);

        TenseurO4Sym lAlpha = (lVectInfoFonctElasVis[lPt].reqValeurChamp())*(lLambda);
        TenseurO4Sym lAlphaPrecedent = (lVectInfoFonctElasVis[lPt].reqValeurChamp())*(lLambdaPrec);
        //std::cout<<"ChampPseudoRelaxation: Alpha  "<<lAlpha << "   AlphaPrecedent "<< lAlphaPrecedent<<std::endl;
        TenseurO4SymMin lYijkl(0.);
        TenseurO4Sym    lGamma(0.);
        TenseurO4Sym    lGammaPrecedent(0.);

        if (aChampIndicateurEtat) {
          lDeriveeB     = (*lVectInfoDeriveeFonctVielRes)[lPt].reqValeurChamp();
          lDeriveeBPrec = (*lVectInfoDeriveeFonctVielResPrec)[lPt].reqValeurChamp();
        }
        lUniteIntO4*= lDeriveeB;
        lUniteIntPrecO4*=lDeriveeBPrec;
        lGamma+=lUniteIntO4;
        lGammaPrecedent+=lUniteIntPrecO4;
        lDivise     = lDeriveeB/lB;
        lDivisePrec = lDeriveeBPrec/lBPrec;

        if(lHookeen) {
          // On complete la construction de Alpha et AlphaPrecedent
          lMoinsUniteO4*=lDivise;
          lMoinsUnitePrecO4*=lDivisePrec;
          lAlpha+=lMoinsUniteO4;
          lAlphaPrecedent+=lMoinsUnitePrecO4;
        }
        else
        {// Bazant
          std::cout<<" !! On est dans la la branche Bazant "<<std::endl;
        }

        // On complete la construction Gamma et GammaPrecedent
        TenseurO4Sym lGammaInterm = lAlpha;
        TenseurO4Sym lGammaIntermPrecedent =lAlphaPrecedent;
        lGammaInterm*=lB;
        lGammaIntermPrecedent*=lBPrec;
        lGamma+=lGammaInterm;
        lGammaPrecedent+=lGammaIntermPrecedent;

         //debut de la recurrence
        lGammaPrecedent*=lCoef1;
        lGamma*=lCoef2;
        lAlpha*=lCoef2;
        lAlpha+=lUniteO4;
        lAlphaPrecedent*=lCoef1;
        lAlphaPrecedent*=lMoisUn;
        lAlphaPrecedent+=lUniteO4;

        TenseurO4Sym lAlphaPrecedentDiviseParlAlpha(divisionSansSommation(lAlphaPrecedent,lAlpha));
        TenseurO4SymMin lYijklHookeen(produitSansSommation(lAlphaPrecedentDiviseParlAlpha,lVectInfoYijklPrec[lPt].reqValeurChamp()));
        TenseurO4SymMin lValeurAdd1Hookeen(produitSansSommation(divisionSansSommation(lGamma,lAlpha), lEpsilonU));
        lValeurAdd1Hookeen+=produitSansSommation(divisionSansSommation(lGammaPrecedent,lAlpha), lEpsilonUPrecedent);
        lYijklHookeen+=lValeurAdd1Hookeen;
        lYijkl+=lYijklHookeen;

        lVectInfoLocalesChamp[lPt].asgnValeurChamp(lYijkl);
      //     std::cout<<"ChampPseudoRelaxation  Elasticite  "<<lYijkl <<std::endl;
      }

    }

    aConteneurMemoireChamp[lNoIndiceSchema].asgnDernierObjetEvalue(pObjet);
  }

  _GIREF_POSTCONDITION(0 != &lVectInfoLocalesChamp, "Pointeur nul!");
  _GIREF_POSTCONDITION(&pObjet == TraitMemoireChamp<PTTypeObjet>::reqDernierObjetEvalue(aConteneurMemoireChamp[lNoIndiceSchema]), "Aye dernier element pas stocke");
  _GIREF_TEST_INVARIANTS;

  return lVectInfoLocalesChamp;
}

// *******************************************************************
//
//  Description: Méthode qui transfert les informations d'interpolation
//     sur un élément.  Si elles sont pré-calculées, on trasnfert simplement
//     le pointeur.
//
//  Entrée: Aucune
//
//  Sortie: Aucune
//
// *******************************************************************
const VectDyn<InfoLocalesChamp<TenseurO4SymMin> >&
ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::transfertChampSur(const Maillage::TypeElement& pElement,
                                                          const SchemaIntg& pSchemaIntg,
                                                          const VectDyn<InfoLocalesTransformation>& pVectInfoLocalesTransformation) const
{
  _GIREF_TEST_INVARIANTS;
  return transfertChampSurGenerique(pElement, pSchemaIntg, pVectInfoLocalesTransformation);
}

// *******************************************************************
//
//  Description: Methode de lecture du Champ
//
//  Entrée: pEntree, un "Input Stream".
//
//  Sortie: Un message d'erreur s'il y a un probleme a la lecture.
//
// *******************************************************************
void ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::lisVirtuel (PRStreamLecture& pPRLecture)
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION((pPRLecture), "Le PRStreamLecture pPRLecture est en erreur");

  //
  std::string lNumeroVersion;
  lisDebutClasse(pPRLecture,"ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas");
  lisNumeroVersion(pPRLecture,lNumeroVersion);
  if(pPRLecture && lNumeroVersion != "Version 1.0") {
    pPRLecture.asgMsg(ERMsg(ERMsg::ERREUR, "ERR_NUMERO_VERSION"));
  }
  //

  ChampAnalytiqueBaseDiscParElement<ChampTensO4SymMinDiscParElement>::lisVirtuel(pPRLecture);

  //
  lisFinClasse(pPRLecture,"ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas");
  //

  _GIREF_TEST_INVARIANTS;
}

// *******************************************************************
//
//  Description: Methode d'ecriture du Champ
//
//  Entrée: pSortie, un "Output Stream".
//
//  Sortie: Un message d'erreur s'il y a un probleme a l'ecriture.
//
// *******************************************************************
void ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::ecrisVirtuel (PRStreamEcriture& pPREcriture) const
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION((pPREcriture), "Le PRStreamEcriture pPREcriture est en erreur");

  //
  ecrisDebutClasse(pPREcriture,"ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas");
  ecrisNumeroVersion(pPREcriture,"Version 1.0");
  //

  ChampAnalytiqueBaseDiscParElement<ChampTensO4SymMinDiscParElement>::ecrisVirtuel(pPREcriture);

  ERMsg lMsg = ERMsg(ERMsg::OK);

  //
  ecrisFinClasse(pPREcriture,"ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas");
  //

  _GIREF_TEST_INVARIANTS;
}


// *******************************************************************
//
//  Description: Méthode qui teste les invariants de la classe.
//
//  Entrée: Aucune
//
//  Sortie: Arrêt du programme en cas d'erreur
//
// *******************************************************************
#ifdef GIREF_MODE_DEBUG
void ChampPseudoRelaxationMateriauVieillisantFormulationThetaSchemas::testInvariants() const
{

  _GIREF_TEST_OBJET_INVARIANTS;

}
#endif // #ifdef GIREF_MODE_DEBUG