Index: XMLIO_V2/dev/dev_rv/src/XMLIO/NetCDF4_data_treatment.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/NetCDF4_data_treatment.hpp	(revision 120)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/NetCDF4_data_treatment.hpp	(revision 120)
@@ -0,0 +1,23 @@
+#ifndef __NETCDF4_DATA_TREATMENT__
+#define __NETCDF4_DATA_TREATMENT__
+
+namespace XMLIOSERVER
+{
+   class NetCDF4DataTreatment : public AbstractDataTreatment
+   {
+      public :
+
+         NetCDF4DataTreatment(Context* const _ctxt) : AbstractDataTreatment(_ctxt)
+         { /* Ne rien faire de plus */ }
+
+         virtual ~NetCDF4DataTreatment()
+         { /* Ne rien faire de plus */ }
+
+      protected :
+      private :
+
+   }; //class NetCDF4DataTreatment
+
+}// namespace XMLIOSERVER
+
+#endif //__NETCDF4_DATA_TREATMENT__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_calendar.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_calendar.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_calendar.hpp	(revision 120)
@@ -31,5 +31,4 @@
             for(_d0.setMonth(1); _d0.getMonth() < d.getMonth(); _d0.setMonth(_d0.getMonth()+1))
                nbday += getMonthLength(_d0);
-            //std::cout << "nombre de jours : " << nbday << std::endl;
             return ((((nbday + d.getDay()) * getDayLength() + d.getHour())
                      * getHourLength() + d.getMinute()) * getMinuteLength() + d.getSecond());
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_data_treatment.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_data_treatment.hpp	(revision 120)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_data_treatment.hpp	(revision 120)
@@ -0,0 +1,92 @@
+#ifndef __ABSTRACT_DATA_TREATMENT__
+#define __ABSTRACT_DATA_TREATMENT__
+
+namespace XMLIOSERVER
+{
+   class AbstractDataTreatment
+   {
+      public :
+
+         const Context* getCurrentContext(void) const
+         { return (currentContext); }
+
+         const std::vector<CFile*> getEnabledFiles(void) const
+         { return (enabledFiles); }
+
+         void getEnabledFilesId(std::vector<std::string>& _vect) const
+         {
+            for (unsigned int i = 0; i < enabledFiles.size(); i++)
+               _vect.push_back(enabledFiles[i]->getId());
+         }
+
+         void printEnabledFilesId(std::ostream& out = std::clog) const
+         {
+            out << "Liste des fichiers Ã  sortir dans le contexte analysÃ© nommÃ© \"" << currentContext->getId() << "\"" << std::endl;
+            std::vector<std::string> __vect; getEnabledFilesId(__vect);
+            for (unsigned int i = 0; i < __vect.size(); i++)
+               out << __vect[i] << "|";
+            out << "fin" << std::endl;
+         }
+
+         virtual ~AbstractDataTreatment()
+         { /* Ne rien faire de plus */ }
+
+      protected :
+
+         AbstractDataTreatment(Context* const _ctxt) : currentContext(_ctxt), enabledFiles()
+         {
+            // 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.
+            findEnabledFiles();
+
+            // Recherche des champs Ã  sortir (enable Ã  true + niveau de sortie correct) pour chaque fichier prÃ©cÃ©demment listÃ©.
+            findAllEnabledFields();
+
+            // RÃ©solution des rÃ©fÃ©rences de grilles pour chacun des champs.
+            solveAllGridRef();
+         }
+
+      private :
+
+         void findAllEnabledFields(void)// <- ajouter attribut par dÃ©fault ici.
+         {
+            for (unsigned int i = 0; i < enabledFiles.size(); i++)
+               enabledFiles[i]->findEnabledFields();
+         }
+
+         void solveAllGridRef(void)
+         {
+
+         }
+
+         void solveAllInheritance(void) const
+         {
+            // RÃ©solution des hÃ©ritages descendants (cÃ d des hÃ©ritages de groupes) pour chacun des contextes.
+            currentContext->resolveDescInheritance();
+
+            // RÃ©solution des hÃ©ritages par rÃ©fÃ©rence au niveau des fichiers.
+            const std::vector<CFile*>& allFiles = CFile::GetCurrentListObject().getVector();
+            for (unsigned int i = 0; i < allFiles.size(); i++) allFiles[i]->resolveFieldRefInheritance();
+         }
+
+         void findEnabledFiles(void)
+         {
+            const std::vector<CFile*>& allFiles = CFile::GetCurrentListObject().getVector();
+            for (unsigned int i = 0; i < allFiles.size(); i++)
+               if (allFiles[i]->enabled.hasValue()) // Si l'attribut 'enabled' est dÃ©fini.
+                  if ((bool)allFiles[i]->enabled) // Si l'attribut 'enabled' est fixÃ© Ã  vrai.
+                     enabledFiles.push_back ( allFiles[i] );
+            if (enabledFiles.size() == 0)
+               WARNING("Aucun fichier ne va Ãªtre sorti dans le contexte nommÃ© \"" + currentContext->getId() + "\" !");
+         }
+
+         Context* const currentContext;
+         std::vector<CFile*> enabledFiles; // Liste des fichiers Ã  crÃ©er dans un context donnÃ©.
+
+   }; //class AbstractDataTreatment
+
+}// namespace XMLIOSERVER
+
+#endif //__ABSTRACT_DATA_TREATMENT__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_object.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_object.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_object.hpp	(revision 120)
@@ -1,58 +1,51 @@
 #ifndef __XMLIO_OBJECT__
-#define __XMLIO_OBJECT__ 
-
-// Classes utilisÃ©es issues de la STL
-using std::pair;
-using std::string;
-using std::ostream;
-using std::ostringstream;
-
-// Classes XMLIOSERVER
-using XMLIOSERVER::XMLIOException;
-using XMLIOSERVER::XMLIOUndefinedValueException;
+#define __XMLIO_OBJECT__
 
 namespace XMLIOSERVER
 {
-   class AbstractObject 
+   class AbstractObject
    {
       public :
-      
+
+         const std::string& getId(void) const throw (XMLIOUndefinedValueException)
+         {
+            if (!hasId()) // Si l'identifiant de l'objet n'est pas dÃ©fini.
+               throw XMLIOSERVER::XMLIOUndefinedValueException("Appel de la mÃ©thode AbstractObject::getId invalide.");
+            return (id);
+         }
+
+         bool hasId(void) const { return(IdDefined); }
+         void resetId(void) { IdDefined = false ;}
+         void setId(const std::string& _id) { id = _id ; IdDefined = true ;}
+
+         bool operator==(const AbstractObject& other) const
+         {
+            // Si l'un ou l'autre des objets n'a pas d'identifiant, les objets ne sont pas "Ã©gaux".
+            if(!this->hasId() || !other.hasId()) return false;
+            return (id.compare(other.id) == 0);
+         }
+
+         std::string printId(void) const
+         { if(hasId()) return (" id=\""+getId()+"\""); return (""); }
+
+         virtual ~AbstractObject(void)
+         {/* Ne rien faire de plus */}
+
+      protected :
+
          AbstractObject(void) : IdDefined(false)
          {/* Ne rien faire de plus */}
-         
-         AbstractObject(const string& _id) : id(_id), IdDefined(true)
-         {/* Ne rien faire de plus */}      
-   
-         const string& getId(void) const throw (XMLIOUndefinedValueException)
-         { if (!IdDefined) throw XMLIOUndefinedValueException("Appel de la mÃ©thode AbstractObject::getId invalide."); return (id); }   
-         
-         bool hasId(void) const { return(IdDefined); }
-         void resetId(void) { IdDefined = false ;}
-         void setId(const string& _id) { id = _id ; IdDefined = true ;}
-         
-         bool operator==(const AbstractObject& other)
-         {
-            // Si l'un ou l'autre des objets n'a pas d'identifiant, les objets ne sont pas "Ã©gaux".
-            if(!this->hasId() or !other.hasId()) return false;
-            return (id.compare(other.id) == 0);
-         }
-         
-         string printId(void) const
-         { if(hasId()) return (" id=\""+getId()+"\""); return (""); }
-         
-         virtual ~AbstractObject(void)
+
+         AbstractObject(const std::string& _id) : id(_id), IdDefined(true)
          {/* Ne rien faire de plus */}
-      
-      protected :
 
-            
       private :
-      
-         string id ;
+
+         std::string id ;
          bool IdDefined ;
-      
+
    };// class AbstractObject
-   
+
 }// namespace XMLIOSERVER
 
-#endif // __XMLIO_OBJECT__   
+#endif // __XMLIO_OBJECT__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/attribut.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/attribut.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/attribut.hpp	(revision 120)
@@ -7,62 +7,40 @@
 using XMLIOSERVER::XMLIOUndefinedValueException;
 using std::ostringstream;
+using namespace blitz ;
 
 namespace XMLIOSERVER
 {
-   class IStringStream_alt
-   {
-      public :
-         IStringStream_alt(const std::string& str) : iss(str)
-         { /* Ne rien faire de plus */}
-
-         istream& operator>> (std::string& s)
-         {s.assign(this->iss.str()); return (this->iss);}
-         istream& operator>> (int& s) { return (iss>>s); }
-         istream& operator>> (bool& s)
-         {
-            if(!this->iss.str().compare(string(".TRUE."))) s =  true;
-            else s = false;
-            return (this->iss);
-         }
-
-      private :
-         istringstream iss;
-
-   }; // class IStringStream_alt
-
-
    template <class Ctype>
       class Attribut : public BaseAttribut
    {
       public :
-
          operator Ctype() const
          {
-            if (!hasValue) throw XMLIOUndefinedValueException("L'attribut \"" + this->getName() + "\" est invalide !");
+            if (!_hasValue) throw XMLIOUndefinedValueException("L'attribut \"" + this->getName() + "\" est invalide !");
             return (value) ;
          }
 
-         virtual bool _hasValue() const { return (hasValue); }
+         Ctype* operator ->() { return (&value) ; }
+         Ctype& operator *() { return (value) ; }
 
-      protected :
+         virtual bool hasValue() const { return (_hasValue); }
+         virtual const char * getType(void) const = 0;
 
-         Attribut(void) : hasValue(false) {} ;
-         Attribut(const Ctype& value_) : hasValue(true), value(value_) {} ;
+         Attribut(void) : _hasValue(false) {} ;
+         Attribut(const Ctype& value_) : _hasValue(true), value(value_) {} ;
 
-         Attribut(const Attribut& attr) : hasValue(attr.hasValue)
-         {  if (hasValue) value=attr.value ; }
+         Attribut(const Attribut& attr) : _hasValue(attr._hasValue)
+         {  if (_hasValue) value = attr.value ; }
 
          Attribut& operator = (const Attribut & attr)
          {
-            hasValue=attr.hasValue ;
-            if (hasValue) value=attr.value ;
-            return *this ;
+            _hasValue = attr._hasValue ;
+            if (_hasValue) setValue(attr.value) ;
+            return (*this) ;
          }
 
-         virtual const char * getType(void) const = 0;
-
-         virtual void setFromString(const std::string str)
+         virtual void setFromString(const std::string& str)
          {
-            IStringStream_alt iss(str); Ctype val;
+            istringstream iss(str); Ctype val;
             iss >> val;
             this->setValue(val);
@@ -70,27 +48,53 @@
 
          virtual void assignValue(const BaseAttribut* _ba)
-         { value = ((Attribut*)_ba) -> value; hasValue = true; }
+         { value = ((Attribut*)_ba) -> value; _hasValue = true; }
 
          virtual ostream& print(ostream & o) const
-         { if (hasValue) o << " " << getName() << "=\"" << boolalpha << value << "\"" ; return o ; }
+         { if (_hasValue) o << " " << getName() << "=\"" << boolalpha << value << "\"" ; return o ; }
 
          virtual void setValue(const Ctype & value_)
-         { hasValue=true ; value=value_ ; }
+         { _hasValue = true ; value = value_ ;}
 
          virtual void getValue(Ctype & value_) const
          {
-            if (!hasValue) throw XMLIOUndefinedValueException("L'attribut \"" + this->getName() + "\" est invalide !");
-            value_=value ;
+            if (!_hasValue) throw XMLIOUndefinedValueException("L'attribut \"" + this->getName() + "\" est invalide !");
+            value_ = value ;
          }
 
       private :
 
-         bool hasValue ;
+         bool _hasValue ;
          Ctype value ;
 
    }; // class Attribut
+
+#define SET_ARRAY_DIM(type,dim)                                              \
+   template<>                                                                \
+      void Attribut<Array<type,dim> >::setValue (const Array<type,dim>& val) \
+   { _hasValue = true ; value.resize(val.shape()); value = val ; }
+
+#define SET_ARRAY_TYPE(type) \
+   SET_ARRAY_DIM(type,1)     \
+   SET_ARRAY_DIM(type,2)     \
+   SET_ARRAY_DIM(type,3)     \
+   SET_ARRAY_DIM(type,4)
+
+   SET_ARRAY_TYPE(double)
+   SET_ARRAY_TYPE(int)
+   SET_ARRAY_TYPE(bool)
+
+   template <>
+      void Attribut<bool>::setFromString(const std::string& str)
+   {
+      istringstream iss(str) ;
+      bool val = (! iss.str().compare(string(".TRUE."))) ? true : false;
+      this->setValue(val);
+   }
+
+   template <>
+      void Attribut<string>::setFromString(const std::string& str)
+   { this->setValue(str); }
+
 } // namespace XMLIOSERVER
 
 #endif //__ATTRIBUT__
-
-
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/attribut_registrar.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/attribut_registrar.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/attribut_registrar.hpp	(revision 120)
@@ -45,5 +45,5 @@
             for(unsigned int i = 0; i < _lattr.getVectorSize(); i++)
             {
-               if(_lattr.getVector()[i]->_hasValue() or !_pattr.getVector()[i]->_hasValue()) continue;
+               if(_lattr.getVector()[i]->hasValue() or !_pattr.getVector()[i]->hasValue()) continue;
                _lattr.getVector()[i]->assignValue(_pattr.getVector()[i]);
             }
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/axis_attribut.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/axis_attribut.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/axis_attribut.hpp	(revision 120)
@@ -1,4 +1,6 @@
 #ifndef __AXIS_ATTRIBUT__
 #define __AXIS_ATTRIBUT__
+
+using namespace blitz ;
 
 namespace XMLIOSERVER
@@ -11,5 +13,6 @@
          DECLARE_ATTR(description, string) ;
          DECLARE_ATTR(unit, string) ;
-         DECLARE_ATTR(size_axis, int) ;
+         DECLARE_ATTR(size, int) ;
+         DECLARE_ATTR(value, Array(double,1)) ;
 
          AxisAttribut(void) : AttributRegistrar()
@@ -23,5 +26,6 @@
             RegisterAttribut(&description) ;
             RegisterAttribut(&unit) ;
-            RegisterAttribut(&size_axis) ;
+            RegisterAttribut(&size) ;
+            RegisterAttribut(&value) ;
          }
 
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/base_attribut.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/base_attribut.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/base_attribut.hpp	(revision 120)
@@ -24,6 +24,6 @@
 
          virtual void assignValue(const BaseAttribut*) = 0;
-         virtual void setFromString(const std::string str) = 0;
-         virtual bool _hasValue() const = 0;
+         virtual void setFromString(const std::string&) = 0;
+         virtual bool hasValue() const = 0;
 
 #define  SETTER_AND_GETTER(TYPE) \
@@ -32,8 +32,10 @@
          virtual void setValue(const Array<TYPE,2>& value)  { error_set() ; }\
          virtual void setValue(const Array<TYPE,3>& value)  { error_set() ; }\
+         virtual void setValue(const Array<TYPE,4>& value)  { error_set() ; }\
          virtual void getValue(TYPE & value)         const  { error_get() ; }\
          virtual void getValue(Array<TYPE,1>& value) const  { error_get() ; }\
          virtual void getValue(Array<TYPE,2>& value) const  { error_get() ; }\
-         virtual void getValue(Array<TYPE,3>& value) const  { error_get() ; }
+         virtual void getValue(Array<TYPE,3>& value) const  { error_get() ; }\
+         virtual void getValue(Array<TYPE,4>& value) const  { error_get() ; }
 
          SETTER_AND_GETTER(int)
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/c_interface.cpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/c_interface.cpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/c_interface.cpp	(revision 120)
@@ -12,5 +12,5 @@
    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");
 
@@ -23,7 +23,35 @@
 
       // On rÃ©soud les hÃ©ritages descendants ainsi que les hÃ©ritages par rÃ©fÃ©rence.
-      Context::ResolveInheritance();*/
+      //Context::ResolveInheritance(); // Plus nÃ©cessaire!!
 
+      // On se place dans le contexte 'context1'.
+      Context::SetCurrentContext("context1") ;
+
+      // 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();
+
+      // On Ã©crit l'arborescence rÃ©sultante du traitement sur la sortie.
+      //Context::ShowTree(std::clog);
+
+      delete dtreat;
+
+   }
+   catch(const Exception &exc)
+   {  // Pour tout type d'exceptions, on note les informations sur la sortie paramÃ©trÃ©e.
+      ERROR(exc.displayText());
+      // On retourne le code d'erreur en fin d'application pour traitements Ã©ventuels.
+      // return (exc.code());
+   }
+
+// return (0);
+}
+
+
+      /* CODE TEST POUR CALENDRIER
       AbstractCalendar* calendar = new GregorianCalendar();
+
       Date dd (*calendar, 2000, 05, 03, 00, 00, 00) ;
       Date ddd(*calendar, 2030, 11, 02, 10, 33, 40) ;
@@ -61,16 +89,4 @@
 
       delete calendar;
+      */
 
-      //On Ã©crit l'arborescence rÃ©sultante du traitement sur la sortie.
-      //Context::ShowTree(std::clog);
-
-   }
-   catch(const Exception &exc)
-   {  // Pour tout type d'exceptions, on note les informations sur la sortie paramÃ©trÃ©e.
-      ERROR(exc.displayText());
-      // On retourne le code d'erreur en fin d'application pour traitements Ã©ventuels.
-      // return (exc.code());
-   }
-
-// return (0);
-}
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/calendar.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/calendar.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/calendar.hpp	(revision 120)
@@ -9,18 +9,18 @@
          JulianCalendar() : AbstractCalendar("Julian")
          {/* Ne rien faire de plus */}
-         JulianCalendar(const string& dateStr) : AbstractCalendar("Julian", dateStr)
+         JulianCalendar(const string& _dateStr) : AbstractCalendar("Julian", _dateStr)
          {/* Ne rien faire de plus */}
 
-         virtual int getYearTotalLength(const Date& d) const
+         virtual int getYearTotalLength(const Date& _d) const
          { // Retourne la durÃ©e d'une annÃ©e en seconde.
-            if (d.getYear()%4 == 0) return (366 * 86400);
+            if (_d.getYear()%4 == 0) return (366 * 86400);
             return (365 * 86400);
          }
 
-         virtual int getMonthLength(const Date& d) const
+         virtual int getMonthLength(const Date& _d) const
          { // Retourne la durÃ©e du mois en jour.
-            if (d.getMonth() == 2)
-            { if (d.getYear()%4 == 0) return 29; return 28; }
-            return AbstractCalendar::getMonthLength(d);
+            if (_d.getMonth() == 2)
+            { if (_d.getYear()%4 == 0) return 29; return 28; }
+            return (AbstractCalendar::getMonthLength(_d));
          }
 
@@ -49,8 +49,8 @@
             { // Traitement du cas particulier en FÃ©vrier.
                if ((d.getYear() % 4 == 0) && (d.getYear() % 100 != 0 || d.getYear() % 400 == 0))
-                  return 29;
-               return 28;
+                  return (29);
+               return (28);
             }
-            return AbstractCalendar::getMonthLength(d);
+            return (AbstractCalendar::getMonthLength(d));
          }
 
@@ -82,5 +82,5 @@
 
          virtual int getMonthLength(const Date& d) const
-         { if (d.getMonth() == 2) return (29); return AbstractCalendar::getMonthLength(d); }
+         { if (d.getMonth() == 2) return (29); return (AbstractCalendar::getMonthLength(d)); }
 
          virtual int getYearTotalLength(const Date& d) const { return (366 * 86400); }
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/container.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/container.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/container.hpp	(revision 120)
@@ -1,8 +1,4 @@
 #ifndef __XMLIO_CONTAINER__
 #define __XMLIO_CONTAINER__
-
-// Classes utilisÃ©es issues de Poco
-using Poco::HashMap;
-using Poco::Hash;
 
 // Classes utilisÃ©es issues de la STL
@@ -12,22 +8,16 @@
 using std::ostream;
 
-// Classes XMLIOSERVER
-using XMLIOSERVER::XMLIOUndefinedValueException;
-
 namespace XMLIOSERVER
 {
-   template<class Key, class Mapped, class HashFunc = Hash<Key> >
+   template<class Key, class Mapped, class HashFunc = Poco::Hash<Key> >
       class ExHashMap
-         : private HashMap<Key, Mapped*, Hash<Key> >
+         : private Poco::HashMap<Key, Mapped*, Poco::Hash<Key> >
    {
       public :
-
-         ExHashMap() :  HashMap<Key, Mapped*, Hash<Key> >(), _elemList()
-         {/* Ne rien faire de plus */}
 
          Mapped* operator[] (const Key& kval) throw (XMLIOUndefinedValueException)
          {
             if(!hasMappedValue(kval))
-               throw XMLIOUndefinedValueException("Appel de la mÃ©thode ExHashMap::operator["+kval+"] invalide.");
+               throw XMLIOSERVER::XMLIOUndefinedValueException("Appel de la mÃ©thode ExHashMap::operator["+kval+"] invalide.");
             return (find(kval)->second);
          }
@@ -44,4 +34,7 @@
 
       protected :
+
+         ExHashMap() :  Poco::HashMap<Key, Mapped*, Poco::Hash<Key> >(), _elemList()
+         {/* Ne rien faire de plus */}
 
          bool addValue(const Key& kval, Mapped* element)
@@ -77,18 +70,18 @@
    template<class Mapped>
       class StrHashMap
-         : public ExHashMap<string, Mapped, Hash<string> >
+         : public ExHashMap<string, Mapped, Poco::Hash<string> >
    {
       public :
 
-         StrHashMap() :  ExHashMap<string, Mapped, Hash<string> >()
+         StrHashMap() :  ExHashMap<string, Mapped, Poco::Hash<string> >()
          {/* Ne rien faire de plus */}
 
          bool addObject(Mapped* element)
-         { if(element->hasId()) return(addValue(element->getId(), element));   return(addValue(element)); }
+         { if(element->hasId()) return(addValue(element->getId(), element)); return(addValue(element)); }
 
          bool removeObject(const string& kval)
          {
-            if(!ExHashMap<string, Mapped, Hash<string> >::hasMappedValue(kval)) return (false);
-            ExHashMap<string, Mapped, Hash<string> >::removeValue(kval); return (true);
+            if(!ExHashMap<string, Mapped, Poco::Hash<string> >::hasMappedValue(kval)) return (false);
+            ExHashMap<string, Mapped, Poco::Hash<string> >::removeValue(kval); return (true);
          }
 
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/context.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/context.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/context.hpp	(revision 120)
@@ -22,6 +22,6 @@
             os << NIndent << "<"<< Context::GetRootName() << ">" << std::endl;
 
-            HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
-            for (HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
+            Poco::HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
+            for (Poco::HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
                // On sort chacun des contextes successivement.
             { Context::SetCurrentContext((*it).first); os << *((*it).second)[(*it).first] << std::endl; }
@@ -32,13 +32,14 @@
          static void FreeMemory(void)
          {
-            HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
-            for (HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
+            Poco::HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
+            for (Poco::HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
             { Context::SetCurrentContext((*it).first); delete ((*it).second)[(*it).first]; }
          }
 
+         // Ne plus utiliser, disponible dans les classe treatment.
          static void ResolveInheritance(void)
          {
-            HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
-            for (HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
+            Poco::HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
+            for (Poco::HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
             {
                // RÃ©solution des hÃ©ritages descendants (cÃ d des hÃ©ritages de groupes) pour chacun des contextes.
@@ -58,18 +59,14 @@
 
             // 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);
          }
 
@@ -107,5 +104,5 @@
                   { gridDef  = CreateInstanceAndParse<GridDefinition >(_node, GridDefinition ::GetDefName().c_str()); continue; }
 
-                  WARNING("La dÃ©finition est invalide, seules les champs, grilles, axes et fichiers peuvent Ãªtre dÃ©finis !");
+                  WARNING("La dÃ©finition est invalide, seuls les champs, grilles, axes et fichiers peuvent Ãªtre dÃ©finis !");
 
                } while (_node.goToNextElement());
@@ -115,6 +112,6 @@
          }
 
-         static string GetName(void) {return ("context"); }
-         static string GetRootName(void) {return ("simulation"); }
+         static string GetName(void)     { return ("context"); }
+         static string GetRootName(void) { return ("simulation"); }
 
          virtual bool hasChild(void) const
@@ -129,5 +126,5 @@
          }
 
-         virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0)
+         virtual void resolveDescInheritance(const AttributRegistrar* const _parent = 0)
          {
             if (_parent != 0) return;
@@ -145,20 +142,20 @@
 
          AbstractCalendar * getCalendar(void) const { return (this->ccalendar ); }
-         AbstractCalendar * setCalendar(const string& _calName, const string& dateStr)
+         AbstractCalendar * setCalendar(const string& _calName, const string& _dateStr)
          {
             if (_calName.compare("D360")      == 0)
-               return (ccalendar = new D360Calendar(dateStr));
+               return (ccalendar = new D360Calendar(_dateStr));
             if (_calName.compare("AllLeap")   == 0)
-               return (ccalendar = new AllLeapCalendar(dateStr));
+               return (ccalendar = new AllLeapCalendar(_dateStr));
             if (_calName.compare("NoLeap")    == 0)
-               return (ccalendar = new NoLeapCalendar(dateStr));
+               return (ccalendar = new NoLeapCalendar(_dateStr));
             if (_calName.compare("Julian")    == 0)
-               return (ccalendar = new JulianCalendar(dateStr));
+               return (ccalendar = new JulianCalendar(_dateStr));
             if (_calName.compare("Gregorian") == 0)
-               return (ccalendar = new GregorianCalendar(dateStr));
+               return (ccalendar = new GregorianCalendar(_dateStr));
 
             WARNING("L'identifiant "+_calName+" est inconnu, le calendrier grÃ©gorien sera choisi par dÃ©fault pour le contexte "+getId());
 
-            return (ccalendar = new GregorianCalendar(dateStr));
+            return (ccalendar = new GregorianCalendar(_dateStr));
          }
 
@@ -166,8 +163,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 ;
+
             // DÃ©sallocation dynamique de mÃ©moire pour le calendrier associÃ© au contexte courant si nÃ©cessaire.
             if(ccalendar !=  NULL) delete ccalendar;
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/date.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/date.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/date.hpp	(revision 120)
@@ -27,6 +27,6 @@
          friend std::ostream& operator<<(std::ostream& out, const Date& d)
          {
-            out << d.day  << "/" << d.month  << "/" << d.year   << "-"
-                << d.hour << ":" << d.minute << ":" << d.second;
+            out << d.day  << '/' << d.month  << '/' << d.year   << '-'
+                << d.hour << ':' << d.minute << ':' << d.second;
             return (out);
          }
@@ -60,4 +60,5 @@
             if (month == 0 ) { year--; month = 12; }
          }
+
          void setYear  (int newyear)  { year  = newyear; }
 
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/declare_attribut.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/declare_attribut.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/declare_attribut.hpp	(revision 120)
@@ -3,4 +3,6 @@
 
 #include "attribut.hpp"
+
+#define Array(x,y) Array<x,y>
 
 #define DECLARE_ATTR(att_name,att_type)               \
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/domain.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/domain.hpp	(revision 120)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/domain.hpp	(revision 120)
@@ -0,0 +1,179 @@
+#ifndef __DOMAIN__
+#define __DOMAIN__
+
+using XMLIOSERVER::XML::XMLNode;
+using XMLIOSERVER::XML::THashAttributes;
+
+namespace XMLIOSERVER
+{
+   class CDomain : public ObjectTemplate<CDomain>, public DomainAttribut
+   {
+      public:
+
+         CDomain(void) : ObjectTemplate<CDomain>(), DomainAttribut()
+         { /* Ne rien faire de plus */ }
+         CDomain(const string& _id) : ObjectTemplate<CDomain>(_id), DomainAttribut()
+         { /* Ne rien faire de plus */ }
+
+         static string GetName(void) {return ("domain"); }
+
+         inline void check(void) ;
+
+         ~CDomain(void) { /* Ne rien faire de plus */ }
+
+   }; // class Domain
+
+   void CDomain::check(void)
+   {
+      static bool isChecked = false ;
+
+      if (isChecked) return; // Si la vÃ©rification a Ã©tÃ© faite, on arrÃªte tout.
+
+      // 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") ;
+
+      //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 ;
+      }
+      else if (ni.hasValue() && iend.hasValue())
+      {
+         if (ibegin!=ni-iend+1) ERROR("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 ;
+      }
+      else ERROR("domain local non dÃ©fini 4") ;
+
+      if (ni<0 || ibegin>iend || ibegin<1 || iend>ni_glo) ERROR("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 ;
+      }
+      else if (nj.hasValue() && jend.hasValue())
+      {
+         if (jbegin!=nj-jend+1) ERROR("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 ;
+      }
+      else ERROR("domain local non dÃ©fini 9") ;
+
+      if (nj<0 || jbegin>jend || jbegin<1 || jend>nj_glo) ERROR("domain local mal dÃ©fini 10") ;
+
+      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 (data_dim.hasValue())
+      {
+         if (!(data_dim==1 || data_dim==2)) ERROR("dimension non comptatible (doit Ãªtre 1 ou 2)") ;
+      }
+      else ERROR("Dimension des donnÃ©e non dÃ©finie") ;
+
+      if (data_ni.hasValue())
+      {
+         if (data_ni<=0) ERROR("Dimension des donnÃ©es nÃ©gative") ;
+      }
+      else
+      {
+         if (data_dim==1) data_ni=ni*nj ;
+         else data_ni=(int) ni ;
+      }
+
+      if (!data_ibegin.hasValue()) data_ibegin=0 ;
+
+      if (data_nj.hasValue())
+      {
+         if (data_nj<=0) ERROR("Dimension des donnÃ©es nÃ©gative") ;
+      }
+      else data_nj=(int) nj ;
+
+      if (!data_jbegin.hasValue()) data_jbegin=0 ;
+
+      if (!mask.hasValue())
+      {
+         mask->resize(shape(ni,nj)) ;
+         *mask=true ;
+      }
+
+      // Gestion de la compression
+
+      if (data_i_index.hasValue())
+      {
+         if (data_n_index.hasValue())
+         {
+            if (data_n_index!=data_i_index->extent(0)) ERROR("Dimension data_i_index incompatible avec data_n_index") ;
+         }
+         else data_n_index=data_i_index->extent(0) ;
+
+         if (data_dim==2)
+         {
+            if (data_j_index.hasValue())
+            {
+               if (data_j_index->extent(0)!=data_i_index->extent(0))
+               ERROR("Dimension data_j_index incompatible avec data_i_index") ;
+            }
+            else ERROR("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") ;
+      }
+      cout<<"data_n_index.hasValue() "<<data_n_index.hasValue()<<endl ;
+      if (!data_n_index.hasValue())
+      {
+         if (data_dim==1)
+         {
+            int i ;
+            data_n_index=*data_ni ;
+            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 ;
+         }
+         else   // data_dim=2
+         {
+            int i ;
+            int j ;
+            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_i_index)(count)=i ;
+                  cout<<count<<"  "<<(*data_i_index)(count)<<endl ;
+                  (*data_j_index)(count)=j ;
+                  cout<<count<<"  "<<(*data_j_index)(count)<<endl ;
+                  count++ ;
+               }
+               cout<<data_ni<<" "<<data_nj<<" "<<data_n_index<<" "<<*data_i_index<<" "<<*data_j_index<<endl ;
+         }
+      }
+
+      isChecked = true ;
+   }
+
+} // namespace XMLIOSERVER
+
+DECLARE_GROUP(Domain)
+
+#endif // __FIELD__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/domain_attribut.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/domain_attribut.hpp	(revision 120)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/domain_attribut.hpp	(revision 120)
@@ -0,0 +1,66 @@
+#ifndef __DOMAIN_ATTRIBUT__
+#define __DOMAIN_ATTRIBUT__
+
+using namespace blitz ;
+
+namespace XMLIOSERVER
+{
+   class DomainAttribut : public virtual AttributRegistrar
+   {
+      public :
+
+         DECLARE_ATTR(name, string) ;
+         DECLARE_ATTR(description, string);
+         DECLARE_ATTR(ni_glo, int);
+         DECLARE_ATTR(nj_glo, int) ;
+         DECLARE_ATTR(ibegin, int) ;
+         DECLARE_ATTR(iend, int) ;
+         DECLARE_ATTR(ni, int) ;
+         DECLARE_ATTR(jbegin, int) ;
+         DECLARE_ATTR(jend, int) ;
+         DECLARE_ATTR(nj, int) ;
+         DECLARE_ATTR(mask, Array(bool, 2)) ;
+
+         DECLARE_ATTR(data_dim, int) ;
+         DECLARE_ATTR(data_ni, int);
+         DECLARE_ATTR(data_nj, int) ;
+         DECLARE_ATTR(data_ibegin, int) ;
+         DECLARE_ATTR(data_jbegin, int) ;
+         DECLARE_ATTR(data_n_index, int) ;
+         DECLARE_ATTR(data_i_index,Array(int, 1)) ;
+         DECLARE_ATTR(data_j_index,Array(int, 1)) ;
+
+         DomainAttribut(void) : AttributRegistrar()
+         { registerAllAttributes(); }
+
+      private :
+
+         void registerAllAttributes(void)
+         {
+            RegisterAttribut(&name) ;
+            RegisterAttribut(&description) ;
+            RegisterAttribut(&ni_glo);
+            RegisterAttribut(&nj_glo) ;
+            RegisterAttribut(&ibegin) ;
+            RegisterAttribut(&iend) ;
+            RegisterAttribut(&ni) ;
+            RegisterAttribut(&jbegin) ;
+            RegisterAttribut(&jend) ;
+            RegisterAttribut(&nj) ;
+            RegisterAttribut(&mask) ;
+
+            RegisterAttribut(&data_dim) ;
+            RegisterAttribut(&data_ni);
+            RegisterAttribut(&data_nj) ;
+            RegisterAttribut(&data_ibegin) ;
+            RegisterAttribut(&data_jbegin) ;
+            RegisterAttribut(&data_n_index) ;
+            RegisterAttribut(&data_i_index) ;
+            RegisterAttribut(&data_j_index) ;
+         }
+
+   } ; // class DomainAttribut
+
+}// namespace XMLIOSERVER
+
+#endif //__DOMAIN_ATTRIBUT__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/field.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/field.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/field.hpp	(revision 120)
@@ -7,26 +7,36 @@
 namespace XMLIOSERVER
 {
+   class CGrid; // CGRID = CDOMAINE + CAXIS
+
    class CField : public ObjectTemplate<CField>, public FieldAttribut
    {
       public:
 
-         CField(void) : ObjectTemplate<CField>(), FieldAttribut()
+         CField(void) : ObjectTemplate<CField>(), FieldAttribut(), grid(NULL)
          {/* Ne rien faire de plus */}
-         CField(const string& _id) : ObjectTemplate<CField>(_id), FieldAttribut()
+         CField(const string& _id) : ObjectTemplate<CField>(_id), FieldAttribut(), grid(NULL)
          {/* Ne rien faire de plus */}
 
          static string GetName(void) {return ("field"); }
 
+         inline void SolveGridRef(void) ;
+
+         CGrid* getGrid(void) const { return (grid); }
+
          virtual CField* getReference(void) const
          {
-            if(!field_ref._hasValue()) return (NULL);
+            if(!field_ref.hasValue()) return (NULL);
             if (!CField::HasObject(field_ref))
             { WARNING("RÃ©fÃ©rence invalide sur l'objet "+GetName()+" nommÃ© \""+((string)field_ref)+"\""); return (NULL);}
 
-            return (&CField::GetObject(field_ref));
+            return (CField::GetObject(field_ref));
          }
 
          virtual ~CField(void)
          { /* Ne rien faire de plus */ }
+
+      private :
+
+         CGrid* grid ;
 
    }; // class CField
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/field_attribut.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/field_attribut.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/field_attribut.hpp	(revision 120)
@@ -19,6 +19,7 @@
          DECLARE_ATTR(enabled, bool);
 
+         DECLARE_ATTR(domain_ref, string);
          DECLARE_ATTR(axis_ref, string);
-         DECLARE_ATTR(grid_ref, string);
+         DECLARE_ATTR(grid_ref, string) ;
          DECLARE_ATTR(zoom_ref, string);
          DECLARE_ATTR(field_ref, string);
@@ -41,4 +42,5 @@
             RegisterAttribut(&enabled);
 
+            RegisterAttribut(&domain_ref);
             RegisterAttribut(&axis_ref);
             RegisterAttribut(&grid_ref);
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/field_gridrefsolver.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/field_gridrefsolver.hpp	(revision 120)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/field_gridrefsolver.hpp	(revision 120)
@@ -0,0 +1,48 @@
+#ifndef __FIELD_SOLVEGRIDREF__
+#define __FIELD_SOLVEGRIDREF__
+
+namespace XMLIOSERVER
+{
+   void CField::SolveGridRef(void)
+   {
+      CDomain* domain = NULL;
+      CAxis* axis = NULL ;
+
+      if (domain_ref.hasValue())
+      {
+         if (CDomain::HasObject(domain_ref)) domain = CDomain::GetObject(domain_ref) ;
+         else ERROR("RÃ©fÃ©rence au domaine incorrecte") ;
+      }
+
+      if (axis_ref.hasValue())
+      {
+         if (CAxis::HasObject(axis_ref)) axis = CAxis::GetObject(axis_ref) ;
+         else ERROR("RÃ©fÃ©rence a l'axe 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 (grid_ref.hasValue())
+      {
+         if (domain_ref.hasValue()) WARNING("DÃ©finition conjointe de la grille et du domaine, la grille prÃ©vaut..." );
+         if (axis_ref.hasValue())   WARNING("DÃ©finition conjointe de la grille et de l'axe vertical, la grille prÃ©vaut...") ;
+      }
+      else
+      {
+         if (domain_ref.hasValue())
+         {
+            if (axis_ref.hasValue()) grid = CGrid::CreateObject(domain, axis) ;
+            else grid = CGrid::CreateObject(domain) ;
+         }
+         else ERROR("Le domaine horizontal pour le champ X n'est pas dÃ©fini") ;
+      }
+
+      grid->solveReference() ;
+   }
+}
+
+#endif //__FIELD_SOLVEGRIDREF__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/file.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/file.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/file.hpp	(revision 120)
@@ -11,7 +11,7 @@
       public:
 
-         CFile(void) : ObjectTemplate<CFile>(), FileAttribut(), vfieldGroup(NULL)
+         CFile(void) : ObjectTemplate<CFile>(), FileAttribut(), vfieldGroup(NULL), enabledFields()
          {/* Ne rien faire de plus */}
-         CFile(const string& _id) : ObjectTemplate<CFile>(_id), FileAttribut(), vfieldGroup(NULL)
+         CFile(const string& _id) : ObjectTemplate<CFile>(_id), FileAttribut(), vfieldGroup(NULL), enabledFields()
          {/* Ne rien faire de plus */}
 
@@ -37,5 +37,7 @@
 
          void getAllFields(std::vector<CField*>& _allF) const {  if (vfieldGroup!=NULL) vfieldGroup->getAllChildren(_allF); }
+
          virtual bool hasChild(void) const { return (vfieldGroup != NULL); }
+
          virtual void printChild(ostream& out) const { out << *vfieldGroup << std::endl; }
          /*{ // Sortie sans affichage des groupes.
@@ -44,4 +46,5 @@
                out << *(allF[i]) << std::endl;
          }*/
+
          virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0)
          { addAttributes(*_parent); if(vfieldGroup != NULL) vfieldGroup->resolveDescInheritance(); }
@@ -55,4 +58,38 @@
          FieldGroup* getVirtualFieldGroup(void) { return (vfieldGroup); }
 
+         void findEnabledFields(int default_outputlevel = 5, int default_level = 1, bool default_enabled = true )
+         {
+            const int _outputlevel = (output_level.hasValue()) ? (int)output_level : default_outputlevel;
+            std::vector<CField*>::iterator it;
+
+            getAllFields(enabledFields);
+
+            for ( it = enabledFields.begin() ; it < enabledFields.end(); it++ )
+            {
+               if ((*it)->enabled.hasValue()) // Si l'attribut 'enabled' est dÃ©fini ...
+               {
+                  if (! ((*it)->enabled))
+                  { enabledFields.erase(it); continue; }
+               }
+               else // Si l'attribut 'enabled' n'est pas dÃ©fini ...
+               {
+                  if (!default_enabled)
+                  { enabledFields.erase(it); continue; }
+               }
+
+               if ((*it)->level.hasValue()) // Si l'attribut 'level' est dÃ©fini ...
+               {
+                  if ((*it)->level > _outputlevel)
+                  { enabledFields.erase(it); continue; }
+               }
+               else // Si l'attribut 'level' n'est pas dÃ©fini ...
+               {
+                  if (default_level > _outputlevel)
+                  { enabledFields.erase(it); continue; }
+               }
+
+            }
+         }
+
          virtual  ~CFile(void)
          { if(vfieldGroup != NULL) delete vfieldGroup; }
@@ -61,4 +98,5 @@
 
          FieldGroup* vfieldGroup; // FieldGroup "virtuel"
+         std::vector<CField*> enabledFields;
 
    }; // class CFile
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/grid.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/grid.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/grid.hpp	(revision 120)
@@ -7,24 +7,234 @@
 namespace XMLIOSERVER
 {
-   class CGrid: public ObjectTemplate<CGrid>, public GridAttribut
+   class CGrid : public ObjectTemplate<CGrid>, public GridAttribut
    {
       public:
 
-         CGrid(void) : ObjectTemplate<CGrid>(), GridAttribut()
-         {/* Ne rien faire de plus */}
-         CGrid(const string& _id) : ObjectTemplate<CGrid>(_id), GridAttribut()
-         {/* Ne rien faire de plus */}
+         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"); }
+
+         inline void solveReference(void) ;
+         inline void solveDomainRef(void) ;
+         inline void solveAxisRef(void) ;
+
+         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);
+
+         inline static CGrid* CreateObject(const CDomain* const a_domain, const CAxis* const a_axis);
+         inline static CGrid* CreateObject(const CDomain* const a_domain);
 
          virtual ~CGrid(void)
          { /* Ne rien faire de plus */ }
 
+
+      private:
+
+         bool hasAxis ;
+
+         CAxis* axis ;
+         CDomain* domain ;
+
+         Array<int,1> storeIndex ;
+         Array<int,1> out_i_index ;
+         Array<int,1> out_j_index ;
+         Array<int,1> out_l_index ;
+
    }; // class CGrid
 
+
+   CGrid* CGrid::CreateObject(const CDomain* const a_domain, const CAxis* const a_axis)
+   {
+      string new_id = string("___") + a_domain->getId() + string("_") + a_axis->getId() + string("__") ;
+      CGrid* const grid = ObjectTemplate<CGrid>::CreateObject(new_id) ;
+
+      grid->domain_ref = a_domain->getId() ;
+      grid->axis_ref = a_axis->getId() ;
+
+      return (grid);
+   }
+
+   CGrid* CGrid::CreateObject(const CDomain* const a_domain)
+   {
+      string new_id = string("___") + a_domain->getId() + string("__") ;
+      CGrid* const grid = ObjectTemplate<CGrid>::CreateObject(new_id) ;
+
+      grid->domain_ref = a_domain->getId() ;
+
+      return (grid);
+   }
+
+   void CGrid::solveReference(void)
+   {
+      static bool isReferenceSolved = false;
+      if (isReferenceSolved) return;
+
+      // RÃ©solution de chacune des rÃ©fÃ©rences et indexation.
+      solveDomainRef() ;
+      solveAxisRef() ;
+      computeIndex() ;
+
+      isReferenceSolved = true ;
+   }
+
+   void CGrid::solveDomainRef(void)
+   {
+      if (domain_ref.hasValue())
+      {
+         if (CDomain::HasObject(domain_ref))
+         {
+           domain=CDomain::GetObject(domain_ref) ;
+           domain->check() ;
+         }
+         else ERROR("RÃ©fÃ©rence au domaine incorrecte") ;
+      }
+      else ERROR("Domaine non dÃ©fini") ;
+   }
+
+   void CGrid::solveAxisRef(void)
+   {
+      if (axis_ref.hasValue())
+      {
+         hasAxis = true ;
+         if (CAxis::HasObject(axis_ref)) axis = CAxis::GetObject(axis_ref) ;
+         else ERROR("RÃ©fÃ©rence a l'axe incorrecte") ;
+      }
+      else hasAxis = false ; // hasAxis est normalement dÃ©jÃ  Ã  false(?).
+   }
+
+   void CGrid::computeIndex(void)
+   {
+      int ni = domain->ni ;
+      int nj = domain->nj ;
+      int size = (hasAxis) ? (int)axis->size : 1 ;
+      int data_dim = domain->data_dim ;
+      int data_n_index = domain->data_n_index ;
+      int data_ibegin  = domain->data_ibegin ;
+      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 ;
+      int i, j, l, n ;
+      int count, indexCount ;
+
+      for(indexCount=0, l=0; l<size ; l++)
+      {
+         for(n=0, indexCount=0; n<data_n_index; n++)
+         {
+            if (data_dim == 1)
+            {
+               i = (data_i_index(n) + data_ibegin) % ni ;
+               j = (data_i_index(n) + data_ibegin) / ni ;
+               cout<<i<<" "<<j<<" "<<mask(i,j)<<endl ;
+            }
+            else
+            {
+               i = data_i_index(n) + data_ibegin ;
+               j = data_j_index(n) + data_jbegin ;
+               cout<<i<<" "<<j<<" "<<mask(i,j)<<endl ;
+            }
+
+            if (i>=0 && i<ni && j>=0 && j<nj && mask(i,j) ) indexCount++ ;
+         }
+      }
+
+      storeIndex.resize(indexCount) ;
+      out_l_index.resize(indexCount) ;
+      out_i_index.resize(indexCount) ;
+      out_j_index.resize(indexCount) ;
+
+      for(count=0, indexCount=0, l=0; l<size; l++)
+      {
+         for(n=0; n<data_n_index; n++)
+         {
+            if (data_dim == 1)
+            {
+               i = (data_i_index(n) + data_ibegin) % ni ;
+               j = (data_i_index(n) + data_ibegin) / ni ;
+            }
+            else
+            {
+               i = data_i_index(n) + data_ibegin ;
+               j = data_j_index(n) + data_jbegin ;
+            }
+
+            if (i>=0 && i<ni && j>=0 && j<nj && mask(i,j))
+            {
+               storeIndex(indexCount) = n ;
+               out_l_index(indexCount) = l ;
+               out_i_index(indexCount) = i ;
+               out_j_index(indexCount) = j ;
+               indexCount++ ;
+            }
+            count++ ;
+         }
+      }
+
+      cout << "Out of CGrid::ComputeIndex" << endl ;
+      cout << storeIndex << endl ;
+      cout << out_i_index << endl ;
+      cout << out_j_index << endl ;
+      cout << out_l_index << endl ;
+   }
+
+   void CGrid::storeField(const Array<double, 1>& field, Array<double, 1>& stored)
+   {
+      storeField(field.dataFirst(), stored) ;
+      //cout<<"Stored 1"<<stored<<endl ;
+   }
+
+   void CGrid::storeField(const Array<double, 2>& field, Array<double, 1>& stored)
+   {
+      storeField(field.dataFirst(), stored) ;
+      //cout<<"Stored 2"<<stored<<endl ;
+   }
+
+   void CGrid::storeField(const Array<double, 3>& field, Array<double, 1>& stored)
+   {
+      storeField(field.dataFirst(), stored) ;
+      //cout<<"Stored 3"<<stored<<endl ;
+   }
+
+   void CGrid::storeField(const double* const data, Array<double, 1>& stored)
+   {
+      int size = storeIndex.size() ;
+      //cout << "size " << size << endl ;
+
+      stored.resize(shape(size)) ;
+      //cout << "Stored " << stored << endl ;
+
+      for(int i = 0; i < size; i++) stored(i) = data[storeIndex(i)] ;
+      //cout << "Stored " << stored << endl ;
+   }
+
+   void CGrid::outputField(const Array<double, 1>& stored, Array<double, 2>& outField)
+   {
+      for(int n = 0; n < storeIndex.size(); n++)
+         outField(out_i_index(n), out_j_index(n)) = stored(n) ;
+   }
+
+   void CGrid::outputField(const Array<double, 1>& stored, Array<double, 3>& outField)
+   {
+      for(int n = 0; n < storeIndex.size(); n++)
+         outField(out_i_index(n), out_j_index(n), out_l_index(n)) = stored(n) ;
+   }
 } // namespace XMLIOSERVER
 
+
 DECLARE_GROUP(Grid)
 
+
+
 #endif // __GRID__
 
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/grid_attribut.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/grid_attribut.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/grid_attribut.hpp	(revision 120)
@@ -10,4 +10,6 @@
          DECLARE_ATTR(name, string) ;
          DECLARE_ATTR(description, string) ;
+         DECLARE_ATTR(domain_ref, string) ;
+         DECLARE_ATTR(axis_ref, string) ; 
 
          GridAttribut(void) : AttributRegistrar()
@@ -20,4 +22,6 @@
             RegisterAttribut(&name) ;
             RegisterAttribut(&description) ;
+            RegisterAttribut(&domain_ref) ;
+            RegisterAttribut(&axis_ref) ;
          }
 
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/group_template.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/group_template.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/group_template.hpp	(revision 120)
@@ -41,4 +41,5 @@
             // on complÃšte les attributs des enfants.
                childvect[i] -> resolveDescInheritance(this);
+
             for(unsigned int i = 0; i < groupvect.size() ; i++)
             // on complÃšte les attributs des groupes enfants.
@@ -48,5 +49,5 @@
          GroupTemplate<T, U>& createGroup(const string& _id) throw (XMLIOUndefinedValueException)
          {
-            GroupTemplate<T, U> &obj = GroupTemplate<T, U>::CreateObject(_id);
+            GroupTemplate<T, U> &obj = *GroupTemplate<T, U>::CreateObject(_id);
             groupList.addObject(&obj);
 
@@ -56,5 +57,5 @@
          GroupTemplate<T, U>& createGroup(void)
          {
-            GroupTemplate<T, U>& obj = GroupTemplate<T, U>::CreateObject();
+            GroupTemplate<T, U>& obj = *(GroupTemplate<T, U>::CreateObject());
             groupList.addObject(&obj);
 
@@ -73,5 +74,5 @@
          T& createChild(const string& _id) throw (XMLIOUndefinedValueException)
          {
-            T& obj = ObjectTemplate<T>::CreateObject(_id);
+            T& obj = *ObjectTemplate<T>::CreateObject(_id);
             childList.addObject(&obj);
             return (obj);
@@ -80,5 +81,5 @@
          T& createChild(void)
          {
-            T& obj = ObjectTemplate<T>::CreateObject();
+            T& obj = *ObjectTemplate<T>::CreateObject();
             childList.addObject(&obj);
             return (obj);
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/logger.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/logger.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/logger.hpp	(revision 120)
@@ -48,5 +48,4 @@
          }
 
-
          static void ShowBTrace(std::ostream& out = std::clog)
          {
@@ -94,9 +93,9 @@
 
    // Initialisation de la classe de Logging
-   static ILogger LOGGER;
+   ILogger LOGGER;
 
    /////////////////////////////////////////////////////////////////////
-   static unsigned int Indent = 0;
-   static const char*  Increm = "   ";
+   unsigned int Indent = 0;
+   const char*  Increm = "   ";
 
    std::ostream& NIndent(std::ostream& out)
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/object_template.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/object_template.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/object_template.hpp	(revision 120)
@@ -27,5 +27,6 @@
 
             if (c.baseObject != NULL)
-               out <<  IncIndent << "<-- Reference resolved for the following "+ T::GetName() +" : \"" << c.baseObject->getId() << "\" -->" << DecEndl << std::endl;
+               out <<  IncIndent << "<-- Reference resolved for the following "+ T::GetName() +
+                       " : \"" << c.baseObject->getId() << "\" -->" << DecEndl << std::endl;
 
             if (c.hasChild())
@@ -48,5 +49,5 @@
 
          virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0) { addAttributes(*_parent); }
-         virtual void resolveRefInheritance(void)
+         virtual void resolveRefInheritance (void)
          {
             std::set<T*> sset;
@@ -76,5 +77,5 @@
          }
 
-         static T& CreateObject(const string& _id) throw (XMLIOUndefinedValueException)
+         static T* CreateObject(const string& _id) throw (XMLIOUndefinedValueException)
          {
             // Si l'identifiant est rÃ©pertoriÃ©, on retourne l'Ã©lÃ©ment existant.
@@ -88,13 +89,13 @@
          }
 
-         static T& CreateObject(void)
+         static T* CreateObject(void)
          {
             T* value = new T;
             ObjectTemplate<T>::AllListObj[CurrContext].addObject(value);
-            return (*value);
+            return (value);
          }
 
-         static T& GetObject(const string& _id) throw (XMLIOUndefinedValueException)
-         { return (*ObjectTemplate<T>::AllListObj[CurrContext][_id]); }
+         static T* GetObject(const string& _id) throw (XMLIOUndefinedValueException)
+         { return (ObjectTemplate<T>::AllListObj[CurrContext][_id]); }
 
          static bool HasObject(const string& _id)
@@ -105,5 +106,5 @@
 
          static const StrHashMap<T>& GetCurrentListObject(void) { return (AllListObj[CurrContext]); }
-         static HashMap<string, StrHashMap<T> >& GetAllListObject(void) { return (AllListObj); }
+         static Poco::HashMap<string, StrHashMap<T> >& GetAllListObject(void) { return (AllListObj); }
 
          static void SetContext(const string& id){ ObjectTemplate<T>::CurrContext = id; }
@@ -134,5 +135,5 @@
                if (V::HasObject(did))
                   WARNING("Le noeud nommÃ© \""+ did +"\" existe dÃ©jÃ  pour les instances de type "+V::GetName()+", le dernier dÃ©fini complÃ©tera le premier dans le context actuel!");
-               instance_ptr = (V*)&V::CreateObject(did);
+               instance_ptr = (V*)V::CreateObject(did);
                instance_ptr->parse(_node, parseAttr);
             }
@@ -144,10 +145,10 @@
 
          static string CurrContext;
-         static HashMap<string, StrHashMap<T> > AllListObj;
+         static Poco::HashMap<string, StrHashMap<T> > AllListObj;
 
    };// class ObjectTemplate
 
    template <class T> string ObjectTemplate<T>::CurrContext ;
-   template <class T> HashMap<string, StrHashMap<T> > ObjectTemplate<T>::AllListObj;
+   template <class T> Poco::HashMap<string, StrHashMap<T> > ObjectTemplate<T>::AllListObj;
 
 }// namespace XMLIOSERVER
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/xml_node.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/xml_node.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/xml_node.hpp	(revision 120)
@@ -2,40 +2,4 @@
 #define __XMLIO_XML_NODE__
 
-// EntÃªtes Poco DOM
-#include <Poco/DOM/DOMParser.h>
-#include <Poco/DOM/Document.h>
-#include <Poco/DOM/Element.h>
-
-#include <Poco/DOM/NamedNodeMap.h>
-
-#include <Poco/DOM/AutoPtr.h>
-
-// EntÃªtes Poco SAX.
-#include <Poco/SAX/InputSource.h>
-
-// Utilisation de la STL.
-using std::string;
-
-using std::pair;
-using std::vector;
-
-using std::istream;
-using std::ostream;
-using std::ostringstream;
-using std::ifstream;
-
-// Utilisation de la biliothÃšque POCO.
-using Poco::XML::DOMParser;
-using Poco::XML::InputSource;
-
-using Poco::XML::Document;
-using Poco::XML::Node;
-using Poco::XML::Element;
-
-using Poco::XML::NamedNodeMap;
-
-using Poco::HashMap;
-
-using Poco::XML::AutoPtr;
 
 namespace XMLIOSERVER
@@ -43,6 +7,5 @@
    namespace XML
    {
-
-      typedef HashMap<string, string> THashAttributes;
+      typedef Poco::HashMap<std::string, std::string> THashAttributes;
 
       class XMLNode
@@ -50,18 +13,17 @@
          public :
 
-            XMLNode(const string& _rootName) : rootName(_rootName)
-            { /* Ne rien faire de plus */}
-
-            static XMLNode CreateNode(istream& _istr, const string& _rootName)
+            static XMLNode CreateNode(std::istream& _istr, const std::string& _rootName)
             {
                XMLNode node(_rootName);
+
                if (_istr.good())
                { // S'il est possible de lire le flux en entrÃ©e ...
-                  InputSource src(_istr);
-                  DOMParser parser;
+
+                  Poco::XML::InputSource src(_istr);
+                  Poco::XML::DOMParser parser;
 
                   node.pDoc = parser.parse(&src);
                   node.setCNode(node.pDoc->documentElement());
-                  if (node.getElementName().compare(_rootName) != 0)
+                  if (node.getElementName().compare(_rootName) != 0) // << A passer en avertissement.
                      throw XMLParsingException("L'Ã©lÃ©ment racine doit avoir pour valeur <" + _rootName + "> (\"" + node.getElementName() + "\" lue)");
                }
@@ -73,9 +35,12 @@
 
             string getElementName(void) const
-            { string _str(this->getCNode()->nodeName()); return (_toLower(_str)); }
+            {
+               std::string _str(this->getCNode()->nodeName());
+               return (_toLower(_str));
+            }
 
             bool goToNextElement(void)
             {
-               Node* nextElement = this->getCNode()->nextSibling();
+               Poco::XML::Node* nextElement = this->getCNode()->nextSibling();
 
                // On parcourt la liste des "siblings" jusqu'Ã  trouver un Ã©lÃ©ment quelconque.
@@ -92,5 +57,5 @@
             bool goToChildElement(void)
             {
-               Node* nextElement = this->getCNode()->firstChild();
+               Poco::XML::Node* nextElement = this->getCNode()->firstChild();
 
                // On parcourt la liste des enfants jusqu'Ã  trouver un Ã©lÃ©ment quelconque.
@@ -98,5 +63,5 @@
                {
                   for(; ; nextElement = nextElement->nextSibling())
-                     if (IsPtrNull(nextElement)) break;
+                     if (IsPtrNull(nextElement)) return (false);
                      else if (nextElement->nodeType() == 1)
                      {// Si l'un des noeuds est un Ã©lÃ©ment...
@@ -104,7 +69,5 @@
                         return (true);
                      }
-                  return (false);
                }
-
                return (false);
             }
@@ -118,15 +81,16 @@
             }
 
-            bool getAttributes(THashAttributes& attributes) const
+            bool getAttributes(THashAttributes& _attributes) const
             {
                if(!this->getCNode()->hasAttributes()) return (false);
-               AutoPtr<NamedNodeMap> map = this->getCNode()->attributes();
+               Poco::XML::AutoPtr<Poco::XML::NamedNodeMap> map = this->getCNode()->attributes();
 
                for(unsigned int i = 0; i< map->length(); i++)
                { // Suppression des espaces en dÃ©but et fin de valeur d'attribut xml.
-                  string _str(map->item(i)->nodeName());
+                  std::string _str(map->item(i)->nodeName());
                   size_t d = map->item(i)->nodeValue().find_first_not_of(' ');
                   size_t f = map->item(i)->nodeValue().find_last_not_of (' ');
-                  attributes[_toLower(_str)] = map->item(i)->nodeValue().substr(d,f-d+1);
+
+                  _attributes[_toLower(_str)] = map->item(i)->nodeValue().substr(d,f-d+1);
                }
                return (true);
@@ -138,12 +102,15 @@
          protected :
 
-            Node* getCNode(void) const { return (this->cNode); }
-            void setCNode(Node* other) { this->cNode = other; }
+            Poco::XML::Node * getCNode(void) const { return (this->cNode); }
+            void setCNode(Poco::XML::Node * _otherNode) { this->cNode = _otherNode; }
 
-            static bool IsPtrNull(Node* ptr) { return (ptr==NULL); }
+            static bool IsPtrNull(const Poco::XML::Node * const _ptr) { return (_ptr == NULL); }
 
          private :
 
-            const string& _toLower(string& _str) const
+            XMLNode(const std::string& _rootName) : rootName(_rootName)
+            { /* Ne rien faire de plus */}
+
+            const string& _toLower(std::string& _str) const
             {
                for (unsigned int i = 0; i < _str.size(); i++)
@@ -152,6 +119,6 @@
             }
 
-            AutoPtr<Document> pDoc;
-            Node*  cNode;
+            Poco::XML::AutoPtr<Poco::XML::Document> pDoc;
+            Poco::XML::Node*  cNode;
 
             string rootName;
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/xml_parser.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/xml_parser.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/xml_parser.hpp	(revision 120)
@@ -35,5 +35,5 @@
 
                   Context::SetCurrentContext(attributes["id"]);
-                  Context& context = Context::CreateObject(attributes["id"]);
+                  Context& context = *Context::CreateObject(attributes["id"]);
 
                   context.parse(_node);
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio.hpp	(revision 119)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio.hpp	(revision 120)
@@ -17,4 +17,16 @@
 #include <Poco/HashMap.h>
 #include <Poco/Hash.h>
+
+// EntÃªtes Poco DOM
+#include <Poco/DOM/DOMParser.h>
+#include <Poco/DOM/Document.h>
+#include <Poco/DOM/Element.h>
+
+#include <Poco/DOM/NamedNodeMap.h>
+
+#include <Poco/DOM/AutoPtr.h>
+
+// EntÃªtes Poco SAX.
+#include <Poco/SAX/InputSource.h>
 
 /// EntÃªte Blitz array ///
@@ -40,4 +52,5 @@
 #include "grid_attribut.hpp"
 #include "axis_attribut.hpp"
+#include "domain_attribut.hpp"
 #include "field_attribut.hpp"
 #include "file_attribut.hpp"
@@ -46,15 +59,18 @@
 #include "declare_group.hpp"
 
-// Prise en charge des champs...
+// Prise en charge des champs, fichiers, axes, domaines, grilles ...
 #include "field.hpp"
-// Prise en charge des fichiers ...
 #include "file.hpp"
-// Prise en charge des axes ...
 #include "axis.hpp"
-// Prise en charge des grilles ...
+#include "domain.hpp"
 #include "grid.hpp"
+
+#include "field_gridrefsolver.hpp"
 
 #include "context.hpp"
 #include "xml_parser.hpp"
 
+#include "abstract_data_treatment.hpp"
+#include "NetCDF4_data_treatment.hpp"
+
 #endif // __XMLIO__
