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

#include "GeorgesVisco_ChampPseudoContraintesO4.h"
#include "CalculBarycentreElement.h"
#include "ChampGeometrique.h"
#include "ChampScalContinu.h"
#include "ChampTensO4SymMinDiscParElement.h"
#include "ChampTensorielO4Sym.h"
#include "ChampTensorielO4SymMin.h"
#include "FonctionsInterpolation.h"
#include "fonctionsTenseurs.h"
#include "RequeteCentreElementReference.h"
#include "UtilPersistance.h"

// ********************************************************************
//
//  Description: Constructeur par défaut.
//
//  Entrée: Aucune
//
//  Sortie: Aucune
//
// ********************************************************************
GeorgesVisco_ChampPseudoContraintesO4::GeorgesVisco_ChampPseudoContraintesO4(const std::string& pNom)
  :aSigmaPrecedent(0),
   aI(0),
   aS(0),
   aChampDeplacements(0),
   aChampDeplacementsPrecedent(0),
   aNonIncrementale(false),
   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: pGeorgesVisco_ChampPseudoContraintesO4: l'objet à copier
//
//  Sortie: Aucune
//
// ********************************************************************
GeorgesVisco_ChampPseudoContraintesO4::GeorgesVisco_ChampPseudoContraintesO4(const GeorgesVisco_ChampPseudoContraintesO4& pGeorgesVisco_ChampPseudoContraintesO4)
  : ChampAnalytiqueBaseDiscParElement<ChampTensO4SymMinDiscParElement>(),
    aAppelRecursifComposante(false)
{
  _GIREF_APPEL_TEST_INVARIANTS(pGeorgesVisco_ChampPseudoContraintesO4);
  _GIREF_CONSTRUCTEUR_INVARIANTS;

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

  asgnNom(pGeorgesVisco_ChampPseudoContraintesO4.reqNom());

  *this = pGeorgesVisco_ChampPseudoContraintesO4;

  _GIREF_TEST_INVARIANTS;
}

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

  _GIREF_DESTRUCTEUR_INVARIANTS;
}

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

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

  if (this != &pGeorgesVisco_ChampPseudoContraintesO4) {
    aChampDeplacements             = pGeorgesVisco_ChampPseudoContraintesO4.aChampDeplacements;
    aChampDeplacementsPrecedent    = pGeorgesVisco_ChampPseudoContraintesO4.aChampDeplacementsPrecedent;
    aI                             = pGeorgesVisco_ChampPseudoContraintesO4.aI;
    aS                             = pGeorgesVisco_ChampPseudoContraintesO4.aS;
    aSigmaPrecedent                = pGeorgesVisco_ChampPseudoContraintesO4.aSigmaPrecedent;
    aNonIncrementale               = pGeorgesVisco_ChampPseudoContraintesO4.aNonIncrementale;
  }

  _GIREF_TEST_INVARIANTS;
  return *this;
}

// ********************************************************************
//
//  Description: Méthode d'assignation des champs necessaires au calcul
//               de la pseud-contrainte
//
//  Entrée:  pSigmaPrecedent                             la contrainte au pas de temps precedent
//           pI                                          le tenseur O4 symetrique appliqué a pSigmaPrecedent
//           pS                                          le tenseur O4 symetrique appliqué aux déformations
//           pChampIncrementDeplacements                 le champs de l'increment des deplacements au temps courant
//
//
//  Sortie: ERMsg: Aucune
//
// ********************************************************************
void GeorgesVisco_ChampPseudoContraintesO4::asgnChamps(ChampTensorielO4SymMin&    pSigmaPrecedent,
                                                       ChampTensorielO4Sym&       pI,
                                                       ChampTensorielO4Sym&       pS,
                                                       ChampVectoriel3D&          pChampIncrementDeplacements)
{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION(0!= &pSigmaPrecedent,             "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pI,                          "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pS,                          "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampIncrementDeplacements, "Pointeur nul!");

  aSigmaPrecedent                = &pSigmaPrecedent;
  aI                             = &pI;
  aS                             = &pS;
  aChampDeplacements             = &pChampIncrementDeplacements;
  aChampDeplacementsPrecedent    = 0;
  aNonIncrementale               = false;

  _GIREF_TEST_INVARIANTS;
}

// ********************************************************************
//
//  Description: Méthode d'assignation des champs necessaires au calcul
//               de la pseud-contrainte
//
//  Entrée:  pSigmaPrecedent                             la contrainte au pas de temps precedent
//           pI                                          le tenseur O4 symetrique appliqué a pSigmaPrecedent
//           pS                                          le tenseur O4 symetrique appliqué aux déformations
//           pChampDeplacements                          le champs des deplacements au temps courant
//           pChampDeplacementsPrecedent                 le champs des deplacements au temps precedent
//
//
//  Sortie: ERMsg: Aucune
//
// ********************************************************************
void GeorgesVisco_ChampPseudoContraintesO4::asgnChamps(ChampTensorielO4SymMin&    pSigmaPrecedent,
                                                       ChampTensorielO4Sym&       pI,
                                                       ChampTensorielO4Sym&       pS,
                                                       ChampVectoriel3D&          pChampDeplacements,
                                                       ChampVectoriel3D&          pChampDeplacementsPrecedent)

{
  _GIREF_TEST_INVARIANTS;
  _GIREF_PRECONDITION(0!= &pSigmaPrecedent,             "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pI,                          "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pS,                          "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampDeplacements,          "Pointeur nul!");
  _GIREF_PRECONDITION(0!= &pChampDeplacementsPrecedent, "Pointeur nul!");

  aSigmaPrecedent                = &pSigmaPrecedent;
  aI                             = &pI;
  aS                             = &pS;
  aChampDeplacements             = &pChampDeplacements;
  aChampDeplacementsPrecedent    = &pChampDeplacementsPrecedent;
  aNonIncrementale               = true;

  _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_ChampPseudoContraintesO4::asgnTemps(const DReel& pTemps)
{
  _GIREF_TEST_INVARIANTS;

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

    aI                            -> asgnTemps(pTemps);
    aS                            -> asgnTemps(pTemps);
    aSigmaPrecedent               -> asgnTemps(pTemps);
    aChampDeplacements            -> asgnTemps(pTemps);
    if(aNonIncrementale) aChampDeplacementsPrecedent   -> 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_ChampPseudoContraintesO4::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éé
//
// ********************************************************************
GeorgesVisco_ChampPseudoContraintesO4* GeorgesVisco_ChampPseudoContraintesO4::newChamp() const
{
  _GIREF_TEST_INVARIANTS;

  return new GeorgesVisco_ChampPseudoContraintesO4();

}

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

  return new GeorgesVisco_ChampPseudoContraintesO4(*this);

}

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

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

  _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_ChampPseudoContraintesO4::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_ChampPseudoContraintesO4::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;

    aSigmaPrecedent               -> ajouteEvaluationsAFaire(EvalsChampLocal::EvalueChamp,pSchemaIntg);
    aI                            -> ajouteEvaluationsAFaire(EvalsChampLocal::EvalueChamp,pSchemaIntg);
    aS                            -> ajouteEvaluationsAFaire(EvalsChampLocal::EvalueChamp,pSchemaIntg);
    aChampDeplacements            -> ajouteEvaluationsAFaire(EvalsChampLocal::EvalueDeriveesPremieresChamp,pSchemaIntg);
  //  aChampDeplacements            -> ajouteEvaluationsAFaire(EvalsChampLocal::EvalueChamp,pSchemaIntg);
    if(aNonIncrementale) aChampDeplacementsPrecedent   -> ajouteEvaluationsAFaire(EvalsChampLocal::EvalueDeriveesPremieresChamp,pSchemaIntg);
  //  aChampDeplacementsPrecedent   -> ajouteEvaluationsAFaire(EvalsChampLocal::EvalueChamp,pSchemaIntg);
  }

  _GIREF_TEST_INVARIANTS;
}

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

  _GIREF_TEST_INVARIANTS;

  if (!aAppelRecursifComposante) {
    aAppelRecursifComposante = true;

    ChampAnalytiqueBaseDiscParElement<ChampTensO4SymMinDiscParElement>::remetAZeroEvaluationsAFaire(pSchemaIntg);

    aAppelRecursifComposante = false;

    aSigmaPrecedent               -> remetAZeroEvaluationsAFaire(pSchemaIntg);
    aI                            -> remetAZeroEvaluationsAFaire(pSchemaIntg);
    aS                            -> remetAZeroEvaluationsAFaire(pSchemaIntg);
    aChampDeplacements            -> remetAZeroEvaluationsAFaire(pSchemaIntg);
    if(aNonIncrementale) aChampDeplacementsPrecedent   -> 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_ChampPseudoContraintesO4::ajouteSchemaIntegration(const SchemaIntg& pSchemaIntg)
{
  _GIREF_TEST_INVARIANTS;

  if (!aAppelRecursifComposante) {
    aAppelRecursifComposante = true;

    ChampAnalytiqueBaseDiscParElement<ChampTensO4SymMinDiscParElement>::ajouteSchemaIntegration(pSchemaIntg);

    aAppelRecursifComposante = false;

    aSigmaPrecedent                -> ajouteSchemaIntegration(pSchemaIntg);
    aI                             -> ajouteSchemaIntegration(pSchemaIntg);
    aS                             -> ajouteSchemaIntegration(pSchemaIntg);
    aChampDeplacements             -> ajouteSchemaIntegration(pSchemaIntg);
    if(aNonIncrementale) aChampDeplacementsPrecedent    -> 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_ChampPseudoContraintesO4::enleveToutSchemaIntegrations()
{
  _GIREF_TEST_INVARIANTS;

  if (!aAppelRecursifComposante) {
    aAppelRecursifComposante = true;

    ChampAnalytiqueBaseDiscParElement<ChampTensO4SymMinDiscParElement>::enleveToutSchemaIntegrations();

    aAppelRecursifComposante = false;

    aSigmaPrecedent                -> enleveToutSchemaIntegrations();
    aI                             -> enleveToutSchemaIntegrations();
    aS                             -> enleveToutSchemaIntegrations();
    aChampDeplacements             -> enleveToutSchemaIntegrations();
    if(aNonIncrementale) aChampDeplacementsPrecedent    -> 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> >&
GeorgesVisco_ChampPseudoContraintesO4::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<TenseurO4SymMin> >& lVectInfoSigmaPrecedent = aSigmaPrecedent->transfertChampSur(pObjet,
                                                                                                                      pSchemaIntg,
                                                                                                                      pVectInfoLocalesTransformation);

      const VectDyn<InfoLocalesChamp<TenseurO4Sym> >& lVectInfoI = aI->transfertChampSur(pObjet,
                                                                                         pSchemaIntg,
                                                                                         pVectInfoLocalesTransformation);

      const VectDyn<InfoLocalesChamp<TenseurO4Sym> >& lVectInfoS = aS->transfertChampSur(pObjet,
                                                                                         pSchemaIntg,
                                                                                         pVectInfoLocalesTransformation);

      const VectDyn<InfoLocalesChamp<Vecteur3D> >& lVectInfoU = aChampDeplacements->transfertChampSur(pObjet,
                                                                                                      pSchemaIntg,
                                                                                                      pVectInfoLocalesTransformation);
      const VectDyn<InfoLocalesChamp<Vecteur3D> >* lVectInfoUPrecedent = 0;

      if(aNonIncrementale) lVectInfoUPrecedent = &(aChampDeplacementsPrecedent->transfertChampSur(pObjet,
                                                                                                  pSchemaIntg,
                                                                                                  pVectInfoLocalesTransformation));

      if(aChampDeplacements == aChampDeplacementsPrecedent) std::cout<<"ATTENTION MEME CHAMP POUR LES DEPLACEMENTS"<<std::endl;

      calculVectInfoLocalesChamp(lVectInfoSigmaPrecedent,
                                 lVectInfoI,
                                 lVectInfoS,
                                 lVectInfoU,
                                 *lVectInfoUPrecedent,
                                 lVectInfoLocalesChamp);
    }

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

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

  ChampAnalytiqueBaseDiscParElement<ChampTensO4SymMinDiscParElement>::lisVirtuel(pPRLecture);

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

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

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

  ChampAnalytiqueBaseDiscParElement<ChampTensO4SymMinDiscParElement>::ecrisVirtuel(pPREcriture);

  ERMsg lMsg = ERMsg(ERMsg::OK);

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

  _GIREF_TEST_INVARIANTS;
}

// ********************************************************************
//
//  Description:
//
//  Entrée:
//
//  Sortie:
//
// ********************************************************************
void GeorgesVisco_ChampPseudoContraintesO4::calculVectInfoLocalesChamp(const VectDyn<InfoLocalesChamp<TenseurO4SymMin> >     & pSigmaPrecedent,
                                                                       const VectDyn<InfoLocalesChamp<TenseurO4Sym> >        & pI,
                                                                       const VectDyn<InfoLocalesChamp<TenseurO4Sym> >        & pS,
                                                                       const VectDyn<InfoLocalesChamp<Vecteur3D> >           & pU,
                                                                       const VectDyn<InfoLocalesChamp<Vecteur3D> >           & pUPrecedent,
                                                                       VectDyn<InfoLocalesChamp<TenseurO4SymMin> >           & pSigma) const
{
  _GIREF_TEST_INVARIANTS;


  const Entier lNbPtIntg = pU.reqLongueur();
  TenseurO4SymMin lSigmaPrec(0.), lSigma(0.);
  TenseurO4Sym lI(0.);
  TenseurO4Sym lS(0.);

  for (Entier lPt = 0; lPt < lNbPtIntg; ++lPt) { // Boucle sur les points d'integrations

    lSigmaPrec = pSigmaPrecedent[lPt].reqValeurChamp();
    lI         = pI[lPt]  .reqValeurChamp();
    lS         = pS[lPt]  .reqValeurChamp();

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

    TenseurO2Sym lEpsilonDeltaU(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(aNonIncrementale){
      const Vecteur3D& ldUPrecdX = pUPrecedent[lPt].reqValeurDeriveeXChamp();
      const Vecteur3D& ldUPrecdY = pUPrecedent[lPt].reqValeurDeriveeYChamp();
      const Vecteur3D& ldUPrecdZ = pUPrecedent[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()) );

      lEpsilonDeltaU -= lEpsilonUPrecedent;
    }

    // On construit le tenseur des contraintes

    lSigma =  produitSansSommation(lI,lSigmaPrec);
    lSigma += produitSansSommation(lS,lEpsilonDeltaU);

    pSigma[lPt].asgnValeurChamp(lSigma);

  }

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

  _GIREF_TEST_OBJET_INVARIANTS;

}
#endif // #ifdef GIREF_MODE_DEBUG