// ************************************************************************
// --- Logiciel MEF++
// ---
// --- Copyright 1996-2002 GIREF, Universite Laval
// --- TOUS DROITS RESERVES
// --- 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 compile, à des fins
// --- personnelles et non commerciales sont autorisees sans frais pour
// --- autant que la presente notice de copyright ainsi que cette
// --- permission apparaissent dans toutes les copies ainsi que dans la
// --- documentation.
// --- Le GIREF et l'Universite Laval ne pretendent en aucune façon que
// --- ce logiciel convient à un emploi quelconque. Celui-ci est
// --- distribue sans aucune garantie implicite ou explicite.
// ************************************************************************

// ********************************************************************
//  Nom du fichier: adaptationThermoHygroMecanik.cc
//
//  Description:
//     Variation issu de adapMultVarkhalid. J'ai modifie le code 
//     pour faire de la reinterpolation sur des champs 3D. J'ai aussi
//     ajouter une macro pour controler l'output du code. En definissant
//     TOTAL on retrouve tout la verbose du code original (exportVU, etc).
//
// ********************************************************************

#include "AdaptationGeometrie2_5D.h"
#include "AdaptationMaillage.h"
#include "AdaptationMaillage1D.h"
#include "AdaptationMaillage3DHierarchique.h"
#include "CalculGradientMoyenne.h"
#include "CalculMetrique.h"
#include "ChampAnalytiqueBaseContinu.h"
#include "ChampGeoLin.h"
#include "ChampGeoQuad.h"
#include "ChampSAExpAlg.h"
#include "ChampScalConstElem.h"
#include "ChampScalLinElem.h"
#include "ChampTensO2SymLin.h"
#include "ChampV3DAExpAlg.h"
#include "ChampVect3DConstElem.h"
#include "ChampVect3DLin.h"
#include "CritereAdaptation.h"
#include "CritereMaillage.h"
#include "ecrireInfoSur.h"
#include "Element1D.h"
#include "ElemTetra.h"
#include "ElemTriangle.h"
#include "ErreurEvaluee.h"
#include "EstimationErreurAnalytique.h"
#include "EstimationErreurComposite.h"
#include "EstimationErreurGeometrique.h"
#include "EstimationErreurGradient.h"
#include "ExportGIREF.h"
#include "ExportVU.h"
#include "ExpressionAlgebrique.h"
#include "fonctionsChaineCar.h"
#include "Geometrie.h"
#include "GestionFichierChamps.h"
#include "InfoSur.h"
#include "InitialisationArgvArgc.h"
#include "InitialisationTraitementSignal.h"
#include "ListEntitesGeometrique.h"
#include "Maillage.h"
#include "MetriqueComposee.h"
#include "MetriqueTensLinCopiee.h"
#include "numerotePorteur.h"
#include "PAStdStreamEcritureUnique.h"
#include "PETScInitialisation.h"
#include "PPCalculGradientHessienMoyenneParAngle.h"
#include "PPNormeL2.h"
#include "PPNormeL2ComposanteGrad.h"
#include "ProblemeEF.h"
#include "PtIntgElem1D.h"
#include "PtIntgHexaedre.h"
#include "PtIntgPrismeTri.h"
#include "PtIntgQuadrangle.h"
#include "PtIntgTetraedre.h"
#include "PtIntgTriangle.h"
#include "reinterpoleSurChampDiscontinuGen.h"
#include "SchemaIntg.h"
#include "SequenceAdaptation.h"
#include "StatistiqueAdaptation.h"
#include "traducteurERMsg.h"
#include "Vecteur3D.h"
#include "VectFixe.h"
#include "VerifieElementsNormalises.h"
#include <cmath>
#include <fstream>
#include <iostream>

//#define TOTAL

using namespace std;

int main(int argc, char *argv[]) {

  // ***********************************
  // * BLOC: Initialisations generales *
  // ***********************************
  PETScInitialisation lPETScInit(&argc, &argv);
  sInitialisationArgvArgc.asgnArguments(argc, argv);
  initialiseTraitementSignal();

  const vector<string> lArgv = sInitialisationArgvArgc.reqArgv();

  // On declare une variable qui contiendra potentiellement un message d'erreur
  ERMsg lMsg = ERMsg(ERMsg::OK);

  // On recupere le GroupeProcessus associe a PETSC_COMM_WORLD
  const PAGroupeProcessus lGroupeGlobal = PETScInitialisation::reqPetscCommWorld();

  // Verification des parametres passes à la ligne de commande.
  const Entier lNbArg = lArgv.size();
  if (lNbArg != 2) {
    ChaineCar lNomProgramme = sInitialisationArgvArgc.reqNomProgramme();
    cerr << "USAGE : ";
    cerr << enleveCheminAccesFichier(lNomProgramme);
    cerr << " Prefixe_fichiers " << endl;
    cerr << " Pour le fichier .champs, les valeurs suivantes seront lues:" << endl;
    cerr << " scalaire Err_Geo     # [Optionnel, defaut=geometrie pas pris en compte] L'erreur desiree à la geometrie" << endl;
    cerr << " scalaire LongMin     # [Optionnel, defaut=0]      Longueur minimale des arêtes acceptee" << endl;
    cerr << " scalaire LongMax     # [Optionnel, defaut=1e30]   Longueur maximale des arêtes acceptee" << endl;
    cerr << " scalaire AngleMin    # [Optionnel, defaut=0]      Angle minimale des arêtes acceptee (2D seulement)." << endl;
    cerr << " scalaire QualiteMin  # [Optionnel, defaut=0.0005] Qualite euclidienne minimale acceptee pour les elements " << endl;
    cerr << " scalaire TolErr      # [Optionnel, defaut=2.5]    Facteur de Tolerance sur l'erreur desiree" << endl;
    cerr << " booleen  Metrique3D  # [Optionnel, defaut=false]  si on est en 3D, on utilise l'adaptation basee sur la metrique" << endl;
    cerr << " scalaire Sequence    # [Optionnel, defaut = 0] Sequence d'adaption à utiliser :" << endl;
    cerr << "              0-> Complete" << endl;
    cerr << "              1-> Deplacement/Retournement" << endl;
    cerr << "              2-> Deplacement" << endl;
    cerr << "              3-> Retournement seul" << endl;
    cerr << "              4-> Raffinement seul" << endl;
    cerr << "              5-> Retournement/Deraffinement" << endl;
    cerr << "              6-> Deraffinement seul" << endl;
    cerr << "              7-> Retournement/Raffinement" << endl;
    cerr << "              8-> Deplacement/Deraffinement" << endl;
    cerr << "              9-> Strategie egalisation erreur et ensuite diminution (ret/dep+der + ordinaire)" << endl;
    cerr << "             10-> Retournement De/Raffinement pas de Deplacement" << endl;
    cerr << "             11-> Retournement De/Raffinement et Deplacement" << endl;
    cerr << "             12-> Complete alternative" << endl;
    cerr << "             99-> Vide" << endl;
    cerr << " scalaire RepSequence # [Optionnel, defaut = 3] Nombre de fois que la Sequence d'adaption choisie est repetee" << endl;
    cerr << " scalaire LongRef     # [Optionnel, defaut = sqrt(Aire_maillage)] Longueur de reference utilisee dans l'adimensionalisation de l'erreur" << endl;
    cerr << " scal*    U0          # Champ utilise dans l'adaptation" << endl;
    cerr << " scalaire Err_D0      # Erreur desiree sur Champ U0" << endl;
    cerr << " scalaire U0Adim      # [Optionnel, defaut = Max-Min] Valeur utilisee pour adimensionnaliser l'erreur sur le Champ U0" << endl;
    cerr << " scal*    U1          # [Optionnel] Champ utilise dans l'adaptation" << endl;
    cerr << " scalaire Err_D1      # [Optionnel] Erreur desiree sur Champ U1" << endl;
    cerr << " scal*    U2          # [Optionnel] Champ utilise dans l'adaptation (on peut aller jusqu'à U99)" << endl;
    cerr << " scalaire Err_D2      # [Optionnel] Erreur desiree sur Champ U2 " << endl;
    cerr << " scalaire U0Ana       # [Optionnel] Champ Analytique correspondant à la solution exacte, utilise pour calculer l'erreur exacte" << endl;
    cerr << " scalaire U1Ana       # [Optionnel] Champ Analytique correspondant à la solution exacte, utilise pour calculer l'erreur exacte" << endl;
    cerr << " scalaire U2Ana       # [Optionnel] Champ Analytique correspondant à la solution exacte, utilise pour calculer l'erreur exacte" << endl;
    cerr << " chainecar NomMailInit# [Optionnel, defaut=Prefixe_fichiers] Le prefixe des fichiers du maillage initial pour la reinterpolation";
    cerr << " et le calcul de la vraie norme L2 finale" << endl;
    cerr << " scal*/vect3D* U0Reint     # [Optionnel] 1er Champ qui sera reinterpole apres l'adaptation, du maillage initial sur l'adapte" << endl;
    cerr << " scal*/vect3D* U1Reint     # [Optionnel] 2e  Champ qui sera reinterpole apres l'adaptation, du maillage initial sur l'adapte";
    cerr << " (on peut aller jusqu'à U99Reint)" << endl;
    cerr << endl;
    cerr << "Exemple:" << endl;
    cerr << "scalaire Err_Geo  0.001" << endl;
    cerr << "scalaire LongMin  0.0" << endl;
    cerr << "scalaire LongMax  1e30" << endl;
    cerr << "scalaire AngleMin 5.0" << endl;
    cerr << "scalaire QualiteMin 0.0005" << endl;
    cerr << "scalaire TolErr 3.0" << endl;
    cerr << "scalaire Sequence 0  " << endl;
    cerr << "scalaire RepSequence 4  " << endl;
    cerr << "booleen  Metrique3D true  " << endl;
    cerr << "v3dcrourav  U ""deplacement.champv3dlin""" << endl;
    cerr << "alias U0=UX" << endl;
    cerr << "scalaire    Err_D0  0.001" << endl;
    cerr << "alias U1=UY" << endl;
    cerr << "scalaire    Err_D1  0.001" << endl;
    cerr << "newchampcopie UReint0=U" << endl;
    cerr << "newchampcopie UReint1=UX" << endl;
    cerr << "newchampcopie UReint2=UZ" << endl;
    return 1;
  }

  const ChaineCar lNom(lArgv[1]);


  // *****************************************************
  // * BLOC: Creation des objets utilises dans le calcul *
  // *****************************************************
  // On cree: la geometrie, la liste d'entites geometriques, le maillage et le champ geometrique.
  Geometrie              lGeo;
  ListEntitesGeometrique lListeEntite;
  Maillage               lMail;
  ChampGeoLin            lChampGeo(lMail);

  //Declaration de l'objet qui fait la gestion des champs pour le probleme.
  GestionFichierChamps lFichierChamp;

  // Creation du schema d'integration pour le calcul de la norme L2
  SchemaIntg lSchemaIntg;
  PtIntgElem1D     lPtIntgElem1D  (4);
  PtIntgTriangle   lPtIntgTriangle  (PtIntgTriangle::Hammer_DouzePtsInternes_Degre6);
  PtIntgQuadrangle lPtIntgQuad  (lPtIntgElem1D,lPtIntgElem1D);
  PtIntgTetraedre  lPtIntgTetra  (PtIntgTetraedre::Hammer_QuinzePtsInternes_Degre5);
  PtIntgPrismeTri  lPtIntgPtri  (lPtIntgTriangle,lPtIntgElem1D);
  PtIntgHexaedre   lPtIntgHexa  (lPtIntgElem1D,lPtIntgElem1D,lPtIntgElem1D);
  lSchemaIntg.asgnIntegration(lPtIntgElem1D);
  lSchemaIntg.asgnIntegration(lPtIntgTriangle);
  lSchemaIntg.asgnIntegration(lPtIntgQuad);
  lSchemaIntg.asgnIntegration(lPtIntgTetra);
  lSchemaIntg.asgnIntegration(lPtIntgPtri);
  lSchemaIntg.asgnIntegration(lPtIntgHexa);
  lSchemaIntg.asgnIntegrationArete(lPtIntgElem1D);
  lSchemaIntg.asgnIntegrationFace3Sommets(lPtIntgTriangle);
  lSchemaIntg.asgnIntegrationFace4Sommets(lPtIntgQuad);

  // *******************************************
  // * BLOC: Declaration  *
  // *******************************************

  //On declare le probleme "vide" n'est utilise que pour lire toutes les donnees
  ProblemeEF lProb;
  lProb.asgnGroupeProcessus(lMail.reqGroupeProcessus());

  // Assignation de la geometrie, entite, maillage, champgeometrique  au probleme
  // et lecture des donnees d'entree
  if (lMsg) {
    lMsg = lProb.lisDonnees(lNom, lMail, lGeo, lChampGeo, lListeEntite);
  }

  
  VerifieElementsNormalises lVerifieElementsNormalises;
  if(!lVerifieElementsNormalises(lMail)) lMsg.ajoute(ERMsg(ERMsg::ERREUR,"Le maillage DOIT etre normalise!"));

  //On demande au gestionnaire de lire le fichier de champ
  if(lMsg) {
    // On assigne le maillage, le champ geometrique, la geometrie et la liste d'entites
    // au Gestionnaire de fichier de champs
    lFichierChamp.asgnDonneesBase(&lMail,&lChampGeo);
    lFichierChamp.asgnDonneesGeometriques(&lGeo,&lListeEntite);

    lMsg = lFichierChamp.lireFichier(lNom + std::string(".champs"));
  }

  std::string lNomSortie = lNom;
  // On demande le nom des fichiers de sortie (optionnel)
  if(lMsg) {
    lMsg = lFichierChamp.reqChaineCar("nomsortie",lNomSortie,false);
  }

  //On demande  l'erreur à la geometrie desiree
  DReel lErreurDesireeGeo = -1;
  if(lMsg) {
    lMsg = lFichierChamp.reqScalaireConstant("Err_Geo",lErreurDesireeGeo,false);
    if (lErreurDesireeGeo == -1) {
      //On adaptera sans tenir compte de l'erreur à la geometrie
      cout << "Pas d'erreur desire à la geometrie (Err_Geo), alors on ne tiendra";
      cout <<" pas compte de l'erreur à la geometrie dans l'adaptation" <<endl;
    }
  }

  //On va chercher les valeurs des constantes LongMin, LongMax et AngleMin dans le fichier champs
  DReel     lErreurLongMin = 0;
  DReel     lErreurLongMax = 1e30;
  DReel     lAngleMin = 0;

  if(lMsg) {
    lMsg = lFichierChamp.reqScalaireConstant("LongMin",lErreurLongMin,false);

    //Si cette valeur n'est pas presente, on continu avec la valeure par defaut
    if (lErreurLongMin == 0) {
      cout << "LongMin mis a 0" <<endl;
    }

  }

  if(lMsg) {
    lMsg = lFichierChamp.reqScalaireConstant("LongMax",lErreurLongMax,false);

    //Si cette valeur n'est pas presente, on continu avec la valeure par defaut
    if (lErreurLongMax == 1e30) {
      cout << "LongMax mis a 1e30" <<endl;
    }

  }

  if(lMsg) {
    lMsg = lFichierChamp.reqScalaireConstant("AngleMin",lAngleMin,false);

    //Si cette valeur n'est pas presente, on continu avec la valeure par defaut
    if (lAngleMin == 0) {
      cout << "AngleMin mis a 0" <<endl;
    }

  }

  DReel lQualiteMin = 0.0005;
  if(lMsg) {
    lMsg = lFichierChamp.reqScalaireConstant("QualiteMin",lQualiteMin,false);

    //Si cette valeur n'est pas presente, on continu avec la valeure par defaut
    if (lQualiteMin == 0.0005) {
      cout << "QualiteMin mis a 0.0005" <<endl;
    }

  }

  //On va chercher quelle sequence l'utilisateur desire utiliser
  DReel lToleranceErreur = 2.5;
  if(lMsg) {
    lMsg = lFichierChamp.reqScalaireConstant("TolErr",lToleranceErreur,false);

    //Si cette valeur n'est pas presente, on continu avec la valeure par defaut
    if (lToleranceErreur == 2.5) {
      cout << "TolErr mis a 2.5" <<endl;
    }

  }

  //On va demander si on utilise l'adaptation basee sur la metrique en 3D
  bool lMetrique3D = false;
  if(lMsg) {
    lMsg = lFichierChamp.reqBooleen("Metrique3D",lMetrique3D,false);

    //Si cette valeur n'est pas presente, on continu avec la valeure par defaut
    if (!lMetrique3D) {
      cout << "On utilise l'adaptation hierarchique si en 3D." <<endl;
    }

  }

  //On va chercher la longueur de reference que l'utilisateur desire utiliser
  DReel lLongRef = 0.0;
  if(lMsg) {
    lMsg = lFichierChamp.reqScalaireConstant("LongRef",lLongRef,false);

    //Si cette valeur n'est pas presente, on calculera la longueure de reference selon le maillage
    if (lLongRef == 0.0) {
      cout << "LongRef sera calcule" <<endl;
    }

  }

  //On va chercher quelle sequence l'utilisateur desire utiliser
  Entier lSequenceChoisie = 0;
  if(lMsg) {
    lMsg = lFichierChamp.reqScalaireConstant("Sequence",lSequenceChoisie,false);
    cout << "Sequ: "<< lSequenceChoisie << endl;
  }

  //On va chercher combien de fois l'utilisateur veut repeter la sequence choisie
  DReel lNbRepSeqGlobale = 3;
  if(lMsg) {
    lMsg = lFichierChamp.reqScalaireConstant("RepSequence",lNbRepSeqGlobale,false);

    //Si cette valeur n'est pas presente, on continu avec la valeure par defaut
    if (lNbRepSeqGlobale == 3) {
      cout << "RepSequence = 3, on repete 3 fois la sequence choisie" <<endl;
    }

  }

  //On va demander le prefixe du maillage initial utilise pour la reinterpolation (et aussi le calcul de la vraie norme L2 finale)
  std::string lNomMailinit(lNom);
  if(lMsg) {
    lMsg = lFichierChamp.reqChaineCar("NomMailInit",lNomMailinit,false);
  }

  // Avons-nous un maillage 1D, 2D ou 3D?
  const bool lMaillage1D = lMail.reqNbElement1D() == lMail.reqNbElement();
  const bool lMaillage2D = lMail.reqNbElement2D() != 0 && lMail.reqNbElement2D() == lMail.reqNbElemTriangle();
  const bool lMaillage3D = lMail.reqNbElement3D() != 0 && lMail.reqNbElement3D() == lMail.reqNbElemTetra();

  // Ce programme ne fonctionne que si nous avons un maillage entierement 2D ou 3D
  if (lMsg && !lMaillage1D && !lMaillage2D && !lMaillage3D) {
    lMsg.ajoute(ERMsg(ERMsg::ERREUR, "ERREUR - Votre maillage doit être entierement compose de triangles ou tetraedres"));
  }

  //On demande  les champs qui se nomment "U?" pour les composantes de l'erreur
  vector<ChampScalContinu *> lVectChampsU;
  vector<ChampAnalytiqueBaseContinu<ChampScalContinu> *> lVectChampsUAna;
  vector<DReel>              lVectErreurDesiree;
  vector<DReel>              lVectAdim;

  //On fixe à 100 le nombre maximal de champs pouvant être utilises en même temps...
  const EntierN lNbMaxChamps = 100;

  for (EntierN i = 0 ; i< lNbMaxChamps && lMsg; ++i) {
    ChampScalContinu *lU = 0;

    string lNomChampU = "U";
    {
      std::stringstream lStream;
      lStream << i;
      lNomChampU += lStream.str();
    }

    lMsg = lFichierChamp.reqChamp<ChampScalContinu>(lNomChampU,lU);
    if (lMsg) {
      lVectChampsU.push_back(lU);

      string lNomErrU = "Err_D";
      {
        std::stringstream lStream;
        lStream << i;
        lNomErrU += lStream.str();
      }

      DReel lErreurDesiree;
      lMsg = lFichierChamp.reqScalaireConstant(lNomErrU,lErreurDesiree);
      if (lMsg) {
        lVectErreurDesiree.push_back(lErreurDesiree);
        lVectAdim.push_back(-1.0);
        ChampAnalytiqueBaseContinu<ChampScalContinu> *lUAna = 0;

        //Si ce champ n'est pas present, on continu quand même
        lMsg = lFichierChamp.reqChamp<ChampAnalytiqueBaseContinu<ChampScalContinu> >(lNomChampU+"Ana", lUAna,false);
        if (lUAna) {
          lVectChampsUAna.push_back(lUAna);
        }

        lMsg = lFichierChamp.reqScalaireConstant(lNomChampU+"Adim", lVectAdim[i],false);
      }
    }
    else if (0 != i || lSequenceChoisie == 99) {
      //On prends pour acquis qu'avec au moins un champs
      //on peut continuer sans erreur
      lMsg = ERMsg(ERMsg::OK);
      cout << "On utilise " << (i) << " solution" << ((0 == i)||(1==i) ? "": "s") << " pour l'adaptation." << endl;
      break;
    }

  }

  //On demande les champs 1D qui devront être reinterpoles
  vector<ChampScalaire *>    lVectChampsU1DReint;
  EntierN lCompteur1D(0);
  for (EntierN i = 0 ; i< lNbMaxChamps && lMsg; ++i) {
    ChampScalaire *lU = 0;

    string lNomChampU = "U";
    {
      std::stringstream lStream;
      lStream << i;
      lNomChampU += lStream.str();
    }

    lMsg = lFichierChamp.reqChamp<ChampScalaire>(lNomChampU+"Reint", lU,false);
    if (lMsg && lU) {
      if (!dynamic_cast<ChampScalContinu*>(lU) && !dynamic_cast<ChampScalDiscParElement*>(lU) ) {
        lMsg.ajoute(ERMsg(ERMsg::ERREUR, "ERREUR - On peut reinterpoler que des solutions 1D continues ou strictement disctoninu pour l'instant..."));
      }
      else {
	++lCompteur1D;
        lVectChampsU1DReint.push_back(lU);
      }
    }
//     if(!lU){
//       cout << "On reinterpolera " << (i) << " solution 1D" << ((0 == i)||(1==i) ? "": "s") << " apres l'adaptation." << endl;
//       break;
//     }
  }
  if(lCompteur1D)
    cout << "On reinterpolera " << (lCompteur1D) << " solution" << ((1 == lCompteur1D) ? " 1D": "s 1D") << " apres l'adaptation." << endl;

  //On demande les champs 3D qui devront être reinterpoles
  vector<ChampVectoriel3D *>    lVectChampsU3DReint;
  EntierN lCompteur3D(0);
  for (EntierN i = 0 ; i< lNbMaxChamps && lMsg; ++i) {
    ChampVectoriel3D *lU = 0;

    string lNomChampU = "U";
    {
      std::stringstream lStream;
      lStream << i;
      lNomChampU += lStream.str();
    }

    lMsg = lFichierChamp.reqChamp<ChampVectoriel3D>(lNomChampU+"Reint", lU,false);
    if (lMsg && lU) {
      if (!dynamic_cast<ChampVect3DContinu*>(lU) && !dynamic_cast<ChampVect3DDiscParElement*>(lU) ) {
        lMsg.ajoute(ERMsg(ERMsg::ERREUR, "ERREUR - On peut reinterpoler que des solutions 3D continues ou strictement disctoninu pour l'instant..."));
      }
      else {
	++lCompteur3D;
        lVectChampsU3DReint.push_back(lU);
      }
    }
//     if(!lU){
//       cout << "On reinterpolera " << (i) << " solution 3D" << ((0 == i)||(1==i) ? "": "s") << " apres l'adaptation." << endl;
//       break;
//     }
  }

  if(lCompteur3D)
    cout << "On reinterpolera " << (lCompteur3D) << " solution" << ((1==lCompteur3D) ? " 3D": "s 3D") << " apres l'adaptation." << endl;


  // On calcul le min/max de chaque solution sur les sommets du maillage
  const EntierN lNbSolutions =   lVectChampsU.size();

  VectDyn<DReel> lVectMax(lNbSolutions, -1e30);
  VectDyn<DReel> lVectMin(lNbSolutions, 1e30);
  Maillage::IterateurSommet       lIterSommet    = lMail.reqSommetDebut();
  const Maillage::IterateurSommet lIterSommetFin = lMail.reqSommetFin();
  while (lIterSommet != lIterSommetFin) {

    for (EntierN i = 0; i< lNbSolutions; ++i) {
      DReel lErreur = 0.0;
      lVectChampsU[i]->interpole(*lIterSommet, lErreur);

      if (lVectMax[i] < lErreur) {
        lVectMax[i] = lErreur;
      }
      if (lVectMin[i] > lErreur) {
        lVectMin[i] = lErreur;
      }
    }
    ++lIterSommet;
  }

  for (EntierN i = 0; i< lNbSolutions; ++i) {
    if (lVectMax[i] == lVectMin[i]) {
      lVectMax[i] += 1e-6;
    }
    if (-1.0 == lVectAdim[i]) {
      lVectAdim[i] = lVectMax[i] - lVectMin[i];
    }
    if (lMetrique3D && lMaillage3D) {
      if (!dynamic_cast<ChampAnalytiqueBaseContinu<ChampScalContinu>*>(lVectChampsU[i])) {
        (*lVectChampsU[i])*=1.0/lVectAdim[i];
      }
    }
    cout << "Ordre de grandeur de la solution #" << i << " : " << (lVectMax[i] - lVectMin[i]) << ", Valeure utilisee pour adimensionnaliser: " << lVectAdim[i] << endl;
  }

  if (lMsg) {
    Maillage::IterateurElement lIterElem    = lMail.reqElementDebut();
    Maillage::IterateurElement lIterElemFin = lMail.reqElementFin();

    const CoorReference lCoorRef(0.,0.,0.);
    MatriceJacobienne lJ;
    DReel lDetMin = 1e6;

    while (lIterElem != lIterElemFin) {
      lChampGeo.reqMatriceJacobienne(*lIterElem,
                                     lCoorRef,
                                     lJ);
      if (lJ.reqDetJ() < lDetMin) {
        lDetMin = lJ.reqDetJ();
      }
      ++lIterElem;
    }
    cout << "Determinant Min Initial: " << lDetMin << endl;
  }

  // ***************************************************************
  //Pour chaque solution, on calcul le gradient, la derivee seconde
  // ***************************************************************

  VectDyn<DReel>             lVectVraieNormeL2ErrAvant(lNbSolutions,0);
  VectDyn<DReel>             lVectVraieNormeL2ErrApres(lNbSolutions,0);
  VectDyn<DReel>             lVectVraieNormeL2GradErrAvant(lNbSolutions,0);
  VectDyn<DReel>             lVectVraieNormeL2GradErrApres(lNbSolutions,0);

  VectDyn<DReel>             lVectNormeL2ErrEstimAvant(lNbSolutions,0);
  VectDyn<DReel>             lVectNormeL2ErrEstimApres(lNbSolutions,0);
  VectDyn<DReel>             lVectNormeL2GradErrEstimAvant(lNbSolutions,0);
  VectDyn<DReel>             lVectNormeL2GradErrEstimApres(lNbSolutions,0);

  VectDyn<DReel>             lVectNormeL2ErrQCAnaAvant(lNbSolutions,0);
  VectDyn<DReel>             lVectNormeL2ErrQCAnaApres(lNbSolutions,0);
  VectDyn<DReel>             lVectNormeL2GradErrQCAnaAvant(lNbSolutions,0);
  VectDyn<DReel>             lVectNormeL2GradErrQCAnaApres(lNbSolutions,0);

  VectDyn<DReel>             lVectRappNormeL2ErrAvant(lNbSolutions,0);
  VectDyn<DReel>             lVectRappNormeL2ErrApres(lNbSolutions,0);
  VectDyn<DReel>             lVectRappNormeL2GradErrAvant(lNbSolutions,0);
  VectDyn<DReel>             lVectRappNormeL2GradErrApres(lNbSolutions,0);

  VectDyn<ChampScalConstElem>lVectChampNormel2Solution(lNbSolutions);
  VectDyn<DReel>             lVectNormel2Solution(lNbSolutions);

  VectDyn<ChampScalLin>      lVectChampSolutionLin(lNbSolutions);
  VectDyn<ChampVect3DLin>    lVectChampGrad(lNbSolutions);
  VectDyn<ChampTensO2SymLin> lVectChampHessien(lNbSolutions);

  PPCalculGradientHessienMoyenneParAngle lCalculGradient(lChampGeo.reqMaillage());
  CalculMetrique lCalculMetrique;

  DReel lCritereArret(1.e-8);
  Entier lNbIterMax(750);
  if(lMsg) {
    DReel lTmp(750);
    lMsg = lFichierChamp.reqScalaireConstant("NbIterMax",lTmp,false);
    lNbIterMax = Entier(lTmp);
  }
  if(lMsg) {
    lMsg = lFichierChamp.reqScalaireConstant("CritereArret",lCritereArret,false);
  }

  // Pour ma version du calcul metrique:
  if(lMsg) lCalculMetrique.asgnCritereConvergence(lNbIterMax,lCritereArret,true,250,50*lCritereArret);
  
  // On va exporter le resultats de nos calculs (les champs) dans un fichier .pie et les valeurs des normes
  // dans un fichier ASCII avec un ExportGIREF
#ifdef TOTAL
  ExportVU lVUInit;
#endif //TOTAL
  ExportGIREF lExportGIREF;
  lExportGIREF.asgnExporteMaillage(false);
  if (lMsg) {

#ifdef TOTAL
    lVUInit.asgnChampGeometrique(lChampGeo);
    lVUInit.asgnDegreInterpolation(Exportation::MAILLAGE_LINEAIRE);

    PPNormeL2<ChampScalContinu> lPPNormeL2(lMail);
    VectDyn<DReel> lNormeL2Solution(lNbSolutions,0.0);
    lPPNormeL2.asgnParametres(lChampGeo, lSchemaIntg);
#endif //TOTAL

    lExportGIREF.asgnChampGeometrique(lChampGeo);
    lExportGIREF.asgnDegreInterpolation(Exportation::MAILLAGE_LINEAIRE);

    for (Entier i = 0; i < lVectChampGrad.reqLongueur() && lMsg; ++i) {
      std::cout <<"Calcul de l'estimation d'erreur sur le champs " << lVectChampsU[i]->reqNom() << std::endl;
      lVectChampSolutionLin[i].asgnChampGeometrique(lChampGeo);
      lMsg = lVectChampSolutionLin[i].reinterpole(*lVectChampsU[i]);
      lVectChampGrad[i].asgnChampGeometrique(lChampGeo);
      lVectChampHessien[i].asgnChampGeometrique(lChampGeo);


#ifdef TOTAL
      if(lMsg) lMsg = lVUInit.ajouteChamp(*lVectChampsU[i], lVectChampsU[i]->reqNom());
      lVectChampNormel2Solution[i].asgnChampGeometrique(lChampGeo);
      if (lMsg) lMsg = lVUInit.ajouteChamp(lVectChampNormel2Solution[i], "nl2_"+lVectChampsU[i]->reqNom());
      if (lMsg) lMsg = lVUInit.ajouteChamp(lVectChampSolutionLin[i], lVectChampsU[i]->reqNom()+"_lin");
      if (lMsg) lMsg = lVUInit.ajouteChamp(lVectChampGrad[i], "d"+lVectChampsU[i]->reqNom()+"d");
      if (lMsg) lMsg = lVUInit.ajouteChamp(lVectChampHessien[i], "dd"+lVectChampsU[i]->reqNom()+"d");

      if (lMsg) {
	lPPNormeL2.ajouteChamp(*lVectChampsU[i],
			       lNormeL2Solution[i],
			       &(lVectChampNormel2Solution[i]));

      }
#endif //TOTAL

      if (!lMaillage1D) {
        lCalculGradient.asgnParametres(lChampGeo,
                                       *lVectChampsU[i],
                                       &lVectChampGrad[i],
                                       &lVectChampHessien[i]);

        lCalculGradient.effectueCalcul();
      }
      if (lMaillage1D && lMsg) {

        ChampScalLin lChampSolution(lChampGeo);

        lMsg = lChampSolution.reinterpole(*lVectChampsU[i]);

        if (lVectChampGrad.reqLongueur() > 1) {
          std::cout << "Attention, pour l'adaptation 1D, seul le champ U0 sera utilise" << std::endl;
        }
      }
      else if (lMaillage2D) {

        lCalculMetrique.calculIteratif (lMail,
					*lVectChampsU[i],
					lVectChampGrad[i],
					lVectChampHessien[i]);
      }
      else if (lMaillage3D) {
        lMsg =  lCalculMetrique.essaiCalculs3D (lMail,
                                                *lVectChampsU[i],
                                                lVectChampGrad[i],
                                                lVectChampHessien[i]);
        if (lMsg && lMetrique3D) {
          lCalculMetrique.rendDefinitPositif(lMail,
                                             lVectChampHessien[i],
                                             1e-4,
                                             1e4);

        }

      }
    } // for (Entier i = 0; i < lVectChampGrad.reqLongueur() && lMsg; ++i) {
#ifdef TOTAL
    if (lMsg) {
      std::cout <<"Calcul des normes L2 " << std::endl;
      lMsg = lPPNormeL2.effectueCalcul();
    }
    for (Entier i = 0; i < lVectChampGrad.reqLongueur() && lMsg; ++i) {
      lVectNormel2Solution[i] =  lNormeL2Solution[i]*lNormeL2Solution[i];
      lExportGIREF.ajouteDReel(lVectNormel2Solution[i], "nl2_"+lVectChampsU[i]->reqNom(),true);
      std::cout << "Norme L2 au carre de la solution " << lVectChampsU[i]->reqNom() << " : " << lVectNormel2Solution[i] << std::endl;
    }
#endif //TOTAL
  }

  if (!lMsg) {
    std::cout << "ERREUR: Pas d'adaptation" << std::endl;
    cout << traducteurERMsg(lMsg);
    return 0;
  }

  // On calcule la longueur, l'aire ou le volume des elements
  ChampScalConstElem lLongAireVolumeElem(lChampGeo);

  DReel lAireMailInit = 0.0;
  VectDyn<DReel> lTmp(1);
  Maillage::IterateurElement       lIterElementd = lMail.reqElementDebut();
  const Maillage::IterateurElement lITerElemFind = lMail.reqElementFin();
  while (lIterElementd != lITerElemFind) {

    if (lMaillage1D) {
      const DReel lLongueur = lChampGeo.reqIntegraleDetJ(*(dynamic_cast<Element1D*>(&(*lIterElementd))));
      lAireMailInit += lLongueur;
      lTmp[0] = lLongueur;
#ifdef TOTAL
      lLongAireVolumeElem.asgnValeurElement(*lIterElementd, lTmp);
#endif //TOTAL
    }
    else if (lMaillage2D) {
      const DReel lAire = lChampGeo.reqIntegraleDetJ(*(dynamic_cast<ElemTriangle*>(&(*lIterElementd))));
      lAireMailInit += lAire;
      lTmp[0] = lAire;
#ifdef TOTAL
      lLongAireVolumeElem.asgnValeurElement(*lIterElementd, lTmp);
#endif //TOTAL
    }
    else {
      const DReel lVolume = lChampGeo.reqIntegraleDetJ(*(dynamic_cast<ElemTetra*>(&(*lIterElementd))));
      lAireMailInit += lVolume;
      lTmp[0] = lVolume;
#ifdef TOTAL
      lLongAireVolumeElem.asgnValeurElement(*lIterElementd, lTmp);
#endif //TOTAL
    }
    ++lIterElementd;
  }
#ifdef TOTAL
  // On va aussi exporter l'aire des elements dans le fichier .pie
  if (lMsg) lMsg = lVUInit.ajouteChamp(lLongAireVolumeElem, "Aire");
#endif //TOTAL

  if (0 == lLongRef) {
    if (lMaillage1D) {
      lLongRef = lAireMailInit;
    }
    else if (lMaillage2D) {
      lLongRef = sqrt(lAireMailInit);
    }
    else if (lMaillage3D) {
      lLongRef = pow(lAireMailInit, 1./3.);
    }
  }

  cout << "Longueur de reference utilisee: " << lLongRef << endl;

  //On cree l'estimateur d'erreur à la geometrie
  EstimationErreurGeometrique lEstimationErreurGeometrique;
  lEstimationErreurGeometrique.asgnGeometrieEtMaillage(lGeo, lMail);
  lEstimationErreurGeometrique.asgnLongueurReference(lLongRef);

  if (-1 != lErreurDesireeGeo) {
    lEstimationErreurGeometrique.asgnErreurDesiree(lErreurDesireeGeo);
  }

#ifdef TOTAL
  // On cree un vecteur de champs qui contiendront la norme L2 de l'erreur et de la norme du gradient de l'erreur
  // pour chaque element
  VectDyn<ChampScalConstElem> lVectNormeL2Erreur(lNbSolutions+1);
  VectDyn<ChampScalConstElem> lVectNormeL2NormeGradErreur(lNbSolutions+1);

  if (lMaillage2D || (lMaillage3D && !lMetrique3D)) {
    lVectNormeL2Erreur[lNbSolutions].asgnChampGeometrique(lChampGeo);
    lVectNormeL2NormeGradErreur[lNbSolutions].asgnChampGeometrique(lChampGeo);

    VectDyn<DReel> lTmp(1);
    Maillage::IterateurElement       lIterElement    = lMail.reqElementDebut();
    const Maillage::IterateurElement lIterElementFin = lMail.reqElementFin();
    while (lIterElement != lIterElementFin) {
      ErreurEvaluee lErreurElem;
      lEstimationErreurGeometrique.reqNormeErreurElement(*lIterElement, lErreurElem);
      lTmp[0] = lErreurElem.reqErreurActuelle();
      lVectNormeL2Erreur[lNbSolutions].asgnValeurElement (*lIterElement, lTmp);

      ErreurEvaluee lGradErreurElem;
      lEstimationErreurGeometrique.reqNormeGradErreurElement(*lIterElement, lGradErreurElem);
      lTmp[0] = lGradErreurElem.reqErreurActuelle();
      lVectNormeL2NormeGradErreur[lNbSolutions].asgnValeurElement (*lIterElement, lTmp);

      ++lIterElement;
    }

    if (lMsg) lMsg = lVUInit.ajouteChamp(lVectNormeL2Erreur[lNbSolutions], "nl2e_geo");
    if (lMsg) lMsg = lVUInit.ajouteChamp(lVectNormeL2NormeGradErreur[lNbSolutions], "nl2nge_geo");

  }
#endif //TOTAL

  //On cree un vecteur d'estimateur d'erreur
  VectDyn<EstimationErreurHierarchique*> lVectEstimationErreur(lNbSolutions,0);
  VectDyn<MetriqueTensLinCopiee*> lVectMetrique(lNbSolutions,0);

  MetriqueComposee<Metrique> lMetriqueComposee;

  EstimationErreurComposite lEstimationErreurComposite;
  lEstimationErreurComposite.asgnTolerance(lToleranceErreur);

  typedef MetriqueTensLinCopiee TypeMetriqueAdaptation;

  CritereAdaptation lCritereAdapMetrique;
  lCritereAdapMetrique.asgnLongueurAreteDesiree(1.0);
  lCritereAdapMetrique.asgnQualiteElementDesiree(0.5);
  lCritereAdapMetrique.asgnTolerance(lToleranceErreur);

  //Statistique du maillage dans la metrique
  TypeMetriqueAdaptation *lMetriqueAdaptation = 0;

  StatistiqueMaillage lStatMetrique;

  for (EntierN i = 0; i < lNbSolutions; ++i) {
    if (!dynamic_cast<ChampAnalytiqueBaseContinu<ChampScalContinu>*>(lVectChampsU[i]) && (lMaillage3D || lMaillage2D)) {
      if (!lMetrique3D) {
        EstimationErreurGradient *lEstimationErreurGradient = new EstimationErreurGradient;
        lEstimationErreurGradient->asgnChampGradient(lVectChampGrad[i]);
        lEstimationErreurGradient->asgnChampMetrique(lVectChampHessien[i]);
        lEstimationErreurGradient->asgnErreurDesiree(lVectErreurDesiree[i]);
        lEstimationErreurGradient->asgnTolerance(lToleranceErreur);
        lEstimationErreurGradient->asgnLongueurReference(lLongRef);
        lVectEstimationErreur[i] = lEstimationErreurGradient;
      }
      else {
        MetriqueTensLinCopiee *lMetriqueTensLinCopiee = new MetriqueTensLinCopiee();
        lMetriqueTensLinCopiee->asgnChamp(lVectChampHessien[i]);
        lMetriqueTensLinCopiee->asgnLongueurDesiree(lVectErreurDesiree[i]);
        lMetriqueComposee.ajouteMetrique(*lMetriqueTensLinCopiee);
        lVectMetrique[i] = lMetriqueTensLinCopiee;
      }
    }
    else if (lMaillage3D || lMaillage2D) {
      if (!lMetrique3D) {
        EstimationErreurAnalytique *lEstimationErreurAnalytique = new EstimationErreurAnalytique;
        lEstimationErreurAnalytique->asgnChampScalAnalytique(*dynamic_cast<ChampAnalytiqueBaseContinu<ChampScalContinu>*>(lVectChampsU[i]));
        lEstimationErreurAnalytique->asgnErreurDesiree(lVectErreurDesiree[i]);
        lEstimationErreurAnalytique->asgnTolerance(lToleranceErreur);
        lEstimationErreurAnalytique->asgnLongueurReference(lLongRef);
        lVectEstimationErreur[i] = lEstimationErreurAnalytique;
      }
      //Pour l'instant même les champs analytiques sont traites comme des solutions....
      // Ici il faudrait encapsuler le champ pour lui extraire les derivees secondes...
      else {
        MetriqueTensLinCopiee *lMetriqueTensLinCopiee = new MetriqueTensLinCopiee();
        lMetriqueTensLinCopiee->asgnChamp(lVectChampHessien[i]);
        lMetriqueTensLinCopiee->asgnLongueurDesiree(lVectErreurDesiree[i]);
        lMetriqueComposee.ajouteMetrique(*lMetriqueTensLinCopiee);
      }

    }
    else {
      //Si maillage 1D
      lCalculMetrique.rendDefinitPositif(lMail,
                                         lVectChampHessien[i],
                                         1e-4,
                                         1e+4);
      lMetriqueAdaptation = new TypeMetriqueAdaptation;
      lMetriqueAdaptation->asgnChamp(lVectChampHessien[i]);
      lMetriqueAdaptation->asgnLongueurDesiree(lVectErreurDesiree[i]);
      lCritereAdapMetrique.asgnLongueurAreteDesiree(1.0);
      lCritereAdapMetrique.asgnQualiteElementDesiree(0.5);
      lCritereAdapMetrique.asgnTolerance(lToleranceErreur);

      lStatMetrique.asgnStatistique(lMail,*lMetriqueAdaptation);

      //On n'aura qu'une erreur...
      break;
    }

    lEstimationErreurComposite.ajouteEstimationErreur(*lVectEstimationErreur[i]);

    //On assigne le maillage aux champs qui contiendront les normes L2
#ifdef TOTAL
    lVectNormeL2Erreur[i].asgnChampGeometrique(lChampGeo);
    lVectNormeL2NormeGradErreur[i].asgnChampGeometrique(lChampGeo);
#endif //TOTAL

  }

  for (EntierN i = 0; i< lNbSolutions && (lMaillage2D || (lMaillage3D && !lMetrique3D)); ++i) {
    if (dynamic_cast<EstimationErreurAnalytique*>(lVectEstimationErreur[i])) {
      static_cast<EstimationErreurAnalytique*>(lVectEstimationErreur[i])->asgnOrdreDeGrandeur(lVectAdim[i]);
    }
    else {
      static_cast<EstimationErreurGradient*>(lVectEstimationErreur[i])->asgnOrdreDeGrandeur(lVectAdim[i]);
    }
  }

  // On definit les sequences d'adaptation utilisables
  SequenceAdaptation lSequenceGlobale;

  // Sequence complete
  switch (lSequenceChoisie) {
  case 0: {
    SequenceAdaptation lSequenceMenage;
    lSequenceMenage.ajouteOperation(SequenceAdaptation::RETOURNEMENT_ARETE);
    if (lMaillage3D) {
    }
    lSequenceMenage.ajouteOperation(SequenceAdaptation::DEPLACEMENT_SOMMET);
    lSequenceMenage.ajouteOperation(SequenceAdaptation::DERAFFINEMENT_ARETE);
    lSequenceMenage.reproduireNbFoisSequence(2);

    lSequenceGlobale.ajouteOperation(SequenceAdaptation::RAFFINEMENT_ARETE);
    lSequenceGlobale += lSequenceMenage;
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DERAFFINEMENT_ARETE);
    lSequenceGlobale += lSequenceMenage;
    lSequenceGlobale.reproduireNbFoisSequence(Entier(lNbRepSeqGlobale));
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DEPLACEMENT_SOMMET);
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DERAFFINEMENT_ARETE);
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DEPLACEMENT_SOMMET);
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DERAFFINEMENT_ARETE);
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DEPLACEMENT_SOMMET);
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DERAFFINEMENT_ARETE);
    break;
  }
    // Deplacement / retournement
  case 1: {
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DEPLACEMENT_SOMMET);
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::RETOURNEMENT_ARETE);
    lSequenceGlobale.reproduireNbFoisSequence(Entier(lNbRepSeqGlobale));
    break;
  }
    // Deplacement seulement
  case 2: {
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DEPLACEMENT_SOMMET);
    lSequenceGlobale.reproduireNbFoisSequence(Entier(lNbRepSeqGlobale));
    break;
  }
    // Retournement seulement
  case 3: {
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::RETOURNEMENT_ARETE);
    lSequenceGlobale.reproduireNbFoisSequence(Entier(lNbRepSeqGlobale));
    break;
  }
    // Raffinement seulement
  case 4: {
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::RAFFINEMENT_ARETE);
    lSequenceGlobale.reproduireNbFoisSequence(Entier(lNbRepSeqGlobale));
    break;
  }
    // Retournement / deraffinement
  case 5: {
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::RETOURNEMENT_ARETE);
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DERAFFINEMENT_ARETE);
    lSequenceGlobale.reproduireNbFoisSequence(Entier(lNbRepSeqGlobale));
    break;
  }
    // Deraffinement seulement
  case 6: {
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DERAFFINEMENT_ARETE);
    lSequenceGlobale.reproduireNbFoisSequence(Entier(lNbRepSeqGlobale));
    break;
  }
  case 7: {
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::RETOURNEMENT_ARETE);
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::RAFFINEMENT_ARETE);
    lSequenceGlobale.reproduireNbFoisSequence(Entier(lNbRepSeqGlobale));
    break;
  }
  case 8: {
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DEPLACEMENT_SOMMET);
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DERAFFINEMENT_ARETE);
    lSequenceGlobale.reproduireNbFoisSequence(Entier(lNbRepSeqGlobale));
    break;
  }
  case 9: {
    SequenceAdaptation lSequenceMenage, lSequenceMinim;
    lSequenceMenage.ajouteOperation(SequenceAdaptation::RETOURNEMENT_ARETE);
    if (lMaillage3D) {
      lSequenceMenage.ajouteOperation(SequenceAdaptation::RETOURNEMENT_FACE);
    }
    lSequenceMenage.ajouteOperation(SequenceAdaptation::DEPLACEMENT_SOMMET);
    lSequenceMenage.ajouteOperation(SequenceAdaptation::DERAFFINEMENT_ARETE);
    lSequenceMenage.reproduireNbFoisSequence(2);

    lSequenceGlobale += lSequenceMenage;
    lSequenceGlobale += lSequenceMenage;
    lSequenceGlobale += lSequenceMenage;

    lSequenceMinim.ajouteOperation(SequenceAdaptation::RAFFINEMENT_ARETE);
    lSequenceMinim  += lSequenceMenage;
    lSequenceMinim.ajouteOperation(SequenceAdaptation::DERAFFINEMENT_ARETE);
    lSequenceMinim.reproduireNbFoisSequence(Entier(lNbRepSeqGlobale));

    lSequenceGlobale+= lSequenceMinim;
    break;
  }
    // Retournement De/Raffinement pas de Deplacement
  case 10: {
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::RAFFINEMENT_ARETE);
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DERAFFINEMENT_ARETE);
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::RETOURNEMENT_ARETE);
    lSequenceGlobale.reproduireNbFoisSequence(Entier(lNbRepSeqGlobale));
    break;
  }
    // Retournement De/Raffinement et Deplacement
  case 11: {
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::RAFFINEMENT_ARETE);
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DERAFFINEMENT_ARETE);
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::RETOURNEMENT_ARETE);
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DEPLACEMENT_SOMMET);
    lSequenceGlobale.reproduireNbFoisSequence(Entier(lNbRepSeqGlobale));
    break;
  }
  case 12: {
    SequenceAdaptation lSequenceMenage;
    lSequenceMenage.ajouteOperation(SequenceAdaptation::RETOURNEMENT_ARETE);
    if (lMaillage3D) {
      lSequenceMenage.ajouteOperation(SequenceAdaptation::RETOURNEMENT_FACE);
    }
    lSequenceMenage.ajouteOperation(SequenceAdaptation::DEPLACEMENT_SOMMET);
    lSequenceMenage.reproduireNbFoisSequence(2);
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::RAFFINEMENT_ARETE);
    lSequenceGlobale += lSequenceMenage;
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DERAFFINEMENT_ARETE);
    lSequenceGlobale += lSequenceMenage;
    lSequenceGlobale.reproduireNbFoisSequence(Entier(lNbRepSeqGlobale));
    lSequenceGlobale += lSequenceMenage;
    lSequenceGlobale += lSequenceMenage;
    break;
  }
  case 13: {
    SequenceAdaptation lSequenceMenage;
    lSequenceMenage.ajouteOperation(SequenceAdaptation::RETOURNEMENT_ARETE);
    if (lMaillage3D) {
      lSequenceMenage.ajouteOperation(SequenceAdaptation::RETOURNEMENT_FACE);
    }
    lSequenceMenage.ajouteOperation(SequenceAdaptation::DEPLACEMENT_SOMMET);

    lSequenceGlobale.ajouteOperation(SequenceAdaptation::RAFFINEMENT_ARETE);
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::RETOURNEMENT_ARETE);
    lSequenceGlobale += lSequenceMenage;
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::DERAFFINEMENT_ARETE);
    lSequenceGlobale.ajouteOperation(SequenceAdaptation::RETOURNEMENT_ARETE);
    lSequenceGlobale += lSequenceMenage;
    lSequenceGlobale.reproduireNbFoisSequence(Entier(lNbRepSeqGlobale));
    lSequenceGlobale += lSequenceMenage;
    lSequenceGlobale += lSequenceMenage;
    break;
  }
  case 99: {
    //Sequence vide...
    break;
  }
  }


  CritereMaillage lCritere;
  lCritere.asgnLongueurAreteDesireeMinMax(lErreurLongMin, lErreurLongMax);
  lCritere.asgnAngleMin(lAngleMin);

#ifdef TOTAL
  // On calcul la norme L2 de l'erreur et la norme L2 de la norme du gradient de l'erreur avant
  ErreurEvaluee lIntNormeL2ErreurAvant;
  ErreurEvaluee lIntNormeL2GradErreurAvant;

  if (lMsg) {
    VectDyn<DReel> lTmp(1);
    Maillage::IterateurElement       lIterElementd = lMail.reqElementDebut();
    const Maillage::IterateurElement lITerElemFind = lMail.reqElementFin();
    while (lIterElementd != lITerElemFind && (lMaillage2D || (lMaillage3D && !lMetrique3D))) {
      ErreurEvaluee lNormeErreurEvaluee;
      lEstimationErreurComposite.reqNormeErreurElement(*lIterElementd, lNormeErreurEvaluee);

      ErreurEvaluee lNormeGradErreurEvaluee;
      lEstimationErreurComposite.reqNormeGradErreurElement(*lIterElementd, lNormeGradErreurEvaluee);

      lIntNormeL2ErreurAvant += lNormeErreurEvaluee;
      lIntNormeL2GradErreurAvant += lNormeGradErreurEvaluee;

      //On stock les resultats dans les champs pour exportation.
      for (EntierN i= 0; i< lNbSolutions; ++i) {
	lTmp[0] = lNormeErreurEvaluee.reqErreurActuelle();
	lVectNormeL2Erreur[i].asgnValeurElement(*lIterElementd, lTmp);
	lTmp[0] = lNormeGradErreurEvaluee.reqErreurActuelle();
	lVectNormeL2NormeGradErreur[i].asgnValeurElement(*lIterElementd, lTmp);
	lNormeErreurEvaluee.incrementeIndiceErreurActuelle();
	lNormeGradErreurEvaluee.incrementeIndiceErreurActuelle();
      }

      ++lIterElementd;
    }
  }

  //On ajoute les champs pour l'exportation avant adaptation.
  if (lMsg && (lMaillage2D || (lMaillage3D && !lMetrique3D)))  {
    for (EntierN i= 0; i< lNbSolutions && lMsg; ++i) {

      if (lMsg) lMsg = lVUInit.ajouteChamp(lVectNormeL2Erreur[i], "nl2e_"+lVectChampsU[i]->reqNom());
      if (lMsg) lMsg = lVUInit.ajouteChamp(lVectNormeL2NormeGradErreur[i], "nl2nge_"+lVectChampsU[i]->reqNom());
    }
  }

  // On calcul la norme L2 de l'erreur et la norme L2 de la norme du gradient de l'erreur avant pour la solution analytique
  const bool lCalcNormeL2Diff =   lVectChampsUAna.size() == lVectChampsU.size();

  ErreurEvaluee lIntNormeL2ErreurAnaAvant;
  ErreurEvaluee lIntNormeL2GradErreurAnaAvant;
  VectDyn<EstimationErreurAnalytique> lVectEstimAnalytique (lVectChampsU.size());
  EstimationErreurComposite  lEstimationErreurCompositeAna;
  if (lMsg) {
    lEstimationErreurCompositeAna.asgnTolerance(lToleranceErreur);

    VectDyn<ChampScalConstElem> lVectNormeL2ErreurAna;
    VectDyn<ChampScalConstElem> lVectNormeL2NormeGradErreurAna;
    VectDyn<ChampScalConstElem> lVectChampVraieNormeErr2;
    VectDyn<ChampVect3DConstElem> lVectChampVraieNormeGradErr2;

    if ((lMaillage2D || (lMaillage3D && !lMetrique3D)) && !lVectChampsUAna.empty()) {
      lVectNormeL2ErreurAna.asgnLongueur(lVectChampsUAna.size());
      lVectNormeL2NormeGradErreurAna.asgnLongueur(lVectChampsUAna.size());
      lVectChampVraieNormeErr2.asgnLongueur(lVectChampsUAna.size());
      lVectChampVraieNormeGradErr2.asgnLongueur(lVectChampsUAna.size());

      for (EntierN i = 0; i< lVectChampsUAna.size(); ++i) {
	lVectEstimAnalytique[i].asgnChampScalAnalytique(*lVectChampsUAna[i]);
	lVectEstimAnalytique[i].asgnErreurDesiree(lVectErreurDesiree[i]);
	lVectEstimAnalytique[i].asgnTolerance(lToleranceErreur);
	lVectEstimAnalytique[i].asgnLongueurReference(lLongRef);
	lEstimationErreurCompositeAna.ajouteEstimationErreur(lVectEstimAnalytique[i]);
	lVectNormeL2ErreurAna[i].asgnChampGeometrique(lChampGeo);
	lVectNormeL2NormeGradErreurAna[i].asgnChampGeometrique(lChampGeo);
      }
      VectDyn<DReel> lTmp(1);
      Maillage::IterateurElement       lIterElementd = lMail.reqElementDebut();
      const Maillage::IterateurElement lITerElemFind = lMail.reqElementFin();
      while (lIterElementd != lITerElemFind && (lMaillage2D || (lMaillage3D && !lMetrique3D))) {
	ErreurEvaluee lNormeErreurEvaluee;
	lEstimationErreurCompositeAna.reqNormeErreurElement(*lIterElementd, lNormeErreurEvaluee);

	ErreurEvaluee lNormeGradErreurEvaluee;
	lEstimationErreurCompositeAna.reqNormeGradErreurElement(*lIterElementd, lNormeGradErreurEvaluee);

	lIntNormeL2ErreurAnaAvant += lNormeErreurEvaluee;
	lIntNormeL2GradErreurAnaAvant += lNormeGradErreurEvaluee;

	//On stock les resultats dans les champs pour exportation.
	//On stock les resultats dans les champs pour exportation.
	for (EntierN i= 0; i< lVectChampsUAna.size(); ++i) {
	  lTmp[0] = lNormeErreurEvaluee.reqErreurActuelle();
	  lVectNormeL2ErreurAna[i].asgnValeurElement(*lIterElementd, lTmp);
	  lTmp[0] = lNormeGradErreurEvaluee.reqErreurActuelle();
	  lVectNormeL2NormeGradErreurAna[i].asgnValeurElement(*lIterElementd, lTmp);
	  lNormeErreurEvaluee.incrementeIndiceErreurActuelle();
	  lNormeGradErreurEvaluee.incrementeIndiceErreurActuelle();
	}

	++lIterElementd;
      }
      for (EntierN i= 0; i< lVectChampsUAna.size() && lMsg; ++i) {
	if (lMsg) lMsg = lVUInit.ajouteChamp(lVectNormeL2ErreurAna[i], "nl2e_"+lVectChampsUAna[i]->reqNom());
	if (lMsg) lMsg = lVUInit.ajouteChamp(lVectNormeL2NormeGradErreurAna[i], "nl2nge_"+lVectChampsUAna[i]->reqNom());
      }

      PPNormeL2<ChampSAExpAlg> lPPNormeL2(lMail);
      lPPNormeL2.asgnParametres(lChampGeo,lSchemaIntg);
      VectDyn<ChampSAExpAlg*> lVectDiffUInitUAna(lVectChampsU.size(),0);
      VectDyn<DReel>          lVecNormeL2DiffUiUa(lVectChampsU.size(),0);

      //On va maintenant reinterpoler chaque solution du maillage initial sur le maillage adapte
      for (EntierN i = 0; i< lVectChampsU.size() && lMsg; ++i) {
	lVectChampVraieNormeErr2[i].asgnChampGeometrique(lChampGeo);
	lVectChampVraieNormeGradErr2[i].asgnChampGeometrique(lChampGeo);

	//On construit une expression algebrique qui represente la difference de cette solution
	//reinterpolee avec la solution analytique.
	ChampSAExpAlg *lDiffUInitUAna = new ChampSAExpAlg();
	lVectDiffUInitUAna[i] = lDiffUInitUAna;
	lDiffUInitUAna->asgnChampGeometrique(lChampGeo);
	lDiffUInitUAna->asgnNom("F");
	lMsg = lDiffUInitUAna->ajouteChamp(lVectChampSolutionLin[i]);
	if (lMsg) {
	  lMsg = lDiffUInitUAna->ajouteChamp(*lVectChampsUAna[i]);
	}
	if (lMsg) {
	  std::string lChaineExpAlg("f("+lVectChampSolutionLin[i].reqNom()+","+lVectChampsUAna[i]->reqNom()+")="+lVectChampSolutionLin[i].reqNom()+"-"+lVectChampsUAna[i]->reqNom());
	  lMsg = lDiffUInitUAna->asgnExpAlg(lChaineExpAlg);
	}
	if (lMsg) {

	  if (lMsg) {

	    lPPNormeL2.ajouteChamp(*lDiffUInitUAna,
				   lVecNormeL2DiffUiUa[i],
				   &(lVectChampVraieNormeErr2[i]));

	  }

	  if (lMsg) {
	    Vecteur3D lNormeL2GradDiffUiUa(0,0,0);
	    PPNormeL2ComposanteGrad lPPNormeL2Grad(lMail);
	    lPPNormeL2Grad.asgnParametres(lChampGeo,
					  *lDiffUInitUAna,
					  lNormeL2GradDiffUiUa,
					  lSchemaIntg,
					  &(lVectChampVraieNormeGradErr2[i]));

	    lPPNormeL2Grad.effectueCalcul();

	    const DReel lPPNormeL2NormeGrad = lNormeL2GradDiffUiUa.reqX()*lNormeL2GradDiffUiUa.reqX()+
	      lNormeL2GradDiffUiUa.reqY()*lNormeL2GradDiffUiUa.reqY()+
	      lNormeL2GradDiffUiUa.reqZ()*lNormeL2GradDiffUiUa.reqZ();

	    lVectVraieNormeL2GradErrAvant[i] = lPPNormeL2NormeGrad;

	    cout << "Vraie NormeL2 au carre de la norme au carre du gradient de l'erreur Avant (UXReint - UXAna) pour " << lVectChampsU[i]->reqNom() << " = " << lVectVraieNormeL2GradErrAvant[i] << endl;

	  }
	}
	if (lMsg) {
	  lMsg = lPPNormeL2.effectueCalcul();

	  for (EntierN i = 0; i< lVectChampsU.size() && lMsg; ++i) {
	    lVectVraieNormeL2ErrAvant[i] =  lVecNormeL2DiffUiUa[i]*lVecNormeL2DiffUiUa[i];
	    cout << "Vraie NormeL2 au carre de l'erreur Avant (UX - UXAna) pour " << lVectChampsU[i]->reqNom() << " = " << (lVectVraieNormeL2ErrAvant[i]) << endl;
	  }
	}


	if (lMsg) lMsg = lVUInit.ajouteChamp(lVectChampVraieNormeErr2[i], "vraienl2e_"+lVectChampsUAna[i]->reqNom());
	if (lMsg) lMsg = lVUInit.ajouteChamp(lVectChampVraieNormeGradErr2[i], "vraienl2ge_"+lVectChampsUAna[i]->reqNom());
	lExportGIREF.ajouteDReel(lVectVraieNormeL2ErrAvant[i], "vraienl2e_"+lVectChampsUAna[i]->reqNom()+"_avant",true);
	lExportGIREF.ajouteDReel(lVectVraieNormeL2GradErrAvant[i], "vraienl2ge_"+lVectChampsUAna[i]->reqNom()+"_avant",true);
      }

    } // if (!lMaillage1D) {

    if (lMsg) {
      lMsg = lVUInit.exporteInfo(lNomSortie + "Init");
    }
  }
#endif //TOTAL

  if (!lMsg) {
    cout << traducteurERMsg(lMsg);
    return 0;
  }


  // ****************************
  // Lancement de l'adaptation
  // ****************************
  typedef std::list<StatistiqueAdaptation > ListeTypeStat;
  ListeTypeStat lListeStatAdapt;
  std::list<Exportation*> lListeExportation;

  ExportVU lVUlin;
  lVUlin.asgnChampGeometrique(lChampGeo);
  lVUlin.asgnDegreInterpolation(Exportation::MAILLAGE_LINEAIRE);
  lListeExportation.push_back(&lVUlin);

  if (lMsg && lMaillage1D) {
    cout << "Lancement de l'adaptation 1D avec metrique." <<endl;
    AdaptationMaillage1D<TypeMetriqueAdaptation> lAdaptation;
    lMsg = lAdaptation.adapteMaillage(lMail,
                                      lChampGeo,
                                      lGeo,
                                      lCritereAdapMetrique,
                                      *lMetriqueAdaptation,
                                      lSequenceGlobale,
                                      lListeStatAdapt);

  }
  else if (lMsg && lMaillage2D) {
    cout << "Lancement de l'adaptation 2D hierarchique." <<endl;
    AdaptationGeometrie2_5D lAdaptation;
    lMsg = lAdaptation.adapteMaillage(lMail,
                                      lChampGeo,
                                      lGeo,
                                      lCritere,
                                      (-1 == lErreurDesireeGeo ? 0: &lEstimationErreurGeometrique),
                                      lEstimationErreurComposite,
                                      lSequenceGlobale,
                                      lListeStatAdapt,
                                      lQualiteMin,
                                      lListeExportation);
    cout << "DeplacementSommetMax : " << lAdaptation.reqDeplacementSommetMax() << endl;
    cout << "DeplacementSommetMoy : " << lAdaptation.reqDeplacementSommetMoy() << endl;
    cout << "NbDeplacementSommet  : " << lAdaptation.reqNbDeplacementSommet () << endl;
    cout << "NbDeraffinementSommet: " << lAdaptation.reqNbDeraffinementArete() << endl;
    cout << "NbRaffinementArete   : " << lAdaptation.reqNbRaffinementArete  () << endl;
    cout << "NbRetournementArete  : " << lAdaptation.reqNbRetournementArete () << endl;
  }
  else if (lMsg && lMaillage3D && !lMetrique3D) {
    cout << "Lancement de l'adaptation 3D hierarchique." <<endl;
    AdaptationMaillage3DHierarchique lAdaptation3D;

    lMsg = lAdaptation3D.adapteMaillage(lMail,
                                        lChampGeo,
                                        lGeo,
                                        lCritere,
                                        (-1 == lErreurDesireeGeo ? 0: &lEstimationErreurGeometrique),
                                        lEstimationErreurComposite,
                                        lSequenceGlobale,
                                        lListeStatAdapt,
                                        lQualiteMin,
                                        lListeExportation);

    cout << "DeplacementSommetMax : " << lAdaptation3D.reqDeplacementSommetMax() << endl;
    cout << "DeplacementSommetMoy : " << lAdaptation3D.reqDeplacementSommetMoy() << endl;
    cout << "NbDeplacementSommet  : " << lAdaptation3D.reqNbDeplacementSommet () << endl;
    cout << "NbDeraffinementSommet: " << lAdaptation3D.reqNbDeraffinementArete() << endl;
    cout << "NbRaffinementArete   : " << lAdaptation3D.reqNbRaffinementArete  () << endl;
    cout << "NbRetournementArete  : " << lAdaptation3D.reqNbRetournementArete () << endl;
    cout << "NbRetournementFace   : " << lAdaptation3D.reqNbRetournementFace () << endl;

  }
  else if (lMsg && lMaillage3D && lMetrique3D) {
    cout << "Lancement de l'adaptation 3D avec metrique." <<endl;
    AdaptationMaillage<MetriqueComposee<Metrique> > lAdaptation3DMetrique;

    //Passe-passe pour le 3D: Dans la classe, on sait que l'angle est en realite
    // la qualite euclidienne...
    lCritere.asgnAngleMin(lQualiteMin);

    lAdaptation3DMetrique.asgnCritereAdaptation(lCritereAdapMetrique);
    lAdaptation3DMetrique.asgnCritereMaillage(lCritere);
    lAdaptation3DMetrique.asgnSequenceAdaptation(lSequenceGlobale);

    lMsg = lAdaptation3DMetrique.adapteMaillage(lMail,
                                                lChampGeo,
                                                lGeo,
                                                lMetriqueComposee,
                                                lListeStatAdapt,
                                                lListeExportation);


    cout << "DeplacementSommetMax : " << lAdaptation3DMetrique.reqDeplacementSommetMax() << endl;
    cout << "DeplacementSommetMoy : " << lAdaptation3DMetrique.reqDeplacementSommetMoy() << endl;
    cout << "NbDeplacementSommet  : " << lAdaptation3DMetrique.reqNbDeplacementSommet () << endl;
    cout << "NbDeraffinementSommet: " << lAdaptation3DMetrique.reqNbDeraffinementArete() << endl;
    cout << "NbRaffinementArete   : " << lAdaptation3DMetrique.reqNbRaffinementArete  () << endl;
    cout << "NbRetournementArete  : " << lAdaptation3DMetrique.reqNbRetournementArete () << endl;
    cout << "NbRetournementFace   : " << lAdaptation3DMetrique.reqNbRetournementFace () << endl;

  }

  if (lMsg) {
    cout << "======================" << endl;
    cout << "nb Sommets: " << lMail.reqNbSommet  () << endl;
    cout << "nb Aretes : " << lMail.reqNbArete   () << endl;
    cout << "nb Faces  : " << lMail.reqNbFace    () << endl;
    cout << "nb Element: " << lMail.reqNbElement () << endl;
  }
  if (lMsg) {
    Maillage::IterateurElement lIterElem    = lMail.reqElementDebut();
    Maillage::IterateurElement lIterElemFin = lMail.reqElementFin();

    const CoorReference lCoorRef(0.,0.,0.);
    MatriceJacobienne lJ;
    DReel lDetMin = 1e6;

    while (lIterElem != lIterElemFin) {
      lChampGeo.reqMatriceJacobienne(*lIterElem,
                                     lCoorRef,
                                     lJ);
      if (lJ.reqDetJ() < lDetMin) {
        lDetMin = lJ.reqDetJ();
      }
      ++lIterElem;
    }
    cout << "Determinant Min Final: " << lDetMin << endl;
  }

  // ****************************
  // Quelques post-traitements
  // ****************************
  numerotePorteur(lMail.reqSommetDebut(), lMail.reqSommetFin(), 0,1);
  numerotePorteur(lMail.reqAreteDebut(), lMail.reqAreteFin(), 0,1);
  numerotePorteur(lMail.reqFaceDebut(), lMail.reqFaceFin(), 0,1);
  numerotePorteur(lMail.reqElementDebut(), lMail.reqElementFin(), 0,1);

  if (lMaillage1D) {
    cout << "longueur Maillage: " << lAireMailInit << endl;
  }
  else if (lMaillage2D) {
    cout << "aire Maillage: " << lAireMailInit << endl;
  }
  else  if (lMaillage3D) {
    cout << "volume Maillage: " << lAireMailInit << endl;
  }

#ifdef TOTAL
  VectDyn<ChampScalConstElem> lVectNormeL2ErreurAna;
  VectDyn<ChampScalConstElem> lVectNormeL2NormeGradErreurAna;
  VectDyn<ChampScalConstElem> lVectChampVraieNormeErr2;
  VectDyn<ChampVect3DConstElem> lVectChampVraieNormeGradErr2;

  ExportVU lVUPost;
  lVUPost.asgnChampGeometrique(lChampGeo);
  lVUPost.asgnDegreInterpolation(Exportation::MAILLAGE_LINEAIRE);

  if (lMsg && lMaillage2D || (lMaillage3D && !lMetrique3D)) {

    VectDyn<DReel> lTmp(1);
    Maillage::IterateurElement       lIterElement    = lMail.reqElementDebut();
    const Maillage::IterateurElement lIterElementFin = lMail.reqElementFin();
    while (lIterElement != lIterElementFin) {
      ErreurEvaluee lErreurElem;
      lEstimationErreurGeometrique.reqNormeErreurElement(*lIterElement, lErreurElem);
      lTmp[0] = lErreurElem.reqErreurActuelle();
      lVectNormeL2Erreur[lNbSolutions].asgnValeurElement (*lIterElement, lTmp);

      ErreurEvaluee lGradErreurElem;
      lEstimationErreurGeometrique.reqNormeGradErreurElement(*lIterElement, lGradErreurElem);
      lTmp[0] = lGradErreurElem.reqErreurActuelle();
      lVectNormeL2NormeGradErreur[lNbSolutions].asgnValeurElement (*lIterElement, lTmp);

      ++lIterElement;
    }

    if (lMsg) lMsg = lVUPost.ajouteChamp(lLongAireVolumeElem, "Aire");
    if (lMsg) lMsg = lVUPost.ajouteChamp(lVectNormeL2Erreur[lNbSolutions], "nl2e_geo");
    if (lMsg) lMsg = lVUPost.ajouteChamp(lVectNormeL2NormeGradErreur[lNbSolutions], "nl2nge_geo");

    for (EntierN i = 0; i < lNbSolutions && lMsg; ++i) {
      if (lMsg) lMsg = lVUPost.ajouteChamp(*lVectChampsU[i], lVectChampsU[i]->reqNom());
      if (lMsg) lMsg = lVUPost.ajouteChamp(lVectChampSolutionLin[i], lVectChampsU[i]->reqNom() + "_lin");
      if (lMsg) lMsg = lVUPost.ajouteChamp(lVectChampGrad[i], "d"+lVectChampsU[i]->reqNom()+"d");
      if (lMsg) lMsg = lVUPost.ajouteChamp(lVectChampHessien[i], "dd"+lVectChampsU[i]->reqNom()+"d");
      if (lMsg) lMsg = lVUPost.ajouteChamp(lVectNormeL2Erreur[i], "nl2e_"+lVectChampsU[i]->reqNom());
      if (lMsg) lMsg = lVUPost.ajouteChamp(lVectNormeL2NormeGradErreur[i], "nl2nge_"+lVectChampsU[i]->reqNom());
    }
  }

  // On calcul la norme L2 de l'erreur et la norme L2 de la norme du gradient de l'erreur apres
  ErreurEvaluee lIntNormeL2ErreurApres;
  ErreurEvaluee lIntNormeL2GradErreurApres;

  if (lMsg && (lMaillage2D || (lMaillage3D && !lMetrique3D)) ) {
    {
      VectDyn<DReel> lTmp(1);
      Maillage::IterateurElement       lIterElementd = lMail.reqElementDebut();
      const Maillage::IterateurElement lITerElemFind = lMail.reqElementFin();
      while (lIterElementd != lITerElemFind) {
	ErreurEvaluee lNormeErreurEvaluee;
	lEstimationErreurComposite.reqNormeErreurElement(*lIterElementd, lNormeErreurEvaluee);

	ErreurEvaluee lNormeGradErreurEvaluee;
	lEstimationErreurComposite.reqNormeGradErreurElement(*lIterElementd, lNormeGradErreurEvaluee);
	DReel lLongAireVol = 0;
	if (lMaillage1D) {
	  lLongAireVol = lChampGeo.reqIntegraleDetJ(*(dynamic_cast<Element1D*>(&(*lIterElementd))));
	}
	else if (lMaillage2D) {
	  lLongAireVol = lChampGeo.reqIntegraleDetJ(*(dynamic_cast<ElemTriangle*>(&(*lIterElementd))));
	}
	else {
	  lLongAireVol = lChampGeo.reqIntegraleDetJ(*(dynamic_cast<ElemTetra*>(&(*lIterElementd))));
	}
	lTmp[0] = lLongAireVol;
	lLongAireVolumeElem.asgnValeurElement(*lIterElementd, lTmp);

	lIntNormeL2ErreurApres += lNormeErreurEvaluee;
	lIntNormeL2GradErreurApres += lNormeGradErreurEvaluee;
	for (EntierN i= 0; i< lNbSolutions; ++i) {
	  lTmp[0] = lNormeErreurEvaluee.reqErreurActuelle();
	  lVectNormeL2Erreur[i].asgnValeurElement(*lIterElementd, lTmp);
	  lTmp[0]= lNormeGradErreurEvaluee.reqErreurActuelle();
	  lVectNormeL2NormeGradErreur[i].asgnValeurElement(*lIterElementd, lTmp);
	  lNormeErreurEvaluee.incrementeIndiceErreurActuelle();
	  lNormeGradErreurEvaluee.incrementeIndiceErreurActuelle();
	}
	++lIterElementd;
      }
    }
    // On calcul la norme L2 de l'erreur et la norme L2 de la norme du gradient de l'erreur apres pour la solution analytique
    ErreurEvaluee lIntNormeL2ErreurAnaApres;
    ErreurEvaluee lIntNormeL2GradErreurAnaApres;
    if (!lVectChampsUAna.empty()) {
      lVectNormeL2ErreurAna.asgnLongueur(lVectChampsUAna.size());
      lVectNormeL2NormeGradErreurAna.asgnLongueur(lVectChampsUAna.size());
      lVectChampVraieNormeErr2.asgnLongueur(lVectChampsUAna.size());
      lVectChampVraieNormeGradErr2.asgnLongueur(lVectChampsUAna.size());

      for (EntierN i= 0; i< lVectChampsUAna.size() && lMsg; ++i) {
	lVectNormeL2ErreurAna[i].asgnChampGeometrique(lChampGeo);
	lVectNormeL2NormeGradErreurAna[i].asgnChampGeometrique(lChampGeo);
	lVectChampVraieNormeErr2[i].asgnChampGeometrique(lChampGeo);
	lVectChampVraieNormeGradErr2[i].asgnChampGeometrique(lChampGeo);
	if (lMsg) lMsg = lVUPost.ajouteChamp(lVectNormeL2ErreurAna[i], "nl2e_"+lVectChampsUAna[i]->reqNom());
	if (lMsg) lMsg = lVUPost.ajouteChamp(lVectNormeL2NormeGradErreurAna[i], "nl2nge_"+lVectChampsUAna[i]->reqNom());
	if (lMsg) lMsg = lVUPost.ajouteChamp(lVectChampVraieNormeErr2[i], "vraienl2e_"+lVectChampsUAna[i]->reqNom());
	if (lMsg) lMsg = lVUPost.ajouteChamp(lVectChampVraieNormeGradErr2[i], "vraienl2ge_"+lVectChampsUAna[i]->reqNom());
      }

      VectDyn<DReel> lTmp(1);
      Maillage::IterateurElement       lIterElementd = lMail.reqElementDebut();
      const Maillage::IterateurElement lITerElemFind = lMail.reqElementFin();
      while (lIterElementd != lITerElemFind && (lMaillage2D || (lMaillage3D && !lMetrique3D))) {
	ErreurEvaluee lNormeErreurEvaluee;
	lEstimationErreurCompositeAna.reqNormeErreurElement(*lIterElementd, lNormeErreurEvaluee);

	ErreurEvaluee lNormeGradErreurEvaluee;
	lEstimationErreurCompositeAna.reqNormeGradErreurElement(*lIterElementd, lNormeGradErreurEvaluee);

	lIntNormeL2ErreurAnaApres += lNormeErreurEvaluee;
	lIntNormeL2GradErreurAnaApres += lNormeGradErreurEvaluee;

	//On stock les resultats dans les champs pour exportation.
	for (EntierN i= 0; i< lVectChampsUAna.size(); ++i) {
	  lTmp[0] = lNormeErreurEvaluee.reqErreurActuelle();
	  lVectNormeL2ErreurAna[i].asgnValeurElement(*lIterElementd, lTmp);
	  lTmp[0] = lNormeGradErreurEvaluee.reqErreurActuelle();
	  lVectNormeL2NormeGradErreurAna[i].asgnValeurElement(*lIterElementd, lTmp);
	  lNormeErreurEvaluee.incrementeIndiceErreurActuelle();
	  lNormeGradErreurEvaluee.incrementeIndiceErreurActuelle();
	}

	++lIterElementd;
      }

    }

    cout << "Norme L2 au carre de l'erreur estime Avant                  : ";
    lIntNormeL2ErreurAvant.exporte(cout);
    cout << " Apres: ";
    lIntNormeL2ErreurApres.exporte(cout);
    cout << endl;


    if (!lVectChampsUAna.empty()) {
      cout << "Norme L2 au carre de l'erreur analytique (UAna - ULin) Avant: ";
      lIntNormeL2ErreurAnaAvant.exporte(cout);
      cout << " Apres: ";
      lIntNormeL2ErreurAnaApres.exporte(cout);
      cout << endl;
    }

    cout << "Norme L2 au carre de la norme du gradient de l'erreur estime Avant                  : ";
    lIntNormeL2GradErreurAvant.exporte(cout);
    cout << " Apres: ";
    lIntNormeL2GradErreurApres.exporte(cout);
    cout << endl;

    if (!lVectChampsUAna.empty()) {
      cout << "Norme L2 au carre de la norme du gradient de l'erreur analytique (UAna - ULin) Avant: ";
      lIntNormeL2GradErreurAnaAvant.exporte(cout);
      cout << " Apres: ";
      lIntNormeL2GradErreurAnaApres.exporte(cout);
      cout << endl;
    }

    //On stock les resultats dans l'exportation GIREF
    for (EntierN i= 0; i< lVectChampsU.size(); ++i) {
      lVectNormeL2ErrEstimAvant[i] = lIntNormeL2ErreurAvant.reqErreurActuelle();
      lVectNormeL2ErrEstimApres[i] = lIntNormeL2ErreurApres.reqErreurActuelle();

      lVectNormeL2GradErrEstimAvant[i] = lIntNormeL2GradErreurAvant.reqErreurActuelle();
      lVectNormeL2GradErrEstimApres[i] = lIntNormeL2GradErreurApres.reqErreurActuelle();

      lExportGIREF.ajouteDReel(lVectNormeL2ErrEstimAvant[i], "nl2e_"+lVectChampsU[i]->reqNom()+"_avant",true);
      lExportGIREF.ajouteDReel(lVectNormeL2ErrEstimApres[i], "nl2e_"+lVectChampsU[i]->reqNom()+"_apres",true);
      lExportGIREF.ajouteDReel(lVectNormeL2GradErrEstimAvant[i], "nl2ge_"+lVectChampsU[i]->reqNom()+"_avant",true);
      lExportGIREF.ajouteDReel(lVectNormeL2GradErrEstimApres[i], "nl2ge_"+lVectChampsU[i]->reqNom()+"_apres",true);

      if (!lVectChampsUAna.empty()) {
	lVectNormeL2ErrQCAnaAvant[i] = lIntNormeL2ErreurAnaAvant.reqErreurActuelle();
	lVectNormeL2ErrQCAnaApres[i] = lIntNormeL2ErreurAnaApres.reqErreurActuelle();

	lVectNormeL2GradErrQCAnaAvant[i] = lIntNormeL2GradErreurAvant.reqErreurActuelle();
	lVectNormeL2GradErrQCAnaApres[i] = lIntNormeL2GradErreurApres.reqErreurActuelle();

	lExportGIREF.ajouteDReel(lVectNormeL2ErrQCAnaAvant[i], "nl2e_"+lVectChampsUAna[i]->reqNom()+"_avant",true);
	lExportGIREF.ajouteDReel(lVectNormeL2ErrQCAnaApres[i], "nl2e_"+lVectChampsUAna[i]->reqNom()+"_apres",true);
	lExportGIREF.ajouteDReel(lVectNormeL2GradErrQCAnaAvant[i], "nl2ge_"+lVectChampsUAna[i]->reqNom()+"_avant",true);
	lExportGIREF.ajouteDReel(lVectNormeL2GradErrQCAnaApres[i], "nl2ge_"+lVectChampsUAna[i]->reqNom()+"_apres",false);
      }

    }

  }

  ListeTypeStat::const_iterator       lIterStat    = lListeStatAdapt.begin();
  const ListeTypeStat::const_iterator lIterStatFin = lListeStatAdapt.end();

  ChaineCar lNomStat(lNomSortie);
  lNomStat += ".stats";

  ofstream lFichierStat(lNomStat.c_str());
  lFichierStat << lListeStatAdapt.size() << endl;
  while (lIterStat != lIterStatFin) {
    lFichierStat << (*lIterStat) << endl;
    ++lIterStat;
  }

#endif //TOTAL
  const bool lReinterpoleChamps = (!lVectChampsU1DReint.empty() ||  !lVectChampsU3DReint.empty());

  //On fait un calcul pour voir la norme L2 de la difference entre les solutions sur le 1er maillage et le 2e...
#ifdef TOTAL
  if (lMsg && (lReinterpoleChamps || lCalcNormeL2Diff) ) {
#else //TOTAL
  if (lMsg && (lReinterpoleChamps ) ) {
#endif //TOTAL

    //On va relire le maillage initial ainsi que le fichier de champ initial...
    Maillage               lMailInit;
    ChampGeoLin            lChampGeoInit(lMailInit);
    ListEntitesGeometrique lListeEntiteInit;

    //Declaration de l'objet qui fait la gestion des champs pour le probleme.
    GestionFichierChamps lFichierChampInit;

    // *******************************************
    // * BLOC: Declaration  *
    // *******************************************

    // Assignation de la geometrie, entite, maillage, champgeometrique  au probleme
    // et lecture des donnees d'entree
    string lNomFichierEntites = lNomMailinit + ".enti";
    ifstream lFichierEntites(lNomFichierEntites.c_str());
    if (!lFichierEntites) {
      lMsg.ajoute(ERMsg(ERMsg::ERREUR, string("ERREUR - Ouverture du fichier ") +lNomFichierEntites +string(" impossible")));

    }

    if (lMsg) {
      lMsg = lListeEntiteInit.importe(lFichierEntites);
    }
    if (lMsg) {
      lMsg = lMailInit.importe(lNomMailinit);
    }

    //On demande au gestionnaire de lire le fichier de champ
    if(lMsg) {
      // On assigne le maillage, le champ geometrique, la geometrie et la liste d'entites
      // au Gestionnaire de fichier de champs
      lFichierChampInit.asgnDonneesBase(&lMailInit,&lChampGeoInit);
      lFichierChampInit.asgnDonneesGeometriques(&lGeo,&lListeEntiteInit);

      lMsg = lFichierChampInit.lireFichier(lNomMailinit + std::string(".champs"));
    }

#ifdef TOTAL
    // Calcul de la norme L2 de la difference entre la solution analytique reinterpolee lineairement et analytique sur le maillage final.
    if (lMsg && lCalcNormeL2Diff) {
      ChampScalLin lChampScalLinTmp;
      lChampScalLinTmp.asgnChampGeometrique(lChampGeo);
      //On va maintenant reinterpoler chaque solution du maillage initial sur le maillage adapte
      PPNormeL2<ChampSAExpAlg> lPPNormeL2(lMail);
      lPPNormeL2.asgnParametres(lChampGeo,
				lSchemaIntg);

      VectDyn<DReel> lVecNormeL2DiffUiUa(lVectChampsUAna.size(), 0);

      for (EntierN i = 0; i< lVectChampsUAna.size() && lMsg; ++i) {

	//On reinterpole la solution analytique lineairement (on preserve lVectChampSolutionLin[i] car on veut l'exporter)
	lChampScalLinTmp.asgnNom(lVectChampSolutionLin[i].reqNom());
	lMsg = lChampScalLinTmp.reinterpole(*lVectChampsUAna[i]);

	//On construit une expression algebrique qui represente la difference de cette solution
	//reinterpolee avec la solution analytique.
	ChampSAExpAlg lDiffUInitUAna;
	if (lMsg) {
	  lDiffUInitUAna.asgnChampGeometrique(lChampGeo);
	  lDiffUInitUAna.asgnNom("F");
	  lMsg = lDiffUInitUAna.ajouteChamp(lChampScalLinTmp);
	}
	if (lMsg) {
	  lMsg = lDiffUInitUAna.ajouteChamp(*lVectChampsUAna[i]);
	}
	if (lMsg) {
	  std::string lChaineExpAlg("f("+lChampScalLinTmp.reqNom()+","+lVectChampsUAna[i]->reqNom()+")="+lChampScalLinTmp.reqNom()+"-"+lVectChampsUAna[i]->reqNom());
	  lMsg = lDiffUInitUAna.asgnExpAlg(lChaineExpAlg);
	}
	if (lMsg) {
	  lPPNormeL2.ajouteChamp(lDiffUInitUAna,
				 lVecNormeL2DiffUiUa[i],
				 &(lVectChampVraieNormeErr2[i]));
	}

	if (lMsg) {
	  Vecteur3D lNormeL2GradDiffUiUa(0,0,0);
	  PPNormeL2ComposanteGrad lPPNormeL2Grad(lMail);
	  lPPNormeL2Grad.asgnParametres(lChampGeo,
					lDiffUInitUAna,
					lNormeL2GradDiffUiUa,
					lSchemaIntg,
					&(lVectChampVraieNormeGradErr2[i]));

	  lPPNormeL2Grad.effectueCalcul();

	  const DReel lPPNormeL2NormeGrad = lNormeL2GradDiffUiUa.reqX()*lNormeL2GradDiffUiUa.reqX()+
	    lNormeL2GradDiffUiUa.reqY()*lNormeL2GradDiffUiUa.reqY()+
	    lNormeL2GradDiffUiUa.reqZ()*lNormeL2GradDiffUiUa.reqZ();

	  lVectVraieNormeL2GradErrApres[i] = lPPNormeL2NormeGrad;

	  cout << "Vraie NormeL2 au carre de la norme au carre du gradient de l'erreur apres (UXAnaReint - UXAna) pour " << lVectChampsU[i]->reqNom() << " = " << lVectVraieNormeL2GradErrApres[i] << endl;

	}
	if (lMsg) {
	  lMsg = lPPNormeL2.effectueCalcul();
	  for (EntierN i = 0; i< lVectChampsUAna.size() && lMsg; ++i) {
	    lVectVraieNormeL2ErrApres[i] =  lVecNormeL2DiffUiUa[i]*lVecNormeL2DiffUiUa[i];

	    cout << "Vraie NormeL2 au carre de l'erreur apres (UXAnaReint - UXAna) pour " << lVectChampsU[i]->reqNom() << " = " << lVectVraieNormeL2ErrApres[i] << endl;
	  }
	}

	lVectRappNormeL2ErrAvant[i] =  lVectNormeL2ErrEstimAvant[i]/lVectVraieNormeL2ErrAvant[i];
	lVectRappNormeL2ErrApres[i] =  lVectNormeL2ErrEstimApres[i]/lVectVraieNormeL2ErrApres[i];

	lVectRappNormeL2GradErrAvant[i] =  lVectNormeL2GradErrEstimAvant[i]/lVectVraieNormeL2GradErrAvant[i];
	lVectRappNormeL2GradErrApres[i] =  lVectNormeL2GradErrEstimApres[i]/lVectVraieNormeL2GradErrApres[i];

	lExportGIREF.ajouteDReel(lVectVraieNormeL2ErrApres[i], "vraienl2e_"+lVectChampsUAna[i]->reqNom()+"_apres",true);
	lExportGIREF.ajouteDReel(lVectVraieNormeL2GradErrApres[i], "vraienl2ge_"+lVectChampsUAna[i]->reqNom()+"_apres",true);

	lExportGIREF.ajouteDReel(lVectRappNormeL2ErrAvant[i], "rapp_nl2e_estim/ana_"+lVectChampsUAna[i]->reqNom()+"_avant",true);
	lExportGIREF.ajouteDReel(lVectRappNormeL2ErrApres[i], "rapp_nl2e_estim/ana_"+lVectChampsUAna[i]->reqNom()+"_apres",true);
	lExportGIREF.ajouteDReel(lVectRappNormeL2GradErrAvant[i], "rapp_nl2ge_estim/ana_"+lVectChampsUAna[i]->reqNom()+"_avant",true);
	lExportGIREF.ajouteDReel(lVectRappNormeL2GradErrApres[i], "rapp_nl2ge_estim/ana_"+lVectChampsUAna[i]->reqNom()+"_apres",true);

      }
    }//    if (lCalcNormeL2Diff) {
#endif //TOTAL

    // Reinterpolation des champs 1D se nommant "UReintX"
    if (lMsg && lReinterpoleChamps) {

      vector<ChampScalaire *> lVectChampsU1DReintInit;

      for (EntierN i = 0; i< lNbMaxChamps && lMsg ; ++i) {
	string lNomChampU = "U";
	{
	  std::stringstream lStream;
	  lStream << i;
	  lNomChampU += lStream.str();
	}

	ChampScalaire *lU = 0;
	lMsg = lFichierChampInit.reqChamp<ChampScalaire>(lNomChampU+"Reint",lU,false);
	if (lU) {
	  lVectChampsU1DReintInit.push_back(lU);
	  //	}
// 	else {
// 	  //On verifie qu'on a le même nombre de champs
// 	  if (lVectChampsU1DReintInit.size() == lVectChampsU1DReint.size()) {
// 	    lMsg = ERMsg(ERMsg::OK);
// 	  }
// 	  break;
// 	}
	  //Si les 2 champs sont continus, on passe par la methode reinterpole:
	  if (dynamic_cast<ChampScalContinu*>(lVectChampsU1DReintInit[i]) && dynamic_cast<ChampScalContinu*>(lVectChampsU1DReint[i])) {
	    lMsg = lVectChampsU1DReint[i]->reinterpole(*lVectChampsU1DReintInit[i]);
	  }
	  else  if (dynamic_cast<ChampScalDiscParElement*>(lU) ) {
	    
	    reinterpoleSurChampDiscontinuGenMaillDiff(*lVectChampsU1DReintInit[i],
						      *dynamic_cast<ChampScalDiscParElement*>(lVectChampsU1DReint[i]));
	  }
	  else {
	    lMsg.ajoute(ERMsg(ERMsg::ERREUR, "ERREUR - On peut reinterpoler que des solutions 1D continues ou strictement disctoninu pour l'instant..."));
	  }
	}
      }

      // Reinterpolation des champs 3D se nommant "UReintX"
      vector<ChampVectoriel3D *> lVectChampsU3DReintInit;

      for (EntierN i = 0; i< lNbMaxChamps && lMsg ; ++i) {
	string lNomChampU = "U";
	{
	  std::stringstream lStream;
	  lStream << i;
	  lNomChampU += lStream.str();
	}

	ChampVectoriel3D *lU = 0;
	lMsg = lFichierChampInit.reqChamp<ChampVectoriel3D>(lNomChampU+"Reint",lU,false);
	if (lU) {
	  lVectChampsU3DReintInit.push_back(lU);
	  //	}
// 	else {
// 	  //On verifie qu'on a le même nombre de champs
// 	  if (lVectChampsU3DReintInit.size() == lVectChampsU3DReint.size()) {
// 	    lMsg = ERMsg(ERMsg::OK);
// 	  }
// 	  break;
// 	}
	  //Si les 2 champs sont continus, on passe par la methode reinterpole:
	  if (dynamic_cast<ChampVect3DContinu*>(lVectChampsU3DReintInit[i]) && dynamic_cast<ChampVect3DContinu*>(lVectChampsU3DReint[i])) {
	    lMsg = lVectChampsU3DReint[i]->reinterpole(*lVectChampsU3DReintInit[i]);
	  }
	  else  if (dynamic_cast<ChampVect3DDiscParElement*>(lU) ) {
	    
	    reinterpoleSurChampDiscontinuGenMaillDiff(*lVectChampsU3DReintInit[i],
						      *dynamic_cast<ChampVect3DDiscParElement*>(lVectChampsU3DReint[i]));
	  }
	  else {
	    lMsg.ajoute(ERMsg(ERMsg::ERREUR, "ERREUR - On peut reinterpoler que des solutions 3D continues ou strictement disctoninu pour l'instant..."));
	  }
	}
      }

      //Ensuite on exporte tous les champs en format GIREF
      if (lMsg) {
	ExportGIREF lExporGIREFReint;
	lExporGIREFReint.asgnExporteMaillage(false);

	lExporGIREFReint.asgnChampGeometrique(lChampGeo);
	lExporGIREFReint.asgnDegreInterpolation(Exportation::MAILLAGE_LINEAIRE);
	for (EntierN i = 0; i< lVectChampsU1DReint.size() && lMsg ; ++i) {
	  std::cout<<"Ajout de " << lVectChampsU1DReint[i]->reqNom() << "aux export des reinterpolations" << std::endl;
	  lMsg = lExporGIREFReint.ajouteChamp(*lVectChampsU1DReint[i], lVectChampsU1DReint[i]->reqNom());
#ifdef TOTAL
	  if (lMsg) lMsg = lVUPost.ajouteChamp(*lVectChampsU1DReint[i], lVectChampsU1DReint[i]->reqNom());
#endif //TOTAL
	}
	for (EntierN i = 0; i< lVectChampsU3DReint.size() && lMsg ; ++i) {
	  std::cout<<"Ajout de " << lVectChampsU1DReint[i]->reqNom() << "aux export des reinterpolations" << std::endl;
	  lMsg = lExporGIREFReint.ajouteChamp(*lVectChampsU3DReint[i], lVectChampsU3DReint[i]->reqNom());
#ifdef TOTAL
	  if (lMsg) lMsg = lVUPost.ajouteChamp(*lVectChampsU3DReint[i], lVectChampsU3DReint[i]->reqNom());
#endif //TOTAL
	}
	if (lMsg) {
	  lMsg = lExporGIREFReint.exporteInfo(lNomSortie);
	}
      }

    } //     if (lReinterpoleChamps) {


  } // if (lMsg && (lReinterpoleChamps || lCalcNormeL2Diff) ) {

#ifdef TOTAL
  if (lMsg) {
    lMsg = lVUPost.exporteInfo(lNomSortie + "Post");
  }

  if (lMsg) {
    lMsg = lExportGIREF.exporteInfo(lNomSortie);
  }
#endif //TOTAL

  if (lMsg) {
    cout << "------------------------------" << endl << "Maillage raffine: " << endl;
    lMsg = lMail.exporte("mailAdapteMetrique");
    cout << "------------------------------" << endl;
  }

  for (EntierN i = 0; i< lNbSolutions; ++i) {
    if (lVectEstimationErreur[i]) {
      delete lVectEstimationErreur[i];
    }
    if (lVectMetrique[i]) {
      delete lVectMetrique[i];
    }
  }

  if (lMetriqueAdaptation) {
    delete lMetriqueAdaptation;
  }


  // Traitement d'erreur: si une erreur s'est produite, on l'affiche.
  if(!lMsg) {
    PAStdStreamEcritureUnique lCerr(std::cerr, lGroupeGlobal, 0);
    lCerr << traducteurERMsg(lMsg);
    return 1;
  }


  return 0;
}