Index: /XIOS/trunk/src/interface/c/icxml_tree.cpp
===================================================================
--- /XIOS/trunk/src/interface/c/icxml_tree.cpp	(revision 835)
+++ /XIOS/trunk/src/interface/c/icxml_tree.cpp	(revision 836)
@@ -21,4 +21,10 @@
 #include "domain.hpp"
 #include "variable.hpp"
+#include "zoom_domain.hpp"
+#include "interpolate_domain.hpp"
+#include "generate_rectilinear_domain.hpp"
+#include "zoom_axis.hpp"
+#include "interpolate_axis.hpp"
+#include "inverse_axis.hpp"
 
 extern "C"
@@ -48,4 +54,14 @@
    typedef xios::CVariableGroup *  XVariableGroupPtr;
 
+   typedef xios::CTransformation<CDomain>   *  XTransformationDomainPtr;
+   typedef xios::CZoomDomain                *  XZoomDomainPtr;
+   typedef xios::CInterpolateDomain         *  XInterpolateDomainPtr;
+   typedef xios::CGenerateRectilinearDomain *  XGenerateRectilinearDomainPtr;
+
+   typedef xios::CTransformation<CAxis>   *  XTransformationAxisPtr;
+   typedef xios::CZoomAxis                *  XZoomAxisPtr;
+   typedef xios::CInterpolateAxis         *  XInterpolateAxisPtr;
+   typedef xios::CInverseAxis             *  XInverseAxisPtr;
+
    // ----------------------- Ajout d'enfant Ã  un parent -----------------------
 
@@ -339,4 +355,112 @@
          *child_ = parent_->addDomain();
       }
+      CTimer::get("XIOS").suspend() ;
+   }
+
+   void cxios_xml_tree_add_zoomdomaintodomain
+      (XDomainPtr parent_, XZoomDomainPtr * child_, const char * child_id, int child_id_size)
+   {
+      std::string child_id_str;
+      XTransformationDomainPtr tmpChild_;
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         tmpChild_ = parent_->addTransformation(TRANS_ZOOM_DOMAIN, child_id_str);
+      }
+      else
+      {
+         tmpChild_ = parent_->addTransformation(TRANS_ZOOM_DOMAIN);
+      }
+      *child_ = static_cast<XZoomDomainPtr>(tmpChild_);
+      CTimer::get("XIOS").suspend() ;
+   }
+
+   void cxios_xml_tree_add_interpolatedomaintodomain
+      (XDomainPtr parent_, XInterpolateDomainPtr * child_, const char * child_id, int child_id_size)
+   {
+      std::string child_id_str;
+      XTransformationDomainPtr tmpChild_;
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         tmpChild_ = parent_->addTransformation(TRANS_INTERPOLATE_DOMAIN, child_id_str);
+      }
+      else
+      {
+         tmpChild_ = parent_->addTransformation(TRANS_INTERPOLATE_DOMAIN);
+      }
+      *child_ = static_cast<XInterpolateDomainPtr>(tmpChild_);
+      CTimer::get("XIOS").suspend() ;
+   }
+
+   void cxios_xml_tree_add_generatedomaintodomain
+      (XDomainPtr parent_, XGenerateRectilinearDomainPtr * child_, const char * child_id, int child_id_size)
+   {
+      std::string child_id_str;
+      XTransformationDomainPtr tmpChild_;
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         tmpChild_ = parent_->addTransformation(TRANS_GENERATE_RECTILINEAR_DOMAIN, child_id_str);
+      }
+      else
+      {
+         tmpChild_ = parent_->addTransformation(TRANS_GENERATE_RECTILINEAR_DOMAIN);
+      }
+      *child_ = static_cast<XGenerateRectilinearDomainPtr>(tmpChild_);
+      CTimer::get("XIOS").suspend() ;
+   }
+
+   void cxios_xml_tree_add_zoomaxistoaxis
+      (XAxisPtr parent_, XZoomAxisPtr * child_, const char * child_id, int child_id_size)
+   {
+      std::string child_id_str;
+      XTransformationAxisPtr tmpChild_;
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         tmpChild_ = parent_->addTransformation(TRANS_ZOOM_AXIS, child_id_str);
+      }
+      else
+      {
+         tmpChild_ = parent_->addTransformation(TRANS_ZOOM_AXIS);
+      }
+      *child_ = static_cast<XZoomAxisPtr>(tmpChild_);
+      CTimer::get("XIOS").suspend() ;
+   }
+
+   void cxios_xml_tree_add_interpolateaxistoaxis
+      (XAxisPtr parent_, XInterpolateAxisPtr * child_, const char * child_id, int child_id_size)
+   {
+      std::string child_id_str;
+      XTransformationAxisPtr tmpChild_;
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         tmpChild_ = parent_->addTransformation(TRANS_INTERPOLATE_AXIS, child_id_str);
+      }
+      else
+      {
+         tmpChild_ = parent_->addTransformation(TRANS_INTERPOLATE_AXIS);
+      }
+      *child_ = static_cast<XInterpolateAxisPtr>(tmpChild_);
+      CTimer::get("XIOS").suspend() ;
+   }
+
+   void cxios_xml_tree_add_inverseaxistoaxis
+      (XAxisPtr parent_, XInverseAxisPtr * child_, const char * child_id, int child_id_size)
+   {
+      std::string child_id_str;
+      XTransformationAxisPtr tmpChild_;
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         tmpChild_ = parent_->addTransformation(TRANS_INVERSE_AXIS, child_id_str);
+      }
+      else
+      {
+         tmpChild_ = parent_->addTransformation(TRANS_INVERSE_AXIS);
+      }
+      *child_ = static_cast<XInverseAxisPtr>(tmpChild_);
       CTimer::get("XIOS").suspend() ;
    }
Index: /XIOS/trunk/src/interface/fortran/ixios_interfaces.F90
===================================================================
--- /XIOS/trunk/src/interface/fortran/ixios_interfaces.F90	(revision 835)
+++ /XIOS/trunk/src/interface/fortran/ixios_interfaces.F90	(revision 836)
@@ -83,5 +83,8 @@
                       xios(add_axisgroup), xios(add_filegroup), xios(add_gridgroup), xios(add_fieldgroup), &
                       xios(add_domaingroup), xios(add_fieldgrouptofile), xios(add_variablegrouptofile),    &
-                      xios(add_variablegrouptofield), xios(add_axistogrid), xios(add_domaintogrid)
+                      xios(add_variablegrouptofield), xios(add_axistogrid), xios(add_domaintogrid),        &
+                      xios(add_zoomdomaintodomain), xios(add_interpolatedomaintodomain),                   &
+                      xios(add_generatedomaintodomain), xios(add_zoomaxistoaxis),                          &
+                      xios(add_interpolateaxistoaxis), xios(add_inverseaxistoaxis)
 
 PRIVATE
@@ -136,5 +139,7 @@
                    xios(add_filegroup), xios(add_gridgroup), xios(add_fieldgroup), xios(add_domaingroup),            &
                    xios(add_fieldgrouptofile), xios(add_variablegrouptofile),xios(add_variablegrouptofield),         &
-                   xios(add_axistogrid), xios(add_domaintogrid)
+                   xios(add_axistogrid), xios(add_domaintogrid), xios(add_zoomdomaintodomain),                       &
+                   xios(add_interpolatedomaintodomain), xios(add_generatedomaintodomain),                            &
+                   xios(add_zoomaxistoaxis), xios(add_interpolateaxistoaxis), xios(add_inverseaxistoaxis)
 END INTERFACE xios(add_child)
 
Index: /XIOS/trunk/src/interface/fortran/ixml_tree.F90
===================================================================
--- /XIOS/trunk/src/interface/fortran/ixml_tree.F90	(revision 835)
+++ /XIOS/trunk/src/interface/fortran/ixml_tree.F90	(revision 836)
@@ -9,4 +9,10 @@
    USE IDOMAIN
    USE IVARIABLE
+   USE IZOOM_DOMAIN
+   USE IINTERPOLATE_DOMAIN
+   USE IGENERATE_RECTILINEAR_DOMAIN
+   USE IZOOM_AXIS
+   USE IINTERPOLATE_AXIS
+   USE IINVERSE_AXIS
 
    INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99
@@ -157,4 +163,52 @@
          INTEGER  (kind = C_INT)     , VALUE        :: child_id_size
       END SUBROUTINE cxios_xml_tree_add_domaintogrid
+
+      SUBROUTINE cxios_xml_tree_add_zoomdomaintodomain(parent_, child_, child_id, child_id_size) BIND(C)
+         USE ISO_C_BINDING
+         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_
+         INTEGER  (kind = C_INTPTR_T)               :: child_
+         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id
+         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size
+      END SUBROUTINE cxios_xml_tree_add_zoomdomaintodomain
+
+      SUBROUTINE cxios_xml_tree_add_interpolatedomaintodomain(parent_, child_, child_id, child_id_size) BIND(C)
+         USE ISO_C_BINDING
+         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_
+         INTEGER  (kind = C_INTPTR_T)               :: child_
+         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id
+         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size
+      END SUBROUTINE cxios_xml_tree_add_interpolatedomaintodomain
+
+      SUBROUTINE cxios_xml_tree_add_generatedomaintodomain(parent_, child_, child_id, child_id_size) BIND(C)
+         USE ISO_C_BINDING
+         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_
+         INTEGER  (kind = C_INTPTR_T)               :: child_
+         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id
+         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size
+      END SUBROUTINE cxios_xml_tree_add_generatedomaintodomain
+
+      SUBROUTINE cxios_xml_tree_add_zoomaxistoaxis(parent_, child_, child_id, child_id_size) BIND(C)
+         USE ISO_C_BINDING
+         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_
+         INTEGER  (kind = C_INTPTR_T)               :: child_
+         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id
+         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size
+      END SUBROUTINE cxios_xml_tree_add_zoomaxistoaxis
+
+      SUBROUTINE cxios_xml_tree_add_interpolateaxistoaxis(parent_, child_, child_id, child_id_size) BIND(C)
+         USE ISO_C_BINDING
+         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_
+         INTEGER  (kind = C_INTPTR_T)               :: child_
+         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id
+         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size
+      END SUBROUTINE cxios_xml_tree_add_interpolateaxistoaxis
+
+      SUBROUTINE cxios_xml_tree_add_inverseaxistoaxis(parent_, child_, child_id, child_id_size) BIND(C)
+         USE ISO_C_BINDING
+         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_
+         INTEGER  (kind = C_INTPTR_T)               :: child_
+         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id
+         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size
+      END SUBROUTINE cxios_xml_tree_add_inverseaxistoaxis
 
       SUBROUTINE cxios_xml_tree_show(filename, filename_size) BIND(C)
@@ -417,3 +471,81 @@
 
    END SUBROUTINE xios(add_domaintogrid)
+
+   SUBROUTINE xios(add_zoomdomaintodomain)(parent_hdl, child_hdl, child_id)
+      TYPE(txios(domain))           , INTENT(IN) :: parent_hdl
+      TYPE(txios(zoom_domain))      , INTENT(OUT):: child_hdl
+      CHARACTER(len = *), OPTIONAL  , INTENT(IN) :: child_id
+
+      IF (PRESENT(child_id)) THEN
+         CALL cxios_xml_tree_add_zoomdomaintodomain(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id))
+      ELSE
+         CALL cxios_xml_tree_add_zoomdomaintodomain(parent_hdl%daddr, child_hdl%daddr, "NONE", -1)
+      END IF
+
+   END SUBROUTINE xios(add_zoomdomaintodomain)
+
+   SUBROUTINE xios(add_interpolatedomaintodomain)(parent_hdl, child_hdl, child_id)
+      TYPE(txios(domain))             , INTENT(IN) :: parent_hdl
+      TYPE(txios(interpolate_domain)) , INTENT(OUT):: child_hdl
+      CHARACTER(len = *), OPTIONAL    , INTENT(IN) :: child_id
+
+      IF (PRESENT(child_id)) THEN
+         CALL cxios_xml_tree_add_interpolatedomaintodomain(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id))
+      ELSE
+         CALL cxios_xml_tree_add_interpolatedomaintodomain(parent_hdl%daddr, child_hdl%daddr, "NONE", -1)
+      END IF
+
+   END SUBROUTINE xios(add_interpolatedomaintodomain)
+
+   SUBROUTINE xios(add_generatedomaintodomain)(parent_hdl, child_hdl, child_id)
+      TYPE(txios(domain))                      , INTENT(IN) :: parent_hdl
+      TYPE(txios(generate_rectilinear_domain)) , INTENT(OUT):: child_hdl
+      CHARACTER(len = *), OPTIONAL             , INTENT(IN) :: child_id
+
+      IF (PRESENT(child_id)) THEN
+         CALL cxios_xml_tree_add_generatedomaintodomain(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id))
+      ELSE
+         CALL cxios_xml_tree_add_generatedomaintodomain(parent_hdl%daddr, child_hdl%daddr, "NONE", -1)
+      END IF
+
+   END SUBROUTINE xios(add_generatedomaintodomain)
+
+   SUBROUTINE xios(add_zoomaxistoaxis)(parent_hdl, child_hdl, child_id)
+      TYPE(txios(axis))                      , INTENT(IN) :: parent_hdl
+      TYPE(txios(zoom_axis))                 , INTENT(OUT):: child_hdl
+      CHARACTER(len = *), OPTIONAL           , INTENT(IN) :: child_id
+
+      IF (PRESENT(child_id)) THEN
+         CALL cxios_xml_tree_add_zoomaxistoaxis(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id))
+      ELSE
+         CALL cxios_xml_tree_add_zoomaxistoaxis(parent_hdl%daddr, child_hdl%daddr, "NONE", -1)
+      END IF
+
+   END SUBROUTINE xios(add_zoomaxistoaxis)
+
+   SUBROUTINE xios(add_interpolateaxistoaxis)(parent_hdl, child_hdl, child_id)
+      TYPE(txios(axis))                      , INTENT(IN) :: parent_hdl
+      TYPE(txios(interpolate_axis))          , INTENT(OUT):: child_hdl
+      CHARACTER(len = *), OPTIONAL           , INTENT(IN) :: child_id
+
+      IF (PRESENT(child_id)) THEN
+         CALL cxios_xml_tree_add_interpolateaxistoaxis(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id))
+      ELSE
+         CALL cxios_xml_tree_add_interpolateaxistoaxis(parent_hdl%daddr, child_hdl%daddr, "NONE", -1)
+      END IF
+
+   END SUBROUTINE xios(add_interpolateaxistoaxis)
+
+      SUBROUTINE xios(add_inverseaxistoaxis)(parent_hdl, child_hdl, child_id)
+      TYPE(txios(axis))                      , INTENT(IN) :: parent_hdl
+      TYPE(txios(zoom_axis))                 , INTENT(OUT):: child_hdl
+      CHARACTER(len = *), OPTIONAL           , INTENT(IN) :: child_id
+
+      IF (PRESENT(child_id)) THEN
+         CALL cxios_xml_tree_add_inverseaxistoaxis(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id))
+      ELSE
+         CALL cxios_xml_tree_add_inverseaxistoaxis(parent_hdl%daddr, child_hdl%daddr, "NONE", -1)
+      END IF
+
+   END SUBROUTINE xios(add_inverseaxistoaxis)
 END MODULE IXML_TREE
Index: /XIOS/trunk/src/node/axis.cpp
===================================================================
--- /XIOS/trunk/src/node/axis.cpp	(revision 835)
+++ /XIOS/trunk/src/node/axis.cpp	(revision 836)
@@ -41,4 +41,13 @@
    CAxis::~CAxis(void)
    { /* Ne rien faire de plus */ }
+
+   std::map<StdString, ETranformationType> CAxis::transformationMapList_ = std::map<StdString, ETranformationType>();
+   bool CAxis::dummyTransformationMapList_ = CAxis::initializeTransformationMap(CAxis::transformationMapList_);
+   bool CAxis::initializeTransformationMap(std::map<StdString, ETranformationType>& m)
+   {
+     m["zoom_axis"] = TRANS_ZOOM_AXIS;
+     m["interpolate_axis"] = TRANS_INTERPOLATE_AXIS;
+     m["inverse_axis"] = TRANS_INVERSE_AXIS;
+   }
 
    ///---------------------------------------------------------------
@@ -884,4 +893,10 @@
   }
 
+  CTransformation<CAxis>* CAxis::addTransformation(ETranformationType transType, const StdString& id)
+  {
+    transformationMap_.push_back(std::make_pair(transType, CTransformation<CAxis>::createTransformation(transType,id)));
+    return transformationMap_.back().second;
+  }
+
   bool CAxis::hasTransformation()
   {
@@ -948,10 +963,5 @@
     if (node.goToChildElement())
     {
-      StdString inverseAxisDefRoot("inverse_axis_definition");
-      StdString inverse("inverse_axis");
-      StdString zoomAxisDefRoot("zoom_axis_definition");
-      StdString zoom("zoom_axis");
-      StdString interpAxisDefRoot("interpolate_axis_definition");
-      StdString interp("interpolate_axis");
+      StdString nodeElementName;
       do
       {
@@ -960,18 +970,12 @@
         { nodeId = node.getAttributes()["id"]; }
 
-        if (node.getElementName() == inverse) {
-          CInverseAxis* tmp = (CInverseAxisGroup::get(inverseAxisDefRoot))->createChild(nodeId);
-          tmp->parse(node);
-          transformationMap_.push_back(std::make_pair(TRANS_INVERSE_AXIS,tmp));
-        }
-        else if (node.getElementName() == zoom) {
-          CZoomAxis* tmp = (CZoomAxisGroup::get(zoomAxisDefRoot))->createChild(nodeId);
-          tmp->parse(node);
-          transformationMap_.push_back(std::make_pair(TRANS_ZOOM_AXIS,tmp));
-        }
-        else if (node.getElementName() == interp) {
-          CInterpolateAxis* tmp = (CInterpolateAxisGroup::get(interpAxisDefRoot))->createChild(nodeId);
-          tmp->parse(node);
-          transformationMap_.push_back(std::make_pair(TRANS_INTERPOLATE_AXIS,tmp));
+        nodeElementName = node.getElementName();
+        std::map<StdString, ETranformationType>::const_iterator ite = transformationMapList_.end(), it;
+        it = transformationMapList_.find(nodeElementName);
+        if (ite != it)
+        {
+          transformationMap_.push_back(std::make_pair(it->second, CTransformation<CAxis>::createTransformation(it->second,
+                                                                                                               nodeId,
+                                                                                                               &node)));
         }
       } while (node.goToNextElement()) ;
Index: /XIOS/trunk/src/node/axis.hpp
===================================================================
--- /XIOS/trunk/src/node/axis.hpp	(revision 835)
+++ /XIOS/trunk/src/node/axis.hpp	(revision 836)
@@ -113,5 +113,6 @@
          TransMapTypes getAllTransformations();
          void fillInValues(const CArray<double,1>& values);
-         void duplicateTransformation(CAxis*);                   \
+         void duplicateTransformation(CAxis*);
+         CTransformation<CAxis>* addTransformation(ETranformationType transType, const StdString& id="");
 
       public:
@@ -162,4 +163,10 @@
          std::map<int, CArray<int,1> > indiSrv_;
          bool hasBounds_;
+
+       private:
+         static bool initializeTransformationMap(std::map<StdString, ETranformationType>& m);
+         static std::map<StdString, ETranformationType> transformationMapList_;
+         static bool dummyTransformationMapList_;
+
          DECLARE_REF_FUNC(Axis,axis)
    }; // class CAxis
Index: /XIOS/trunk/src/node/domain.cpp
===================================================================
--- /XIOS/trunk/src/node/domain.cpp	(revision 835)
+++ /XIOS/trunk/src/node/domain.cpp	(revision 836)
@@ -56,4 +56,14 @@
      CDomain* domain = CDomainGroup::get("domain_definition")->createChild();
      return domain;
+   }
+
+   std::map<StdString, ETranformationType> CDomain::transformationMapList_ = std::map<StdString, ETranformationType>();
+   bool CDomain::_dummyTransformationMapList = CDomain::initializeTransformationMap(CDomain::transformationMapList_);
+
+   bool CDomain::initializeTransformationMap(std::map<StdString, ETranformationType>& m)
+   {
+     m["zoom_domain"] = TRANS_ZOOM_DOMAIN;
+     m["interpolate_domain"] = TRANS_INTERPOLATE_DOMAIN;
+     m["generate_rectilinear_domain"] = TRANS_GENERATE_RECTILINEAR_DOMAIN;
    }
 
@@ -1906,4 +1916,10 @@
   }
 
+  CTransformation<CDomain>* CDomain::addTransformation(ETranformationType transType, const StdString& id)
+  {
+    transformationMap_.push_back(std::make_pair(transType, CTransformation<CDomain>::createTransformation(transType,id)));
+    return transformationMap_.back().second;
+  }
+
   /*!
     Check whether a domain has transformation
@@ -1987,10 +2003,5 @@
     if (node.goToChildElement())
     {
-      StdString zoomDomainDefRoot("zoom_domain_definition");
-      StdString zoom("zoom_domain");
-      StdString interpDomainDefRoot("interpolate_domain_definition");
-      StdString interpFromFile("interpolate_domain");
-      StdString generateRectilinearDefRoot("generate_rectilinear_domain_definition");
-      StdString generateRectilinear("generate_rectilinear_domain");
+      StdString nodeElementName;
       do
       {
@@ -1999,20 +2010,12 @@
         { nodeId = node.getAttributes()["id"]; }
 
-        if (node.getElementName() == zoom) {
-          CZoomDomain* tmp = (CZoomDomainGroup::get(zoomDomainDefRoot))->createChild(nodeId);
-          tmp->parse(node);
-          transformationMap_.push_back(std::make_pair(TRANS_ZOOM_DOMAIN,tmp));
-        }
-        else if (node.getElementName() == interpFromFile)
+        nodeElementName = node.getElementName();
+        std::map<StdString, ETranformationType>::const_iterator ite = transformationMapList_.end(), it;
+        it = transformationMapList_.find(nodeElementName);
+        if (ite != it)
         {
-          CInterpolateDomain* tmp = (CInterpolateDomainGroup::get(interpDomainDefRoot))->createChild(nodeId);
-          tmp->parse(node);
-          transformationMap_.push_back(std::make_pair(TRANS_INTERPOLATE_DOMAIN,tmp));
-        }
-        else if (node.getElementName() == generateRectilinear)
-        {
-          CGenerateRectilinearDomain* tmp = (CGenerateRectilinearDomainGroup::get(generateRectilinearDefRoot))->createChild(nodeId);
-          tmp->parse(node);
-          transformationMap_.push_back(std::make_pair(TRANS_GENERATE_RECTILINEAR_DOMAIN,tmp));
+          transformationMap_.push_back(std::make_pair(it->second, CTransformation<CDomain>::createTransformation(it->second,
+                                                                                                                nodeId,
+                                                                                                                &node)));
         }
       } while (node.goToNextElement()) ;
Index: /XIOS/trunk/src/node/domain.hpp
===================================================================
--- /XIOS/trunk/src/node/domain.hpp	(revision 835)
+++ /XIOS/trunk/src/node/domain.hpp	(revision 836)
@@ -79,4 +79,5 @@
          void redistribute(int nbLocalDomain);
          void duplicateTransformation(CDomain*);
+         CTransformation<CDomain>* addTransformation(ETranformationType transType, const StdString& id="");
 
       public:
@@ -198,4 +199,9 @@
          bool isUnstructed_;
 
+       private:
+         static bool initializeTransformationMap(std::map<StdString, ETranformationType>& m);
+         static std::map<StdString, ETranformationType> transformationMapList_;
+         static bool _dummyTransformationMapList;
+
          DECLARE_REF_FUNC(Domain,domain)
 
Index: /XIOS/trunk/src/node/generate_rectilinear_domain.cpp
===================================================================
--- /XIOS/trunk/src/node/generate_rectilinear_domain.cpp	(revision 835)
+++ /XIOS/trunk/src/node/generate_rectilinear_domain.cpp	(revision 836)
@@ -16,4 +16,17 @@
   CGenerateRectilinearDomain::~CGenerateRectilinearDomain(void)
   {}
+
+  CTransformation<CDomain>* CGenerateRectilinearDomain::create(const StdString& id, xml::CXMLNode* node)
+  {
+    CGenerateRectilinearDomain* genDomain = CGenerateRectilinearDomainGroup::get("generate_rectilinear_domain_definition")->createChild(id);
+    if (node) genDomain->parse(*node);
+    return static_cast<CTransformation<CDomain>*>(genDomain);
+  }
+
+  bool CGenerateRectilinearDomain::_dummyRegistered = CGenerateRectilinearDomain::registerTrans();
+  bool CGenerateRectilinearDomain::registerTrans()
+  {
+    registerTransformation(TRANS_GENERATE_RECTILINEAR_DOMAIN, create);
+  }
 
   //----------------------------------------------------------------
Index: /XIOS/trunk/src/node/generate_rectilinear_domain.hpp
===================================================================
--- /XIOS/trunk/src/node/generate_rectilinear_domain.hpp	(revision 835)
+++ /XIOS/trunk/src/node/generate_rectilinear_domain.hpp	(revision 836)
@@ -57,5 +57,7 @@
       static ENodeType GetType(void);
     private:
-
+      static bool registerTrans();
+      static CTransformation<CDomain>* create(const StdString& id, xml::CXMLNode* node);
+      static bool _dummyRegistered;
   }; // class CGenerateRectilinearDomain
 
Index: /XIOS/trunk/src/node/interpolate_axis.cpp
===================================================================
--- /XIOS/trunk/src/node/interpolate_axis.cpp	(revision 835)
+++ /XIOS/trunk/src/node/interpolate_axis.cpp	(revision 836)
@@ -17,4 +17,18 @@
   CInterpolateAxis::~CInterpolateAxis(void)
   {}
+
+  CTransformation<CAxis>* CInterpolateAxis::create(const StdString& id, xml::CXMLNode* node)
+  {
+    CInterpolateAxis* interpAxis = CInterpolateAxisGroup::get("interpolate_axis_definition")->createChild(id);
+    if (node) interpAxis->parse(*node);
+    return static_cast<CTransformation<CAxis>*>(interpAxis);
+  }
+
+  bool CInterpolateAxis::registerTrans()
+  {
+    return registerTransformation(TRANS_INTERPOLATE_AXIS, CInterpolateAxis::create);
+  }
+
+  bool CInterpolateAxis::_dummyRegistered = CInterpolateAxis::registerTrans();
 
   //----------------------------------------------------------------
Index: /XIOS/trunk/src/node/interpolate_axis.hpp
===================================================================
--- /XIOS/trunk/src/node/interpolate_axis.hpp	(revision 835)
+++ /XIOS/trunk/src/node/interpolate_axis.hpp	(revision 836)
@@ -59,5 +59,7 @@
       static ENodeType GetType(void);
     private:
-
+      static bool registerTrans();
+      static CTransformation<CAxis>* create(const StdString& id, xml::CXMLNode* node);
+      static bool _dummyRegistered;
   }; // class CInterpolateAxis
 
Index: /XIOS/trunk/src/node/interpolate_domain.cpp
===================================================================
--- /XIOS/trunk/src/node/interpolate_domain.cpp	(revision 835)
+++ /XIOS/trunk/src/node/interpolate_domain.cpp	(revision 836)
@@ -16,4 +16,17 @@
   CInterpolateDomain::~CInterpolateDomain(void)
   {}
+
+  CTransformation<CDomain>* CInterpolateDomain::create(const StdString& id, xml::CXMLNode* node)
+  {
+    CInterpolateDomain* interpDomain = CInterpolateDomainGroup::get("interpolate_domain_definition")->createChild(id);
+    if (node) interpDomain->parse(*node);
+    return static_cast<CTransformation<CDomain>*>(interpDomain);
+  }
+
+  bool CInterpolateDomain::_dummyRegistered = CInterpolateDomain::registerTrans();
+  bool CInterpolateDomain::registerTrans()
+  {
+    registerTransformation(TRANS_INTERPOLATE_DOMAIN, create);
+  }
 
   //----------------------------------------------------------------
Index: /XIOS/trunk/src/node/interpolate_domain.hpp
===================================================================
--- /XIOS/trunk/src/node/interpolate_domain.hpp	(revision 835)
+++ /XIOS/trunk/src/node/interpolate_domain.hpp	(revision 836)
@@ -57,5 +57,7 @@
       static ENodeType GetType(void);
     private:
-
+      static bool registerTrans();
+      static CTransformation<CDomain>* create(const StdString& id, xml::CXMLNode* node);
+      static bool _dummyRegistered;
   }; // class CInterpolateDomain
 
Index: /XIOS/trunk/src/node/inverse_axis.cpp
===================================================================
--- /XIOS/trunk/src/node/inverse_axis.cpp	(revision 835)
+++ /XIOS/trunk/src/node/inverse_axis.cpp	(revision 836)
@@ -17,6 +17,19 @@
   {}
 
+  CTransformation<CAxis>* CInverseAxis::create(const StdString& id, xml::CXMLNode* node)
+  {
+    CInverseAxis* invAxis = CInverseAxisGroup::get("inverse_axis_definition")->createChild(id);
+    if (node) invAxis->parse(*node);
+    return static_cast<CTransformation<CAxis>*>(invAxis);
+  }
+
+  bool CInverseAxis::registerTrans()
+  {
+    return registerTransformation(TRANS_INVERSE_AXIS, CInverseAxis::create);
+  }
+
+  bool CInverseAxis::_dummyRegistered = CInverseAxis::registerTrans();
+
   //----------------------------------------------------------------
-
   StdString CInverseAxis::GetName(void)    { return StdString("inverse_axis"); }
   StdString CInverseAxis::GetDefName(void) { return StdString("inverse_axis"); }
Index: /XIOS/trunk/src/node/inverse_axis.hpp
===================================================================
--- /XIOS/trunk/src/node/inverse_axis.hpp	(revision 835)
+++ /XIOS/trunk/src/node/inverse_axis.hpp	(revision 836)
@@ -54,5 +54,9 @@
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+
     private:
+      static bool registerTrans();
+      static CTransformation<CAxis>* create(const StdString& id, xml::CXMLNode* node);
+      static bool _dummyRegistered;
 
   }; // class CInverseAxis
Index: /XIOS/trunk/src/node/transformation.hpp
===================================================================
--- /XIOS/trunk/src/node/transformation.hpp	(revision 835)
+++ /XIOS/trunk/src/node/transformation.hpp	(revision 836)
@@ -25,4 +25,5 @@
 
       std::vector<StdString> checkAuxInputs() { return checkAuxInputs_(); }
+      static CTransformation<T>* createTransformation(ETranformationType transType, const StdString& id, xml::CXMLNode* node=0);
 
       /// Destructeur ///
@@ -30,6 +31,47 @@
 
     protected:
+      typedef CTransformation<T>* (*CreateTransformationCallBack)(const StdString&, xml::CXMLNode*);
+      typedef std::map<ETranformationType, CreateTransformationCallBack> CallBackMap;
+      static CallBackMap* transformationCreationCallBacks_;
+
+      static bool registerTransformation(ETranformationType transType, CreateTransformationCallBack createFn);
+      static bool unregisterTransformation(ETranformationType transType);
+
+    protected:
       virtual std::vector<StdString> checkAuxInputs_() { return std::vector<StdString>(); }
   }; // class CTransformation
+
+  template<typename T>
+  CTransformation<T>::CallBackMap* CTransformation<T>::transformationCreationCallBacks_ = 0; //CTransformation<T>::CallBackMap();
+
+  template<typename T>
+  CTransformation<T>* CTransformation<T>::createTransformation(ETranformationType transType, const StdString& id, xml::CXMLNode* node)
+  {
+    int transTypeInt = transType;
+    typename CallBackMap::const_iterator it = (*transformationCreationCallBacks_).find(transType);
+    if ((*transformationCreationCallBacks_).end() == it)
+    {
+       ERROR("CTransformation<T>::createTransformation(ETranformationType transType)",
+             << "Transformation type " << transType
+             << "doesn't exist. Please define.");
+    }
+    return (it->second)(id,node);
+  }
+
+  template<typename T>
+  bool CTransformation<T>::registerTransformation(ETranformationType transType, CreateTransformationCallBack createFn)
+  {
+    if (0 == transformationCreationCallBacks_)
+      transformationCreationCallBacks_ = new CallBackMap();
+
+    return (*transformationCreationCallBacks_).insert(make_pair(transType, createFn)).second;
+  }
+
+  template<typename T>
+  bool CTransformation<T>::unregisterTransformation(ETranformationType transType)
+  {
+    int transTypeInt = transType;
+    return (1 == (*transformationCreationCallBacks_).erase(transType));
+  }
 
 } // namespace xios
Index: /XIOS/trunk/src/node/transformation_enum.hpp
===================================================================
--- /XIOS/trunk/src/node/transformation_enum.hpp	(revision 835)
+++ /XIOS/trunk/src/node/transformation_enum.hpp	(revision 836)
@@ -7,10 +7,10 @@
       typedef enum transformation_type
       {
-        TRANS_ZOOM_AXIS,
-        TRANS_INVERSE_AXIS,
-        TRANS_INTERPOLATE_AXIS,
-        TRANS_ZOOM_DOMAIN,
-        TRANS_INTERPOLATE_DOMAIN,
-        TRANS_GENERATE_RECTILINEAR_DOMAIN
+        TRANS_ZOOM_AXIS = 0,
+        TRANS_INVERSE_AXIS = 1,
+        TRANS_INTERPOLATE_AXIS = 2,
+        TRANS_ZOOM_DOMAIN = 3,
+        TRANS_INTERPOLATE_DOMAIN = 4,
+        TRANS_GENERATE_RECTILINEAR_DOMAIN = 5
       } ETranformationType;
 
Index: /XIOS/trunk/src/node/zoom_axis.cpp
===================================================================
--- /XIOS/trunk/src/node/zoom_axis.cpp	(revision 835)
+++ /XIOS/trunk/src/node/zoom_axis.cpp	(revision 836)
@@ -16,4 +16,18 @@
   CZoomAxis::~CZoomAxis(void)
   {}
+
+  CTransformation<CAxis>* CZoomAxis::create(const StdString& id, xml::CXMLNode* node)
+  {
+    CZoomAxis* zoomAxis = CZoomAxisGroup::get("zoom_axis_definition")->createChild(id);
+    if (node) zoomAxis->parse(*node);
+    return static_cast<CTransformation<CAxis>*>(zoomAxis);
+  }
+
+  bool CZoomAxis::registerTrans()
+  {
+    return registerTransformation(TRANS_ZOOM_AXIS, CZoomAxis::create);
+  }
+
+  bool CZoomAxis::_dummyRegistered = CZoomAxis::registerTrans();
 
   //----------------------------------------------------------------
Index: /XIOS/trunk/src/node/zoom_axis.hpp
===================================================================
--- /XIOS/trunk/src/node/zoom_axis.hpp	(revision 835)
+++ /XIOS/trunk/src/node/zoom_axis.hpp	(revision 836)
@@ -57,5 +57,7 @@
       static ENodeType GetType(void);
     private:
-
+      static bool registerTrans();
+      static CTransformation<CAxis>* create(const StdString& id, xml::CXMLNode* node);
+      static bool _dummyRegistered;
   }; // class CZoomAxis
 
Index: /XIOS/trunk/src/node/zoom_domain.cpp
===================================================================
--- /XIOS/trunk/src/node/zoom_domain.cpp	(revision 835)
+++ /XIOS/trunk/src/node/zoom_domain.cpp	(revision 836)
@@ -16,4 +16,17 @@
   CZoomDomain::~CZoomDomain(void)
   {}
+
+  CTransformation<CDomain>* CZoomDomain::create(const StdString& id, xml::CXMLNode* node)
+  {
+    CZoomDomain* zoomDomain = CZoomDomainGroup::get("zoom_domain_definition")->createChild(id);
+    if (node) zoomDomain->parse(*node);
+    return static_cast<CTransformation<CDomain>*>(zoomDomain);
+  }
+
+  bool CZoomDomain::_dummyRegistered = CZoomDomain::registerTrans();
+  bool CZoomDomain::registerTrans()
+  {
+    registerTransformation(TRANS_ZOOM_DOMAIN, CZoomDomain::create);
+  }
 
   //----------------------------------------------------------------
Index: /XIOS/trunk/src/node/zoom_domain.hpp
===================================================================
--- /XIOS/trunk/src/node/zoom_domain.hpp	(revision 835)
+++ /XIOS/trunk/src/node/zoom_domain.hpp	(revision 836)
@@ -57,5 +57,7 @@
       static ENodeType GetType(void);
     private:
-
+      static bool registerTrans();
+      static CTransformation<CDomain>* create(const StdString& id, xml::CXMLNode* node);
+      static bool _dummyRegistered;
   }; // class CZoomDomain
 
Index: /XIOS/trunk/src/test/test_new_features.f90
===================================================================
--- /XIOS/trunk/src/test/test_new_features.f90	(revision 835)
+++ /XIOS/trunk/src/test/test_new_features.f90	(revision 836)
@@ -17,5 +17,5 @@
   INTEGER,PARAMETER :: ni_glo=100
   INTEGER,PARAMETER :: nj_glo=100
-  INTEGER,PARAMETER :: llm=5
+  INTEGER,PARAMETER :: llm=10
   INTEGER,PARAMETER :: llmInterPolated=4
   DOUBLE PRECISION  :: lval(llm)=1, tsTemp, lvalInterPolated(llmInterPolated)=1
Index: /XIOS/trunk/src/transformation/transformation_mapping.cpp
===================================================================
--- /XIOS/trunk/src/transformation/transformation_mapping.cpp	(revision 835)
+++ /XIOS/trunk/src/transformation/transformation_mapping.cpp	(revision 836)
@@ -41,6 +41,5 @@
 
   gridIndexClientClientMapping_ = new CClientClientDHTPairIntInt(globalIndexOfServer,
-                                                                 client->intraComm,
-                                                                 true);
+                                                                 client->intraComm);
 }
 
@@ -65,6 +64,5 @@
 
   gridIndexClientClientMapping_ = new CClientClientDHTPairIntInt(globalIndexOfAxisSource,
-                                                                 client->intraComm,
-                                                                 true);
+                                                                 client->intraComm);
 }
 
