Index: XMLIO_V2/dev/dev_rv/src/XMLIO/NetCDF4_data_output.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/NetCDF4_data_output.hpp	(revision 122)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/NetCDF4_data_output.hpp	(revision 122)
@@ -0,0 +1,215 @@
+#ifndef __NETCDF4_DATA_OUTPUT__
+#define __NETCDF4_DATA_OUTPUT__
+
+#include <netcdfcpp.h>
+
+namespace XMLIOSERVER
+{
+   class NetCDF4DataOutput : public AbstractDataOutput
+   {
+      public :
+
+         NetCDF4DataOutput(CFile* const _file) : AbstractDataOutput(_file), dataFile(NULL)
+         { /* Ne rien faire de plus */ }
+
+         const NcFile* getDataFile(void) const { return (dataFile); }
+
+         virtual ~NetCDF4DataOutput()
+         { if (dataFile != NULL) delete dataFile; }
+
+      protected :
+
+         Poco::HashMap<string, int> getAllLimitedDim(void)
+         {
+            Poco::HashMap<string, int> dims;
+            const std::set<const CDomain*> sdom = getRelFile()->getEnabledDomains();
+            const std::set<const CAxis*> saxis = getRelFile()->getEnabledAxis();
+
+            const CDomain* pdom = *sdom.begin();
+
+            // TODO AmÃ©liorer ci-dessous -> un seul domaine pris en compte pour le moment
+            dims["lon"] = pdom->nj;
+            dims["lat"] = pdom->ni;
+
+            std::set<const CAxis*>::const_iterator it;
+            for ( it = saxis.begin() ; it != saxis.end(); it++ )
+               dims[(*it)->getId()] = (*it)->size;
+
+            return (dims);
+         }
+
+         std::string getFileName(void)
+         { return ((getRelFile()->name.hasValue()) ? string(getRelFile()->name): getRelFile()->name.getId()); }
+
+         std::string getTimeStamp(void)
+         {
+              time_t rawtime;
+              struct tm * timeinfo;
+              char buffer [100];
+
+              time ( &rawtime );
+              timeinfo = localtime ( &rawtime );
+
+              strftime (buffer, 100,"%Y-%b-%d %H:%M:%S %Z",timeinfo);
+
+              return (string(buffer));
+         }
+
+         virtual void initFile(void)
+         {
+            string filename = getFileName();
+
+            // CrÃ©ation du fichier ou remplacement si celui-ci existe dÃ©jÃ .
+            dataFile = new NcFile(filename.c_str(), NcFile::Replace);
+            if(!dataFile->is_valid())
+               throw XMLIOUndefinedValueException("Impossible d'ouvrir le fichier '"+ filename +"' pour l'Ã©criture des donnÃ©es' !");
+
+            // Ajout de quelques attributs globaux.
+            dataFile->add_att("conventions", "CF-1.1");
+            dataFile->add_att("file_name"  , getFileName().c_str());
+            if (getRelFile()->description.hasValue())
+               dataFile->add_att("file_desc" , string(getRelFile()->description).c_str());
+            dataFile->add_att("production" , "An IPSL model");
+            dataFile->add_att("timeStamp"  , getTimeStamp().c_str()) ;
+         }
+
+         virtual void setDims(void)
+         {
+            bool withTime = true;
+            const Poco::HashMap<string, int>& allDim = getAllLimitedDim();
+            Poco::HashMap<string, int>::ConstIterator it;
+
+            // Ajout des dimensions limitÃ©es.
+            for (it = allDim.begin() ; it != allDim.end(); it++)
+               if (NULL == dataFile->add_dim((*it).first.c_str(), (*it).second))
+                  throw XMLIOUndefinedValueException("Impossible d'ajouter la dimension "+ (*it).first +" !");
+
+            // Ajout de la dimension temporelle non limitÃ©e.
+            if (withTime)
+               if (NULL == dataFile->add_dim("time"))
+                  throw XMLIOUndefinedValueException("Impossible d'ajouter la dimension temporelle !");
+         }
+
+         virtual void setCoords(void)
+         {
+            NcVar *latVar = NULL, // variable de latitude.
+                  *lonVar = NULL, // variable de longitude.
+                  *othvar = NULL; // toute autre variable.
+
+            Poco::HashMap<string, string> hm;
+
+            const std::set<const CDomain*> sdom = getRelFile()->getEnabledDomains();
+            const std::set<const CAxis*> saxis = getRelFile()->getEnabledAxis();
+
+            if (!(latVar = dataFile->add_var("lat", ncFloat, dataFile->get_dim("lat"))))
+               throw XMLIOUndefinedValueException("Impossible d'ajouter la variable de latitude !");
+            if (!(lonVar = dataFile->add_var("lon", ncFloat, dataFile->get_dim("lon"))))
+               throw XMLIOUndefinedValueException("Impossible d'ajouter la variable de longitude !");
+
+            // Attribut de latitude.
+            hm["axis"]          = "Y" ;
+            hm["standard_name"] = "latitude" ;
+            hm["units"]         = "degrees_north";
+            hm["long_name"]     = "Latitude" ;
+            addStringAttributesToVar(latVar, hm);
+            hm.clear();
+
+            // Attribut de longitude.
+            hm["axis"]           = "X" ;
+            hm["standard_name"]  = "longitude" ;
+            hm["units"]          = "degrees_east";
+            hm["long_name"]      = "Longitude" ;
+            addStringAttributesToVar(lonVar, hm);
+            hm.clear();
+
+            // Attribut des autres coordonnÃ©es.
+            std::set<const CAxis*>::const_iterator it;
+            for ( it = saxis.begin() ; it != saxis.end(); it++ )
+            {
+               if (!(othvar = dataFile->add_var((*it)->getId().c_str(), ncFloat, dataFile->get_dim((*it)->getId().c_str()))))
+                  throw XMLIOUndefinedValueException("Impossible d'ajouter la variable "+ (*it)->getId() +" !");
+
+               hm["axis"] = "Z" ;
+               if ((*it)->name.hasValue())        hm["standard_name"] = (*it)->name ;
+               if ((*it)->unit.hasValue())        hm["units"]         = (*it)->unit;
+               if ((*it)->description.hasValue()) hm["long_name"]     = (*it)->description ;
+               addStringAttributesToVar(othvar, hm);
+               hm.clear();
+            }
+         }
+
+         virtual void setVars(void)
+         {
+            NcVar *var  = NULL;
+            Poco::HashMap<string, string> hm;
+            bool lonlat = false, wtime = true;
+            const std::vector<CField*>& enabledFields = getRelFile()->getEnabledFields();
+
+            std::vector<CField*>::const_iterator it;
+            for ( it = enabledFields.begin() ; it != enabledFields.end(); it++ )
+            {
+               const CField* field = (*it);
+               const CField* bfield = (*it)->getBaseObject();
+
+               lonlat = !field->getGrid()->_hasAxis();
+               if (field->operation.hasValue())
+                  if (string(field->operation).compare("once") == 0) wtime = false;
+
+               if (wtime)
+               {
+                  if (lonlat) // 2D spatio + temps
+                  {
+                     if (!(var = dataFile->add_var(bfield->getId().c_str(), ncFloat,
+                        dataFile->get_dim("time"), dataFile->get_dim("lon"), dataFile->get_dim("lat"))))
+                        throw XMLIOUndefinedValueException("Impossible d'ajouter le champ "+ field->getId() +" !");
+                  }
+                  else // 3D spatio + temps
+                  {
+                     if (!(var = dataFile->add_var(bfield->getId().c_str(), ncFloat,
+                        dataFile->get_dim("time"), dataFile->get_dim("lon"), dataFile->get_dim("lat"),
+                        dataFile->get_dim(field->getGrid()->getRelAxis()->getId().c_str()))))
+                        throw XMLIOUndefinedValueException("Impossible d'ajouter le champ "+ field->getId() +" !");
+                  }
+               }
+               else
+               {
+                  if (lonlat) // 2D spatio sans temps
+                  {
+                     if (!(var = dataFile->add_var(bfield->getId().c_str(), ncFloat,
+                        dataFile->get_dim("lon"), dataFile->get_dim("lat"))))
+                        throw XMLIOUndefinedValueException("Impossible d'ajouter le champ "+ field->getId() +" !");
+                  }
+                  else // 3D spatio sans temps
+                  {
+                     if (!(var = dataFile->add_var(bfield->getId().c_str(), ncFloat,
+                        dataFile->get_dim("lon"), dataFile->get_dim("lat"),
+                        dataFile->get_dim(field->getGrid()->getRelAxis()->getId().c_str()))))
+                        throw XMLIOUndefinedValueException("Impossible d'ajouter le champ "+ field->getId() +" !");
+                  }
+               }
+
+               if (field->name.hasValue())        hm["standard_name"] = field->name ;
+               if (field->unit.hasValue())        hm["units"]         = field->unit;
+               if (field->description.hasValue()) hm["long_name"]     = field->description ;
+               addStringAttributesToVar(var, hm);
+               hm.clear();
+            }
+         }
+
+      private :
+
+         void addStringAttributesToVar(NcVar * var, const Poco::HashMap<string, string>& attr)
+         {
+            Poco::HashMap<string, string>::ConstIterator it;
+            for ( it = attr.begin() ; it != attr.end(); it++ )
+               if (!var->add_att((*it).first.c_str(), (*it).second.c_str()))
+                  throw XMLIOUndefinedValueException("Impossible d'ajouter l'attribut' "+ (*it).first +" Ã  la variable "+ var->name() +" !");
+         }
+
+         NcFile* dataFile;
+
+   }; //class NetCDF4DataOutput
+
+}// namespace XMLIOSERVER
+
+#endif //__NETCDF4_DATA_OUTPUT__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_data_output.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_data_output.hpp	(revision 122)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_data_output.hpp	(revision 122)
@@ -0,0 +1,49 @@
+#ifndef __ABSTRACT_DATA_OUTPUT__
+#define __ABSTRACT_DATA_OUTPUT__
+
+namespace XMLIOSERVER
+{
+
+   class CFile;
+
+   class AbstractDataOutput
+   {
+      public :
+
+         const CFile* getRelFile(void) const { return (file); }
+
+         virtual void createFileAndHeader(void)
+         {
+            // CrÃ©ation du fichier de sortie.
+            initFile();
+            // DÃ©finition des dimensions.
+            setDims();
+            // DÃ©finition des coordonnÃ©es.
+            setCoords();
+            // DÃ©finitions des variables.
+            setVars();
+         }
+
+         virtual ~AbstractDataOutput()
+         { /* Ne rien faire de plus */ }
+
+      protected :
+
+         AbstractDataOutput(CFile* const _file): file(_file)
+         { /* Ne rien faire de plus */ }
+
+
+         virtual void initFile(void) = 0;
+         virtual void setDims(void) = 0;
+         virtual void setCoords(void) = 0;
+         virtual void setVars(void) = 0;
+
+      private :
+
+         CFile* const file;
+
+   }; //class AbstractDataOutput
+
+}// namespace XMLIOSERVER
+
+#endif //__ABSTRACT_DATA_OUTPUT__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_data_treatment.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_data_treatment.hpp	(revision 121)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_data_treatment.hpp	(revision 122)
@@ -36,15 +36,21 @@
          AbstractDataTreatment(Context* const _ctxt) : currentContext(_ctxt), enabledFiles()
          {
+            std::cout << "(Message temporaire) RÃ©solution des hÃ©ritages ..." << std::endl;
             // RÃ©solution des hÃ©ritages pour le context actuel (Context::ResolveInheritance() rÃ©soud les hÃ©ritages pour tous les contextes).
             solveAllInheritance();
 
             // Initialisation du vecteur 'enabledFiles' contenant la liste des fichiers Ã  sortir.
+            std::cout << "(Message temporaire) Initialisation du vecteur enabledFiles ..." << std::endl;
             findEnabledFiles();
 
             // Recherche des champs Ã  sortir (enable Ã  true + niveau de sortie correct) pour chaque fichier prÃ©cÃ©demment listÃ©.
+            std::cout << "(Message temporaire) Recherche des champs Ã  sortir ..." << std::endl;
             findAllEnabledFields();
 
             // RÃ©solution des rÃ©fÃ©rences de grilles pour chacun des champs.
+            std::cout << "(Message temporaire) RÃ©solution des rÃ©fÃ©rences de grilles ..." << std::endl;
             solveAllGridRef();
+
+            std::cout << "(Message temporaire) fin traitement sorties ..." << std::endl;
          }
 
@@ -59,5 +65,6 @@
          void solveAllGridRef(void)
          {
-
+            for (unsigned int i = 0; i < enabledFiles.size(); i++)
+               enabledFiles[i]->solveEFGridRef();
          }
 
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/attribut.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/attribut.hpp	(revision 121)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/attribut.hpp	(revision 122)
@@ -85,4 +85,30 @@
 
    template <>
+      ostream& Attribut<Array<double,1> >::print(ostream & o) const
+   {
+      if (_hasValue) o << " " << getName() << "=\"" << value(0);
+      for (int i = 1; i < value.size(); i++) { o << "," << value(i); }
+      o << "\"" ;
+      return (o) ;
+   }
+
+   template <>
+      void Attribut<Array<double,1> >::setFromString(const std::string& str)
+   {
+      istringstream iss(str) ;
+      char c = '\0'; double d = 0.;
+      vector<double> vect;
+      Array<double, 1> arr;
+
+      iss >> d; vect.push_back(d);
+      while(!iss.eof ()) { iss >> c >> d; vect.push_back(d); }
+
+      arr.resize(vect.size());
+      for (unsigned int i = 0; i < vect.size(); i++) arr(i) = vect[i];
+
+      this->setValue(arr);
+   }
+
+   template <>
       void Attribut<bool>::setFromString(const std::string& str)
    {
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/base_attribut.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/base_attribut.hpp	(revision 121)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/base_attribut.hpp	(revision 122)
@@ -17,5 +17,5 @@
          virtual ostream & print(ostream& o) const = 0  ;
 
-         friend ostream& operator <<(ostream& o,const BaseAttribut& Attr) { return (Attr.print(o)) ; }
+         friend ostream& operator <<(ostream& o,const BaseAttribut& attr) { return (attr.print(o)) ; }
 
          bool hasId(void) const { return (true); }
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/c_interface.cpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/c_interface.cpp	(revision 121)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/c_interface.cpp	(revision 122)
@@ -12,6 +12,7 @@
    try
    {
-      string file("/local/XMLIOSERVER_DEV/dev_rv/test/iodef_test.xml");
+      //string file("/local/XMLIOSERVER_DEV/dev_rv/test/iodef_test.xml");
       //string file("/local/XMLIOSERVER_DEV/dev_rv/iodef_test.xml");
+      string file("/local/XMLIOSERVER_DEV/dev_rv/test/iodef_simple_test.xml");
 
       ifstream istr( file.c_str() , ifstream::in );
@@ -28,9 +29,13 @@
       Context::SetCurrentContext("context1") ;
 
+      std::cout << " * ----------- <<<TOP>>> DÃ©but du traitement ----------- * " << std::endl;
       // On crÃ©e une instance de traitement de donnÃ©es dans le format NetCDF4.
       AbstractDataTreatment *dtreat = new NetCDF4DataTreatment(Context::GetObject("context1"));
 
       // Affichage de la liste des fichiers Ã  sortir (par id).
-      dtreat->printEnabledFilesId();
+      //dtreat->printEnabledFilesId();
+
+      NetCDF4DataOutput dop(CFile::GetObject("fichier1"));
+      dop.createFileAndHeader();
 
       // On Ã©crit l'arborescence rÃ©sultante du traitement sur la sortie.
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/context.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/context.hpp	(revision 121)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/context.hpp	(revision 122)
@@ -10,9 +10,9 @@
 
          Context(void) : ObjectTemplate<Context>(), ccalendar(NULL),
-            fieldDef(NULL), fileDef(NULL), axisDef(NULL), gridDef(NULL)
+            fieldDef(NULL), fileDef(NULL), axisDef(NULL), gridDef(NULL), domainDef(NULL)
          {/* Ne rien faire de plus */}
 
          Context(const string& _id) : ObjectTemplate<Context>(_id), ccalendar(NULL),
-            fieldDef(NULL), fileDef(NULL), axisDef(NULL), gridDef(NULL)
+            fieldDef(NULL), fileDef(NULL), axisDef(NULL), gridDef(NULL), domainDef(NULL)
          {/* Ne rien faire de plus */}
 
@@ -20,5 +20,5 @@
          {
             os << NIndent << "<?xml version=\"1.0\"?>" << std::endl;
-            os << NIndent << "<"<< Context::GetRootName() << ">" << std::endl;
+            os << NIndent << "<" << Context::GetRootName() << ">" << std::endl;
 
             Poco::HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
@@ -59,14 +59,17 @@
 
             // Changement de context pour les champs et groupes de champs.
-            FieldGroup::SetContext(id); CField::SetContext(id);
+            FieldGroup::SetContext(id);  CField::SetContext(id);
 
             // Changement de context pour les fichiers et groupes de fichiers.
-            FileGroup::SetContext(id);  CFile::SetContext(id);
+            FileGroup::SetContext(id);   CFile::SetContext(id);
 
             // Changement de context pour les grilles et groupes de grilles.
-            GridGroup::SetContext(id);  CGrid::SetContext(id);
+            GridGroup::SetContext(id);   CGrid::SetContext(id);
 
             // Changement de context pour les axes et groupes d'axes.
-            AxisGroup::SetContext(id);  CAxis::SetContext(id);
+            AxisGroup::SetContext(id);   CAxis::SetContext(id);
+
+            // Changement de context pour les domaines et groupes de domaines.
+            DomainGroup::SetContext(id); CDomain::SetContext(id);
          }
 
@@ -92,15 +95,22 @@
                   { WARNING("Le noeud de dÃ©finition possÃšde un identifiant, ce dernier ne sera pas pris en compte lors du traitement !"); }
 
-                  if (name.compare(FieldDefinition::GetDefName()) == 0) // Parsing pour la dÃ©finition des champs.
-                  { fieldDef = CreateInstanceAndParse<FieldDefinition>(_node, FieldDefinition::GetDefName().c_str()); continue; }
+                  if (attributes.end() != attributes.find("calendar_type") && attributes.end() != attributes.find("start_date"))
+                     setCalendar(attributes["calendar_type"], attributes["start_date"]);
 
-                  if (name.compare(FileDefinition::GetDefName()) == 0) // Parsing pour la dÃ©finition des fichiers.
-                  { fileDef  = CreateInstanceAndParse<FileDefinition >(_node, FileDefinition ::GetDefName().c_str()); continue; }
 
-                  if (name.compare(AxisDefinition::GetDefName()) == 0) // Parsing pour la dÃ©finition des axes.
-                  { axisDef  = CreateInstanceAndParse<AxisDefinition >(_node, AxisDefinition ::GetDefName().c_str()); continue; }
+                  if (name.compare(FieldDefinition::GetDefName())  == 0) // Parsing pour la dÃ©finition des champs.
+                  { fieldDef  = CreateInstanceAndParse<FieldDefinition >(_node, FieldDefinition::GetDefName().c_str()); continue; }
 
-                  if (name.compare(GridDefinition::GetDefName()) == 0) // Parsing pour la dÃ©finition des grilles.
-                  { gridDef  = CreateInstanceAndParse<GridDefinition >(_node, GridDefinition ::GetDefName().c_str()); continue; }
+                  if (name.compare(FileDefinition::GetDefName())  == 0) // Parsing pour la dÃ©finition des fichiers.
+                  { fileDef   = CreateInstanceAndParse<FileDefinition  >(_node, FileDefinition  ::GetDefName().c_str()); continue; }
+
+                  if (name.compare(AxisDefinition::GetDefName())  == 0) // Parsing pour la dÃ©finition des axes.
+                  { axisDef   = CreateInstanceAndParse<AxisDefinition  >(_node, AxisDefinition  ::GetDefName().c_str()); continue; }
+
+                  if (name.compare(GridDefinition::GetDefName())  == 0) // Parsing pour la dÃ©finition des grilles.
+                  { gridDef   = CreateInstanceAndParse<GridDefinition  >(_node, GridDefinition  ::GetDefName().c_str()); continue; }
+
+                  if (name.compare(DomainDefinition::GetDefName()) == 0) // Parsing pour la dÃ©finition des domaines.
+                  { domainDef = CreateInstanceAndParse<DomainDefinition>(_node, DomainDefinition::GetDefName().c_str()); continue; }
 
                   WARNING("La dÃ©finition est invalide, seuls les champs, grilles, axes et fichiers peuvent Ãªtre dÃ©finis !");
@@ -116,12 +126,13 @@
 
          virtual bool hasChild(void) const
-         { return ((fieldDef != NULL) or (fileDef != NULL)  or (axisDef != NULL) or (gridDef != NULL)); }
+         { return ((fieldDef != NULL) or (fileDef != NULL)  or (axisDef != NULL) or (gridDef != NULL) or (domainDef != NULL)); }
 
          virtual void printChild(ostream& out) const
          {
-            if(fieldDef != NULL) out << *(FieldGroup*)     fieldDef << std::endl;
-            if(fileDef  != NULL) out << *(FileGroup*)      fileDef  << std::endl;
-            if(axisDef  != NULL) out << *(AxisDefinition*) axisDef  << std::endl;
-            if(gridDef  != NULL) out << *(GridDefinition*) gridDef  << std::endl;
+            if(fieldDef  != NULL) out << *(FieldGroup*)       fieldDef  << std::endl;
+            if(fileDef   != NULL) out << *(FileGroup*)        fileDef   << std::endl;
+            if(axisDef   != NULL) out << *(AxisDefinition*)   axisDef   << std::endl;
+            if(gridDef   != NULL) out << *(GridDefinition*)   gridDef   << std::endl;
+            if(domainDef != NULL) out << *(DomainDefinition*) domainDef << std::endl;
          }
 
@@ -130,14 +141,16 @@
             if (_parent != 0) return;
             // RÃ©solution des hÃ©ritages descendants pour chacun des groupes de dÃ©finitions.
-            if(fieldDef != NULL) fieldDef->resolveDescInheritance();
-            if(fileDef  != NULL) fileDef ->resolveDescInheritance();
-            if(axisDef  != NULL) axisDef ->resolveDescInheritance();
-            if(gridDef  != NULL) gridDef ->resolveDescInheritance();
+            if(fieldDef  != NULL) fieldDef ->resolveDescInheritance();
+            if(fileDef   != NULL) fileDef  ->resolveDescInheritance();
+            if(axisDef   != NULL) axisDef  ->resolveDescInheritance();
+            if(gridDef   != NULL) gridDef  ->resolveDescInheritance();
+            if(domainDef != NULL) domainDef->resolveDescInheritance();
          }
 
-         FieldDefinition* getFieldDefinition(void) const { return (this->fieldDef); }
-         FileDefinition * getFileDefinition(void)  const { return (this->fileDef ); }
-         AxisDefinition * getAxisDefinition(void)  const { return (this->axisDef ); }
-         GridDefinition * getGridDefinition(void)  const { return (this->gridDef ); }
+         FieldDefinition  * getFieldDefinition(void)  const { return (this->fieldDef ); }
+         FileDefinition   * getFileDefinition(void)   const { return (this->fileDef  ); }
+         AxisDefinition   * getAxisDefinition(void)   const { return (this->axisDef  ); }
+         GridDefinition   * getGridDefinition(void)   const { return (this->gridDef  ); }
+         DomainDefinition * getDomainDefinition(void) const { return (this->domainDef); }
 
          AbstractCalendar * getCalendar(void) const { return (this->ccalendar ); }
@@ -163,6 +176,7 @@
          {
             // DÃ©sallocation dynamique de mÃ©moire pour chacun des groupes de dÃ©finition si nÃ©cessaire.
-            if(fieldDef != NULL) delete fieldDef; if(fileDef  != NULL) delete fileDef ;
-            if(axisDef  != NULL) delete axisDef ; if(gridDef  != NULL) delete gridDef ;
+            if(fieldDef  != NULL) delete fieldDef  ; if(fileDef  != NULL) delete fileDef ;
+            if(axisDef   != NULL) delete axisDef   ; if(gridDef  != NULL) delete gridDef ;
+            if(domainDef != NULL) delete domainDef ;
 
             // DÃ©sallocation dynamique de mÃ©moire pour le calendrier associÃ© au contexte courant si nÃ©cessaire.
@@ -178,4 +192,5 @@
          AxisDefinition*   axisDef;
          GridDefinition*   gridDef;
+         DomainDefinition* domainDef;
 
    }; //class Context
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/domain.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/domain.hpp	(revision 121)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/domain.hpp	(revision 122)
@@ -31,60 +31,61 @@
 
       // domaine global
-      if (!ni_glo.hasValue() || ni_glo<=0 ) ERROR("domaine global mal defini") ;
-      if (!nj_glo.hasValue() || nj_glo<=0 ) ERROR("domaine global mal defini") ;
+      if (!ni_glo.hasValue() || ni_glo<=0 ) throw XMLIOSERVER::XMLIOUndefinedValueException("domaine global mal defini") ;
+      if (!nj_glo.hasValue() || nj_glo<=0 ) throw XMLIOSERVER::XMLIOUndefinedValueException("domaine global mal defini") ;
 
       //domaine local en i
       if ( ni.hasValue() && ibegin.hasValue())
       {
-         if (iend.hasValue() && iend!=ibegin+ni-1) ERROR("domain local mal dÃ©fini 1") ;
-         iend=ibegin+ni-1 ;
+         if (iend.hasValue() && iend!=ibegin+ni-1) throw XMLIOSERVER::XMLIOUndefinedValueException("domain local mal dÃ©fini 1") ;
+         iend = ibegin + ni - 1 ;
       }
       else if (ni.hasValue() && iend.hasValue())
       {
-         if (ibegin!=ni-iend+1) ERROR("domain local mal dÃ©fini 2") ;
-         ibegin=ni-iend+1 ;
+         if (ibegin != ni-iend+1) throw XMLIOSERVER::XMLIOUndefinedValueException("domain local mal dÃ©fini 2") ;
+         ibegin = ni - iend + 1 ;
       }
       else if (ibegin.hasValue() && iend.hasValue())
       {
-         if (ni!=iend-ibegin-1) ERROR("domain local mal dÃ©fini 3") ;
-         ni=iend-ibegin-1 ;
+         if (ni!=iend-ibegin-1) throw XMLIOSERVER::XMLIOUndefinedValueException("domain local mal dÃ©fini 3") ;
+         ni = iend - ibegin - 1 ;
       }
-      else ERROR("domain local non dÃ©fini 4") ;
+      else throw XMLIOSERVER::XMLIOUndefinedValueException("domain local non dÃ©fini 4") ;
 
-      if (ni<0 || ibegin>iend || ibegin<1 || iend>ni_glo) ERROR("domain local mal dÃ©fini 5") ;
+      if (ni<0 || ibegin>iend || ibegin<1 || iend>ni_glo) throw XMLIOSERVER::XMLIOUndefinedValueException("domain local mal dÃ©fini 5") ;
 
       //domaine local en j
       if ( nj.hasValue() && jbegin.hasValue())
       {
-         if (jend.hasValue() && jend!=jbegin+nj-1) ERROR("domain local mal dÃ©fini 6") ;
-         jend=jbegin+nj-1 ;
+         if (jend.hasValue() && jend!=jbegin+nj-1) throw XMLIOSERVER::XMLIOUndefinedValueException("domain local mal dÃ©fini 6") ;
+         jend = jbegin + nj - 1 ;
       }
       else if (nj.hasValue() && jend.hasValue())
       {
-         if (jbegin!=nj-jend+1) ERROR("domain local mal dÃ©fini 7") ;
-         jbegin=nj-jend+1 ;
+         if (jbegin!=nj-jend+1) throw XMLIOSERVER::XMLIOUndefinedValueException("domain local mal dÃ©fini 7") ;
+         jbegin = nj - jend + 1 ;
       }
       else if (jbegin.hasValue() && jend.hasValue())
       {
-         if (nj!=jend-jbegin-1) ERROR("domain local mal dÃ©fini 8") ;
-         nj=jend-jbegin-1 ;
+         if (nj!=jend-jbegin-1) throw XMLIOSERVER::XMLIOUndefinedValueException("domain local mal dÃ©fini 8") ;
+         nj = jend - jbegin - 1 ;
       }
-      else ERROR("domain local non dÃ©fini 9") ;
+      else throw XMLIOSERVER::XMLIOUndefinedValueException("domain local non dÃ©fini 9") ;
 
-      if (nj<0 || jbegin>jend || jbegin<1 || jend>nj_glo) ERROR("domain local mal dÃ©fini 10") ;
+      if (nj<0 || jbegin>jend || jbegin<1 || jend>nj_glo) throw XMLIOSERVER::XMLIOUndefinedValueException("domain local mal dÃ©fini 10") ;
 
-      cout<<"mask ni "<<mask->extent(0)<<" nj "<<mask->extent(1)<<"  "<<mask<<endl ;
+      //cout<<"mask ni "<<mask->extent(0)<<" nj "<<mask->extent(1)<<"  "<<mask<<endl ;
       if (mask.hasValue())
-         if (mask->extent(0) != ni || mask->extent(1) != nj) ERROR("le champ mask n'a pas la mÃªme taille que le domaine local") ;
+         if (mask->extent(0) != ni || mask->extent(1) != nj)
+            throw XMLIOSERVER::XMLIOUndefinedValueException("le champ mask n'a pas la mÃªme taille que le domaine local") ;
 
       if (data_dim.hasValue())
       {
-         if (!(data_dim==1 || data_dim==2)) ERROR("dimension non comptatible (doit Ãªtre 1 ou 2)") ;
+         if (!(data_dim==1 || data_dim==2)) throw XMLIOSERVER::XMLIOUndefinedValueException("dimension non comptatible (doit Ãªtre 1 ou 2)") ;
       }
-      else ERROR("Dimension des donnÃ©e non dÃ©finie") ;
+      else throw XMLIOSERVER::XMLIOUndefinedValueException("Dimension des donnÃ©e non dÃ©finie") ;
 
       if (data_ni.hasValue())
       {
-         if (data_ni<=0) ERROR("Dimension des donnÃ©es nÃ©gative") ;
+         if (data_ni<=0) throw XMLIOSERVER::XMLIOUndefinedValueException("Dimension des donnÃ©es nÃ©gative") ;
       }
       else
@@ -98,5 +99,5 @@
       if (data_nj.hasValue())
       {
-         if (data_nj<=0) ERROR("Dimension des donnÃ©es nÃ©gative") ;
+         if (data_nj<=0) throw XMLIOSERVER::XMLIOUndefinedValueException("Dimension des donnÃ©es nÃ©gative") ;
       }
       else data_nj=(int) nj ;
@@ -105,5 +106,5 @@
 
       if (!mask.hasValue())
-      {
+      { // Si aucun masque n'est dÃ©fini, on en crÃ©e un nouveau qui valide l'intÃ©gralitÃ© du domaine.
          mask->resize(shape(ni,nj)) ;
          *mask=true ;
@@ -116,5 +117,6 @@
          if (data_n_index.hasValue())
          {
-            if (data_n_index!=data_i_index->extent(0)) ERROR("Dimension data_i_index incompatible avec data_n_index") ;
+            if (data_n_index!=data_i_index->extent(0))
+               throw XMLIOSERVER::XMLIOUndefinedValueException("Dimension data_i_index incompatible avec data_n_index") ;
          }
          else data_n_index=data_i_index->extent(0) ;
@@ -125,14 +127,15 @@
             {
                if (data_j_index->extent(0)!=data_i_index->extent(0))
-               ERROR("Dimension data_j_index incompatible avec data_i_index") ;
+                  throw XMLIOSERVER::XMLIOUndefinedValueException("Dimension data_j_index incompatible avec data_i_index") ;
             }
-            else ERROR("data_j_index non dÃ©fini") ;
+            else throw XMLIOSERVER::XMLIOUndefinedValueException("data_j_index non dÃ©fini") ;
          }
       }
       else
       {
-         if (data_n_index.hasValue() || (data_dim==2 && data_j_index.hasValue())) ERROR("data_i_index non dÃ©fini") ;
+         if (data_n_index.hasValue() || (data_dim==2 && data_j_index.hasValue()))
+            throw XMLIOSERVER::XMLIOUndefinedValueException("data_i_index non dÃ©fini") ;
       }
-      cout<<"data_n_index.hasValue() "<<data_n_index.hasValue()<<endl ;
+      //cout<<"data_n_index.hasValue() "<<data_n_index.hasValue()<<endl ;
       if (!data_n_index.hasValue())
       {
@@ -141,10 +144,10 @@
             int i ;
             data_n_index=*data_ni ;
-            cout <<"data_n_index "<<data_n_index<<"  "<<data_ni<<" "<<data_nj<<endl ;
+            //cout <<"data_n_index "<<data_n_index<<"  "<<data_ni<<" "<<data_nj<<endl ;
 
             data_i_index->resize(data_n_index) ;
 
             for (i=0;i<data_ni;i++) (*data_i_index)(i)=i ;
-            cout <<"data_i_index "<<*data_i_index<<endl ;
+            //cout <<"data_i_index "<<*data_i_index<<endl ;
          }
          else   // data_dim=2
@@ -154,17 +157,17 @@
             int count ;
 
-            data_n_index=data_ni*data_nj ;
-            data_i_index-> resize(data_n_index) ;
-            data_j_index-> resize(data_n_index) ;
-            for(count=0,i=0;i<data_ni;i++)
-               for(j=0;j<data_nj;j++)
+            data_n_index = data_ni * data_nj ;
+            data_i_index -> resize(data_n_index) ;
+            data_j_index -> resize(data_n_index) ;
+            for(count=0,i=0; i<data_ni;i++)
+               for(j=0; j<data_nj;j++)
                {
                   (*data_i_index)(count)=i ;
-                  cout<<count<<"  "<<(*data_i_index)(count)<<endl ;
+                 // cout<<count<<"  "<<(*data_i_index)(count)<<endl ;
                   (*data_j_index)(count)=j ;
-                  cout<<count<<"  "<<(*data_j_index)(count)<<endl ;
+                  //cout<<count<<"  "<<(*data_j_index)(count)<<endl ;
                   count++ ;
                }
-               cout<<data_ni<<" "<<data_nj<<" "<<data_n_index<<" "<<*data_i_index<<" "<<*data_j_index<<endl ;
+               //cout<<data_ni<<" "<<data_nj<<" "<<data_n_index<<" "<<*data_i_index<<" "<<*data_j_index<<endl ;
          }
       }
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/field.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/field.hpp	(revision 121)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/field.hpp	(revision 122)
@@ -18,9 +18,9 @@
          {/* Ne rien faire de plus */}
 
-         static string GetName(void) {return ("field"); }
+         static string GetName(void) { return ("field"); }
 
          inline void SolveGridRef(void) ;
 
-         CGrid* getGrid(void) const { return (grid); }
+         const CGrid* getGrid(void) const { return (grid); }
 
          virtual CField* getReference(void) const
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/field_gridrefsolver.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/field_gridrefsolver.hpp	(revision 121)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/field_gridrefsolver.hpp	(revision 122)
@@ -9,8 +9,8 @@
       CAxis* axis = NULL ;
 
-      if (domain_ref.hasValue())
+     if (domain_ref.hasValue())
       {
          if (CDomain::HasObject(domain_ref)) domain = CDomain::GetObject(domain_ref) ;
-         else ERROR("RÃ©fÃ©rence au domaine incorrecte") ;
+         else throw XMLIOSERVER::XMLIOUndefinedValueException("RÃ©fÃ©rence au domaine nommÃ© \'"+ (string)domain_ref +"\' incorrecte") ;
       }
 
@@ -18,11 +18,11 @@
       {
          if (CAxis::HasObject(axis_ref)) axis = CAxis::GetObject(axis_ref) ;
-         else ERROR("RÃ©fÃ©rence a l'axe incorrecte") ;
+         else throw XMLIOSERVER::XMLIOUndefinedValueException("RÃ©fÃ©rence Ã  l'axe nommÃ© \'"+ (string)axis_ref +"\' incorrecte") ;
       }
 
       if (grid_ref.hasValue())
       {
-         if (CGrid::HasObject(axis_ref)) grid = CGrid::GetObject(grid_ref) ;
-         else ERROR("RÃ©fÃ©rence a la grille incorrecte") ;
+         if (CGrid::HasObject(grid_ref)) grid = CGrid::GetObject(grid_ref) ;
+         else throw XMLIOSERVER::XMLIOUndefinedValueException("RÃ©fÃ©rence Ã  la grille nommÃ©e \'"+ (string)grid_ref +"\' incorrecte");
       }
 
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/file.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/file.hpp	(revision 121)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/file.hpp	(revision 122)
@@ -11,7 +11,7 @@
       public:
 
-         CFile(void) : ObjectTemplate<CFile>(), FileAttribut(), vfieldGroup(NULL), enabledFields()
+         CFile(void) : ObjectTemplate<CFile>(), FileAttribut(), vfieldGroup(NULL), enabledFields(), output(NULL)
          {/* Ne rien faire de plus */}
-         CFile(const string& _id) : ObjectTemplate<CFile>(_id), FileAttribut(), vfieldGroup(NULL), enabledFields()
+         CFile(const string& _id) : ObjectTemplate<CFile>(_id), FileAttribut(), vfieldGroup(NULL), enabledFields(), output(NULL)
          {/* Ne rien faire de plus */}
 
@@ -36,16 +36,56 @@
          }
 
+         const AbstractDataOutput* getDataOutput(void) const { return (output); }
+         void initializeDataOutput(AbstractDataOutput* _output)
+         {
+            if (_output != NULL) output = _output;
+            else throw XMLIOSERVER::XMLIOUndefinedValueException("Impossible d'initialiser la sortie de donnÃ©es pour le fichier nommÃ© '"+ getId() +"'.") ;
+         }
+
          void getAllFields(std::vector<CField*>& _allF) const {  if (vfieldGroup!=NULL) vfieldGroup->getAllChildren(_allF); }
+         const std::vector<CField*>& getEnabledFields(void) const { return (enabledFields); }
+
+         const std::set<const CGrid*> getEnabledGrids(void) const
+         {
+            std::set<const CGrid*> sgrid;
+            const std::vector<CField*> enabledFields = getEnabledFields();
+            std::vector<CField*>::const_iterator it;
+
+            for ( it = enabledFields.begin() ; it != enabledFields.end(); it++ )
+               sgrid.insert((*it)->getGrid());
+
+            return (sgrid);
+         }
+
+         const std::set<const CDomain*> getEnabledDomains(void) const
+         {
+            const std::set<const CGrid*> sgrid = getEnabledGrids();
+            std::set<const CDomain*> sdomain;
+
+            std::set<const CGrid*>::const_iterator it;
+
+            for ( it = sgrid.begin() ; it != sgrid.end(); it++ )
+               sdomain.insert((*it)->getRelDomain());
+
+            return (sdomain);
+         }
+
+         const std::set<const CAxis*> getEnabledAxis(void) const
+         {
+            const std::set<const CGrid*> sgrid = getEnabledGrids();
+            std::set<const CAxis*> saxis;
+
+            std::set<const CGrid*>::const_iterator it;
+
+            for ( it = sgrid.begin() ; it != sgrid.end(); it++ )
+               saxis.insert((*it)->getRelAxis());
+
+            return (saxis);
+         }
 
          virtual bool hasChild(void) const { return (vfieldGroup != NULL); }
+         virtual void printChild(ostream& out) const { out << *vfieldGroup << std::endl; }
 
-         virtual void printChild(ostream& out) const { out << *vfieldGroup << std::endl; }
-         /*{ // Sortie sans affichage des groupes.
-            std::vector<CField*> allF; getAllFields(allF);
-            for (unsigned int i = 0; i < allF.size(); i++)
-               out << *(allF[i]) << std::endl;
-         }*/
-
-         virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0)
+         virtual void resolveDescInheritance(const AttributRegistrar* const _parent = 0)
          { addAttributes(*_parent); if(vfieldGroup != NULL) vfieldGroup->resolveDescInheritance(); }
 
@@ -65,5 +105,5 @@
             getAllFields(enabledFields);
 
-            for ( it = enabledFields.begin() ; it < enabledFields.end(); it++ )
+            for ( it = enabledFields.begin() ; it != enabledFields.end(); it++ )
             {
                if ((*it)->enabled.hasValue()) // Si l'attribut 'enabled' est dÃ©fini ...
@@ -88,15 +128,24 @@
                   { enabledFields.erase(it); continue; }
                }
-
             }
          }
 
+         void solveEFGridRef(void)
+         {
+            for (unsigned int i = 0; i < enabledFields.size(); i++)
+               enabledFields[i]->SolveGridRef();
+         }
+
          virtual  ~CFile(void)
-         { if(vfieldGroup != NULL) delete vfieldGroup; }
+         {
+            if(vfieldGroup != NULL) delete vfieldGroup;
+            if(output != NULL) delete output;
+         }
 
       private :
 
          FieldGroup* vfieldGroup; // FieldGroup "virtuel"
-         std::vector<CField*> enabledFields;
+         std::vector<CField*> enabledFields; // Liste des champs Ã  sortie dans le fichier courant.
+         AbstractDataOutput* output; // Gestion de la sortie des donnÃ©es.
 
    }; // class CFile
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/grid.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/grid.hpp	(revision 121)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/grid.hpp	(revision 122)
@@ -13,8 +13,12 @@
          CGrid(void) : ObjectTemplate<CGrid>(), GridAttribut(), hasAxis(false), axis(NULL), domain(NULL)
          { /* Ne rien faire de plus */ }
+
          CGrid(const string& _id) : ObjectTemplate<CGrid>(_id), GridAttribut(), hasAxis(false), axis(NULL), domain(NULL)
          { /* Ne rien faire de plus */ }
 
          static string GetName(void) { return ("grid"); }
+
+         const CAxis* getRelAxis(void) const { return (axis); }
+         const CDomain* getRelDomain(void) const { return (domain); }
 
          inline void solveReference(void) ;
@@ -24,11 +28,13 @@
          inline void computeIndex(void);
 
-         inline void storeField(const Array<double,1>& field, Array<double,1>& stored);
-         inline void storeField(const Array<double,2>& field, Array<double,1>& stored);
-         inline void storeField(const Array<double,3>& field, Array<double,1>& stored);
-         inline void storeField(const double* const data, Array<double,1>& stored);
-
-         inline void outputField(const Array<double,1>& stored, Array<double,2>& outField);
-         inline void outputField(const Array<double,1>& stored, Array<double,3>& outField);
+         bool _hasAxis(void) const { return (hasAxis); }
+
+         inline void storeField(const Array<double, 1>& field, Array<double, 1>& stored);
+         inline void storeField(const Array<double, 2>& field, Array<double, 1>& stored);
+         inline void storeField(const Array<double, 3>& field, Array<double, 1>& stored);
+         inline void storeField(const double* const data, Array<double, 1>& stored);
+
+         inline void outputField(const Array<double,1>& stored, Array<double, 2>& outField);
+         inline void outputField(const Array<double,1>& stored, Array<double, 3>& outField);
 
          inline static CGrid* CreateObject(const CDomain* const a_domain, const CAxis* const a_axis);
@@ -77,4 +83,5 @@
    void CGrid::solveReference(void)
    {
+
       static bool isReferenceSolved = false;
       if (isReferenceSolved) return;
@@ -94,5 +101,5 @@
          if (CDomain::HasObject(domain_ref))
          {
-           domain=CDomain::GetObject(domain_ref) ;
+           domain = CDomain::GetObject(domain_ref) ;
            domain->check() ;
          }
@@ -115,4 +122,5 @@
    void CGrid::computeIndex(void)
    {
+
       int ni = domain->ni ;
       int nj = domain->nj ;
@@ -123,7 +131,7 @@
       int data_jbegin  = (data_dim == 2) ? (int)domain->data_jbegin : -1;
 
-      Array<int,1>& data_i_index =* domain->data_i_index ;
-      Array<int,1>& data_j_index =* domain->data_j_index ;
-      Array<bool,2>& mask =* domain->mask ;
+      Array<int, 1>& data_i_index =* domain->data_i_index ;
+      Array<int, 1>& data_j_index =* domain->data_j_index ;
+      Array<bool, 2>& mask =* domain->mask ;
       int i, j, l, n ;
       int count, indexCount ;
@@ -131,5 +139,5 @@
       for(indexCount=0, l=0; l<size ; l++)
       {
-         for(n=0, indexCount=0; n<data_n_index; n++)
+         for(n=0; n<data_n_index; n++)
          {
             if (data_dim == 1)
@@ -137,5 +145,5 @@
                i = (data_i_index(n) + data_ibegin) % ni ;
                j = (data_i_index(n) + data_ibegin) / ni ;
-               cout<<i<<" "<<j<<" "<<mask(i,j)<<endl ;
+               //cout<<i<<" "<<j<<" "<<mask(i,j)<<endl ;
             }
             else
@@ -143,5 +151,5 @@
                i = data_i_index(n) + data_ibegin ;
                j = data_j_index(n) + data_jbegin ;
-               cout<<i<<" "<<j<<" "<<mask(i,j)<<endl ;
+               //cout<<i<<" "<<j<<" "<<mask(i,j)<<endl ;
             }
 
@@ -157,5 +165,5 @@
       for(count=0, indexCount=0, l=0; l<size; l++)
       {
-         for(n=0; n<data_n_index; n++)
+         for(n=0; n<data_n_index; n++, count++)
          {
             if (data_dim == 1)
@@ -164,5 +172,5 @@
                j = (data_i_index(n) + data_ibegin) / ni ;
             }
-            else
+            else // (dat_dim == 2)
             {
                i = data_i_index(n) + data_ibegin ;
@@ -172,5 +180,5 @@
             if (i>=0 && i<ni && j>=0 && j<nj && mask(i,j))
             {
-               storeIndex(indexCount) = n ;
+               storeIndex(indexCount) = count ;
                out_l_index(indexCount) = l ;
                out_i_index(indexCount) = i ;
@@ -178,13 +186,25 @@
                indexCount++ ;
             }
-            count++ ;
          }
       }
 
+      /** Pour tests
+
       cout << "Out of CGrid::ComputeIndex" << endl ;
+
+      cout << "storeIndex : " << endl ;
       cout << storeIndex << endl ;
+
+      cout << "out_i_index : " << endl ;
       cout << out_i_index << endl ;
+
+      cout << "out_j_index : " << endl ;
       cout << out_j_index << endl ;
+
+      cout << "out_l_index : " << endl ;
       cout << out_l_index << endl ;
+
+      **/
+
    }
 
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/group_template.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/group_template.hpp	(revision 121)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/group_template.hpp	(revision 122)
@@ -30,5 +30,5 @@
          }
 
-         virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0)
+         virtual void resolveDescInheritance(const AttributRegistrar* const _parent = 0)
          {
             const vector<T*>&  childvect = childList.getVector();
@@ -112,5 +112,4 @@
 
       protected:
-
 
          template <class W> void _parse (XMLNode& _node, bool _withAttr = true)
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/logger.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/logger.hpp	(revision 121)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/logger.hpp	(revision 122)
@@ -3,13 +3,4 @@
 
 // EntÃªte Poco logging
-#include <Poco/Logger.h>
-#include <Poco/PatternFormatter.h>
-#include <Poco/FormattingChannel.h>
-#include <Poco/ConsoleChannel.h>
-#include <Poco/FileChannel.h>
-#include <Poco/Message.h>
-
-#include <Poco/AutoPtr.h>
-
 #include <csignal>
 
@@ -19,32 +10,20 @@
 #endif // __GNUC__
 
-// Classes utilisÃ©es issues de Poco
-using Poco::Logger;
-using Poco::PatternFormatter;
-using Poco::FormattingChannel;
-using Poco::ConsoleChannel;
-using Poco::FileChannel;
-using Poco::Message;
-
-using Poco::AutoPtr;
+using std::string;
 
 namespace XMLIOSERVER
 {
-   class ILogger
+   class ILogger : public std::ostringstream
    {
+      private :
+
+         ILogger()
+         { signal(SIGSEGV, SigHandler); }
+
+         static ILogger LOGGER;
+
       public :
 
-         ILogger()
-         {
-            // TODO CrÃ©er une sortie fichier.
-            AutoPtr<PatternFormatter> pf = new PatternFormatter("[%Y-%m-%d %H:%M:%S] %t");
-            AutoPtr<ConsoleChannel> cc = new ConsoleChannel();
-            AutoPtr<FormattingChannel> pFCConsole = new FormattingChannel(pf);
-            pFCConsole->setChannel(cc);
-            pFCConsole->open();
-            Logger::create("ConsoleLogger", pFCConsole, Message::PRIO_INFORMATION);
-
-            signal(SIGSEGV, SigHandler);
-         }
+         static ILogger& GetLogger(void) { return (ILogger::LOGGER); }
 
          static void ShowBTrace(std::ostream& out = std::clog)
@@ -84,14 +63,11 @@
          }
 
-
-         static Logger & GetConsoleLogger(void) {return (Logger::get("ConsoleLogger"));}
-
          ~ILogger(void)
-         { /* Ne rien faire de plus */ }
+         { std::cout << str() << std::endl; }
 
    }; // class XMLIOLogger
 
    // Initialisation de la classe de Logging
-   ILogger LOGGER;
+   ILogger ILogger::LOGGER;
 
    /////////////////////////////////////////////////////////////////////
@@ -113,7 +89,7 @@
 } // namespace XMLIOSERVER
 
-#define   ERROR(MSG)   (XMLIOSERVER::ILogger::GetConsoleLogger().error(MSG))
-#define   WARNING(MSG) (XMLIOSERVER::ILogger::GetConsoleLogger().warning(MSG))
-#define   INFO(MSG)    (XMLIOSERVER::ILogger::GetConsoleLogger().information(MSG))
+#define   ERROR(MSG)   (ILogger::GetLogger() << __FILE__ << ":" << __LINE__ << ": error : "   << MSG << std::endl)
+#define   WARNING(MSG) (ILogger::GetLogger() << __FILE__ << ":" << __LINE__ << ": warning : " << MSG << std::endl)
+#define   INFO(MSG)    (ILogger::GetLogger() << __FILE__ << ":" << __LINE__ << ": info : "    << MSG << std::endl)
 // A complÃ©ter.
 
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/object_template.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/object_template.hpp	(revision 121)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/object_template.hpp	(revision 122)
@@ -42,4 +42,6 @@
 
          string getName(void) const {return (T::GetName()); }
+
+         const T* getBaseObject(void) const { return (baseObject); }
 
          virtual T* getReference(void) const { return (NULL); }
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio.hpp	(revision 121)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio.hpp	(revision 122)
@@ -12,4 +12,5 @@
 #include <iostream>
 #include <fstream>
+#include <sstream>
 
 /// EntÃªtes Poco ///
@@ -34,6 +35,6 @@
 
 /// EntÃªtes crÃ©Ã©s dans le cadre du projet XMLIOSERVER. ///
+#include "logger.hpp"
 #include "exception.hpp"
-#include "logger.hpp"
 #include "container.hpp"
 #include "abstract_object.hpp"
@@ -45,4 +46,7 @@
 #include "calendar.hpp"
 #include "calendar_utils.hpp"
+
+// Gestion de l'Ã©criture des donnÃ©es
+#include "abstract_data_output.hpp"
 
 #include "xml_node.hpp"
@@ -61,8 +65,8 @@
 // Prise en charge des champs, fichiers, axes, domaines, grilles ...
 #include "field.hpp"
-#include "file.hpp"
 #include "axis.hpp"
 #include "domain.hpp"
 #include "grid.hpp"
+#include "file.hpp"
 
 #include "field_gridrefsolver.hpp"
@@ -71,4 +75,9 @@
 #include "xml_parser.hpp"
 
+
+// Gestion de l'Ã©criture des donnÃ©es NetCDF
+#include "NetCDF4_data_output.hpp"
+
+// Traitement des donnÃ©es
 #include "abstract_data_treatment.hpp"
 #include "NetCDF4_data_treatment.hpp"
