Changeset 836


Ignore:
Timestamp:
04/08/16 15:00:45 (5 years ago)
Author:
mhnguyen
Message:

Exposing transformation to Fortran interface

+) Export zoom and axis transformation to Fortran interface

Test
+) On Curie
+) All work

Location:
XIOS/trunk/src
Files:
23 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/src/interface/c/icxml_tree.cpp

    r835 r836  
    2121#include "domain.hpp" 
    2222#include "variable.hpp" 
     23#include "zoom_domain.hpp" 
     24#include "interpolate_domain.hpp" 
     25#include "generate_rectilinear_domain.hpp" 
     26#include "zoom_axis.hpp" 
     27#include "interpolate_axis.hpp" 
     28#include "inverse_axis.hpp" 
    2329 
    2430extern "C" 
     
    4854   typedef xios::CVariableGroup *  XVariableGroupPtr; 
    4955 
     56   typedef xios::CTransformation<CDomain>   *  XTransformationDomainPtr; 
     57   typedef xios::CZoomDomain                *  XZoomDomainPtr; 
     58   typedef xios::CInterpolateDomain         *  XInterpolateDomainPtr; 
     59   typedef xios::CGenerateRectilinearDomain *  XGenerateRectilinearDomainPtr; 
     60 
     61   typedef xios::CTransformation<CAxis>   *  XTransformationAxisPtr; 
     62   typedef xios::CZoomAxis                *  XZoomAxisPtr; 
     63   typedef xios::CInterpolateAxis         *  XInterpolateAxisPtr; 
     64   typedef xios::CInverseAxis             *  XInverseAxisPtr; 
     65 
    5066   // ----------------------- Ajout d'enfant à un parent ----------------------- 
    5167 
     
    339355         *child_ = parent_->addDomain(); 
    340356      } 
     357      CTimer::get("XIOS").suspend() ; 
     358   } 
     359 
     360   void cxios_xml_tree_add_zoomdomaintodomain 
     361      (XDomainPtr parent_, XZoomDomainPtr * child_, const char * child_id, int child_id_size) 
     362   { 
     363      std::string child_id_str; 
     364      XTransformationDomainPtr tmpChild_; 
     365      CTimer::get("XIOS").resume() ; 
     366      if (cstr2string(child_id, child_id_size, child_id_str)) 
     367      { 
     368         tmpChild_ = parent_->addTransformation(TRANS_ZOOM_DOMAIN, child_id_str); 
     369      } 
     370      else 
     371      { 
     372         tmpChild_ = parent_->addTransformation(TRANS_ZOOM_DOMAIN); 
     373      } 
     374      *child_ = static_cast<XZoomDomainPtr>(tmpChild_); 
     375      CTimer::get("XIOS").suspend() ; 
     376   } 
     377 
     378   void cxios_xml_tree_add_interpolatedomaintodomain 
     379      (XDomainPtr parent_, XInterpolateDomainPtr * child_, const char * child_id, int child_id_size) 
     380   { 
     381      std::string child_id_str; 
     382      XTransformationDomainPtr tmpChild_; 
     383      CTimer::get("XIOS").resume() ; 
     384      if (cstr2string(child_id, child_id_size, child_id_str)) 
     385      { 
     386         tmpChild_ = parent_->addTransformation(TRANS_INTERPOLATE_DOMAIN, child_id_str); 
     387      } 
     388      else 
     389      { 
     390         tmpChild_ = parent_->addTransformation(TRANS_INTERPOLATE_DOMAIN); 
     391      } 
     392      *child_ = static_cast<XInterpolateDomainPtr>(tmpChild_); 
     393      CTimer::get("XIOS").suspend() ; 
     394   } 
     395 
     396   void cxios_xml_tree_add_generatedomaintodomain 
     397      (XDomainPtr parent_, XGenerateRectilinearDomainPtr * child_, const char * child_id, int child_id_size) 
     398   { 
     399      std::string child_id_str; 
     400      XTransformationDomainPtr tmpChild_; 
     401      CTimer::get("XIOS").resume() ; 
     402      if (cstr2string(child_id, child_id_size, child_id_str)) 
     403      { 
     404         tmpChild_ = parent_->addTransformation(TRANS_GENERATE_RECTILINEAR_DOMAIN, child_id_str); 
     405      } 
     406      else 
     407      { 
     408         tmpChild_ = parent_->addTransformation(TRANS_GENERATE_RECTILINEAR_DOMAIN); 
     409      } 
     410      *child_ = static_cast<XGenerateRectilinearDomainPtr>(tmpChild_); 
     411      CTimer::get("XIOS").suspend() ; 
     412   } 
     413 
     414   void cxios_xml_tree_add_zoomaxistoaxis 
     415      (XAxisPtr parent_, XZoomAxisPtr * child_, const char * child_id, int child_id_size) 
     416   { 
     417      std::string child_id_str; 
     418      XTransformationAxisPtr tmpChild_; 
     419      CTimer::get("XIOS").resume() ; 
     420      if (cstr2string(child_id, child_id_size, child_id_str)) 
     421      { 
     422         tmpChild_ = parent_->addTransformation(TRANS_ZOOM_AXIS, child_id_str); 
     423      } 
     424      else 
     425      { 
     426         tmpChild_ = parent_->addTransformation(TRANS_ZOOM_AXIS); 
     427      } 
     428      *child_ = static_cast<XZoomAxisPtr>(tmpChild_); 
     429      CTimer::get("XIOS").suspend() ; 
     430   } 
     431 
     432   void cxios_xml_tree_add_interpolateaxistoaxis 
     433      (XAxisPtr parent_, XInterpolateAxisPtr * child_, const char * child_id, int child_id_size) 
     434   { 
     435      std::string child_id_str; 
     436      XTransformationAxisPtr tmpChild_; 
     437      CTimer::get("XIOS").resume() ; 
     438      if (cstr2string(child_id, child_id_size, child_id_str)) 
     439      { 
     440         tmpChild_ = parent_->addTransformation(TRANS_INTERPOLATE_AXIS, child_id_str); 
     441      } 
     442      else 
     443      { 
     444         tmpChild_ = parent_->addTransformation(TRANS_INTERPOLATE_AXIS); 
     445      } 
     446      *child_ = static_cast<XInterpolateAxisPtr>(tmpChild_); 
     447      CTimer::get("XIOS").suspend() ; 
     448   } 
     449 
     450   void cxios_xml_tree_add_inverseaxistoaxis 
     451      (XAxisPtr parent_, XInverseAxisPtr * child_, const char * child_id, int child_id_size) 
     452   { 
     453      std::string child_id_str; 
     454      XTransformationAxisPtr tmpChild_; 
     455      CTimer::get("XIOS").resume() ; 
     456      if (cstr2string(child_id, child_id_size, child_id_str)) 
     457      { 
     458         tmpChild_ = parent_->addTransformation(TRANS_INVERSE_AXIS, child_id_str); 
     459      } 
     460      else 
     461      { 
     462         tmpChild_ = parent_->addTransformation(TRANS_INVERSE_AXIS); 
     463      } 
     464      *child_ = static_cast<XInverseAxisPtr>(tmpChild_); 
    341465      CTimer::get("XIOS").suspend() ; 
    342466   } 
  • XIOS/trunk/src/interface/fortran/ixios_interfaces.F90

    r835 r836  
    8383                      xios(add_axisgroup), xios(add_filegroup), xios(add_gridgroup), xios(add_fieldgroup), & 
    8484                      xios(add_domaingroup), xios(add_fieldgrouptofile), xios(add_variablegrouptofile),    & 
    85                       xios(add_variablegrouptofield), xios(add_axistogrid), xios(add_domaintogrid) 
     85                      xios(add_variablegrouptofield), xios(add_axistogrid), xios(add_domaintogrid),        & 
     86                      xios(add_zoomdomaintodomain), xios(add_interpolatedomaintodomain),                   & 
     87                      xios(add_generatedomaintodomain), xios(add_zoomaxistoaxis),                          & 
     88                      xios(add_interpolateaxistoaxis), xios(add_inverseaxistoaxis) 
    8689 
    8790PRIVATE 
     
    136139                   xios(add_filegroup), xios(add_gridgroup), xios(add_fieldgroup), xios(add_domaingroup),            & 
    137140                   xios(add_fieldgrouptofile), xios(add_variablegrouptofile),xios(add_variablegrouptofield),         & 
    138                    xios(add_axistogrid), xios(add_domaintogrid) 
     141                   xios(add_axistogrid), xios(add_domaintogrid), xios(add_zoomdomaintodomain),                       & 
     142                   xios(add_interpolatedomaintodomain), xios(add_generatedomaintodomain),                            & 
     143                   xios(add_zoomaxistoaxis), xios(add_interpolateaxistoaxis), xios(add_inverseaxistoaxis) 
    139144END INTERFACE xios(add_child) 
    140145 
  • XIOS/trunk/src/interface/fortran/ixml_tree.F90

    r835 r836  
    99   USE IDOMAIN 
    1010   USE IVARIABLE 
     11   USE IZOOM_DOMAIN 
     12   USE IINTERPOLATE_DOMAIN 
     13   USE IGENERATE_RECTILINEAR_DOMAIN 
     14   USE IZOOM_AXIS 
     15   USE IINTERPOLATE_AXIS 
     16   USE IINVERSE_AXIS 
    1117 
    1218   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
     
    157163         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size 
    158164      END SUBROUTINE cxios_xml_tree_add_domaintogrid 
     165 
     166      SUBROUTINE cxios_xml_tree_add_zoomdomaintodomain(parent_, child_, child_id, child_id_size) BIND(C) 
     167         USE ISO_C_BINDING 
     168         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_ 
     169         INTEGER  (kind = C_INTPTR_T)               :: child_ 
     170         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id 
     171         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size 
     172      END SUBROUTINE cxios_xml_tree_add_zoomdomaintodomain 
     173 
     174      SUBROUTINE cxios_xml_tree_add_interpolatedomaintodomain(parent_, child_, child_id, child_id_size) BIND(C) 
     175         USE ISO_C_BINDING 
     176         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_ 
     177         INTEGER  (kind = C_INTPTR_T)               :: child_ 
     178         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id 
     179         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size 
     180      END SUBROUTINE cxios_xml_tree_add_interpolatedomaintodomain 
     181 
     182      SUBROUTINE cxios_xml_tree_add_generatedomaintodomain(parent_, child_, child_id, child_id_size) BIND(C) 
     183         USE ISO_C_BINDING 
     184         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_ 
     185         INTEGER  (kind = C_INTPTR_T)               :: child_ 
     186         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id 
     187         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size 
     188      END SUBROUTINE cxios_xml_tree_add_generatedomaintodomain 
     189 
     190      SUBROUTINE cxios_xml_tree_add_zoomaxistoaxis(parent_, child_, child_id, child_id_size) BIND(C) 
     191         USE ISO_C_BINDING 
     192         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_ 
     193         INTEGER  (kind = C_INTPTR_T)               :: child_ 
     194         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id 
     195         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size 
     196      END SUBROUTINE cxios_xml_tree_add_zoomaxistoaxis 
     197 
     198      SUBROUTINE cxios_xml_tree_add_interpolateaxistoaxis(parent_, child_, child_id, child_id_size) BIND(C) 
     199         USE ISO_C_BINDING 
     200         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_ 
     201         INTEGER  (kind = C_INTPTR_T)               :: child_ 
     202         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id 
     203         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size 
     204      END SUBROUTINE cxios_xml_tree_add_interpolateaxistoaxis 
     205 
     206      SUBROUTINE cxios_xml_tree_add_inverseaxistoaxis(parent_, child_, child_id, child_id_size) BIND(C) 
     207         USE ISO_C_BINDING 
     208         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_ 
     209         INTEGER  (kind = C_INTPTR_T)               :: child_ 
     210         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id 
     211         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size 
     212      END SUBROUTINE cxios_xml_tree_add_inverseaxistoaxis 
    159213 
    160214      SUBROUTINE cxios_xml_tree_show(filename, filename_size) BIND(C) 
     
    417471 
    418472   END SUBROUTINE xios(add_domaintogrid) 
     473 
     474   SUBROUTINE xios(add_zoomdomaintodomain)(parent_hdl, child_hdl, child_id) 
     475      TYPE(txios(domain))           , INTENT(IN) :: parent_hdl 
     476      TYPE(txios(zoom_domain))      , INTENT(OUT):: child_hdl 
     477      CHARACTER(len = *), OPTIONAL  , INTENT(IN) :: child_id 
     478 
     479      IF (PRESENT(child_id)) THEN 
     480         CALL cxios_xml_tree_add_zoomdomaintodomain(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id)) 
     481      ELSE 
     482         CALL cxios_xml_tree_add_zoomdomaintodomain(parent_hdl%daddr, child_hdl%daddr, "NONE", -1) 
     483      END IF 
     484 
     485   END SUBROUTINE xios(add_zoomdomaintodomain) 
     486 
     487   SUBROUTINE xios(add_interpolatedomaintodomain)(parent_hdl, child_hdl, child_id) 
     488      TYPE(txios(domain))             , INTENT(IN) :: parent_hdl 
     489      TYPE(txios(interpolate_domain)) , INTENT(OUT):: child_hdl 
     490      CHARACTER(len = *), OPTIONAL    , INTENT(IN) :: child_id 
     491 
     492      IF (PRESENT(child_id)) THEN 
     493         CALL cxios_xml_tree_add_interpolatedomaintodomain(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id)) 
     494      ELSE 
     495         CALL cxios_xml_tree_add_interpolatedomaintodomain(parent_hdl%daddr, child_hdl%daddr, "NONE", -1) 
     496      END IF 
     497 
     498   END SUBROUTINE xios(add_interpolatedomaintodomain) 
     499 
     500   SUBROUTINE xios(add_generatedomaintodomain)(parent_hdl, child_hdl, child_id) 
     501      TYPE(txios(domain))                      , INTENT(IN) :: parent_hdl 
     502      TYPE(txios(generate_rectilinear_domain)) , INTENT(OUT):: child_hdl 
     503      CHARACTER(len = *), OPTIONAL             , INTENT(IN) :: child_id 
     504 
     505      IF (PRESENT(child_id)) THEN 
     506         CALL cxios_xml_tree_add_generatedomaintodomain(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id)) 
     507      ELSE 
     508         CALL cxios_xml_tree_add_generatedomaintodomain(parent_hdl%daddr, child_hdl%daddr, "NONE", -1) 
     509      END IF 
     510 
     511   END SUBROUTINE xios(add_generatedomaintodomain) 
     512 
     513   SUBROUTINE xios(add_zoomaxistoaxis)(parent_hdl, child_hdl, child_id) 
     514      TYPE(txios(axis))                      , INTENT(IN) :: parent_hdl 
     515      TYPE(txios(zoom_axis))                 , INTENT(OUT):: child_hdl 
     516      CHARACTER(len = *), OPTIONAL           , INTENT(IN) :: child_id 
     517 
     518      IF (PRESENT(child_id)) THEN 
     519         CALL cxios_xml_tree_add_zoomaxistoaxis(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id)) 
     520      ELSE 
     521         CALL cxios_xml_tree_add_zoomaxistoaxis(parent_hdl%daddr, child_hdl%daddr, "NONE", -1) 
     522      END IF 
     523 
     524   END SUBROUTINE xios(add_zoomaxistoaxis) 
     525 
     526   SUBROUTINE xios(add_interpolateaxistoaxis)(parent_hdl, child_hdl, child_id) 
     527      TYPE(txios(axis))                      , INTENT(IN) :: parent_hdl 
     528      TYPE(txios(interpolate_axis))          , INTENT(OUT):: child_hdl 
     529      CHARACTER(len = *), OPTIONAL           , INTENT(IN) :: child_id 
     530 
     531      IF (PRESENT(child_id)) THEN 
     532         CALL cxios_xml_tree_add_interpolateaxistoaxis(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id)) 
     533      ELSE 
     534         CALL cxios_xml_tree_add_interpolateaxistoaxis(parent_hdl%daddr, child_hdl%daddr, "NONE", -1) 
     535      END IF 
     536 
     537   END SUBROUTINE xios(add_interpolateaxistoaxis) 
     538 
     539      SUBROUTINE xios(add_inverseaxistoaxis)(parent_hdl, child_hdl, child_id) 
     540      TYPE(txios(axis))                      , INTENT(IN) :: parent_hdl 
     541      TYPE(txios(zoom_axis))                 , INTENT(OUT):: child_hdl 
     542      CHARACTER(len = *), OPTIONAL           , INTENT(IN) :: child_id 
     543 
     544      IF (PRESENT(child_id)) THEN 
     545         CALL cxios_xml_tree_add_inverseaxistoaxis(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id)) 
     546      ELSE 
     547         CALL cxios_xml_tree_add_inverseaxistoaxis(parent_hdl%daddr, child_hdl%daddr, "NONE", -1) 
     548      END IF 
     549 
     550   END SUBROUTINE xios(add_inverseaxistoaxis) 
    419551END MODULE IXML_TREE 
  • XIOS/trunk/src/node/axis.cpp

    r829 r836  
    4141   CAxis::~CAxis(void) 
    4242   { /* Ne rien faire de plus */ } 
     43 
     44   std::map<StdString, ETranformationType> CAxis::transformationMapList_ = std::map<StdString, ETranformationType>(); 
     45   bool CAxis::dummyTransformationMapList_ = CAxis::initializeTransformationMap(CAxis::transformationMapList_); 
     46   bool CAxis::initializeTransformationMap(std::map<StdString, ETranformationType>& m) 
     47   { 
     48     m["zoom_axis"] = TRANS_ZOOM_AXIS; 
     49     m["interpolate_axis"] = TRANS_INTERPOLATE_AXIS; 
     50     m["inverse_axis"] = TRANS_INVERSE_AXIS; 
     51   } 
    4352 
    4453   ///--------------------------------------------------------------- 
     
    884893  } 
    885894 
     895  CTransformation<CAxis>* CAxis::addTransformation(ETranformationType transType, const StdString& id) 
     896  { 
     897    transformationMap_.push_back(std::make_pair(transType, CTransformation<CAxis>::createTransformation(transType,id))); 
     898    return transformationMap_.back().second; 
     899  } 
     900 
    886901  bool CAxis::hasTransformation() 
    887902  { 
     
    948963    if (node.goToChildElement()) 
    949964    { 
    950       StdString inverseAxisDefRoot("inverse_axis_definition"); 
    951       StdString inverse("inverse_axis"); 
    952       StdString zoomAxisDefRoot("zoom_axis_definition"); 
    953       StdString zoom("zoom_axis"); 
    954       StdString interpAxisDefRoot("interpolate_axis_definition"); 
    955       StdString interp("interpolate_axis"); 
     965      StdString nodeElementName; 
    956966      do 
    957967      { 
     
    960970        { nodeId = node.getAttributes()["id"]; } 
    961971 
    962         if (node.getElementName() == inverse) { 
    963           CInverseAxis* tmp = (CInverseAxisGroup::get(inverseAxisDefRoot))->createChild(nodeId); 
    964           tmp->parse(node); 
    965           transformationMap_.push_back(std::make_pair(TRANS_INVERSE_AXIS,tmp)); 
    966         } 
    967         else if (node.getElementName() == zoom) { 
    968           CZoomAxis* tmp = (CZoomAxisGroup::get(zoomAxisDefRoot))->createChild(nodeId); 
    969           tmp->parse(node); 
    970           transformationMap_.push_back(std::make_pair(TRANS_ZOOM_AXIS,tmp)); 
    971         } 
    972         else if (node.getElementName() == interp) { 
    973           CInterpolateAxis* tmp = (CInterpolateAxisGroup::get(interpAxisDefRoot))->createChild(nodeId); 
    974           tmp->parse(node); 
    975           transformationMap_.push_back(std::make_pair(TRANS_INTERPOLATE_AXIS,tmp)); 
     972        nodeElementName = node.getElementName(); 
     973        std::map<StdString, ETranformationType>::const_iterator ite = transformationMapList_.end(), it; 
     974        it = transformationMapList_.find(nodeElementName); 
     975        if (ite != it) 
     976        { 
     977          transformationMap_.push_back(std::make_pair(it->second, CTransformation<CAxis>::createTransformation(it->second, 
     978                                                                                                               nodeId, 
     979                                                                                                               &node))); 
    976980        } 
    977981      } while (node.goToNextElement()) ; 
  • XIOS/trunk/src/node/axis.hpp

    r823 r836  
    113113         TransMapTypes getAllTransformations(); 
    114114         void fillInValues(const CArray<double,1>& values); 
    115          void duplicateTransformation(CAxis*);                   \ 
     115         void duplicateTransformation(CAxis*); 
     116         CTransformation<CAxis>* addTransformation(ETranformationType transType, const StdString& id=""); 
    116117 
    117118      public: 
     
    162163         std::map<int, CArray<int,1> > indiSrv_; 
    163164         bool hasBounds_; 
     165 
     166       private: 
     167         static bool initializeTransformationMap(std::map<StdString, ETranformationType>& m); 
     168         static std::map<StdString, ETranformationType> transformationMapList_; 
     169         static bool dummyTransformationMapList_; 
     170 
    164171         DECLARE_REF_FUNC(Axis,axis) 
    165172   }; // class CAxis 
  • XIOS/trunk/src/node/domain.cpp

    r829 r836  
    5656     CDomain* domain = CDomainGroup::get("domain_definition")->createChild(); 
    5757     return domain; 
     58   } 
     59 
     60   std::map<StdString, ETranformationType> CDomain::transformationMapList_ = std::map<StdString, ETranformationType>(); 
     61   bool CDomain::_dummyTransformationMapList = CDomain::initializeTransformationMap(CDomain::transformationMapList_); 
     62 
     63   bool CDomain::initializeTransformationMap(std::map<StdString, ETranformationType>& m) 
     64   { 
     65     m["zoom_domain"] = TRANS_ZOOM_DOMAIN; 
     66     m["interpolate_domain"] = TRANS_INTERPOLATE_DOMAIN; 
     67     m["generate_rectilinear_domain"] = TRANS_GENERATE_RECTILINEAR_DOMAIN; 
    5868   } 
    5969 
     
    19061916  } 
    19071917 
     1918  CTransformation<CDomain>* CDomain::addTransformation(ETranformationType transType, const StdString& id) 
     1919  { 
     1920    transformationMap_.push_back(std::make_pair(transType, CTransformation<CDomain>::createTransformation(transType,id))); 
     1921    return transformationMap_.back().second; 
     1922  } 
     1923 
    19081924  /*! 
    19091925    Check whether a domain has transformation 
     
    19872003    if (node.goToChildElement()) 
    19882004    { 
    1989       StdString zoomDomainDefRoot("zoom_domain_definition"); 
    1990       StdString zoom("zoom_domain"); 
    1991       StdString interpDomainDefRoot("interpolate_domain_definition"); 
    1992       StdString interpFromFile("interpolate_domain"); 
    1993       StdString generateRectilinearDefRoot("generate_rectilinear_domain_definition"); 
    1994       StdString generateRectilinear("generate_rectilinear_domain"); 
     2005      StdString nodeElementName; 
    19952006      do 
    19962007      { 
     
    19992010        { nodeId = node.getAttributes()["id"]; } 
    20002011 
    2001         if (node.getElementName() == zoom) { 
    2002           CZoomDomain* tmp = (CZoomDomainGroup::get(zoomDomainDefRoot))->createChild(nodeId); 
    2003           tmp->parse(node); 
    2004           transformationMap_.push_back(std::make_pair(TRANS_ZOOM_DOMAIN,tmp)); 
    2005         } 
    2006         else if (node.getElementName() == interpFromFile) 
     2012        nodeElementName = node.getElementName(); 
     2013        std::map<StdString, ETranformationType>::const_iterator ite = transformationMapList_.end(), it; 
     2014        it = transformationMapList_.find(nodeElementName); 
     2015        if (ite != it) 
    20072016        { 
    2008           CInterpolateDomain* tmp = (CInterpolateDomainGroup::get(interpDomainDefRoot))->createChild(nodeId); 
    2009           tmp->parse(node); 
    2010           transformationMap_.push_back(std::make_pair(TRANS_INTERPOLATE_DOMAIN,tmp)); 
    2011         } 
    2012         else if (node.getElementName() == generateRectilinear) 
    2013         { 
    2014           CGenerateRectilinearDomain* tmp = (CGenerateRectilinearDomainGroup::get(generateRectilinearDefRoot))->createChild(nodeId); 
    2015           tmp->parse(node); 
    2016           transformationMap_.push_back(std::make_pair(TRANS_GENERATE_RECTILINEAR_DOMAIN,tmp)); 
     2017          transformationMap_.push_back(std::make_pair(it->second, CTransformation<CDomain>::createTransformation(it->second, 
     2018                                                                                                                nodeId, 
     2019                                                                                                                &node))); 
    20172020        } 
    20182021      } while (node.goToNextElement()) ; 
  • XIOS/trunk/src/node/domain.hpp

    r823 r836  
    7979         void redistribute(int nbLocalDomain); 
    8080         void duplicateTransformation(CDomain*); 
     81         CTransformation<CDomain>* addTransformation(ETranformationType transType, const StdString& id=""); 
    8182 
    8283      public: 
     
    198199         bool isUnstructed_; 
    199200 
     201       private: 
     202         static bool initializeTransformationMap(std::map<StdString, ETranformationType>& m); 
     203         static std::map<StdString, ETranformationType> transformationMapList_; 
     204         static bool _dummyTransformationMapList; 
     205 
    200206         DECLARE_REF_FUNC(Domain,domain) 
    201207 
  • XIOS/trunk/src/node/generate_rectilinear_domain.cpp

    r775 r836  
    1616  CGenerateRectilinearDomain::~CGenerateRectilinearDomain(void) 
    1717  {} 
     18 
     19  CTransformation<CDomain>* CGenerateRectilinearDomain::create(const StdString& id, xml::CXMLNode* node) 
     20  { 
     21    CGenerateRectilinearDomain* genDomain = CGenerateRectilinearDomainGroup::get("generate_rectilinear_domain_definition")->createChild(id); 
     22    if (node) genDomain->parse(*node); 
     23    return static_cast<CTransformation<CDomain>*>(genDomain); 
     24  } 
     25 
     26  bool CGenerateRectilinearDomain::_dummyRegistered = CGenerateRectilinearDomain::registerTrans(); 
     27  bool CGenerateRectilinearDomain::registerTrans() 
     28  { 
     29    registerTransformation(TRANS_GENERATE_RECTILINEAR_DOMAIN, create); 
     30  } 
    1831 
    1932  //---------------------------------------------------------------- 
  • XIOS/trunk/src/node/generate_rectilinear_domain.hpp

    r687 r836  
    5757      static ENodeType GetType(void); 
    5858    private: 
    59  
     59      static bool registerTrans(); 
     60      static CTransformation<CDomain>* create(const StdString& id, xml::CXMLNode* node); 
     61      static bool _dummyRegistered; 
    6062  }; // class CGenerateRectilinearDomain 
    6163 
  • XIOS/trunk/src/node/interpolate_axis.cpp

    r827 r836  
    1717  CInterpolateAxis::~CInterpolateAxis(void) 
    1818  {} 
     19 
     20  CTransformation<CAxis>* CInterpolateAxis::create(const StdString& id, xml::CXMLNode* node) 
     21  { 
     22    CInterpolateAxis* interpAxis = CInterpolateAxisGroup::get("interpolate_axis_definition")->createChild(id); 
     23    if (node) interpAxis->parse(*node); 
     24    return static_cast<CTransformation<CAxis>*>(interpAxis); 
     25  } 
     26 
     27  bool CInterpolateAxis::registerTrans() 
     28  { 
     29    return registerTransformation(TRANS_INTERPOLATE_AXIS, CInterpolateAxis::create); 
     30  } 
     31 
     32  bool CInterpolateAxis::_dummyRegistered = CInterpolateAxis::registerTrans(); 
    1933 
    2034  //---------------------------------------------------------------- 
  • XIOS/trunk/src/node/interpolate_axis.hpp

    r827 r836  
    5959      static ENodeType GetType(void); 
    6060    private: 
    61  
     61      static bool registerTrans(); 
     62      static CTransformation<CAxis>* create(const StdString& id, xml::CXMLNode* node); 
     63      static bool _dummyRegistered; 
    6264  }; // class CInterpolateAxis 
    6365 
  • XIOS/trunk/src/node/interpolate_domain.cpp

    r689 r836  
    1616  CInterpolateDomain::~CInterpolateDomain(void) 
    1717  {} 
     18 
     19  CTransformation<CDomain>* CInterpolateDomain::create(const StdString& id, xml::CXMLNode* node) 
     20  { 
     21    CInterpolateDomain* interpDomain = CInterpolateDomainGroup::get("interpolate_domain_definition")->createChild(id); 
     22    if (node) interpDomain->parse(*node); 
     23    return static_cast<CTransformation<CDomain>*>(interpDomain); 
     24  } 
     25 
     26  bool CInterpolateDomain::_dummyRegistered = CInterpolateDomain::registerTrans(); 
     27  bool CInterpolateDomain::registerTrans() 
     28  { 
     29    registerTransformation(TRANS_INTERPOLATE_DOMAIN, create); 
     30  } 
    1831 
    1932  //---------------------------------------------------------------- 
  • XIOS/trunk/src/node/interpolate_domain.hpp

    r689 r836  
    5757      static ENodeType GetType(void); 
    5858    private: 
    59  
     59      static bool registerTrans(); 
     60      static CTransformation<CDomain>* create(const StdString& id, xml::CXMLNode* node); 
     61      static bool _dummyRegistered; 
    6062  }; // class CInterpolateDomain 
    6163 
  • XIOS/trunk/src/node/inverse_axis.cpp

    r621 r836  
    1717  {} 
    1818 
     19  CTransformation<CAxis>* CInverseAxis::create(const StdString& id, xml::CXMLNode* node) 
     20  { 
     21    CInverseAxis* invAxis = CInverseAxisGroup::get("inverse_axis_definition")->createChild(id); 
     22    if (node) invAxis->parse(*node); 
     23    return static_cast<CTransformation<CAxis>*>(invAxis); 
     24  } 
     25 
     26  bool CInverseAxis::registerTrans() 
     27  { 
     28    return registerTransformation(TRANS_INVERSE_AXIS, CInverseAxis::create); 
     29  } 
     30 
     31  bool CInverseAxis::_dummyRegistered = CInverseAxis::registerTrans(); 
     32 
    1933  //---------------------------------------------------------------- 
    20  
    2134  StdString CInverseAxis::GetName(void)    { return StdString("inverse_axis"); } 
    2235  StdString CInverseAxis::GetDefName(void) { return StdString("inverse_axis"); } 
  • XIOS/trunk/src/node/inverse_axis.hpp

    r625 r836  
    5454      static StdString GetDefName(void); 
    5555      static ENodeType GetType(void); 
     56 
    5657    private: 
     58      static bool registerTrans(); 
     59      static CTransformation<CAxis>* create(const StdString& id, xml::CXMLNode* node); 
     60      static bool _dummyRegistered; 
    5761 
    5862  }; // class CInverseAxis 
  • XIOS/trunk/src/node/transformation.hpp

    r827 r836  
    2525 
    2626      std::vector<StdString> checkAuxInputs() { return checkAuxInputs_(); } 
     27      static CTransformation<T>* createTransformation(ETranformationType transType, const StdString& id, xml::CXMLNode* node=0); 
    2728 
    2829      /// Destructeur /// 
     
    3031 
    3132    protected: 
     33      typedef CTransformation<T>* (*CreateTransformationCallBack)(const StdString&, xml::CXMLNode*); 
     34      typedef std::map<ETranformationType, CreateTransformationCallBack> CallBackMap; 
     35      static CallBackMap* transformationCreationCallBacks_; 
     36 
     37      static bool registerTransformation(ETranformationType transType, CreateTransformationCallBack createFn); 
     38      static bool unregisterTransformation(ETranformationType transType); 
     39 
     40    protected: 
    3241      virtual std::vector<StdString> checkAuxInputs_() { return std::vector<StdString>(); } 
    3342  }; // class CTransformation 
     43 
     44  template<typename T> 
     45  CTransformation<T>::CallBackMap* CTransformation<T>::transformationCreationCallBacks_ = 0; //CTransformation<T>::CallBackMap(); 
     46 
     47  template<typename T> 
     48  CTransformation<T>* CTransformation<T>::createTransformation(ETranformationType transType, const StdString& id, xml::CXMLNode* node) 
     49  { 
     50    int transTypeInt = transType; 
     51    typename CallBackMap::const_iterator it = (*transformationCreationCallBacks_).find(transType); 
     52    if ((*transformationCreationCallBacks_).end() == it) 
     53    { 
     54       ERROR("CTransformation<T>::createTransformation(ETranformationType transType)", 
     55             << "Transformation type " << transType 
     56             << "doesn't exist. Please define."); 
     57    } 
     58    return (it->second)(id,node); 
     59  } 
     60 
     61  template<typename T> 
     62  bool CTransformation<T>::registerTransformation(ETranformationType transType, CreateTransformationCallBack createFn) 
     63  { 
     64    if (0 == transformationCreationCallBacks_) 
     65      transformationCreationCallBacks_ = new CallBackMap(); 
     66 
     67    return (*transformationCreationCallBacks_).insert(make_pair(transType, createFn)).second; 
     68  } 
     69 
     70  template<typename T> 
     71  bool CTransformation<T>::unregisterTransformation(ETranformationType transType) 
     72  { 
     73    int transTypeInt = transType; 
     74    return (1 == (*transformationCreationCallBacks_).erase(transType)); 
     75  } 
    3476 
    3577} // namespace xios 
  • XIOS/trunk/src/node/transformation_enum.hpp

    r689 r836  
    77      typedef enum transformation_type 
    88      { 
    9         TRANS_ZOOM_AXIS, 
    10         TRANS_INVERSE_AXIS, 
    11         TRANS_INTERPOLATE_AXIS, 
    12         TRANS_ZOOM_DOMAIN, 
    13         TRANS_INTERPOLATE_DOMAIN, 
    14         TRANS_GENERATE_RECTILINEAR_DOMAIN 
     9        TRANS_ZOOM_AXIS = 0, 
     10        TRANS_INVERSE_AXIS = 1, 
     11        TRANS_INTERPOLATE_AXIS = 2, 
     12        TRANS_ZOOM_DOMAIN = 3, 
     13        TRANS_INTERPOLATE_DOMAIN = 4, 
     14        TRANS_GENERATE_RECTILINEAR_DOMAIN = 5 
    1515      } ETranformationType; 
    1616 
  • XIOS/trunk/src/node/zoom_axis.cpp

    r787 r836  
    1616  CZoomAxis::~CZoomAxis(void) 
    1717  {} 
     18 
     19  CTransformation<CAxis>* CZoomAxis::create(const StdString& id, xml::CXMLNode* node) 
     20  { 
     21    CZoomAxis* zoomAxis = CZoomAxisGroup::get("zoom_axis_definition")->createChild(id); 
     22    if (node) zoomAxis->parse(*node); 
     23    return static_cast<CTransformation<CAxis>*>(zoomAxis); 
     24  } 
     25 
     26  bool CZoomAxis::registerTrans() 
     27  { 
     28    return registerTransformation(TRANS_ZOOM_AXIS, CZoomAxis::create); 
     29  } 
     30 
     31  bool CZoomAxis::_dummyRegistered = CZoomAxis::registerTrans(); 
    1832 
    1933  //---------------------------------------------------------------- 
  • XIOS/trunk/src/node/zoom_axis.hpp

    r625 r836  
    5757      static ENodeType GetType(void); 
    5858    private: 
    59  
     59      static bool registerTrans(); 
     60      static CTransformation<CAxis>* create(const StdString& id, xml::CXMLNode* node); 
     61      static bool _dummyRegistered; 
    6062  }; // class CZoomAxis 
    6163 
  • XIOS/trunk/src/node/zoom_domain.cpp

    r787 r836  
    1616  CZoomDomain::~CZoomDomain(void) 
    1717  {} 
     18 
     19  CTransformation<CDomain>* CZoomDomain::create(const StdString& id, xml::CXMLNode* node) 
     20  { 
     21    CZoomDomain* zoomDomain = CZoomDomainGroup::get("zoom_domain_definition")->createChild(id); 
     22    if (node) zoomDomain->parse(*node); 
     23    return static_cast<CTransformation<CDomain>*>(zoomDomain); 
     24  } 
     25 
     26  bool CZoomDomain::_dummyRegistered = CZoomDomain::registerTrans(); 
     27  bool CZoomDomain::registerTrans() 
     28  { 
     29    registerTransformation(TRANS_ZOOM_DOMAIN, CZoomDomain::create); 
     30  } 
    1831 
    1932  //---------------------------------------------------------------- 
  • XIOS/trunk/src/node/zoom_domain.hpp

    r631 r836  
    5757      static ENodeType GetType(void); 
    5858    private: 
    59  
     59      static bool registerTrans(); 
     60      static CTransformation<CDomain>* create(const StdString& id, xml::CXMLNode* node); 
     61      static bool _dummyRegistered; 
    6062  }; // class CZoomDomain 
    6163 
  • XIOS/trunk/src/test/test_new_features.f90

    r827 r836  
    1717  INTEGER,PARAMETER :: ni_glo=100 
    1818  INTEGER,PARAMETER :: nj_glo=100 
    19   INTEGER,PARAMETER :: llm=5 
     19  INTEGER,PARAMETER :: llm=10 
    2020  INTEGER,PARAMETER :: llmInterPolated=4 
    2121  DOUBLE PRECISION  :: lval(llm)=1, tsTemp, lvalInterPolated(llmInterPolated)=1 
  • XIOS/trunk/src/transformation/transformation_mapping.cpp

    r831 r836  
    4141 
    4242  gridIndexClientClientMapping_ = new CClientClientDHTPairIntInt(globalIndexOfServer, 
    43                                                                  client->intraComm, 
    44                                                                  true); 
     43                                                                 client->intraComm); 
    4544} 
    4645 
     
    6564 
    6665  gridIndexClientClientMapping_ = new CClientClientDHTPairIntInt(globalIndexOfAxisSource, 
    67                                                                  client->intraComm, 
    68                                                                  true); 
     66                                                                 client->intraComm); 
    6967} 
    7068 
Note: See TracChangeset for help on using the changeset viewer.