// ***********************************************************************
// --- 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:   GeorgesVisco_ChampContraintesHPPMateriauVieillissant.cc
//
//  Nom de la classe: GeorgesVisco_ChampContraintesHPPMateriauVieillissant
//
// *******************************************************************

#include "GeorgesVisco_ChampContraintesHPPMateriauVieillissant.h"
#include "ChampScalContinu.h"
#include "ChampTensO2SymDiscParElement.h"
#include "ChampTensorielO4Sym.h"
#include "ChampVect3DContinu.h"
#include "UtilPersistance.h"

// *******************************************************************
//
//  Description: Constructeur par défaut.
//
//  Entrée: Aucune
//
//  Sortie: Aucune
//
// *******************************************************************
GeorgesVisco_ChampContraintesHPPMateriauVieillissant::GeorgesVisco_ChampContraintesHPPMateriauVieillissant(const std::string& pNom)
  :aChampDeplacements(0),
   aChampDeplacementsPrecedents(0),
   aChampElasticite(0),
   aChampContraintesPrecedentes(0),
   aChampIndicateurEtat(0),
   aAppelRecursifComposante(false)
{
  _GIREF_CONSTRUCTEUR_INVARIANTS;

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

  asgnNom(pNom);

  _GIREF_TEST_INVARIANTS;
}

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

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

  asgnNom(pGeorgesVisco_ChampContraintesHPPMateriauVieillissant.reqNom());

  *this = pGeorgesVisco_ChampContraintesHPPMateriauVieillissant;

  _GIREF_TEST_INVARIANTS;
}

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

  _GIREF_DESTRUCTEUR_INVARIANTS;
}

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

  ChampAnalytiqueBaseDiscParElement<ChampTensO2SymDiscParElement>::operator=(pGeorgesVisco_ChampContraintesHPPMateriauVieillissant);

  if (this != &pGeorgesVisco_ChampContraintesHPPMateriauVieillissant) {
    aChampDeplacements           = pGeorgesVisco_ChampContraintesHPPMateriauVieillissant.aChampDeplacements;
    aChampDeplacementsPrecedents = pGeorgesVisco_ChampContraintesHPPMateriauVieillissant.aChampDeplacementsPrecedents;
    aChampElasticite             = pGeorgesVisco_ChampContraintesHPPMateriauVieillissant.aChampElasticite;
    aChampContraintesPrecedentes = pGeorgesVisco_ChampContraintesHPPMateriauVieillissant.aChampContraintesPrecedentes;
    aChampIndicateurEtat         = pGeorgesVisco_ChampContraintesHPPMateriauVieillissant.aChampIndicateurEtat;
  }

  _GIREF_TEST_INVARIANTS;
  return *this;
}

// *******************************************************************
//
//  Description:
//
//  Entrée:
//
//  Sortie: ERMsg: Message d'erreur
//
// *******************************************************************
void GeorgesVisco_ChampContraintesHPPMateriauVieillissant::asgnChamps(ChampVect3DContinu  &pChampDeplacements,
                                                                      ChampVect3DContinu  &pChampDeplacementsPrecedents,
                                                                      ChampTensorielO4Sym &pChampElasticite,
                                                                      ChampTensorielO2Sym &pChampContraintesPrecedentes,
                                                                      ChampScalaire       &pChampIndicateurEtat)
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION(0!= &pChampDeplacements,           "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampDeplacementsPrecedents, "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampElasticite,             "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampContraintesPrecedentes, "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampIndicateurEtat,         "Pointeur nul!");

  aChampDeplacements           = &pChampDeplacements;
  aChampDeplacementsPrecedents = &pChampDeplacementsPrecedents;
  aChampElasticite             = &pChampElasticite;
  aChampContraintesPrecedentes = &pChampContraintesPrecedentes;
  aChampIndicateurEtat         = &pChampIndicateurEtat;

  _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 GeorgesVisco_ChampContraintesHPPMateriauVieillissant::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<ChampTensO2SymDiscParElement>::asgnTemps(pTemps);

    aChampDeplacements          ->asgnTemps(pTemps);
    aChampDeplacementsPrecedents->asgnTemps(pTemps);
    aChampElasticite            ->asgnTemps(pTemps);
    aChampContraintesPrecedentes->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 GeorgesVisco_ChampContraintesHPPMateriauVieillissant::evalue(const Vecteur3D& /*pCoor*/, const DReel& /*pTemps*/, TenseurO2Sym& /*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éé
//
// *******************************************************************
GeorgesVisco_ChampContraintesHPPMateriauVieillissant* GeorgesVisco_ChampContraintesHPPMateriauVieillissant::newChamp() const
{
  _GIREF_TEST_INVARIANTS;

  return new GeorgesVisco_ChampContraintesHPPMateriauVieillissant();
}

// *******************************************************************
//
//  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éé
//
// *******************************************************************
GeorgesVisco_ChampContraintesHPPMateriauVieillissant* GeorgesVisco_ChampContraintesHPPMateriauVieillissant::newChampCopie() const
{
  _GIREF_TEST_INVARIANTS;

  return new GeorgesVisco_ChampContraintesHPPMateriauVieillissant(*this);
}

// *******************************************************************
//
//  Description: Retourne le ChampScalContinu representant la
//  composante X du Champ courant.
//
//  Entrée: Aucune
//
//  Sortie: Une reference sur la composante X
//
// *******************************************************************
ChampScalaire& GeorgesVisco_ChampContraintesHPPMateriauVieillissant::reqComposante(const Entier pIndice)
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION(6 > 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& GeorgesVisco_ChampContraintesHPPMateriauVieillissant::reqComposante(const Entier pIndice) const
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION(6 > 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 GeorgesVisco_ChampContraintesHPPMateriauVieillissant::importeVersion0(std::istream& /*pEntree*/)
{
  _GIREF_TEST_INVARIANTS;
  ERMsg lMsg;

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

  _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 GeorgesVisco_ChampContraintesHPPMateriauVieillissant::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 GeorgesVisco_ChampContraintesHPPMateriauVieillissant::ajouteEvaluationsAFaire(Entier pChoixEvaluations,
                                                                                   const SchemaIntg& pSchemaIntg)
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION(!EvalsChampLocal::reqChoixPourChampComporteEvaluationsAutresQueChamp(pChoixEvaluations), "Pas supporté");

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

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

    aAppelRecursifComposante = false;

    Entier lEvaluationChamp = EvalsChampLocal::EvalueChamp;

    aChampElasticite             ->ajouteEvaluationsAFaire(lEvaluationChamp,pSchemaIntg);
    aChampContraintesPrecedentes ->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 GeorgesVisco_ChampContraintesHPPMateriauVieillissant::remetAZeroEvaluationsAFaire(const SchemaIntg& pSchemaIntg)
{

  _GIREF_TEST_INVARIANTS;

  if (!aAppelRecursifComposante) {
    aAppelRecursifComposante = true;

    ChampAnalytiqueBaseDiscParElement<ChampTensO2SymDiscParElement>::remetAZeroEvaluationsAFaire(pSchemaIntg);

    aAppelRecursifComposante = false;

    aChampDeplacements           ->remetAZeroEvaluationsAFaire(pSchemaIntg);
    aChampDeplacementsPrecedents ->remetAZeroEvaluationsAFaire(pSchemaIntg);
    aChampElasticite             ->remetAZeroEvaluationsAFaire(pSchemaIntg);
    aChampContraintesPrecedentes ->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 GeorgesVisco_ChampContraintesHPPMateriauVieillissant::ajouteSchemaIntegration(const SchemaIntg& pSchemaIntg)
{
  _GIREF_TEST_INVARIANTS;

  if (!aAppelRecursifComposante) {
    aAppelRecursifComposante = true;

    ChampAnalytiqueBaseDiscParElement<ChampTensO2SymDiscParElement>::ajouteSchemaIntegration(pSchemaIntg);

    aAppelRecursifComposante = false;

    aChampDeplacements           ->ajouteSchemaIntegration(pSchemaIntg);
    aChampDeplacementsPrecedents ->ajouteSchemaIntegration(pSchemaIntg);
    aChampElasticite             ->ajouteSchemaIntegration(pSchemaIntg);
    aChampContraintesPrecedentes ->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 GeorgesVisco_ChampContraintesHPPMateriauVieillissant::enleveToutSchemaIntegrations()
{
  _GIREF_TEST_INVARIANTS;

  if (!aAppelRecursifComposante) {
    aAppelRecursifComposante = true;

    ChampAnalytiqueBaseDiscParElement<ChampTensO2SymDiscParElement>::enleveToutSchemaIntegrations();

    aAppelRecursifComposante = false;

    aChampDeplacements           ->enleveToutSchemaIntegrations();
    aChampDeplacementsPrecedents ->enleveToutSchemaIntegrations();
    aChampElasticite             ->enleveToutSchemaIntegrations();
    aChampContraintesPrecedentes ->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<TenseurO2Sym> >&
GeorgesVisco_ChampContraintesHPPMateriauVieillissant::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<TenseurO2Sym> >& 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> >& lVectInfoElas = aChampElasticite->transfertChampSur(pObjet,
                                                                                                          pSchemaIntg,
                                                                                                          pVectInfoLocalesTransformation);

      const VectDyn<InfoLocalesChamp<TenseurO2Sym> >& lVectInfoSigmaPrecedent = aChampContraintesPrecedentes->transfertChampSur(pObjet,
                                                                                                                                pSchemaIntg,
                                                                                                                                pVectInfoLocalesTransformation);

      const VectDyn<InfoLocalesChamp<DReel> >&        lVectInfoEtat = aChampIndicateurEtat->transfertChampSur(pObjet,
                                                                                                              pSchemaIntg,
                                                                                                              pVectInfoLocalesTransformation);



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

        bool 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 lEpsilon(ldUdX.reqX(),ldUdY.reqY(),ldUdZ.reqZ(),
                              0.5*(ldUdX.reqY() +ldUdY.reqX()), 0.5*(ldUdY.reqZ() +ldUdZ.reqY()),0.5*(ldUdX.reqZ() +ldUdZ.reqX()) );
        if(!lHookeen){
          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()) );

          lEpsilon -= lEpsilonUPrecedent;
        }


        TenseurO2Sym lContraintes = lVectInfoElas[lPt].reqValeurChamp().contractionDoubleIndicesDeGauche(lEpsilon);

        if(!lHookeen) lContraintes += lVectInfoSigmaPrecedent[lPt].reqValeurChamp();

        lVectInfoLocalesChamp[lPt].asgnValeurChamp(lContraintes);
      }
    }

    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<TenseurO2Sym> >&
GeorgesVisco_ChampContraintesHPPMateriauVieillissant::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 GeorgesVisco_ChampContraintesHPPMateriauVieillissant::lisVirtuel (PRStreamLecture& pPRLecture)
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION((pPRLecture), "Le PRStreamLecture pPRLecture est en erreur");

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

  ChampAnalytiqueBaseDiscParElement<ChampTensO2SymDiscParElement>::lisVirtuel(pPRLecture);

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

  _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 GeorgesVisco_ChampContraintesHPPMateriauVieillissant::ecrisVirtuel (PRStreamEcriture& pPREcriture) const
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION((pPREcriture), "Le PRStreamEcriture pPREcriture est en erreur");

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

  ChampAnalytiqueBaseDiscParElement<ChampTensO2SymDiscParElement>::ecrisVirtuel(pPREcriture);

  ERMsg lMsg = ERMsg(ERMsg::OK);

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

  _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 GeorgesVisco_ChampContraintesHPPMateriauVieillissant::testInvariants() const
{

  _GIREF_TEST_OBJET_INVARIANTS;

}
#endif // #ifdef GIREF_MODE_DEBUG