Index: XMLIO_V2/dev/dev_rv/src/xmlio/node/axis.cpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/xmlio/node/axis.cpp	(revision 157)
+++ XMLIO_V2/dev/dev_rv/src/xmlio/node/axis.cpp	(revision 168)
@@ -5,58 +5,61 @@
 #include "group_template_impl.hpp"
 
-namespace xmlioserver
-{
-   namespace tree
+namespace xmlioserver {
+namespace tree {
+   
+   /// ////////////////////// DÃ©finitions ////////////////////// ///
+
+   CAxis::CAxis(void)
+      : CObjectTemplate<CAxis>()
+      , CAxisAttributes(), isChecked(false), relFiles()
+   { /* Ne rien faire de plus */ }
+
+   CAxis::CAxis(const StdString & id)
+      : CObjectTemplate<CAxis>(id)
+      , CAxisAttributes(), isChecked(false), relFiles()
+   { /* Ne rien faire de plus */ }
+
+   CAxis::~CAxis(void)
+   { /* Ne rien faire de plus */ }
+
+   ///---------------------------------------------------------------
+
+   const std::set<StdString> & CAxis::getRelFiles(void) const
    {
-      /// ////////////////////// DÃ©finitions ////////////////////// ///
+      return (this->relFiles);
+   }
 
-      CAxis::CAxis(void)
-         : CObjectTemplate<CAxis>()
-         , CAxisAttributes(), isChecked(false), relFiles()
-      { /* Ne rien faire de plus */ }
+   bool CAxis::IsWritten(const StdString & filename) const
+   {
+      return (this->relFiles.find(filename) != this->relFiles.end());
+   }
 
-      CAxis::CAxis(const StdString & id)
-         : CObjectTemplate<CAxis>(id)
-         , CAxisAttributes(), isChecked(false), relFiles()
-      { /* Ne rien faire de plus */ }
+   void CAxis::addRelFile(const StdString & filename)
+   {
+      this->relFiles.insert(filename);
+   }
 
-      CAxis::~CAxis(void)
-      { /* Ne rien faire de plus */ }
+   //----------------------------------------------------------------
 
-      ///---------------------------------------------------------------
+   StdString CAxis::GetName(void)   { return (StdString("axis")); }
+   StdString CAxis::GetDefName(void){ return (CAxis::GetName()); }
+   ENodeType CAxis::GetType(void)   { return (eAxis); }
 
-      const std::set<StdString> & CAxis::getRelFiles(void) const
-      {
-         return (this->relFiles);
-      }
+   //----------------------------------------------------------------
 
-      bool CAxis::IsWritten(const StdString & filename) const
-      {
-         return (this->relFiles.find(filename) != this->relFiles.end());
-      }
+   void CAxis::checkAttributes(void)
+   {
+      if (this->isChecked) return;
+      StdSize size = this->size.getValue();
+      StdSize true_size = zvalue.getValue()->num_elements();
+      if (size != true_size)
+         ERROR("CAxis::checkAttributes(void)",
+               << "Le tableau \'zvalue\' a une taille diffÃ©rente de celle indiquÃ©e dans l'attribut \'size\'")
 
-      void CAxis::addRelFile(const StdString & filename)
-      {
-         this->relFiles.insert(filename);
-      }
+      this->isChecked = true;
+   }
 
-      //----------------------------------------------------------------
-      StdString CAxis::GetName(void)   { return (StdString("axis")); }
-      StdString CAxis::GetDefName(void){ return (CAxis::GetName()); }
+   ///---------------------------------------------------------------
 
-      void CAxis::checkAttributes(void)
-      {
-         if (this->isChecked) return;
-         StdSize size = this->size.getValue();
-         StdSize true_size = zvalue.getValue()->num_elements();
-         if (size != true_size)
-            ERROR("CAxis::checkAttributes(void)",
-                  << "Le tableau \'zvalue\' a une taille diffÃ©rente de celle indiquÃ©e dans l'attribut \'size\'")
-
-         this->isChecked = true;
-      }
-
-      ///---------------------------------------------------------------
-
-   } // namespace tree
+} // namespace tree
 } // namespace xmlioserver
Index: XMLIO_V2/dev/dev_rv/src/xmlio/node/axis.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/xmlio/node/axis.hpp	(revision 157)
+++ XMLIO_V2/dev/dev_rv/src/xmlio/node/axis.hpp	(revision 168)
@@ -8,75 +8,78 @@
 #include "declare_group.hpp"
 
-namespace xmlioserver
-{
-   namespace tree
+namespace xmlioserver {
+namespace tree {
+   
+   /// ////////////////////// DÃ©clarations ////////////////////// ///
+
+   class CAxisGroup;
+   class CAxisAttributes;
+   class CAxis;
+
+   ///--------------------------------------------------------------
+
+   // Declare/Define CAxisAttribute
+   BEGIN_DECLARE_ATTRIBUTE_MAP(CAxis)
+   #include "axis_attribute.conf"
+   END_DECLARE_ATTRIBUTE_MAP(CAxis)
+
+   ///--------------------------------------------------------------
+
+   class CAxis
+      : public CObjectTemplate<CAxis>
+      , public CAxisAttributes
    {
-      /// ////////////////////// DÃ©clarations ////////////////////// ///
+         /// typedef ///
+         typedef CObjectTemplate<CAxis>   SuperClass;
+         typedef CAxisAttributes SuperClassAttribute;
 
-      class CAxisGroup;
-      class CAxisAttributes;
-      class CAxis;
+      public :
 
-      ///--------------------------------------------------------------
+         typedef CAxisAttributes RelAttributes;
+         typedef CAxisGroup      RelGroup;
 
-      // Declare/Define CAxisAttribute
-      BEGIN_DECLARE_ATTRIBUTE_MAP(CAxis)
-#include "axis_attribute.conf"
-      END_DECLARE_ATTRIBUTE_MAP(CAxis)
+         /// Constructeurs ///
+         CAxis(void);
+         explicit CAxis(const StdString & id);
+         CAxis(const CAxis & axis);       // Not implemented yet.
+         CAxis(const CAxis * const axis); // Not implemented yet.
 
-      ///--------------------------------------------------------------
+         /// Accesseurs ///
+         const std::set<StdString> & getRelFiles(void) const;
 
-      class CAxis
-         : public CObjectTemplate<CAxis>
-         , public CAxisAttributes
-      {
-            /// typedef ///
-            typedef CObjectTemplate<CAxis>   SuperClass;
-            typedef CAxisAttributes SuperClassAttribute;
+         /// Test ///
+         bool IsWritten(const StdString & filename) const;
 
-         public :
+         /// Mutateur ///
+         void addRelFile(const StdString & filename);
 
-            typedef CAxisAttributes RelAttributes;
-            typedef CAxisGroup      RelGroup;
+         /// VÃ©rifications ///
+         void checkAttributes(void);
 
-            /// Constructeurs ///
-            CAxis(void);
-            explicit CAxis(const StdString & id);
-            CAxis(const CAxis & axis);       // Not implemented yet.
-            CAxis(const CAxis * const axis); // Not implemented yet.
+         /// Destructeur ///
+         virtual ~CAxis(void);
 
-            /// Accesseurs ///
-            const std::set<StdString> & getRelFiles(void) const;
+         /// Accesseurs statiques ///
+         static StdString GetName(void);
+         static StdString GetDefName(void);
+         
+         static ENodeType GetType(void);
 
-            /// Test ///
-            bool IsWritten(const StdString & filename) const;
+      private :
 
-            /// Mutateur ///
-            void addRelFile(const StdString & filename);
-
-            /// VÃ©rifications ///
-            void checkAttributes(void);
-
-            /// Destructeur ///
-            virtual ~CAxis(void);
-
-            /// Accesseurs statiques ///
-            static StdString GetName(void);
-            static StdString GetDefName(void);
-
-         private :
-
-            bool isChecked;
-            std::set<StdString> relFiles;
+         bool isChecked;
+         std::set<StdString> relFiles;
 
 
-      }; // class CAxis
+   }; // class CAxis
 
-      ///--------------------------------------------------------------
+   ///--------------------------------------------------------------
 
-      // Declare/Define CAxisGroup and CAxisDefinition
-      DECLARE_GROUP(CAxis);
+   // Declare/Define CAxisGroup and CAxisDefinition
+   DECLARE_GROUP(CAxis);
 
-   } // namespace tree
+   ///--------------------------------------------------------------
+
+} // namespace tree
 } // namespace xmlioserver
 
Index: XMLIO_V2/dev/dev_rv/src/xmlio/node/context.cpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/xmlio/node/context.cpp	(revision 157)
+++ XMLIO_V2/dev/dev_rv/src/xmlio/node/context.cpp	(revision 168)
@@ -5,158 +5,178 @@
 #include "group_template_impl.hpp"
 
-namespace xmlioserver
-{
-   namespace tree
+namespace xmlioserver {
+namespace tree {
+   
+   /// ////////////////////// DÃ©finitions ////////////////////// ///
+
+   CContext::CContext(void)
+      : CObjectTemplate<CContext>(), CContextAttributes()
+   { /* Ne rien faire de plus */ }
+
+   CContext::CContext(const StdString & id)
+      : CObjectTemplate<CContext>(id), CContextAttributes()
+   { /* Ne rien faire de plus */ }
+
+   CContext::~CContext(void)
+   { /* Ne rien faire de plus */ }
+
+   //----------------------------------------------------------------
+
+   StdString CContext::GetName(void)   { return (StdString("context")); }
+   StdString CContext::GetDefName(void){ return (CContext::GetName()); }
+   ENodeType CContext::GetType(void)   { return (eContext); }
+
+   //----------------------------------------------------------------
+
+   boost::shared_ptr<CContextGroup> CContext::GetContextGroup(void)
+   {  
+      static boost::shared_ptr<CContextGroup> group_context
+                          (new CContextGroup(xml::CXMLNode::GetRootName()));
+      return (group_context); 
+   }
+
+   //----------------------------------------------------------------
+
+   void CContext::parse(xml::CXMLNode & node)
    {
-      /// ////////////////////// DÃ©finitions ////////////////////// ///
+      CContext::SuperClass::parse(node);
 
-      CContext::CContext(void)
-         : CObjectTemplate<CContext>(), CContextAttributes()
-      { /* Ne rien faire de plus */ }
+      // PARSING POUR GESTION DES ENFANTS
+      xml::THashAttributes attributes;
 
-      CContext::CContext(const StdString & id)
-         : CObjectTemplate<CContext>(id), CContextAttributes()
-      { /* Ne rien faire de plus */ }
+      if (node.getElementName().compare(CContext::GetName()))
+         DEBUG("Le noeud est mal nommÃ© mais sera traitÃ© comme un contexte !");
 
-      CContext::~CContext(void)
-      { /* Ne rien faire de plus */ }
+      if (!(node.goToChildElement()))
+      {
+         DEBUG("Le context ne contient pas d'enfant !");
+      }
+      else
+      {
+         do { // Parcours des contextes pour traitement.
 
-      StdString CContext::GetName(void)   { return (StdString("context")); }
-      StdString CContext::GetDefName(void){ return (CContext::GetName()); }
+            StdString name = node.getElementName();
+            attributes.clear();
+            attributes = node.getAttributes();
 
-      boost::shared_ptr<CContextGroup> CContext::GetContextGroup(void)
-      {  static boost::shared_ptr<CContextGroup> group_context
-                             (new CContextGroup(xml::CXMLNode::GetRootName()));
-         return (group_context); }
+            if (attributes.end() != attributes.find("id"))
+            { DEBUG(<< "Le noeud de dÃ©finition possÃšde un identifiant,"
+                    << " ce dernier ne sera pas pris en compte lors du traitement !"); }
 
-      void CContext::parse(xml::CXMLNode & node)
+   #define DECLARE_NODE(Name_, name_)    \
+      if (name.compare(C##Name_##Definition::GetDefName()) == 0) \
+      { CObjectFactory::CreateObject<C##Name_##Definition>(C##Name_##Definition::GetDefName()) -> parse(node); \
+   continue; }
+   #define DECLARE_NODE_PAR(Name_, name_)
+   #include "node_type.conf"
+
+            DEBUG(<< "L'Ã©lÃ©ment nommÃ© \'"     << name
+                  << "\' dans le contexte \'" << CObjectFactory::GetCurrentContextId()
+                  << "\' ne reprÃ©sente pas une dÃ©finition !");
+
+         } while (node.goToNextElement());
+
+         node.goToParentElement(); // Retour au parent
+      }
+   }
+
+   //----------------------------------------------------------------
+
+   void CContext::ShowTree(StdOStream & out)
+   {
+      StdString currentContextId =
+         CObjectFactory::GetCurrentContextId();
+      std::vector<boost::shared_ptr<CContext> > def_vector =
+         CContext::GetContextGroup()->getChildList();
+      std::vector<boost::shared_ptr<CContext> >::iterator
+         it = def_vector.begin(), end = def_vector.end();
+
+      out << "<? xml version=\"1.0\" ?>" << std::endl;
+      out << "< "  << xml::CXMLNode::GetRootName() << " >" << std::endl;
+      
+      for (; it != end; it++)
       {
-         CContext::SuperClass::parse(node);
+         boost::shared_ptr<CContext> context = *it;
+         CObjectFactory::SetCurrentContextId(context->getId());
+         CGroupFactory::SetCurrentContextId(context->getId());
+         out << *context << std::endl;
+      }
+      
+      out << "</ " << xml::CXMLNode::GetRootName() << " >" << std::endl;
 
-         // PARSING POUR GESTION DES ENFANTS
-         xml::THashAttributes attributes;
+      CObjectFactory::SetCurrentContextId(currentContextId);
+       CGroupFactory::SetCurrentContextId(currentContextId);
+   }
 
-         if (node.getElementName().compare(CContext::GetName()))
-            DEBUG("Le noeud est mal nommÃ© mais sera traitÃ© comme un contexte !");
+   //----------------------------------------------------------------
 
-         if (!(node.goToChildElement()))
-         {
-            DEBUG("Le context ne contient pas d'enfant !");
-         }
-         else
-         {
-            do { // Parcours des contextes pour traitement.
+   StdString CContext::toString(void) const
+   {
+      StdOStringStream oss;
+      oss << "< " << CContext::GetName()
+          << " id=\"" << this->getId() << "\" "
+          << SuperClassAttribute::toString() << ">" << std::endl;
+      if (!this->hasChild())
+      {
+         //oss << "<!-- No definition -->" << std::endl; // fait planter l'incrÃ©mentation
+      }
+      else
+      {
 
-               StdString name = node.getElementName();
-               attributes.clear();
-               attributes = node.getAttributes();
+   #define DECLARE_NODE(Name_, name_)    \
+      if (CObjectFactory::HasObject<C##Name_##Definition>(C##Name_##Definition::GetDefName())) \
+   oss << *CObjectFactory::GetObject<C##Name_##Definition>(C##Name_##Definition::GetDefName()) << std::endl;
+   #define DECLARE_NODE_PAR(Name_, name_)
+   #include "node_type.conf"
 
-               if (attributes.end() != attributes.find("id"))
-               { DEBUG(<< "Le noeud de dÃ©finition possÃšde un identifiant,"
-                       << " ce dernier ne sera pas pris en compte lors du traitement !"); }
-
-#define DECLARE_NODE(Name_, name_)    \
-   if (name.compare(C##Name_##Definition::GetDefName()) == 0) \
-   { CObjectFactory::CreateObject<C##Name_##Definition>(C##Name_##Definition::GetDefName()) -> parse(node); \
-      continue; }
-#define DECLARE_NODE_PAR(Name_, name_)
-#include "node_type.conf"
-
-               DEBUG(<< "L'Ã©lÃ©ment nommÃ© \'"     << name
-                     << "\' dans le contexte \'" << CObjectFactory::GetCurrentContextId()
-                     << "\' ne reprÃ©sente pas une dÃ©finition !");
-
-            } while (node.goToNextElement());
-
-            node.goToParentElement(); // Retour au parent
-         }
       }
 
-      void CContext::ShowTree(StdOStream & out)
+      oss << "</ " << CContext::GetName() << " >";
+
+      return (oss.str());
+   }
+
+   //----------------------------------------------------------------
+
+   void CContext::solveDescInheritance(const CAttributeMap * const UNUSED(parent))
+   {
+   #define DECLARE_NODE(Name_, name_)    \
+      if (CObjectFactory::HasObject<C##Name_##Definition>(C##Name_##Definition::GetDefName())) \
+   CObjectFactory::GetObject<C##Name_##Definition>(C##Name_##Definition::GetDefName())->solveDescInheritance();
+   #define DECLARE_NODE_PAR(Name_, name_)
+   #include "node_type.conf"
+   }
+
+   //----------------------------------------------------------------
+
+   bool CContext::hasChild(void) const
+   {
+      return (false ||
+   #define DECLARE_NODE(Name_, name_)    \
+      CObjectFactory::HasObject<C##Name_##Definition>  (C##Name_##Definition::GetDefName())   ||
+   #define DECLARE_NODE_PAR(Name_, name_)
+   #include "node_type.conf"
+      false);
+   }
+
+   //----------------------------------------------------------------
+
+   void CContext::solveFieldRefInheritance(void)
+   {
+      if (!this->hasId()) return;
+      std::vector<boost::shared_ptr<CField> > allField
+               = CObjectTemplate<CField>::GetAllVectobject(this->getId());
+      std::vector<boost::shared_ptr<CField> >::iterator 
+         it = allField.begin(), end = allField.end();
+            
+      for (; it != end; it++)
       {
-         StdString currentContextId =
-            CObjectFactory::GetCurrentContextId();
-         std::vector<boost::shared_ptr<CContext> > def_vector =
-            CContext::GetContextGroup()->getChildList();
-         std::vector<boost::shared_ptr<CContext> >::iterator
-            it = def_vector.begin(), end = def_vector.end();
+         boost::shared_ptr<CField> field = *it;
+         field->solveRefInheritance();
+      }
+   }
 
-         out << "<? xml version=\"1.0\" ?>" << std::endl;
-         out << "< "  << xml::CXMLNode::GetRootName() << " >" << std::endl;
-         
-         for (; it != end; it++)
-         {
-            boost::shared_ptr<CContext> context = *it;
-            CObjectFactory::SetCurrentContextId(context->getId());
-            CGroupFactory::SetCurrentContextId(context->getId());
-            out << *context << std::endl;
-         }
-         
-         out << "</ " << xml::CXMLNode::GetRootName() << " >" << std::endl;
+   ///---------------------------------------------------------------
 
-         CObjectFactory::SetCurrentContextId(currentContextId);
-          CGroupFactory::SetCurrentContextId(currentContextId);
-      }
-
-      StdString CContext::toString(void) const
-      {
-         StdOStringStream oss;
-         oss << "< " << CContext::GetName()
-             << " id=\"" << this->getId() << "\" "
-             << SuperClassAttribute::toString() << ">" << std::endl;
-         if (!this->hasChild())
-         {
-            //oss << "<!-- No definition -->" << std::endl; // fait planter l'incrÃ©mentation
-         }
-         else
-         {
-
-#define DECLARE_NODE(Name_, name_)    \
-   if (CObjectFactory::HasObject<C##Name_##Definition>(C##Name_##Definition::GetDefName())) \
-      oss << *CObjectFactory::GetObject<C##Name_##Definition>(C##Name_##Definition::GetDefName()) << std::endl;
-#define DECLARE_NODE_PAR(Name_, name_)
-#include "node_type.conf"
-
-         }
-
-         oss << "</ " << CContext::GetName() << " >";
-
-         return (oss.str());
-      }
-
-      void CContext::solveDescInheritance(const CAttributeMap * const UNUSED(parent))
-      {
-#define DECLARE_NODE(Name_, name_)    \
-   if (CObjectFactory::HasObject<C##Name_##Definition>(C##Name_##Definition::GetDefName())) \
-      CObjectFactory::GetObject<C##Name_##Definition>(C##Name_##Definition::GetDefName())->solveDescInheritance();
-#define DECLARE_NODE_PAR(Name_, name_)
-#include "node_type.conf"
-      }
-
-      bool CContext::hasChild(void) const
-      {
-         return (false ||
-#define DECLARE_NODE(Name_, name_)    \
-   CObjectFactory::HasObject<C##Name_##Definition>  (C##Name_##Definition::GetDefName())   ||
-#define DECLARE_NODE_PAR(Name_, name_)
-#include "node_type.conf"
-         false);
-      }
-
-      void CContext::solveFieldRefInheritance(void)
-      {
-         if (!this->hasId()) return;
-         std::vector<boost::shared_ptr<CField> > allField
-                  = CObjectTemplate<CField>::GetAllVectobject(this->getId());
-         std::vector<boost::shared_ptr<CField> >::iterator 
-            it = allField.begin(), end = allField.end();
-               
-         for (; it != end; it++)
-         {
-            boost::shared_ptr<CField> field = *it;
-            field->solveRefInheritance();
-         }
-      }
-
-   } // namespace tree
+} // namespace tree
 } // namespace xmlioserver
Index: XMLIO_V2/dev/dev_rv/src/xmlio/node/context.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/xmlio/node/context.hpp	(revision 157)
+++ XMLIO_V2/dev/dev_rv/src/xmlio/node/context.hpp	(revision 168)
@@ -8,77 +8,80 @@
 #include "declare_group.hpp"
 
-namespace xmlioserver
-{
-   namespace tree
+namespace xmlioserver {
+namespace tree {
+   
+   /// ////////////////////// DÃ©clarations ////////////////////// ///
+   class CContextGroup;
+   class CContextAttributes;
+   class CContext;
+
+   ///--------------------------------------------------------------
+
+   // Declare/Define CFileAttribute
+   BEGIN_DECLARE_ATTRIBUTE_MAP(CContext)
+   #include "context_attribute.conf"
+   END_DECLARE_ATTRIBUTE_MAP(CContext)
+
+   ///--------------------------------------------------------------
+
+   class CContext
+      : public CObjectTemplate<CContext>
+      , public CContextAttributes
    {
-      /// ////////////////////// DÃ©clarations ////////////////////// ///
-      class CContextGroup;
-      class CContextAttributes;
-      class CContext;
+         /// typedef ///
+         typedef CObjectTemplate<CContext>   SuperClass;
+         typedef CContextAttributes SuperClassAttribute;
 
-      ///--------------------------------------------------------------
+      public :
 
-      // Declare/Define CFileAttribute
-      BEGIN_DECLARE_ATTRIBUTE_MAP(CContext)
-#include "context_attribute.conf"
-      END_DECLARE_ATTRIBUTE_MAP(CContext)
+         typedef CContextAttributes RelAttributes;
+         typedef CContext           RelGroup;
 
-      ///--------------------------------------------------------------
+         //---------------------------------------------------------
 
-      class CContext
-         : public CObjectTemplate<CContext>
-         , public CContextAttributes
-      {
-            /// typedef ///
-            typedef CObjectTemplate<CContext>   SuperClass;
-            typedef CContextAttributes SuperClassAttribute;
+         /// Constructeurs ///
+         CContext(void);
+         explicit CContext(const StdString & id);
+         CContext(const CContext & context);       // Not implemented yet.
+         CContext(const CContext * const context); // Not implemented yet.
 
-         public :
+         /// Destructeur ///
+         virtual ~CContext(void);
 
-            typedef CContextAttributes RelAttributes;
-            typedef CContext           RelGroup;
+         //---------------------------------------------------------
 
-            //---------------------------------------------------------
+         /// Accesseurs statiques ///
+         static StdString GetName(void);
+         static StdString GetDefName(void);
+         
+         static ENodeType GetType(void);
 
-            /// Constructeurs ///
-            CContext(void);
-            explicit CContext(const StdString & id);
-            CContext(const CContext & context);       // Not implemented yet.
-            CContext(const CContext * const context); // Not implemented yet.
+         static boost::shared_ptr<CContextGroup> GetContextGroup(void);
 
-            /// Destructeur ///
-            virtual ~CContext(void);
+         /// Traitements ///
+         virtual void solveDescInheritance(const CAttributeMap * const parent = 0);
+         void solveFieldRefInheritance(void);
 
-            //---------------------------------------------------------
+         /// Autres mÃ©thodes statiques ///
+         static void ShowTree(StdOStream & out = std::clog);
 
-            /// Accesseurs statiques ///
-            static StdString GetName(void);
-            static StdString GetDefName(void);
+         /// Test ///
+         virtual bool hasChild(void) const;
 
-            static boost::shared_ptr<CContextGroup> GetContextGroup(void);
+         /// Autres ///
+         virtual void parse(xml::CXMLNode & node);
 
-            /// Traitements ///
-            virtual void solveDescInheritance(const CAttributeMap * const parent = 0);
-            void solveFieldRefInheritance(void);
+         virtual StdString toString(void) const;
 
-            /// Autres mÃ©thodes statiques ///
-            static void ShowTree(StdOStream & out = std::clog);
+   }; // class CContext
 
-            /// Test ///
-            virtual bool hasChild(void) const;
+   ///--------------------------------------------------------------
 
-            /// Autres ///
-            virtual void parse(xml::CXMLNode & node);
+   // Declare/Define CContextGroup and CContextDefinition
+   DECLARE_GROUP(CContext);
 
-            virtual StdString toString(void) const;
+   ///--------------------------------------------------------------
 
-      }; // class CContext
-
-      ///--------------------------------------------------------------
-
-      // Declare/Define CContextGroup and CContextDefinition
-      DECLARE_GROUP(CContext);
-
-   } // namespace tree
+} // namespace tree
 } // namespace xmlioserver
 
Index: XMLIO_V2/dev/dev_rv/src/xmlio/node/domain.cpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/xmlio/node/domain.cpp	(revision 157)
+++ XMLIO_V2/dev/dev_rv/src/xmlio/node/domain.cpp	(revision 168)
@@ -5,296 +5,301 @@
 #include "group_template_impl.hpp"
 
-namespace xmlioserver
-{
-   namespace tree
-   {
-      /// ////////////////////// DÃ©finitions ////////////////////// ///
-
-      CDomain::CDomain(void)
-         : CObjectTemplate<CDomain>(), CDomainAttributes()
-         , isChecked(false), local_mask(new CMask()), relFiles()
-      { /* Ne rien faire de plus */ }
-
-      CDomain::CDomain(const StdString & id)
-         : CObjectTemplate<CDomain>(id), CDomainAttributes()
-         , isChecked(false), local_mask(new CMask()), relFiles()
-      { /* Ne rien faire de plus */ }
-
-      CDomain::~CDomain(void)
-      { /* Ne rien faire de plus */ }
-
-      ///---------------------------------------------------------------
-
-      const std::set<StdString> & CDomain::getRelFiles(void) const
-      {
-         return (this->relFiles);
-      }
-
-      bool CDomain::IsWritten(const StdString & filename) const
-      {
-         return (this->relFiles.find(filename) != this->relFiles.end());
-      }
-
-      void CDomain::addRelFile(const StdString & filename)
-      {
-         this->relFiles.insert(filename);
-      }
-
-      //----------------------------------------------------------------
-
-      StdString CDomain::GetName(void)   { return (StdString("domain")); }
-      StdString CDomain::GetDefName(void){ return (CDomain::GetName()); }
-
-      //----------------------------------------------------------------
-
-      void CDomain::checkGlobalDomain(void)
-      {
-         if ((ni_glo.isEmpty() || ni_glo.getValue() <= 0 ) ||
-             (ni_glo.isEmpty() || nj_glo.getValue() <= 0 ))
+namespace xmlioserver {
+namespace tree {
+   
+   /// ////////////////////// DÃ©finitions ////////////////////// ///
+
+   CDomain::CDomain(void)
+      : CObjectTemplate<CDomain>(), CDomainAttributes()
+      , isChecked(false), local_mask(new CMask()), relFiles()
+   { /* Ne rien faire de plus */ }
+
+   CDomain::CDomain(const StdString & id)
+      : CObjectTemplate<CDomain>(id), CDomainAttributes()
+      , isChecked(false), local_mask(new CMask()), relFiles()
+   { /* Ne rien faire de plus */ }
+
+   CDomain::~CDomain(void)
+   { /* Ne rien faire de plus */ }
+
+   ///---------------------------------------------------------------
+
+   const std::set<StdString> & CDomain::getRelFiles(void) const
+   {
+      return (this->relFiles);
+   }
+
+   bool CDomain::IsWritten(const StdString & filename) const
+   {
+      return (this->relFiles.find(filename) != this->relFiles.end());
+   }
+
+   void CDomain::addRelFile(const StdString & filename)
+   {
+      this->relFiles.insert(filename);
+   }
+
+   //----------------------------------------------------------------
+
+   StdString CDomain::GetName(void)   { return (StdString("domain")); }
+   StdString CDomain::GetDefName(void){ return (CDomain::GetName()); }
+   ENodeType CDomain::GetType(void)   { return (eDomain); }
+
+   //----------------------------------------------------------------
+
+   void CDomain::checkGlobalDomain(void)
+   {
+      if ((ni_glo.isEmpty() || ni_glo.getValue() <= 0 ) ||
+          (ni_glo.isEmpty() || nj_glo.getValue() <= 0 ))
+         ERROR("CDomain::checkAttributes(void)",
+               << "Le domaine global est mal dÃ©fini,"
+               << " vÃ©rifiez les valeurs de \'ni_glo\' et \'nj_glo\' !") ;
+   }
+
+
+   //----------------------------------------------------------------
+
+   void CDomain::checkLocalIDomain(void)
+   {
+      if (!ni.isEmpty() && !ibegin.isEmpty() && iend.isEmpty())
+         iend.setValue(ibegin.getValue() + ni.getValue() - 1) ;
+
+      else if (!ni.isEmpty() && !iend.isEmpty()   && ibegin.isEmpty())
+         ibegin.setValue( - ni.getValue() + iend.getValue() + 1) ;
+
+      else if (!ibegin.isEmpty() && !iend.isEmpty() && ni.isEmpty())
+         ni.setValue(iend.getValue() - ibegin.getValue() + 1) ;
+
+      else if (!ibegin.isEmpty() && !iend.isEmpty() &&
+               !ni.isEmpty() && (iend.getValue() != ibegin.getValue() + ni.getValue() - 1))
+      {
+         ERROR("CDomain::checkAttributes(void)",
+               << "Le domaine est mal dÃ©fini,"
+               << " iend est diffÃ©rent de (ibegin + ni - 1) !") ;
+      }
+      else
+      {
+         ERROR("CDomain::checkAttributes(void)",
+               << "Le domaine est mal dÃ©fini,"
+               << " deux valeurs au moins parmis iend, ibegin, ni doivent Ãªtre dÃ©finies !") ;
+      }
+
+
+      if (ni.getValue() < 0 || ibegin.getValue() > iend.getValue() ||
+          ibegin.getValue() < 1 || iend.getValue() > ni_glo.getValue())
+         ERROR("CDomain::checkAttributes(void)",
+               << "Domaine local mal dÃ©fini,"
+               << " vÃ©rifiez les valeurs ni, ni_glo, ibegin, iend") ;
+
+   }
+
+   //----------------------------------------------------------------
+
+   void CDomain::checkLocalJDomain(void)
+   {
+      if (!nj.isEmpty() && !jbegin.isEmpty() && jend.isEmpty())
+         jend.setValue(jbegin.getValue() + nj.getValue() - 1) ;
+
+      else if (!nj.isEmpty() && !jend.isEmpty() && jbegin.isEmpty())
+         jbegin.setValue( - nj.getValue() + jend.getValue() + 1) ;
+
+      else if (!jbegin.isEmpty() && !jend.isEmpty() && nj.isEmpty())
+         nj.setValue(jend.getValue() - jbegin.getValue() + 1) ;
+
+      else if (!jbegin.isEmpty() && !jend.isEmpty() &&
+               !nj.isEmpty() && (jend.getValue() != jbegin.getValue() + nj.getValue() - 1))
+      {
+         ERROR("CDomain::checkAttributes(void)",
+               << "Le domaine est mal dÃ©fini,"
+               << " iend est diffÃ©rent de (jbegin + nj - 1) !") ;
+      }
+      else
+      {
+         ERROR("CDomain::checkAttributes(void)",
+               << "Le domaine est mal dÃ©fini,"
+               << " deux valeurs au moins parmis jend, jbegin, nj doivent Ãªtre dÃ©finies !") ;
+      }
+
+      if (nj.getValue() < 0 || jbegin.getValue() > jend.getValue() ||
+          jbegin.getValue() < 1 || jend.getValue() > nj_glo.getValue())
+         ERROR("CDomain::checkAttributes(void)",
+               << "Domaine local mal dÃ©fini,"
+               << " vÃ©rifiez les valeurs nj, nj_glo, jbegin, jend") ;
+   }
+
+
+   //----------------------------------------------------------------
+
+   void CDomain::checkMask(void)
+   {
+      if (!mask.isEmpty())
+      {
+         unsigned int niu = ni.getValue(), nju = nj.getValue();
+         if ((mask.getValue()->shape()[0] != niu) ||
+             (mask.getValue()->shape()[1] != nju))
             ERROR("CDomain::checkAttributes(void)",
-                  << "Le domaine global est mal dÃ©fini,"
-                  << " vÃ©rifiez les valeurs de \'ni_glo\' et \'nj_glo\' !") ;
-      }
-
-
-      //----------------------------------------------------------------
-
-      void CDomain::checkLocalIDomain(void)
-      {
-         if (!ni.isEmpty() && !ibegin.isEmpty() && iend.isEmpty())
-            iend.setValue(ibegin.getValue() + ni.getValue() - 1) ;
-
-         else if (!ni.isEmpty() && !iend.isEmpty()   && ibegin.isEmpty())
-            ibegin.setValue( - ni.getValue() + iend.getValue() + 1) ;
-
-         else if (!ibegin.isEmpty() && !iend.isEmpty() && ni.isEmpty())
-            ni.setValue(iend.getValue() - ibegin.getValue() + 1) ;
-
-         else if (!ibegin.isEmpty() && !iend.isEmpty() &&
-                  !ni.isEmpty() && (iend.getValue() != ibegin.getValue() + ni.getValue() - 1))
+                  <<"Le masque n'a pas la mÃªme taille que le domaine local") ;
+      }
+      else // (!mask.hasValue())
+      { // Si aucun masque n'est dÃ©fini,
+        // on en crÃ©e un nouveau qui valide l'intÃ©gralitÃ© du domaine.
+         ARRAY_CREATE(__arr, bool, 2, [ni.getValue()][nj.getValue()]);
+         for (int i = 0; i < ni.getValue(); i++)
+            for (int j = 0; j < nj.getValue(); j++)
+               (*__arr)[i][j] = true;
+         mask.setValue(__arr);
+      }
+
+   }
+
+
+   //----------------------------------------------------------------
+
+   void CDomain::checkDomainData(void)
+   {
+      if (!data_dim.isEmpty() &&
+         !(data_dim.getValue() == 1 || data_dim.getValue() == 2))
+      {
+         ERROR("CDomain::checkAttributes(void)",
+               << "Dimension des donnÃ©es non comptatible (doit Ãªtre 1 ou 2) !") ;
+      }
+      else if (data_dim.isEmpty())
+      {
+         ERROR("CDomain::checkAttributes(void)",
+               << "Dimension des donnÃ©es non dÃ©finie !") ;
+      }
+
+      if (data_ibegin.isEmpty())
+         data_ibegin.setValue(0) ;
+      if (data_jbegin.isEmpty() && (data_dim.getValue() == 2))
+           data_jbegin.setValue(0) ;
+
+      if (!data_ni.isEmpty() && (data_ni.getValue() <= 0))
+      {
+         ERROR("CDomain::checkAttributes(void)",
+               << "Dimension des donnÃ©es nÃ©gative (data_ni).") ;
+      }
+      else if (data_ni.isEmpty())
+      {
+         data_ni.setValue((data_dim.getValue() == 1)
+                           ? (ni.getValue() * nj.getValue())
+                           : ni.getValue());
+      }
+
+      if (data_dim.getValue() == 2)
+      {
+         if (!data_nj.isEmpty() && (data_nj.getValue() <= 0) )
          {
             ERROR("CDomain::checkAttributes(void)",
-                  << "Le domaine est mal dÃ©fini,"
-                  << " iend est diffÃ©rent de (ibegin + ni - 1) !") ;
-         }
-         else
+                  << "Dimension des donnÃ©es nÃ©gative (data_nj).") ;
+         }
+         else if (data_nj.isEmpty())
+            data_nj.setValue(nj.getValue()) ;
+      }
+
+   }
+
+   //----------------------------------------------------------------
+
+   void CDomain::checkCompression(void)
+   {
+      if (!data_i_index.isEmpty())
+      {
+         int ssize = data_i_index.getValue()->size();
+         if (!data_n_index.isEmpty() &&
+            (data_n_index.getValue() != ssize))
          {
             ERROR("CDomain::checkAttributes(void)",
-                  << "Le domaine est mal dÃ©fini,"
-                  << " deux valeurs au moins parmis iend, ibegin, ni doivent Ãªtre dÃ©finies !") ;
-         }
-
-
-         if (ni.getValue() < 0 || ibegin.getValue() > iend.getValue() ||
-             ibegin.getValue() < 1 || iend.getValue() > ni_glo.getValue())
-            ERROR("CDomain::checkAttributes(void)",
-                  << "Domaine local mal dÃ©fini,"
-                  << " vÃ©rifiez les valeurs ni, ni_glo, ibegin, iend") ;
-
-      }
-
-      //----------------------------------------------------------------
-
-      void CDomain::checkLocalJDomain(void)
-      {
-         if (!nj.isEmpty() && !jbegin.isEmpty() && jend.isEmpty())
-            jend.setValue(jbegin.getValue() + nj.getValue() - 1) ;
-
-         else if (!nj.isEmpty() && !jend.isEmpty() && jbegin.isEmpty())
-            jbegin.setValue( - nj.getValue() + jend.getValue() + 1) ;
-
-         else if (!jbegin.isEmpty() && !jend.isEmpty() && nj.isEmpty())
-            nj.setValue(jend.getValue() - jbegin.getValue() + 1) ;
-
-         else if (!jbegin.isEmpty() && !jend.isEmpty() &&
-                  !nj.isEmpty() && (jend.getValue() != jbegin.getValue() + nj.getValue() - 1))
-         {
-            ERROR("CDomain::checkAttributes(void)",
-                  << "Le domaine est mal dÃ©fini,"
-                  << " iend est diffÃ©rent de (jbegin + nj - 1) !") ;
-         }
-         else
-         {
-            ERROR("CDomain::checkAttributes(void)",
-                  << "Le domaine est mal dÃ©fini,"
-                  << " deux valeurs au moins parmis jend, jbegin, nj doivent Ãªtre dÃ©finies !") ;
-         }
-
-         if (nj.getValue() < 0 || jbegin.getValue() > jend.getValue() ||
-             jbegin.getValue() < 1 || jend.getValue() > nj_glo.getValue())
-            ERROR("CDomain::checkAttributes(void)",
-                  << "Domaine local mal dÃ©fini,"
-                  << " vÃ©rifiez les valeurs nj, nj_glo, jbegin, jend") ;
-      }
-
-
-      //----------------------------------------------------------------
-
-      void CDomain::checkMask(void)
-      {
-         if (!mask.isEmpty())
-         {
-            unsigned int niu = ni.getValue(), nju = nj.getValue();
-            if ((mask.getValue()->shape()[0] != niu) ||
-                (mask.getValue()->shape()[1] != nju))
-               ERROR("CDomain::checkAttributes(void)",
-                     <<"Le masque n'a pas la mÃªme taille que le domaine local") ;
-         }
-         else // (!mask.hasValue())
-         { // Si aucun masque n'est dÃ©fini,
-           // on en crÃ©e un nouveau qui valide l'intÃ©gralitÃ© du domaine.
-            ARRAY_CREATE(__arr, bool, 2, [ni.getValue()][nj.getValue()]);
-            for (int i = 0; i < ni.getValue(); i++)
-               for (int j = 0; j < nj.getValue(); j++)
-                  (*__arr)[i][j] = true;
-            mask.setValue(__arr);
-         }
-
-      }
-
-
-      //----------------------------------------------------------------
-
-      void CDomain::checkDomainData(void)
-      {
-         if (!data_dim.isEmpty() &&
-            !(data_dim.getValue() == 1 || data_dim.getValue() == 2))
-         {
-            ERROR("CDomain::checkAttributes(void)",
-                  << "Dimension des donnÃ©es non comptatible (doit Ãªtre 1 ou 2) !") ;
-         }
-         else if (data_dim.isEmpty())
-         {
-            ERROR("CDomain::checkAttributes(void)",
-                  << "Dimension des donnÃ©es non dÃ©finie !") ;
-         }
-
-         if (data_ibegin.isEmpty())
-            data_ibegin.setValue(0) ;
-         if (data_jbegin.isEmpty() && (data_dim.getValue() == 2))
-              data_jbegin.setValue(0) ;
-
-         if (!data_ni.isEmpty() && (data_ni.getValue() <= 0))
-         {
-            ERROR("CDomain::checkAttributes(void)",
-                  << "Dimension des donnÃ©es nÃ©gative (data_ni).") ;
-         }
-         else if (data_ni.isEmpty())
-         {
-            data_ni.setValue((data_dim.getValue() == 1)
-                              ? (ni.getValue() * nj.getValue())
-                              : ni.getValue());
-         }
+                  <<"Dimension data_i_index incompatible avec data_n_index.") ;
+         }
+         else if (data_n_index.isEmpty())
+            data_n_index.setValue(ssize) ;
 
          if (data_dim.getValue() == 2)
          {
-            if (!data_nj.isEmpty() && (data_nj.getValue() <= 0) )
+            if (!data_j_index.isEmpty() &&
+               (data_j_index.getValue()->size() != data_i_index.getValue()->size()))
             {
                ERROR("CDomain::checkAttributes(void)",
-                     << "Dimension des donnÃ©es nÃ©gative (data_nj).") ;
+                     <<"Dimension data_j_index incompatible avec data_i_index.") ;
             }
-            else if (data_nj.isEmpty())
-               data_nj.setValue(nj.getValue()) ;
-         }
-
-      }
-
-      //----------------------------------------------------------------
-
-      void CDomain::checkCompression(void)
-      {
-         if (!data_i_index.isEmpty())
-         {
-            int ssize = data_i_index.getValue()->size();
-            if (!data_n_index.isEmpty() &&
-               (data_n_index.getValue() != ssize))
+            else if (data_j_index.isEmpty())
             {
                ERROR("CDomain::checkAttributes(void)",
-                     <<"Dimension data_i_index incompatible avec data_n_index.") ;
+                     <<"La donnÃ©e data_j_index doit Ãªtre renseignÃ©e !") ;
             }
-            else if (data_n_index.isEmpty())
-               data_n_index.setValue(ssize) ;
-
-            if (data_dim.getValue() == 2)
-            {
-               if (!data_j_index.isEmpty() &&
-                  (data_j_index.getValue()->size() != data_i_index.getValue()->size()))
-               {
-                  ERROR("CDomain::checkAttributes(void)",
-                        <<"Dimension data_j_index incompatible avec data_i_index.") ;
+         }
+      }
+      else
+      {
+         if (!data_n_index.isEmpty() ||
+            ((data_dim.getValue() == 2) && (!data_j_index.isEmpty())))
+            ERROR("CDomain::checkAttributes(void)", << "data_i_index non dÃ©fini") ;
+      }
+
+      if (data_n_index.isEmpty())
+      { // -> bloc re-vÃ©rifiÃ© OK
+         if (data_dim.getValue() == 1)
+         {
+            const int dni = data_ni.getValue();
+            ARRAY_CREATE(__arri, int, 1, [dni]);
+            data_n_index.setValue(dni);
+            for (int i = 0; i < dni; i++)
+               (*__arri)[i] = i+1 ;
+            data_i_index.setValue(__arri) ;
+         }
+         else   // (data_dim == 2)
+         {
+            const int dni = data_ni.getValue() * data_nj.getValue();
+            ARRAY_CREATE(__arri, int, 1, [dni]);
+            ARRAY_CREATE(__arrj, int, 1, [dni]);               
+            data_n_index.setValue(dni);
+            
+            for(int count = 0, i = 0; i  < data_ni.getValue(); i++)
+               for(int j = 0; j < data_nj.getValue(); j++, count++)
+               { 
+                  (*__arri)[count] = i+1 ;
+                  (*__arrj)[count] = j+1 ;
                }
-               else if (data_j_index.isEmpty())
-               {
-                  ERROR("CDomain::checkAttributes(void)",
-                        <<"La donnÃ©e data_j_index doit Ãªtre renseignÃ©e !") ;
-               }
-            }
-         }
-         else
-         {
-            if (!data_n_index.isEmpty() ||
-               ((data_dim.getValue() == 2) && (!data_j_index.isEmpty())))
-               ERROR("CDomain::checkAttributes(void)", << "data_i_index non dÃ©fini") ;
-         }
-
-         if (data_n_index.isEmpty())
-         { // -> bloc re-vÃ©rifiÃ© OK
-            if (data_dim.getValue() == 1)
-            {
-               const int dni = data_ni.getValue();
-               ARRAY_CREATE(__arri, int, 1, [dni]);
-               data_n_index.setValue(dni);
-               for (int i = 0; i < dni; i++)
-                  (*__arri)[i] = i+1 ;
-               data_i_index.setValue(__arri) ;
-            }
-            else   // (data_dim == 2)
-            {
-               const int dni = data_ni.getValue() * data_nj.getValue();
-               ARRAY_CREATE(__arri, int, 1, [dni]);
-               ARRAY_CREATE(__arrj, int, 1, [dni]);
-               data_n_index.setValue(dni);
-               for(int count = 0, i = 0; i  < data_ni.getValue(); i++)
-                  for(int j = 0; j < data_nj.getValue(); j++, count++)
-               { (*__arri)[count] = i+1 ;  (*__arrj)[count] = j+1 ; }
-               data_i_index.setValue(__arri) ;
-               data_j_index.setValue(__arrj) ;
-            }
-         }
-      }
-
-      //----------------------------------------------------------------
-
-      void CDomain::checkAttributes(void)
-      {
-         if (this->isChecked) return;
-
-         this->checkGlobalDomain();
-         this->checkLocalIDomain();
-         this->checkLocalJDomain();
-
-         this->checkMask();
-         this->checkDomainData();
-         this->checkCompression();
-         this->completeMask();
-
-         this->isChecked = true;
-      }
-
-      void CDomain::completeMask(void)
-      {
-         this->local_mask->resize(data_ni.getValue(), data_nj.getValue());
-         /*this->local_mask->setDataPosition
-            (data_dim.getValue(), data_ni.getValue(), data_nj.getValue(),
-             data_ibegin.getValue(), data_jbegin.getValue(), data_n_index.getValue(),
-             data_i_index.getValue(), data_j_index.getValue());*/
-      }
-
-      boost::shared_ptr<CMask> CDomain::getLocalMask(void) const
-      {
-         return (this->local_mask);
-      }
-      ///---------------------------------------------------------------
-
-   } // namespace tree
+               
+            data_i_index.setValue(__arri) ;
+            data_j_index.setValue(__arrj) ;
+         }
+      }
+   }
+
+   //----------------------------------------------------------------
+
+   void CDomain::checkAttributes(void)
+   {
+      if (this->isChecked) return;
+
+      this->checkGlobalDomain();
+      this->checkLocalIDomain();
+      this->checkLocalJDomain();
+
+      this->checkMask();
+      this->checkDomainData();
+      this->checkCompression();
+      this->completeMask();
+
+      this->isChecked = true;
+   }
+
+   void CDomain::completeMask(void)
+   {
+      this->local_mask->resize(data_ni.getValue(), data_nj.getValue());
+      /*this->local_mask->setDataPosition
+         (data_dim.getValue(), data_ni.getValue(), data_nj.getValue(),
+          data_ibegin.getValue(), data_jbegin.getValue(), data_n_index.getValue(),
+          data_i_index.getValue(), data_j_index.getValue());*/
+   }
+
+   boost::shared_ptr<CMask> CDomain::getLocalMask(void) const
+   {
+      return (this->local_mask);
+   }
+   ///---------------------------------------------------------------
+
+} // namespace tree
 } // namespace xmlioserver
Index: XMLIO_V2/dev/dev_rv/src/xmlio/node/domain.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/xmlio/node/domain.hpp	(revision 157)
+++ XMLIO_V2/dev/dev_rv/src/xmlio/node/domain.hpp	(revision 168)
@@ -9,92 +9,95 @@
 #include "declare_group.hpp"
 
-namespace xmlioserver
-{
-   namespace tree
+namespace xmlioserver {
+namespace tree {
+   
+   /// ////////////////////// DÃ©clarations ////////////////////// ///
+
+   class CDomainGroup;
+   class CDomainAttributes;
+   class CDomain;
+
+   ///--------------------------------------------------------------
+
+   // Declare/Define CDomainAttribute
+   BEGIN_DECLARE_ATTRIBUTE_MAP(CDomain)
+   #include "domain_attribute.conf"
+   END_DECLARE_ATTRIBUTE_MAP(CDomain)
+
+   ///--------------------------------------------------------------
+
+   class CDomain
+      : public CObjectTemplate<CDomain>
+      , public CDomainAttributes
    {
-      /// ////////////////////// DÃ©clarations ////////////////////// ///
+         /// typedef ///
+         typedef CObjectTemplate<CDomain>   SuperClass;
+         typedef CDomainAttributes SuperClassAttribute;
 
-      class CDomainGroup;
-      class CDomainAttributes;
-      class CDomain;
+      public :
 
-      ///--------------------------------------------------------------
+         typedef CDomainAttributes RelAttributes;
+         typedef CDomainGroup      RelGroup;
 
-      // Declare/Define CDomainAttribute
-      BEGIN_DECLARE_ATTRIBUTE_MAP(CDomain)
-#include "domain_attribute.conf"
-      END_DECLARE_ATTRIBUTE_MAP(CDomain)
+         /// Constructeurs ///
+         CDomain(void);
+         explicit CDomain(const StdString & id);
+         CDomain(const CDomain & domain);       // Not implemented yet.
+         CDomain(const CDomain * const domain); // Not implemented yet.
 
-      ///--------------------------------------------------------------
+         /// VÃ©rifications ///
+         void checkAttributes(void);
 
-      class CDomain
-         : public CObjectTemplate<CDomain>
-         , public CDomainAttributes
-      {
-            /// typedef ///
-            typedef CObjectTemplate<CDomain>   SuperClass;
-            typedef CDomainAttributes SuperClassAttribute;
+      private :
 
-         public :
+         virtual void checkGlobalDomain(void);
 
-            typedef CDomainAttributes RelAttributes;
-            typedef CDomainGroup      RelGroup;
+         virtual void checkLocalIDomain(void);
+         virtual void checkLocalJDomain(void);
 
-            /// Constructeurs ///
-            CDomain(void);
-            explicit CDomain(const StdString & id);
-            CDomain(const CDomain & domain);       // Not implemented yet.
-            CDomain(const CDomain * const domain); // Not implemented yet.
+         virtual void checkMask(void);
+         virtual void checkDomainData(void);
+         virtual void checkCompression(void);
 
-            /// VÃ©rifications ///
-            void checkAttributes(void);
+         virtual void completeMask(void);
 
-         private :
+      public :
 
-            virtual void checkGlobalDomain(void);
+         /// Accesseurs ///
+         boost::shared_ptr<CMask> getLocalMask(void) const;
+         const std::set<StdString> & getRelFiles(void) const;
 
-            virtual void checkLocalIDomain(void);
-            virtual void checkLocalJDomain(void);
+         /// Test ///
+         bool IsWritten(const StdString & filename) const;
 
-            virtual void checkMask(void);
-            virtual void checkDomainData(void);
-            virtual void checkCompression(void);
+         /// Mutateur ///
+         void addRelFile(const StdString & filename);
 
-            virtual void completeMask(void);
+         /// Destructeur ///
+         virtual ~CDomain(void);
 
-         public :
+         /// Accesseurs statiques ///
+         static StdString GetName(void);
+         static StdString GetDefName(void);
+         
+         static ENodeType GetType(void);
 
-            /// Accesseurs ///
-            boost::shared_ptr<CMask> getLocalMask(void) const;
-            const std::set<StdString> & getRelFiles(void) const;
+       private :
 
-            /// Test ///
-            bool IsWritten(const StdString & filename) const;
+         /// ProriÃ©tÃ©s protÃ©gÃ©es ///
+         bool isChecked;
+         boost::shared_ptr<CMask> local_mask;
+         std::set<StdString> relFiles;
 
-            /// Mutateur ///
-            void addRelFile(const StdString & filename);
+   }; // class CDomain
 
-            /// Destructeur ///
-            virtual ~CDomain(void);
+   ///--------------------------------------------------------------
 
-            /// Accesseurs statiques ///
-            static StdString GetName(void);
-            static StdString GetDefName(void);
+   // Declare/Define CDomainGroup and CDomainDefinition
+   DECLARE_GROUP(CDomain);
 
-          private :
+   ///--------------------------------------------------------------
 
-            /// ProriÃ©tÃ©s protÃ©gÃ©es ///
-            bool isChecked;
-            boost::shared_ptr<CMask> local_mask;
-            std::set<StdString> relFiles;
-
-      }; // class CDomain
-
-      ///--------------------------------------------------------------
-
-      // Declare/Define CDomainGroup and CDomainDefinition
-      DECLARE_GROUP(CDomain);
-
-   } // namespace tree
+} // namespace tree
 } // namespace xmlioserver
 
Index: XMLIO_V2/dev/dev_rv/src/xmlio/node/field.cpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/xmlio/node/field.cpp	(revision 157)
+++ XMLIO_V2/dev/dev_rv/src/xmlio/node/field.cpp	(revision 168)
@@ -7,164 +7,195 @@
 #include "node_type.hpp"
 
-namespace xmlioserver
-{
-   namespace tree
-   {
-      /// ////////////////////// DÃ©finitions ////////////////////// ///
-
-      CField::CField(void)
-         : CObjectTemplate<CField>(), CFieldAttributes()
-         , baseRefObject(), refObject(), grid(), file(), foperation(NULL)
-      { /* Ne rien faire de plus */ }
-
-      CField::CField(const StdString & id)
-         : CObjectTemplate<CField>(id), CFieldAttributes()
-         , baseRefObject(), refObject(), foperation(NULL)
-      { /* Ne rien faire de plus */ }
-
-      CField::~CField(void)
-      {
-         if (this->foperation == NULL)
-            delete this->foperation;
-      }
-
-      void CField::setRelFile(const boost::shared_ptr<CFile> _file)
-      { this->file = _file; }
-
-      //----------------------------------------------------------------
-
-      StdString CField::GetName(void)   { return (StdString("field")); }
-      StdString CField::GetDefName(void){ return (CField::GetName()); }
-
-      boost::shared_ptr<CGrid> CField::getRelGrid(void) const
-      { return (this->grid); }
-
-      boost::shared_ptr<CFile> CField::getRelFile(void) const
-      { return (this->file); }
-
-      boost::shared_ptr<CField> CField::getDirectFieldReference(void) const
-      {
-         if (this->field_ref.isEmpty())
-            return (this->getBaseFieldReference());
-
-         if (! CObjectFactory::HasObject<CField>(this->field_ref.getValue()))
-            ERROR("CField::getDirectFieldReference(void)",
-                  << "[ ref_name = " << this->field_ref.getValue() << "]"
-                  << " invalid field name !");
-
-         return (CObjectFactory::GetObject<CField>(this->field_ref.getValue()));
-      }
-
-      const boost::shared_ptr<CField>
-         CField::getBaseFieldReference(void) const { return (baseRefObject); }
-
-      const std::vector<boost::shared_ptr<CField> > &
-         CField::getAllReference(void) const { return (refObject); }
-
-      const StdString & CField::getBaseFieldId(void) const
-      { return (this->getBaseFieldReference()->getId()); }
-
-      bool CField::hasDirectFieldReference(void) const
-      { return (!this->field_ref.isEmpty()); }
-
-      //----------------------------------------------------------------
-
-      void CField::solveRefInheritance(void)
-      {
-         std::set<CField *> sset;
-         boost::shared_ptr<CField> refer_sptr;
-         CField * refer_ptr = this;
-         this->baseRefObject = CObjectFactory::GetObject<CField>(this);
-         while (refer_ptr->hasDirectFieldReference())
+namespace xmlioserver{
+namespace tree {
+   
+   /// ////////////////////// DÃ©finitions ////////////////////// ///
+
+   CField::CField(void)
+      : CObjectTemplate<CField>(), CFieldAttributes()
+      , baseRefObject(), refObject(), grid(), file(), foperation(NULL)
+   { /* Ne rien faire de plus */ }
+
+   CField::CField(const StdString & id)
+      : CObjectTemplate<CField>(id), CFieldAttributes()
+      , baseRefObject(), refObject(), foperation(NULL)
+   { /* Ne rien faire de plus */ }
+
+   CField::~CField(void)
+   {
+      if (this->foperation == NULL)
+         delete this->foperation;
+   }
+
+   //----------------------------------------------------------------
+
+   void CField::setRelFile(const boost::shared_ptr<CFile> _file)
+   { 
+      this->file = _file; 
+   }
+
+   //----------------------------------------------------------------
+
+   StdString CField::GetName(void)   { return (StdString("field")); }
+   StdString CField::GetDefName(void){ return (CField::GetName()); }
+   ENodeType CField::GetType(void)   { return (eField); }
+
+   //----------------------------------------------------------------
+
+   boost::shared_ptr<CGrid> CField::getRelGrid(void) const
+   { 
+      return (this->grid); 
+   }
+
+   //----------------------------------------------------------------
+
+   boost::shared_ptr<CFile> CField::getRelFile(void) const
+   { 
+      return (this->file);
+   }
+
+   //----------------------------------------------------------------
+
+   boost::shared_ptr<CField> CField::getDirectFieldReference(void) const
+   {
+      if (this->field_ref.isEmpty())
+         return (this->getBaseFieldReference());
+
+      if (! CObjectFactory::HasObject<CField>(this->field_ref.getValue()))
+         ERROR("CField::getDirectFieldReference(void)",
+               << "[ ref_name = " << this->field_ref.getValue() << "]"
+               << " invalid field name !");
+
+      return (CObjectFactory::GetObject<CField>(this->field_ref.getValue()));
+   }
+
+   //----------------------------------------------------------------
+
+   const boost::shared_ptr<CField> CField::getBaseFieldReference(void) const
+   { 
+      return (baseRefObject); 
+   }
+
+   //----------------------------------------------------------------
+
+   const std::vector<boost::shared_ptr<CField> > & CField::getAllReference(void) const 
+   { 
+      return (refObject);
+   }
+
+   //----------------------------------------------------------------
+
+   const StdString & CField::getBaseFieldId(void) const
+   { 
+      return (this->getBaseFieldReference()->getId());
+   }
+
+   //----------------------------------------------------------------
+
+   bool CField::hasDirectFieldReference(void) const
+   { 
+      return (!this->field_ref.isEmpty()); 
+   }
+
+   //----------------------------------------------------------------
+
+   void CField::solveRefInheritance(void)
+   {
+      std::set<CField *> sset;
+      boost::shared_ptr<CField> refer_sptr;
+      CField * refer_ptr = this;
+      this->baseRefObject = CObjectFactory::GetObject<CField>(this);
+      while (refer_ptr->hasDirectFieldReference())
+      {
+         refer_sptr = refer_ptr->getDirectFieldReference();
+         refer_ptr  = refer_sptr.get();
+
+         if(sset.end() != sset.find(refer_ptr))
          {
-            refer_sptr = refer_ptr->getDirectFieldReference();
-            refer_ptr  = refer_sptr.get();
-
-            if(sset.end() != sset.find(refer_ptr))
-            {
-               DEBUG (<< "DÃ©pendance circulaire stoppÃ©e pour l'objet de type CField sur "
-                      << "\"" + refer_ptr->getId() + "\" !");
-               break;
-            }
-
-            SuperClassAttribute::setAttributes(refer_ptr);
-            sset.insert(refer_ptr);
-            baseRefObject = refer_sptr;
-            refObject.push_back(refer_sptr);
+            DEBUG (<< "DÃ©pendance circulaire stoppÃ©e pour l'objet de type CField sur "
+                   << "\"" + refer_ptr->getId() + "\" !");
+            break;
          }
-      }
-
-      //----------------------------------------------------------------
-
-      void  CField::solveOperation(void)
-      {
-         // TODO : Ã  complÃ©ter;
-      }
-
-      //----------------------------------------------------------------
-
-      void CField::solveGridReference(void)
-      {
-         boost::shared_ptr<CDomain> domain;
-         boost::shared_ptr<CAxis> axis;
-
+
+         SuperClassAttribute::setAttributes(refer_ptr);
+         sset.insert(refer_ptr);
+         baseRefObject = refer_sptr;
+         refObject.push_back(refer_sptr);
+      }
+   }
+
+   //----------------------------------------------------------------
+
+   void  CField::solveOperation(void)
+   {
+      // TODO : Ã  complÃ©ter;
+   }
+
+   //----------------------------------------------------------------
+
+   void CField::solveGridReference(void)
+   {
+      boost::shared_ptr<CDomain> domain;
+      boost::shared_ptr<CAxis> axis;
+
+      if (!domain_ref.isEmpty())
+      {
+         if (CObjectFactory::HasObject<CDomain>(domain_ref.getValue()))
+            domain = CObjectFactory::GetObject<CDomain>(domain_ref.getValue()) ;
+         else
+            ERROR("CField::solveGridReference(void)",
+                  << "RÃ©fÃ©rence au domaine nommÃ© \'"
+                  << domain_ref.getValue() << "\' incorrecte") ;
+      }
+
+      if (!axis_ref.isEmpty())
+      {
+         if (CObjectFactory::HasObject<CAxis>(axis_ref.getValue()))
+            axis = CObjectFactory::GetObject<CAxis>(axis_ref.getValue()) ;
+         else
+            ERROR("CField::solveGridReference(void)",
+                  << "RÃ©fÃ©rence Ã  l'axe nommÃ© \'"
+                  << axis_ref.getValue() <<"\' incorrecte") ;
+      }
+
+      if (!grid_ref.isEmpty())
+      {
+         if (CObjectFactory::HasObject<CGrid>(grid_ref.getValue()))
+            this->grid = CObjectFactory::GetObject<CGrid>(grid_ref.getValue()) ;
+         else
+            ERROR("CField::solveGridReference(void)",
+                  << "RÃ©fÃ©rence Ã  la grille nommÃ©e \'"
+                  << grid_ref.getValue() << "\' incorrecte");
+         if (!domain_ref.isEmpty())
+            DEBUG(<< "DÃ©finition conjointe de la grille "
+                  << "et du domaine, la grille prÃ©vaut..." );
+         if (!axis_ref.isEmpty())
+            DEBUG(<< "DÃ©finition conjointe de la grille "
+                  << "et de l'axe vertical, la grille prÃ©vaut...") ;
+      }
+      else
+      {
          if (!domain_ref.isEmpty())
          {
-            if (CObjectFactory::HasObject<CDomain>(domain_ref.getValue()))
-               domain = CObjectFactory::GetObject<CDomain>(domain_ref.getValue()) ;
-            else
-               ERROR("CField::solveGridReference(void)",
-                     << "RÃ©fÃ©rence au domaine nommÃ© \'"
-                     << domain_ref.getValue() << "\' incorrecte") ;
-         }
-
-         if (!axis_ref.isEmpty())
-         {
-            if (CObjectFactory::HasObject<CAxis>(axis_ref.getValue()))
-               axis = CObjectFactory::GetObject<CAxis>(axis_ref.getValue()) ;
-            else
-               ERROR("CField::solveGridReference(void)",
-                     << "RÃ©fÃ©rence Ã  l'axe nommÃ© \'"
-                     << axis_ref.getValue() <<"\' incorrecte") ;
-         }
-
-         if (!grid_ref.isEmpty())
-         {
-            if (CObjectFactory::HasObject<CGrid>(grid_ref.getValue()))
-               this->grid = CObjectFactory::GetObject<CGrid>(grid_ref.getValue()) ;
-            else
-               ERROR("CField::solveGridReference(void)",
-                     << "RÃ©fÃ©rence Ã  la grille nommÃ©e \'"
-                     << grid_ref.getValue() << "\' incorrecte");
-            if (!domain_ref.isEmpty())
-               DEBUG(<< "DÃ©finition conjointe de la grille "
-                     << "et du domaine, la grille prÃ©vaut..." );
             if (!axis_ref.isEmpty())
-               DEBUG(<< "DÃ©finition conjointe de la grille "
-                     << "et de l'axe vertical, la grille prÃ©vaut...") ;
-         }
-         else
-         {
-            if (!domain_ref.isEmpty())
             {
-               if (!axis_ref.isEmpty())
-               {
-                  this->grid = CGrid::CreateGrid(domain, axis) ;
-                  this->grid_ref.setValue(this->grid->getId());
-               }
-               else
-               {
-                  this->grid = CGrid::CreateGrid(domain) ;
-                  this->grid_ref.setValue(this->grid->getId());
-               }
+               this->grid = CGrid::CreateGrid(domain, axis) ;
+               this->grid_ref.setValue(this->grid->getId());
             }
             else
             {
-               ERROR("CField::solveGridReference(void)",
-                     << "Le domaine horizontal pour le champ X n'est pas dÃ©fini");
+               this->grid = CGrid::CreateGrid(domain) ;
+               this->grid_ref.setValue(this->grid->getId());
             }
          }
-         grid->solveReference() ;
-      }
+         else
+         {
+            ERROR("CField::solveGridReference(void)",
+                  << "Le domaine horizontal pour le champ X n'est pas dÃ©fini");
+         }
+      }
+      grid->solveReference() ;
+   }
+
    } // namespace tree
 
Index: XMLIO_V2/dev/dev_rv/src/xmlio/node/field.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/xmlio/node/field.hpp	(revision 157)
+++ XMLIO_V2/dev/dev_rv/src/xmlio/node/field.hpp	(revision 168)
@@ -11,94 +11,95 @@
 #include "declare_group.hpp"
 
-namespace xmlioserver
-{
-   namespace tree
+namespace xmlioserver {
+namespace tree {
+   
+   /// ////////////////////// DÃ©clarations ////////////////////// ///
+
+   class CFieldGroup;
+   class CFieldAttributes;
+   class CField;
+
+   class CFile;
+   class CGrid;
+
+   ///--------------------------------------------------------------
+
+   // Declare/Define CFieldAttribute
+   BEGIN_DECLARE_ATTRIBUTE_MAP(CField)
+   #include "field_attribute.conf"
+   END_DECLARE_ATTRIBUTE_MAP(CField)
+
+   ///--------------------------------------------------------------
+   class CField
+      : public CObjectTemplate<CField>
+      , public CFieldAttributes
    {
-      /// ////////////////////// DÃ©clarations ////////////////////// ///
+         /// friend ///
+         friend class CFile;
 
-      class CFieldGroup;
-      class CFieldAttributes;
-      class CField;
+         /// typedef ///
+         typedef CObjectTemplate<CField>   SuperClass;
+         typedef CFieldAttributes SuperClassAttribute;
 
-      class CFile;
-      class CGrid;
+      public :
 
-      ///--------------------------------------------------------------
+         typedef CFieldAttributes RelAttributes;
+         typedef CFieldGroup      RelGroup;
 
-      // Declare/Define CFieldAttribute
-      BEGIN_DECLARE_ATTRIBUTE_MAP(CField)
-#include "field_attribute.conf"
-      END_DECLARE_ATTRIBUTE_MAP(CField)
+         /// Constructeurs ///
+         CField(void);
+         explicit CField(const StdString & id);
+         CField(const CField & field);       // Not implemented yet.
+         CField(const CField * const field); // Not implemented yet.
 
-      ///--------------------------------------------------------------
-      class CField
-         : public CObjectTemplate<CField>
-         , public CFieldAttributes
-      {
-            /// friend ///
-            friend class CFile;
+         /// Accesseurs ///
+         boost::shared_ptr<CField> getDirectFieldReference(void) const;
+         const boost::shared_ptr<CField> getBaseFieldReference(void) const;
+         const std::vector<boost::shared_ptr<CField> > & getAllReference(void) const;
 
-            /// typedef ///
-            typedef CObjectTemplate<CField>   SuperClass;
-            typedef CFieldAttributes SuperClassAttribute;
+         boost::shared_ptr<CGrid> getRelGrid(void) const ;
+         boost::shared_ptr<CFile> getRelFile(void) const ;
 
-         public :
+         const StdString & getBaseFieldId(void) const;
 
-            typedef CFieldAttributes RelAttributes;
-            typedef CFieldGroup      RelGroup;
+         /// Mutateur ///
+         void setRelFile(const boost::shared_ptr<CFile> _file);
 
-            /// Constructeurs ///
-            CField(void);
-            explicit CField(const StdString & id);
-            CField(const CField & field);       // Not implemented yet.
-            CField(const CField * const field); // Not implemented yet.
+      public :
 
-            /// Accesseurs ///
-            boost::shared_ptr<CField> getDirectFieldReference(void) const;
-            const boost::shared_ptr<CField> getBaseFieldReference(void) const;
-            const std::vector<boost::shared_ptr<CField> > & getAllReference(void) const;
+         /// Test ///
+         bool hasDirectFieldReference(void) const;
 
-            boost::shared_ptr<CGrid> getRelGrid(void) const ;
-            boost::shared_ptr<CFile> getRelFile(void) const ;
+         /// Traitements ///
+         void solveRefInheritance(void);
+         void solveGridReference(void);
+         void solveOperation(void);
 
-            const StdString & getBaseFieldId(void) const;
+         /// Destructeur ///
+         virtual ~CField(void);
 
-            /// Mutateur ///
-            void setRelFile(const boost::shared_ptr<CFile> _file);
+         /// Accesseurs statiques ///
+         static StdString GetName(void);
+         static StdString GetDefName(void);
+         
+         static ENodeType GetType(void);
 
-         public :
+      private :
 
-            /// Test ///
-            bool hasDirectFieldReference(void) const;
+         /// PropriÃ©tÃ©s privÃ©es ///
+         boost::shared_ptr<CField> baseRefObject;
+         std::vector<boost::shared_ptr<CField> > refObject;
 
-            /// Traitements ///
-            void solveRefInheritance(void);
-            void solveGridReference(void);
-            void solveOperation(void);
+         boost::shared_ptr<CGrid> grid ;
+         boost::shared_ptr<CFile> file;
 
-            /// Destructeur ///
-            virtual ~CField(void);
+         func::CFunctor * foperation;
 
-            /// Accesseurs statiques ///
-            static StdString GetName(void);
-            static StdString GetDefName(void);
+   }; // class CField
 
-         private :
+   ///--------------------------------------------------------------
 
-            /// PropriÃ©tÃ©s privÃ©es ///
-            boost::shared_ptr<CField> baseRefObject;
-            std::vector<boost::shared_ptr<CField> > refObject;
-
-            boost::shared_ptr<CGrid> grid ;
-            boost::shared_ptr<CFile> file;
-
-            func::CFunctor * foperation;
-
-      }; // class CField
-
-      ///--------------------------------------------------------------
-
-      // Declare/Define CFieldGroup and CFieldDefinition
-      DECLARE_GROUP(CField);
+   // Declare/Define CFieldGroup and CFieldDefinition
+   DECLARE_GROUP(CField);
 
    } // namespace tree
Index: XMLIO_V2/dev/dev_rv/src/xmlio/node/file.cpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/xmlio/node/file.cpp	(revision 157)
+++ XMLIO_V2/dev/dev_rv/src/xmlio/node/file.cpp	(revision 168)
@@ -8,170 +8,173 @@
 #include "object_factory_impl.hpp"
 
-namespace xmlioserver
-{
-   namespace tree
+namespace xmlioserver {
+namespace tree {
+   
+   /// ////////////////////// DÃ©finitions ////////////////////// ///
+
+   CFile::CFile(void)
+      : CObjectTemplate<CFile>(), CFileAttributes()
+      , vFieldGroup(), data_out(), enabledFields()
+   { /* Ne rien faire de plus */ }
+
+   CFile::CFile(const StdString & id)
+      : CObjectTemplate<CFile>(id), CFileAttributes()
+      , vFieldGroup(), data_out(), enabledFields()
+   { /* Ne rien faire de plus */ }
+
+   CFile::~CFile(void)
+   { /* Ne rien faire de plus */ }
+
+   ///---------------------------------------------------------------
+
+   StdString CFile::GetName(void)   { return (StdString("file")); }
+   StdString CFile::GetDefName(void){ return (CFile::GetName()); }
+   ENodeType CFile::GetType(void)   { return (eFile); }
+
+   //----------------------------------------------------------------
+
+   boost::shared_ptr<CFieldGroup> CFile::getVirtualFieldGroup(void) const
    {
-      /// ////////////////////// DÃ©finitions ////////////////////// ///
+      return (this->vFieldGroup);
+   }
 
-      CFile::CFile(void)
-         : CObjectTemplate<CFile>(), CFileAttributes()
-         , vFieldGroup(), data_out(), enabledFields()
-      { /* Ne rien faire de plus */ }
+   std::vector<boost::shared_ptr<CField> > CFile::getAllFields(void) const
+   {
+      return (this->vFieldGroup->getAllChildren());
+   }
 
-      CFile::CFile(const StdString & id)
-         : CObjectTemplate<CFile>(id), CFileAttributes()
-         , vFieldGroup(), data_out(), enabledFields()
-      { /* Ne rien faire de plus */ }
+   //----------------------------------------------------------------
 
-      CFile::~CFile(void)
-      { /* Ne rien faire de plus */ }
+   std::vector<boost::shared_ptr<CField> > CFile::getEnabledFields
+      (int default_outputlevel, int default_level, bool default_enabled)
+   {
+      if (!this->enabledFields.empty())
+         return (this->enabledFields);
 
-      ///---------------------------------------------------------------
+      const int _outputlevel =
+         (!output_level.isEmpty()) ? output_level.getValue() : default_outputlevel;
+      std::vector<boost::shared_ptr<CField> >::iterator it;
+      this->enabledFields = this->getAllFields();
 
-      StdString CFile::GetName(void)   { return (StdString("file")); }
-      StdString CFile::GetDefName(void){ return (CFile::GetName()); }
+      for ( it = this->enabledFields.begin() ; it != this->enabledFields.end(); it++ )
+      {
+         if (!(*it)->enabled.isEmpty()) // Si l'attribut 'enabled' est dÃ©fini ...
+         {
+            if (! (*it)->enabled.getValue())
+            { it--; this->enabledFields.erase(it+1); continue; }
+         }
+         else // Si l'attribut 'enabled' n'est pas dÃ©fini ...
+         {
+            if (!default_enabled)
+            { it--; this->enabledFields.erase(it+1); continue; }
+         }
 
-      boost::shared_ptr<CFieldGroup> CFile::getVirtualFieldGroup(void) const
-      {
-         return (this->vFieldGroup);
+         if (!(*it)->level.isEmpty()) // Si l'attribut 'level' est dÃ©fini ...
+         {
+            if ((*it)->level.getValue() > _outputlevel)
+            { it--; this->enabledFields.erase(it+1); continue; }
+         }
+         else // Si l'attribut 'level' n'est pas dÃ©fini ...
+         {
+            if (default_level > _outputlevel)
+            { it--; this->enabledFields.erase(it+1); continue; }
+         }
+
+         // Le champ est finalement actif, on ajoute la rÃ©fÃ©rence au champ de base.
+         (*it)->setRelFile(CObjectFactory::GetObject(this));
+         (*it)->baseRefObject->refObject.push_back(*it);
       }
 
-      std::vector<boost::shared_ptr<CField> > CFile::getAllFields(void) const
+      return (this->enabledFields);
+   }
+
+   //----------------------------------------------------------------
+
+   void CFile::setVirtualFieldGroup(boost::shared_ptr<CFieldGroup> newVFieldGroup)
+   { this->vFieldGroup = newVFieldGroup; }
+
+   void CFile::setVirtualFieldGroup(const StdString & newVFieldGroupId)
+   {
+      this->setVirtualFieldGroup
+         (CObjectFactory::CreateObject<CFieldGroup>(newVFieldGroupId));
+   }
+
+   void CFile::initializeDataOutput(boost::shared_ptr<io::CDataOutput> dout)
+   {
+      this->data_out = dout;
+      this->data_out->writeFile(CObjectFactory::GetObject<CFile>(this));
+      
+      std::vector<boost::shared_ptr<CField> >::iterator it, end = this->enabledFields.end();
+
+      for (it = this->enabledFields.begin() ;it != end; it++)
       {
-         return (this->vFieldGroup->getAllChildren());
+         boost::shared_ptr<CField> field = *it;
+         this->data_out->writeFieldGrid(field);
       }
+         
+      for (it = this->enabledFields.begin() ;it != end; it++)
+      {
+         boost::shared_ptr<CField> field = *it;
+         this->data_out->writeField(field);
+      }
+         
+      this->data_out->definition_end();
+   }
 
-      //----------------------------------------------------------------
+   void CFile::parse(xml::CXMLNode & node)
+   {
+      SuperClass::parse(node);
+      if (node.goToChildElement() & this->hasId())
+      { // Si la dÃ©finition du fichier intÃ©gre des champs et si le fichier est identifiÃ©.
+         node.goToParentElement();
+         this->setVirtualFieldGroup(this->getId());
+         this->getVirtualFieldGroup()->parse(node, false);
+      }
+   }
+   //----------------------------------------------------------------
 
-      std::vector<boost::shared_ptr<CField> > CFile::getEnabledFields
-         (int default_outputlevel, int default_level, bool default_enabled)
-      {
-         if (!this->enabledFields.empty())
-            return (this->enabledFields);
+   StdString CFile::toString(void) const
+   {
+      StdOStringStream oss;
 
-         const int _outputlevel =
-            (!output_level.isEmpty()) ? output_level.getValue() : default_outputlevel;
-         std::vector<boost::shared_ptr<CField> >::iterator it;
-         this->enabledFields = this->getAllFields();
-
-         for ( it = this->enabledFields.begin() ; it != this->enabledFields.end(); it++ )
-         {
-            if (!(*it)->enabled.isEmpty()) // Si l'attribut 'enabled' est dÃ©fini ...
-            {
-               if (! (*it)->enabled.getValue())
-               { it--; this->enabledFields.erase(it+1); continue; }
-            }
-            else // Si l'attribut 'enabled' n'est pas dÃ©fini ...
-            {
-               if (!default_enabled)
-               { it--; this->enabledFields.erase(it+1); continue; }
-            }
-
-            if (!(*it)->level.isEmpty()) // Si l'attribut 'level' est dÃ©fini ...
-            {
-               if ((*it)->level.getValue() > _outputlevel)
-               { it--; this->enabledFields.erase(it+1); continue; }
-            }
-            else // Si l'attribut 'level' n'est pas dÃ©fini ...
-            {
-               if (default_level > _outputlevel)
-               { it--; this->enabledFields.erase(it+1); continue; }
-            }
-
-            // Le champ est finalement actif, on ajoute la rÃ©fÃ©rence au champ de base.
-            (*it)->setRelFile(CObjectFactory::GetObject(this));
-            (*it)->baseRefObject->refObject.push_back(*it);
-         }
-
-         return (this->enabledFields);
-      }
-
-      //----------------------------------------------------------------
-
-      void CFile::setVirtualFieldGroup(boost::shared_ptr<CFieldGroup> newVFieldGroup)
-      { this->vFieldGroup = newVFieldGroup; }
-
-      void CFile::setVirtualFieldGroup(const StdString & newVFieldGroupId)
-      {
-         this->setVirtualFieldGroup
-            (CObjectFactory::CreateObject<CFieldGroup>(newVFieldGroupId));
-      }
-
-      void CFile::initializeDataOutput(boost::shared_ptr<io::CDataOutput> dout)
-      {
-         this->data_out = dout;
-         this->data_out->writeFile(CObjectFactory::GetObject<CFile>(this));
-         
-         std::vector<boost::shared_ptr<CField> >::iterator it, end = this->enabledFields.end();
-
-         for (it = this->enabledFields.begin() ;it != end; it++)
-         {
-            boost::shared_ptr<CField> field = *it;
-            this->data_out->writeFieldGrid(field);
-         }
-            
-         for (it = this->enabledFields.begin() ;it != end; it++)
-         {
-            boost::shared_ptr<CField> field = *it;
-            this->data_out->writeField(field);
-         }
-            
-         this->data_out->definition_end();
-      }
-
-      void CFile::parse(xml::CXMLNode & node)
-      {
-         SuperClass::parse(node);
-         if (node.goToChildElement() & this->hasId())
-         { // Si la dÃ©finition du fichier intÃ©gre des champs et si le fichier est identifiÃ©.
-            node.goToParentElement();
-            this->setVirtualFieldGroup(this->getId());
-            this->getVirtualFieldGroup()->parse(node, false);
-         }
-      }
-      //----------------------------------------------------------------
-
-      StdString CFile::toString(void) const
-      {
-         StdOStringStream oss;
-
-         oss << "< " << CFile::GetName() << " ";
-         if (this->hasId())
-            oss << " id=\"" << this->getId() << "\" ";
-         oss << SuperClassAttribute::toString() << ">" << std::endl;
-         if (this->getVirtualFieldGroup().get() != NULL)
-            oss << *this->getVirtualFieldGroup() << std::endl;
-         oss << "</ " << CFile::GetName() << " >";
-         return (oss.str());
-      }
+      oss << "< " << CFile::GetName() << " ";
+      if (this->hasId())
+         oss << " id=\"" << this->getId() << "\" ";
+      oss << SuperClassAttribute::toString() << ">" << std::endl;
+      if (this->getVirtualFieldGroup().get() != NULL)
+         oss << *this->getVirtualFieldGroup() << std::endl;
+      oss << "</ " << CFile::GetName() << " >";
+      return (oss.str());
+   }
 
 
-      void CFile::solveDescInheritance(const CAttributeMap * const parent)
-      {
-         SuperClassAttribute::setAttributes(parent);
-         this->getVirtualFieldGroup()->solveDescInheritance(NULL);
-      }
+   void CFile::solveDescInheritance(const CAttributeMap * const parent)
+   {
+      SuperClassAttribute::setAttributes(parent);
+      this->getVirtualFieldGroup()->solveDescInheritance(NULL);
+   }
 
-      void CFile::solveFieldRefInheritance(void)
-      {
-         // RÃ©solution des hÃ©ritages par rÃ©fÃ©rence de chacun des champs contenus dans le fichier.
-         std::vector<boost::shared_ptr<CField> > allF = this->getAllFields();
-         for (unsigned int i = 0; i < allF.size(); i++)
-            allF[i]->solveRefInheritance();
-      }
+   void CFile::solveFieldRefInheritance(void)
+   {
+      // RÃ©solution des hÃ©ritages par rÃ©fÃ©rence de chacun des champs contenus dans le fichier.
+      std::vector<boost::shared_ptr<CField> > allF = this->getAllFields();
+      for (unsigned int i = 0; i < allF.size(); i++)
+         allF[i]->solveRefInheritance();
+   }
 
-      void CFile::solveEFGridRef(void)
-      {
-         for (unsigned int i = 0; i < this->enabledFields.size(); i++)
-            this->enabledFields[i]->solveGridReference();
-      }
+   void CFile::solveEFGridRef(void)
+   {
+      for (unsigned int i = 0; i < this->enabledFields.size(); i++)
+         this->enabledFields[i]->solveGridReference();
+   }
 
-      void CFile::solveEFOperation(void)
-      {
-         for (unsigned int i = 0; i < this->enabledFields.size(); i++)
-            this->enabledFields[i]->solveOperation();
-      }
+   void CFile::solveEFOperation(void)
+   {
+      for (unsigned int i = 0; i < this->enabledFields.size(); i++)
+         this->enabledFields[i]->solveOperation();
+   }
 
-      ///---------------------------------------------------------------
-   } // namespace tree
+   ///---------------------------------------------------------------
+
+} // namespace tree
 } // namespace xmlioserver
Index: XMLIO_V2/dev/dev_rv/src/xmlio/node/file.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/xmlio/node/file.hpp	(revision 157)
+++ XMLIO_V2/dev/dev_rv/src/xmlio/node/file.hpp	(revision 168)
@@ -9,89 +9,92 @@
 #include "data_output.hpp"
 
-namespace xmlioserver
-{
-   namespace tree
+namespace xmlioserver {
+namespace tree {
+   
+   /// ////////////////////// DÃ©clarations ////////////////////// ///
+
+   class CFileGroup;
+   class CFileAttributes;
+   class CFile;
+
+   ///--------------------------------------------------------------
+
+   // Declare/Define CFileAttribute
+   BEGIN_DECLARE_ATTRIBUTE_MAP(CFile)
+   #include "file_attribute.conf"
+   END_DECLARE_ATTRIBUTE_MAP(CFile)
+
+   ///--------------------------------------------------------------
+
+   class CFile
+      : public CObjectTemplate<CFile>
+      , public CFileAttributes
    {
-      /// ////////////////////// DÃ©clarations ////////////////////// ///
+         /// typedef ///
+         typedef CObjectTemplate<CFile>   SuperClass;
+         typedef CFileAttributes SuperClassAttribute;
 
-      class CFileGroup;
-      class CFileAttributes;
-      class CFile;
+      public :
 
-      ///--------------------------------------------------------------
+         typedef CFileAttributes RelAttributes;
+         typedef CFileGroup      RelGroup;
 
-      // Declare/Define CFileAttribute
-      BEGIN_DECLARE_ATTRIBUTE_MAP(CFile)
-#include "file_attribute.conf"
-      END_DECLARE_ATTRIBUTE_MAP(CFile)
+         /// Constructeurs ///
+         CFile(void);
+         explicit CFile(const StdString & id);
+         CFile(const CFile & file);       // Not implemented yet.
+         CFile(const CFile * const file); // Not implemented yet.
 
-      ///--------------------------------------------------------------
+         /// Accesseurs ///
+         boost::shared_ptr<CFieldGroup> getVirtualFieldGroup(void) const;
+         std::vector<boost::shared_ptr<CField> > getAllFields(void) const;
 
-      class CFile
-         : public CObjectTemplate<CFile>
-         , public CFileAttributes
-      {
-            /// typedef ///
-            typedef CObjectTemplate<CFile>   SuperClass;
-            typedef CFileAttributes SuperClassAttribute;
+         std::vector<boost::shared_ptr<CField> >
+            getEnabledFields(int default_outputlevel = 5,
+                             int default_level = 1,
+                             bool default_enabled = true);
 
-         public :
+         /// Mutateurs ///
+         void setVirtualFieldGroup(boost::shared_ptr<CFieldGroup> newVFieldGroup);
+         void setVirtualFieldGroup(const StdString & newVFieldGroupId);
 
-            typedef CFileAttributes RelAttributes;
-            typedef CFileGroup      RelGroup;
+         void initializeDataOutput(boost::shared_ptr<io::CDataOutput> dout);
 
-            /// Constructeurs ///
-            CFile(void);
-            explicit CFile(const StdString & id);
-            CFile(const CFile & file);       // Not implemented yet.
-            CFile(const CFile * const file); // Not implemented yet.
+         /// Traitements ///
+         virtual void solveDescInheritance(const CAttributeMap * const parent = 0);
+         void solveFieldRefInheritance(void);
+         void solveEFGridRef(void);
+         void solveEFOperation(void);
 
-            /// Accesseurs ///
-            boost::shared_ptr<CFieldGroup> getVirtualFieldGroup(void) const;
-            std::vector<boost::shared_ptr<CField> > getAllFields(void) const;
+         /// Destructeur ///
+         virtual ~CFile(void);
 
-            std::vector<boost::shared_ptr<CField> >
-               getEnabledFields(int default_outputlevel = 5,
-                                int default_level = 1,
-                                bool default_enabled = true);
+         /// Autres ///
+         virtual void parse(xml::CXMLNode & node);
+         virtual StdString toString(void) const;
 
-            /// Mutateurs ///
-            void setVirtualFieldGroup(boost::shared_ptr<CFieldGroup> newVFieldGroup);
-            void setVirtualFieldGroup(const StdString & newVFieldGroupId);
+         /// Accesseurs statiques ///
+         static StdString GetName(void);
+         static StdString GetDefName(void);
+         
+         static ENodeType GetType(void);
 
-            void initializeDataOutput(boost::shared_ptr<io::CDataOutput> dout);
+      private :
 
-            /// Traitements ///
-            virtual void solveDescInheritance(const CAttributeMap * const parent = 0);
-            void solveFieldRefInheritance(void);
-            void solveEFGridRef(void);
-            void solveEFOperation(void);
+         /// PropriÃ©tÃ©s privÃ©es ///
+         boost::shared_ptr<CFieldGroup> vFieldGroup;
+         boost::shared_ptr<io::CDataOutput> data_out;
+         std::vector<boost::shared_ptr<CField> > enabledFields;
 
-            /// Destructeur ///
-            virtual ~CFile(void);
+   }; // class CFile
 
-            /// Autres ///
-            virtual void parse(xml::CXMLNode & node);
-            virtual StdString toString(void) const;
+   ///--------------------------------------------------------------
 
-            /// Accesseurs statiques ///
-            static StdString GetName(void);
-            static StdString GetDefName(void);
+   // Declare/Define CFileGroup and CFileDefinition
+   DECLARE_GROUP(CFile);
 
-         private :
+   ///--------------------------------------------------------------
 
-            /// PropriÃ©tÃ©s privÃ©es ///
-            boost::shared_ptr<CFieldGroup> vFieldGroup;
-            boost::shared_ptr<io::CDataOutput> data_out;
-            std::vector<boost::shared_ptr<CField> > enabledFields;
-
-      }; // class CFile
-
-      ///--------------------------------------------------------------
-
-      // Declare/Define CFileGroup and CFileDefinition
-      DECLARE_GROUP(CFile);
-
-   } // namespace tree
+} // namespace tree
 } // namespace xmlioserver
 
Index: XMLIO_V2/dev/dev_rv/src/xmlio/node/grid.cpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/xmlio/node/grid.cpp	(revision 157)
+++ XMLIO_V2/dev/dev_rv/src/xmlio/node/grid.cpp	(revision 168)
@@ -5,226 +5,232 @@
 #include "group_template_impl.hpp"
 
-namespace xmlioserver
-{
-   namespace tree
-   {
-
-      /// ////////////////////// DÃ©finitions ////////////////////// ///
-
-      CGrid::CGrid(void)
-         : CObjectTemplate<CGrid>(), CGridAttributes()
-         , withAxis(false), isChecked(false), axis(), domain()
-         , storeIndex(), out_i_index(), out_j_index(), out_l_index()
-      { /* Ne rien faire de plus */ }
-
-      CGrid::CGrid(const StdString & id)
-         : CObjectTemplate<CGrid>(id), CGridAttributes()
-         , withAxis(false), isChecked(false), axis(), domain()
-         , storeIndex(), out_i_index(), out_j_index(), out_l_index()
-      { /* Ne rien faire de plus */ }
-
-      CGrid::~CGrid(void)
-      { /* Ne rien faire de plus */ }
-
-      ///---------------------------------------------------------------
-
-      StdString CGrid::GetName(void)   { return (StdString("grid")); }
-      StdString CGrid::GetDefName(void){ return (CGrid::GetName()); }
-
-      const ARRAY(int, 1) & CGrid::getStoreIndex(void) const
-      { return (this->storeIndex ); }
-      const ARRAY(int, 1) & CGrid::getOutIIndex(void)  const
-      { return (this->out_i_index ); }
-      const ARRAY(int, 1) & CGrid::getOutJIndex(void)  const
-      { return (this->out_j_index ); }
-      const ARRAY(int, 1) & CGrid::getOutLIndex(void)  const
-      { return (this->out_l_index ); }
-
-      const boost::shared_ptr<CAxis>   CGrid::getRelAxis  (void) const
-      { return (this->axis ); }
-      const boost::shared_ptr<CDomain> CGrid::getRelDomain(void) const
-      { return (this->domain ); }
-
-      bool CGrid::hasAxis(void) const { return (this->withAxis); }
-
-      //---------------------------------------------------------------
-
-      void CGrid::solveReference(void)
-      {
-         if (this->isChecked) return;
-         this->solveDomainRef() ;
-         this->solveAxisRef() ;
-         this->computeIndex() ;
-         this->isChecked = true;
-      }
-
-      void CGrid::solveDomainRef(void)
-      {
-         if (!domain_ref.isEmpty())
-         {
-            if (CObjectFactory::HasObject<CDomain>(domain_ref.getValue()))
+namespace xmlioserver {
+namespace tree {
+
+   /// ////////////////////// DÃ©finitions ////////////////////// ///
+
+   CGrid::CGrid(void)
+      : CObjectTemplate<CGrid>(), CGridAttributes()
+      , withAxis(false), isChecked(false), axis(), domain()
+      , storeIndex(), out_i_index(), out_j_index(), out_l_index()
+   { /* Ne rien faire de plus */ }
+
+   CGrid::CGrid(const StdString & id)
+      : CObjectTemplate<CGrid>(id), CGridAttributes()
+      , withAxis(false), isChecked(false), axis(), domain()
+      , storeIndex(), out_i_index(), out_j_index(), out_l_index()
+   { /* Ne rien faire de plus */ }
+
+   CGrid::~CGrid(void)
+   { /* Ne rien faire de plus */ }
+
+   ///---------------------------------------------------------------
+
+   StdString CGrid::GetName(void)    { return (StdString("grid")); }
+   StdString CGrid::GetDefName(void) { return (CGrid::GetName()); }
+   ENodeType CGrid::GetType(void)    { return (eGrid); }
+
+   //----------------------------------------------------------------
+
+   const ARRAY(int, 1) & CGrid::getStoreIndex(void) const
+   { return (this->storeIndex ); }
+   const ARRAY(int, 1) & CGrid::getOutIIndex(void)  const
+   { return (this->out_i_index ); }
+   const ARRAY(int, 1) & CGrid::getOutJIndex(void)  const
+   { return (this->out_j_index ); }
+   const ARRAY(int, 1) & CGrid::getOutLIndex(void)  const
+   { return (this->out_l_index ); }
+
+   const boost::shared_ptr<CAxis>   CGrid::getRelAxis  (void) const
+   { return (this->axis ); }
+   const boost::shared_ptr<CDomain> CGrid::getRelDomain(void) const
+   { return (this->domain ); }
+
+   bool CGrid::hasAxis(void) const { return (this->withAxis); }
+
+   //---------------------------------------------------------------
+
+   void CGrid::solveReference(void)
+   {
+      if (this->isChecked) return;
+      this->solveDomainRef() ;
+      this->solveAxisRef() ;
+      this->computeIndex() ;
+      this->isChecked = true;
+   }
+
+   void CGrid::solveDomainRef(void)
+   {
+      if (!domain_ref.isEmpty())
+      {
+         if (CObjectFactory::HasObject<CDomain>(domain_ref.getValue()))
+         {
+            this->domain = CObjectFactory::GetObject<CDomain>(domain_ref.getValue()) ;
+            domain->checkAttributes() ;
+         }
+         else ERROR("CGrid::solveDomainRef(void)",
+                     << "RÃ©fÃ©rence au domaine incorrecte") ;
+      }
+      else ERROR("CGrid::solveDomainRef(void)",
+                  << "Domaine non dÃ©fini") ;
+   }
+
+   void CGrid::solveAxisRef(void)
+   {
+      if (!axis_ref.isEmpty())
+      {
+         this->withAxis = true ;
+         if (CObjectFactory::GetObject<CAxis>(axis_ref.getValue()))
+         {
+            this->axis = CObjectFactory::GetObject<CAxis>(axis_ref.getValue()) ;
+            axis->checkAttributes() ;
+         }
+         else ERROR("CGrid::solveAxisRef(void)",
+                    << "RÃ©fÃ©rence a l'axe incorrecte") ;
+      }
+      else withAxis = false ;
+   }
+
+   //---------------------------------------------------------------
+
+   void CGrid::computeIndex(void)
+   {
+      const int ni   = domain->ni.getValue() ,
+                nj   = domain->nj.getValue() ,
+                size = (this->hasAxis()) ? axis->size.getValue() : 1 ;
+
+      /*std::cout << ni   << " : "
+                  << nj   << " : "
+                  << size << std::endl;*/
+
+      const int data_dim     = domain->data_dim.getValue() ,
+                data_n_index = domain->data_n_index.getValue() ,
+                data_ibegin  = domain->data_ibegin.getValue() ,
+                data_jbegin  = (data_dim == 2)
+                             ? domain->data_jbegin.getValue() : -1;
+
+      ARRAY(int, 1) data_i_index = domain->data_i_index.getValue() ,
+                    data_j_index = domain->data_j_index.getValue() ;
+
+      /*std::cout << data_n_index        << " : "
+                  << data_i_index.size() << " : "
+                  << data_j_index.size() << std::endl;*/
+
+      ARRAY(bool, 2) mask = domain->mask.getValue() ;
+
+      int indexCount = 0;
+
+      for(int l = 0; l < size ; l++)
+      {
+         for(int n = 0, i = 0, j = 0; n < data_n_index; n++)
+         {
+            int temp_i = (*data_i_index)[n] + data_ibegin,
+                temp_j = (data_dim == 1) ? -1
+                       : (*data_j_index)[n] + data_jbegin;
+            i = (data_dim == 1) ? (temp_i - 2) % ni
+                                : (temp_i - 1) ;
+            j = (data_dim == 1) ? (temp_i - 2) / ni
+                                : (temp_j - 1) ;
+
+            if ((i >= 0 && i < ni) &&
+                (j >= 0 && j < nj) && (*mask)[i][j])
+               indexCount++ ;
+         }
+      }
+      
+      //std::cout << indexCount  << std::endl;
+      ARRAY_ASSIGN(this->storeIndex , int, 1, [indexCount]);
+      ARRAY_ASSIGN(this->out_l_index, int, 1, [indexCount]);
+      ARRAY_ASSIGN(this->out_i_index, int, 1, [indexCount]);
+      ARRAY_ASSIGN(this->out_j_index, int, 1, [indexCount]);
+
+      for(int count = 0, indexCount = 0,  l = 0; l < size; l++)
+      {
+         for(int n = 0, i = 0, j = 0; n < data_n_index; n++, count++)
+         {
+            int temp_i = (*data_i_index)[n] + data_ibegin,
+                temp_j = (data_dim == 1) ? -1
+                       : (*data_j_index)[n] + data_jbegin;
+            i = (data_dim == 1) ? (temp_i - 2) % ni
+                                : (temp_i - 1) ;
+            j = (data_dim == 1) ? (temp_i - 2) / ni
+                                : (temp_j - 1) ;
+
+            if ((i >= 0 && i < ni) &&
+                (j >= 0 && j < nj) && (*mask)[i][j])
             {
-               this->domain = CObjectFactory::GetObject<CDomain>(domain_ref.getValue()) ;
-               domain->checkAttributes() ;
+               (*this->storeIndex) [indexCount] = count ;
+               (*this->out_l_index)[indexCount] = l ;
+               (*this->out_i_index)[indexCount] = i ;
+               (*this->out_j_index)[indexCount] = j ;
+               indexCount++ ;
             }
-            else ERROR("CGrid::solveDomainRef(void)",
-                        << "RÃ©fÃ©rence au domaine incorrecte") ;
-         }
-         else ERROR("CGrid::solveDomainRef(void)",
-                     << "Domaine non dÃ©fini") ;
-      }
-
-      void CGrid::solveAxisRef(void)
-      {
-         if (!axis_ref.isEmpty())
-         {
-            this->withAxis = true ;
-            if (CObjectFactory::GetObject<CAxis>(axis_ref.getValue()))
-            {
-               this->axis = CObjectFactory::GetObject<CAxis>(axis_ref.getValue()) ;
-               axis->checkAttributes() ;
-            }
-            else ERROR("CGrid::solveAxisRef(void)",
-                       << "RÃ©fÃ©rence a l'axe incorrecte") ;
-         }
-         else withAxis = false ;
-      }
-
-
-      void CGrid::computeIndex(void)
-      {
-         const int ni   = domain->ni.getValue() ,
-                   nj   = domain->nj.getValue() ,
-                   size = (this->hasAxis()) ? axis->size.getValue() : 1 ;
-
-         /*std::cout << ni   << " : "
-                     << nj   << " : "
-                     << size << std::endl;*/
-
-         const int data_dim     = domain->data_dim.getValue() ,
-                   data_n_index = domain->data_n_index.getValue() ,
-                   data_ibegin  = domain->data_ibegin.getValue() ,
-                   data_jbegin  = (data_dim == 2)
-                                ? domain->data_jbegin.getValue() : -1;
-
-         ARRAY(int, 1) data_i_index = domain->data_i_index.getValue() ,
-                       data_j_index = domain->data_j_index.getValue() ;
-
-         /*std::cout << data_n_index        << " : "
-                     << data_i_index.size() << " : "
-                     << data_j_index.size() << std::endl;*/
-
-         ARRAY(bool, 2) mask = domain->mask.getValue() ;
-
-         int indexCount = 0;
-
-         for(int l = 0; l < size ; l++)
-         {
-            for(int n = 0, i = 0, j = 0; n < data_n_index; n++)
-            {
-               int temp_i = (*data_i_index)[n] + data_ibegin,
-                   temp_j = (data_dim == 1) ? -1
-                          : (*data_j_index)[n] + data_jbegin;
-               i = (data_dim == 1) ? (temp_i - 2) % ni
-                                   : (temp_i - 1) ;
-               j = (data_dim == 1) ? (temp_i - 2) / ni
-                                   : (temp_j - 1) ;
-
-               if ((i >= 0 && i < ni) &&
-                   (j >= 0 && j < nj) && (*mask)[i][j])
-                  indexCount++ ;
-            }
-         }
-         //std::cout << indexCount  << std::endl;
-         ARRAY_ASSIGN(this->storeIndex , int, 1, [indexCount]);
-         ARRAY_ASSIGN(this->out_l_index, int, 1, [indexCount]);
-         ARRAY_ASSIGN(this->out_i_index, int, 1, [indexCount]);
-         ARRAY_ASSIGN(this->out_j_index, int, 1, [indexCount]);
-
-         for(int count = 0, indexCount = 0,  l = 0; l < size; l++)
-         {
-            for(int n = 0, i = 0, j = 0; n < data_n_index; n++, count++)
-            {
-               int temp_i = (*data_i_index)[n] + data_ibegin,
-                   temp_j = (data_dim == 1) ? -1
-                          : (*data_j_index)[n] + data_jbegin;
-               i = (data_dim == 1) ? (temp_i - 2) % ni
-                                   : (temp_i - 1) ;
-               j = (data_dim == 1) ? (temp_i - 2) / ni
-                                   : (temp_j - 1) ;
-
-               if ((i >= 0 && i < ni) &&
-                   (j >= 0 && j < nj) && (*mask)[i][j])
-               {
-                  (*this->storeIndex)[indexCount]  = count ;
-                  (*this->out_l_index)[indexCount] = l ;
-                  (*this->out_i_index)[indexCount] = i ;
-                  (*this->out_j_index)[indexCount] = j ;
-                  indexCount++ ;
-               }
-            }
-         }
-      }
-
-      //----------------------------------------------------------------
-      boost::shared_ptr<CGrid>
-         CGrid::CreateGrid(boost::shared_ptr<CDomain> domain)
-      {
-         StdString new_id = StdString("__") + domain->getId() + StdString("__") ;
-         boost::shared_ptr<CGrid> grid =
-            CGroupFactory::CreateChild(CObjectFactory::GetObject<CGridGroup> ("grid_definition"), new_id);
-         grid->domain_ref.setValue(domain->getId());
-         return (grid);
-      }
-
-      boost::shared_ptr<CGrid>
-         CGrid::CreateGrid(boost::shared_ptr<CDomain> domain, boost::shared_ptr<CAxis> axis)
-      {
-         StdString new_id = StdString("__") + domain->getId() +
-                            StdString("_") + axis->getId() + StdString("__") ;
-         boost::shared_ptr<CGrid> grid =
-            CGroupFactory::CreateChild(CObjectFactory::GetObject<CGridGroup> ("grid_definition"), new_id);
-         grid->domain_ref.setValue(domain->getId());
-         grid->axis_ref.setValue(axis->getId());
-         return (grid);
-      }
-
-      //----------------------------------------------------------------
-
-      template <>
-         void CGrid::outputField
-            (const ARRAY(double, 1) stored,  ARRAY(double, 3) field) const
-      {
-         for(StdSize n = 0; n < storeIndex->num_elements(); n++)
-            (*field)[(*out_i_index)[n]][(*out_j_index)[n]][(*out_l_index)[n]] = (*stored)[n] ;
-      }
-
-      template <>
-         void CGrid::outputField
-            (const ARRAY(double, 1) stored,  ARRAY(double, 2) field) const
-      {
-         for(StdSize n = 0; n < storeIndex->num_elements(); n++)
-            (*field)[(*out_i_index)[n]][(*out_j_index)[n]] = (*stored)[n] ;
-      }
-
-      template <>
-         void CGrid::outputField
-            (const ARRAY(double, 1) stored,  ARRAY(double, 1) field) const
-      {
-         for(StdSize n = 0; n < storeIndex->num_elements(); n++)
-            (*field)[(*out_i_index)[n]] = (*stored)[n] ;
-      }
-
-      void CGrid::storeField_arr
-         (const double * const data, ARRAY(double, 1) stored) const
-      {
-         const StdSize size = storeIndex->num_elements() ;
-         stored->resize(boost::extents[size]) ;
-         for(StdSize i = 0; i < size; i++)
-            (*stored)[i] = data[(*storeIndex)[i]] ;
-      }
-
-      ///---------------------------------------------------------------
-
-   } // namespace tree
+         }
+      }
+   }
+
+   //----------------------------------------------------------------
+
+   boost::shared_ptr<CGrid>
+      CGrid::CreateGrid(boost::shared_ptr<CDomain> domain)
+   {
+      StdString new_id = StdString("__") + domain->getId() + StdString("__") ;
+      boost::shared_ptr<CGrid> grid =
+         CGroupFactory::CreateChild(CObjectFactory::GetObject<CGridGroup> ("grid_definition"), new_id);
+      grid->domain_ref.setValue(domain->getId());
+      return (grid);
+   }
+
+   boost::shared_ptr<CGrid>
+      CGrid::CreateGrid(boost::shared_ptr<CDomain> domain, boost::shared_ptr<CAxis> axis)
+   {
+      StdString new_id = StdString("__") + domain->getId() +
+                         StdString("_") + axis->getId() + StdString("__") ;
+      boost::shared_ptr<CGrid> grid =
+         CGroupFactory::CreateChild(CObjectFactory::GetObject<CGridGroup> ("grid_definition"), new_id);
+      grid->domain_ref.setValue(domain->getId());
+      grid->axis_ref.setValue(axis->getId());
+      return (grid);
+   }
+
+   //----------------------------------------------------------------
+
+   template <>
+      void CGrid::outputField
+         (const ARRAY(double, 1) stored,  ARRAY(double, 3) field) const
+   {
+      for(StdSize n = 0; n < storeIndex->num_elements(); n++)
+         (*field)[(*out_i_index)[n]][(*out_j_index)[n]][(*out_l_index)[n]] = (*stored)[n] ;
+   }
+
+   template <>
+      void CGrid::outputField
+         (const ARRAY(double, 1) stored,  ARRAY(double, 2) field) const
+   {
+      for(StdSize n = 0; n < storeIndex->num_elements(); n++)
+         (*field)[(*out_i_index)[n]][(*out_j_index)[n]] = (*stored)[n] ;
+   }
+
+   template <>
+      void CGrid::outputField
+         (const ARRAY(double, 1) stored,  ARRAY(double, 1) field) const
+   {
+      for(StdSize n = 0; n < storeIndex->num_elements(); n++)
+         (*field)[(*out_i_index)[n]] = (*stored)[n] ;
+   }
+
+   //----------------------------------------------------------------
+
+   void CGrid::storeField_arr
+      (const double * const data, ARRAY(double, 1) stored) const
+   {
+      const StdSize size = storeIndex->num_elements() ;
+      stored->resize(boost::extents[size]) ;
+      for(StdSize i = 0; i < size; i++)
+         (*stored)[i] = data[(*storeIndex)[i]] ;
+   }
+
+   ///---------------------------------------------------------------
+
+} // namespace tree
 } // namespace xmlioserver
Index: XMLIO_V2/dev/dev_rv/src/xmlio/node/grid.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/xmlio/node/grid.hpp	(revision 157)
+++ XMLIO_V2/dev/dev_rv/src/xmlio/node/grid.hpp	(revision 168)
@@ -10,117 +10,122 @@
 #include "axis.hpp"
 
-namespace xmlioserver
-{
-   namespace tree
+namespace xmlioserver {
+namespace tree {
+   
+   /// ////////////////////// DÃ©clarations ////////////////////// ///
+
+   class CGridGroup;
+   class CGridAttributes;
+   class CGrid;
+
+   ///--------------------------------------------------------------
+
+   // Declare/Define CGridAttribute
+   BEGIN_DECLARE_ATTRIBUTE_MAP(CGrid)
+   #include "grid_attribute.conf"
+   END_DECLARE_ATTRIBUTE_MAP(CGrid)
+
+   ///--------------------------------------------------------------
+
+   class CGrid
+      : public CObjectTemplate<CGrid>
+      , public CGridAttributes
    {
-      /// ////////////////////// DÃ©clarations ////////////////////// ///
+         /// typedef ///
+         typedef CObjectTemplate<CGrid>   SuperClass;
+         typedef CGridAttributes SuperClassAttribute;
 
-      class CGridGroup;
-      class CGridAttributes;
-      class CGrid;
+      public :
 
-      ///--------------------------------------------------------------
+         typedef CGridAttributes RelAttributes;
+         typedef CGridGroup      RelGroup;
 
-      // Declare/Define CGridAttribute
-      BEGIN_DECLARE_ATTRIBUTE_MAP(CGrid)
-#include "grid_attribute.conf"
-      END_DECLARE_ATTRIBUTE_MAP(CGrid)
+         /// Constructeurs ///
+         CGrid(void);
+         explicit CGrid(const StdString & id);
+         CGrid(const CGrid & grid);       // Not implemented yet.
+         CGrid(const CGrid * const grid); // Not implemented yet.
 
-      ///--------------------------------------------------------------
+         /// Traitements ///
+         void solveReference(void);
 
-      class CGrid
-         : public CObjectTemplate<CGrid>
-         , public CGridAttributes
-      {
-            /// typedef ///
-            typedef CObjectTemplate<CGrid>   SuperClass;
-            typedef CGridAttributes SuperClassAttribute;
+         /// Tests ///
+         bool hasAxis(void) const;
 
-         public :
+      public :
 
-            typedef CGridAttributes RelAttributes;
-            typedef CGridGroup      RelGroup;
+         /// Accesseurs ///
+         const ARRAY(int, 1) & getStoreIndex(void) const;
+         const ARRAY(int, 1) & getOutIIndex(void)  const;
+         const ARRAY(int, 1) & getOutJIndex(void)  const;
+         const ARRAY(int, 1) & getOutLIndex(void)  const;
 
-            /// Constructeurs ///
-            CGrid(void);
-            explicit CGrid(const StdString & id);
-            CGrid(const CGrid & grid);       // Not implemented yet.
-            CGrid(const CGrid * const grid); // Not implemented yet.
+         const boost::shared_ptr<CAxis>   getRelAxis  (void) const;
+         const boost::shared_ptr<CDomain> getRelDomain(void) const;
 
-            /// Traitements ///
-            void solveReference(void);
+         /// EntrÃ©es-sorties de champs ///
+         template <StdSize n>
+            void inputField(const  ARRAY(double, n) field, ARRAY(double, 1) stored) const;
 
-            /// Tests ///
-            bool hasAxis(void) const;
+         template <StdSize n>
+            void outputField(const ARRAY(double, 1) stored,  ARRAY(double, n) field) const;
 
-         public :
+         /// Destructeur ///
+         virtual ~CGrid(void);
 
-            /// Accesseurs ///
-            const ARRAY(int, 1) & getStoreIndex(void) const;
-            const ARRAY(int, 1) & getOutIIndex(void)  const;
-            const ARRAY(int, 1) & getOutJIndex(void)  const;
-            const ARRAY(int, 1) & getOutLIndex(void)  const;
+      public :
 
-            const boost::shared_ptr<CAxis>   getRelAxis  (void) const;
-            const boost::shared_ptr<CDomain> getRelDomain(void) const;
+         /// Accesseurs statiques ///
+         static StdString GetName(void);
+         static StdString GetDefName(void);
+         
+         static ENodeType GetType(void);
 
-            /// EntrÃ©es-sorties de champs ///
-            template <StdSize n>
-               void inputField(const  ARRAY(double, n) field, ARRAY(double, 1) stored) const;
+         /// Instanciateurs Statiques ///
+         static boost::shared_ptr<CGrid>
+            CreateGrid(boost::shared_ptr<CDomain> domain);
+         static boost::shared_ptr<CGrid>
+            CreateGrid(boost::shared_ptr<CDomain> domain, boost::shared_ptr<CAxis> axis);
 
-            template <StdSize n>
-               void outputField(const ARRAY(double, 1) stored,  ARRAY(double, n) field) const;
+      protected :
 
-            /// Destructeur ///
-            virtual ~CGrid(void);
+         /// EntrÃ©es-sorties de champs (interne) ///
+         void storeField_arr(const double * const data, ARRAY(double, 1) stored) const;
 
-         public :
+         /// Traitements protÃ©gÃ©s ///
+         void computeIndex(void);
+         void solveDomainRef(void);
+         void solveAxisRef(void);
 
-            /// Accesseurs statiques ///
-            static StdString GetName(void);
-            static StdString GetDefName(void);
+      private:
 
-            /// Instanciateurs Statiques ///
-            static boost::shared_ptr<CGrid>
-               CreateGrid(boost::shared_ptr<CDomain> domain);
-            static boost::shared_ptr<CGrid>
-               CreateGrid(boost::shared_ptr<CDomain> domain, boost::shared_ptr<CAxis> axis);
+         /// PropriÃ©tÃ©s privÃ©es ///
+         bool withAxis ;
+         bool isChecked;
 
-         protected :
+         boost::shared_ptr<CAxis>   axis ;
+         boost::shared_ptr<CDomain> domain ;
 
-            /// EntrÃ©es-sorties de champs (interne) ///
-            void storeField_arr(const double * const data, ARRAY(double, 1) stored) const;
+         ARRAY(int, 1) storeIndex ;
+         ARRAY(int, 1) out_i_index ;
+         ARRAY(int, 1) out_j_index ;
+         ARRAY(int, 1) out_l_index ;
 
-            /// Traitements protÃ©gÃ©s ///
-            void computeIndex(void);
-            void solveDomainRef(void);
-            void solveAxisRef(void);
+   }; // class CGrid
 
-         private:
+   ///--------------------------------------------------------------
 
-            /// PropriÃ©tÃ©s privÃ©es ///
-            bool withAxis ;
-            bool isChecked;
+   template <StdSize n>
+      void CGrid::inputField(const  ARRAY(double, n) field, ARRAY(double, 1) stored) const
+   { this->storeField_arr(field.data(), stored) ; }
 
-            boost::shared_ptr<CAxis>   axis ;
-            boost::shared_ptr<CDomain> domain ;
+   ///--------------------------------------------------------------
 
-            ARRAY(int, 1) storeIndex ;
-            ARRAY(int, 1) out_i_index ;
-            ARRAY(int, 1) out_j_index ;
-            ARRAY(int, 1) out_l_index ;
+   // Declare/Define CGridGroup and CGridDefinition
+   DECLARE_GROUP(CGrid);
 
-      }; // class CGrid
+   ///--------------------------------------------------------------
 
-      ///--------------------------------------------------------------
-
-      template <StdSize n>
-         void CGrid::inputField(const  ARRAY(double, n) field, ARRAY(double, 1) stored) const
-      { this->storeField_arr(field.data(), stored) ; }
-
-      // Declare/Define CGridGroup and CGridDefinition
-      DECLARE_GROUP(CGrid);
-
-   } // namespace tree
+} // namespace tree
 } // namespace xmlioserver
 
