Changeset 631


Ignore:
Timestamp:
07/07/15 10:46:33 (6 years ago)
Author:
mhnguyen
Message:

Implementing zooming on a domain

+) Add algorithm to do zooming on a domain
+) Remove some redundant codes

Test
+) On Curie
+) test_complete and test_client are correct

Location:
XIOS/trunk
Files:
7 added
25 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/inputs/Version2/iodef.xml

    r630 r631  
    5454     </axis> 
    5555     <axis id="axis_H" axis_ref="axis_C"> 
    56 <!--       <inverse_axis />--> 
    57        <zoom_axis zoom_begin="0" zoom_size="3" /> 
     56       <inverse_axis /> 
     57       <zoom_axis zoom_begin="0" zoom_size="1" /> 
    5858     </axis> 
    5959   </axis_definition> 
     
    6161   <domain_definition> 
    6262     <domain id="domain_A" /> 
     63     <domain id="domain_A_zoom" domain_ref="domain_A"> 
     64       <zoom_domain zoom_ibegin="1" zoom_ni="3" zoom_jbegin="0" zoom_nj="4"/> 
     65       <zoom_domain zoom_ibegin="0" zoom_ni="2" zoom_jbegin="0" zoom_nj="2"/> 
     66     </domain> 
    6367   </domain_definition> 
    6468 
     
    8286       </grid> 
    8387       <grid id="grid_Axis_tranformed"> 
    84          <domain domain_ref="domain_A" /> 
    85             <axis axis_ref="axis_H" /> 
     88<!--         <domain domain_ref="domain_A" />--> 
     89         <domain domain_ref="domain_A_zoom" /> 
     90         <axis axis_ref="axis_H" /> 
    8691<!--         <axis axis_ref="axis_E" />--> 
    8792<!--         <axis axis_ref="axis_F" />--> 
  • XIOS/trunk/src/config/node_type.conf

    r630 r631  
    4343#endif //__XIOS_CInterpolateAxis__ 
    4444 
     45#ifdef __XIOS_CZoomDomain__ 
     46   DECLARE_NODE(ZoomDomain, zoom_domain) 
     47#endif //__XIOS_CZoomDomain__ 
     48 
    4549#ifdef __XIOS_CContext__ 
    4650   DECLARE_NODE_PAR(Context, context) 
  • XIOS/trunk/src/distribution_client.cpp

    r624 r631  
    200200      nBeginLocal_.at(indexMap_[idx]+1) = 0; 
    201201      nBeginGlobal_.at(indexMap_[idx]+1) = domList[domIndex]->jbegin; 
    202       nZoomBegin_.at((indexMap_[idx]+1)) = domList[domIndex]->zoom_jbegin; 
    203       nZoomEnd_.at((indexMap_[idx]+1))   = domList[domIndex]->zoom_jbegin + domList[domIndex]->zoom_nj-1; 
     202      nZoomBegin_.at((indexMap_[idx]+1)) = domList[domIndex]->global_zoom_jbegin; 
     203      nZoomEnd_.at((indexMap_[idx]+1))   = domList[domIndex]->global_zoom_jbegin + domList[domIndex]->global_zoom_nj-1; 
    204204 
    205205      dataBegin_.at(indexMap_[idx]+1) = (2 == domList[domIndex]->data_dim) ? domList[domIndex]->data_jbegin.getValue() : -1; 
     
    212212      nBeginLocal_.at(indexMap_[idx]) = 0; 
    213213      nBeginGlobal_.at(indexMap_[idx]) = domList[domIndex]->ibegin; 
    214       nZoomBegin_.at((indexMap_[idx])) = domList[domIndex]->zoom_ibegin; 
    215       nZoomEnd_.at((indexMap_[idx]))   = domList[domIndex]->zoom_ibegin + domList[domIndex]->zoom_ni-1; 
     214      nZoomBegin_.at((indexMap_[idx])) = domList[domIndex]->global_zoom_ibegin; 
     215      nZoomEnd_.at((indexMap_[idx]))   = domList[domIndex]->global_zoom_ibegin + domList[domIndex]->global_zoom_ni-1; 
    216216 
    217217      dataBegin_.at(indexMap_[idx]) = domList[domIndex]->data_ibegin.getValue(); 
  • XIOS/trunk/src/group_factory_decl.cpp

    r630 r631  
    2828  macro(CZoomAxisGroup) 
    2929  macro(CInterpolateAxisGroup) 
     30  macro(CZoomDomainGroup) 
    3031} 
  • XIOS/trunk/src/group_template_decl.cpp

    r630 r631  
    1717  macro(ZoomAxis) 
    1818  macro(InterpolateAxis) 
     19  macro(ZoomDomain) 
    1920 
    2021} 
  • XIOS/trunk/src/node/axis.cpp

    r630 r631  
    104104//               << "The array \'value\' of axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] has a different size that the one defined by the \'size\' attribute"); 
    105105 
    106       if (0 == global_zoom_size) global_zoom_size = size; 
     106 
    107107      this->checkData(); 
    108108      this->checkMask(); 
    109 //      this->checkZoom(); 
     109      this->checkZoom(); 
    110110 
    111111      if (!bounds.isEmpty()) 
     
    138138   } 
    139139 
    140 //   void CAxis::checkZoom(void) 
    141 //   { 
    142 //      StdSize zoom_begin,zoom_end, zoom_size, axisSize; 
    143 // 
    144 //      zoom_begin = (this->zoom_begin.isEmpty()) ?  0 : this->zoom_begin.getValue() ; 
    145 //      zoom_size  = (this->zoom_size.isEmpty()) ?  size.getValue() : this->zoom_size.getValue() ; 
    146 //      zoom_end   = (this->zoom_end.isEmpty()) ?  (size.getValue() - 1) : this->zoom_end.getValue() ; 
    147 // 
    148 //      if (this->zoom_begin.isEmpty()) zoom_begin=zoom_end-zoom_size+1 ; 
    149 //      if (this->zoom_end.isEmpty()) zoom_end=zoom_begin+zoom_size-1 ; 
    150 //      if (this->zoom_size.isEmpty()) zoom_size=zoom_end-zoom_begin+1 ; 
    151 //      axisSize = size.getValue(); 
    152 // 
    153 //      if ( (zoom_begin < 0) || (zoom_begin > axisSize-1) || (zoom_end<0) || (zoom_end>axisSize-1) || (zoom_size<1) || (zoom_size>axisSize) || (zoom_begin>zoom_end)) 
    154 //        ERROR("CAxis::checkAttributes(void)", 
    155 //              << "One or more attributes among <zoom_begin>, <zoom_end>, <zoom_size> of axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] are not well specified"); 
    156 // 
    157 //      this->zoom_begin.setValue(zoom_begin) ; 
    158 //      this->zoom_end.setValue(zoom_end) ; 
    159 //      this->zoom_size.setValue(zoom_size) ; 
    160 //   } 
     140   void CAxis::checkZoom(void) 
     141   { 
     142     if (0 == global_zoom_size) global_zoom_size = this->size.getValue(); 
     143   } 
    161144 
    162145   void CAxis::checkMask() 
  • XIOS/trunk/src/node/axis.hpp

    r630 r631  
    105105         void checkData(); 
    106106         void checkMask(); 
    107 //         void checkZoom(); 
     107         void checkZoom(); 
    108108         void checkTransformations(); 
    109109         void computeServerIndex(const std::vector<int>& globalDim, int orderPositionInGrid, 
  • XIOS/trunk/src/node/domain.cpp

    r622 r631  
    1616#include "server_distribution_description.hpp" 
    1717#include "client_server_mapping_distributed.hpp" 
     18#include "zoom_domain.hpp" 
    1819 
    1920namespace xios { 
     
    547548 
    548549      // compute client zoom indices 
    549  
    550       int zoom_iend=zoom_ibegin+zoom_ni-1 ; 
    551       zoom_ibegin_client = ibegin_client > zoom_ibegin ? ibegin_client : zoom_ibegin ; 
    552       zoom_iend_client = iend_client < zoom_iend ? iend_client : zoom_iend ; 
     550      // compute client zoom indices 
     551      if (0 == global_zoom_ni) global_zoom_ni = ni_glo; 
     552      if (0 == global_zoom_nj) global_zoom_nj = nj_glo; 
     553 
     554      int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1 ; 
     555      zoom_ibegin_client = ibegin_client > global_zoom_ibegin ? ibegin_client : global_zoom_ibegin ; 
     556      zoom_iend_client = iend_client < global_zoom_iend ? iend_client : global_zoom_iend ; 
    553557      zoom_ni_client=zoom_iend_client-zoom_ibegin_client+1 ; 
    554558      if (zoom_ni_client<0) zoom_ni_client=0 ; 
    555559 
    556560 
    557       int zoom_jend=zoom_jbegin+zoom_nj-1 ; 
    558       zoom_jbegin_client = jbegin_client > zoom_jbegin ? jbegin_client : zoom_jbegin ; 
    559       zoom_jend_client = jend_client < zoom_jend ? jend_client : zoom_jend ; 
     561      int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1 ; 
     562      zoom_jbegin_client = jbegin_client > global_zoom_jbegin ? jbegin_client : global_zoom_jbegin ; 
     563      zoom_jend_client = jend_client < global_zoom_jend ? jend_client : global_zoom_jend ; 
    560564      zoom_nj_client=zoom_jend_client-zoom_jbegin_client+1 ; 
    561565      if (zoom_nj_client<0) zoom_nj_client=0 ; 
     566 
     567//      int zoom_iend=zoom_ibegin+zoom_ni-1 ; 
     568//      zoom_ibegin_client = ibegin_client > zoom_ibegin ? ibegin_client : zoom_ibegin ; 
     569//      zoom_iend_client = iend_client < zoom_iend ? iend_client : zoom_iend ; 
     570//      zoom_ni_client=zoom_iend_client-zoom_ibegin_client+1 ; 
     571//      if (zoom_ni_client<0) zoom_ni_client=0 ; 
     572// 
     573// 
     574//      int zoom_jend=zoom_jbegin+zoom_nj-1 ; 
     575//      zoom_jbegin_client = jbegin_client > zoom_jbegin ? jbegin_client : zoom_jbegin ; 
     576//      zoom_jend_client = jend_client < zoom_jend ? jend_client : zoom_jend ; 
     577//      zoom_nj_client=zoom_jend_client-zoom_jbegin_client+1 ; 
     578//      if (zoom_nj_client<0) zoom_nj_client=0 ; 
    562579 
    563580   } 
     
    598615 
    599616      this->checkDomain(); 
    600       this->checkZoom(); 
     617//      this->checkZoom(); 
    601618      this->checkBounds(); 
    602619      this->checkArea(); 
     
    607624         this->checkDomainData(); 
    608625         this->checkCompression(); 
    609          this->completeLonLatClient(); 
    610          this->computeConnectedServer() ; 
     626//         this->completeLonLatClient(); 
     627//         this->computeConnectedServer() ; 
    611628      } 
    612629      else 
     
    625642     CContext* context=CContext::getCurrent() ; 
    626643 
     644     this->checkZoom(); 
    627645     if (this->isChecked) return; 
    628646     if (context->hasClient) 
    629647     { 
     648       this->computeConnectedServer(); 
     649       this->completeLonLatClient(); 
     650 
    630651       sendServerAttribut() ; 
    631652       sendLonLatArea() ; 
     
    703724        msg << this->getId() ; 
    704725        msg << ni_srv << ibegin_srv << iend_srv << nj_srv << jbegin_srv << jend_srv; 
     726        msg << global_zoom_ni << global_zoom_ibegin << global_zoom_nj << global_zoom_jbegin; 
    705727 
    706728        event.push(*itRank,1,msg); 
     
    722744 
    723745    int i,j,i_ind,j_ind ; 
    724     int zoom_iend=zoom_ibegin+zoom_ni-1 ; 
    725     int zoom_jend=zoom_jbegin+zoom_nj-1 ; 
     746    int zoom_iend=global_zoom_ibegin+global_zoom_ni-1 ; 
     747    int zoom_jend=global_zoom_jbegin+global_zoom_nj-1 ; 
    726748 
    727749    // Precompute number of index 
     
    733755        j_ind=jbegin+j_index(i,j) ; 
    734756 
    735         if (i_ind >= zoom_ibegin && i_ind <= zoom_iend && j_ind >= zoom_jbegin && j_ind <= zoom_jend) 
     757        if (i_ind >= global_zoom_ibegin && i_ind <= zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= zoom_jend) 
    736758        { 
    737759          ++globalIndexCountZoom; 
     
    755777        globalIndexDomain(globalIndexCount) = globalIndex; 
    756778        ++globalIndexCount; 
    757         if (i_ind >= zoom_ibegin && i_ind <= zoom_iend && j_ind >= zoom_jbegin && j_ind <= zoom_jend) 
     779        if (i_ind >= global_zoom_ibegin && i_ind <= zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= zoom_jend) 
    758780        { 
    759781          globalIndexDomainZoom(globalIndexCountZoom) = globalIndex; 
     
    976998  void CDomain::recvServerAttribut(CBufferIn& buffer) 
    977999  { 
    978     int zoom_iend = zoom_ibegin.getValue() + zoom_ni.getValue() - 1; 
    979     int zoom_jend = zoom_jbegin.getValue() + zoom_nj.getValue() - 1; 
    980  
    981     buffer >> ni_srv >> ibegin_srv >> iend_srv >> nj_srv >> jbegin_srv >> jend_srv; 
    982  
    983     zoom_ibegin_srv = zoom_ibegin.getValue() > ibegin_srv ? zoom_ibegin.getValue() : ibegin_srv ; 
     1000    buffer >> ni_srv >> ibegin_srv >> iend_srv >> nj_srv >> jbegin_srv >> jend_srv 
     1001           >> global_zoom_ni >> global_zoom_ibegin >> global_zoom_nj >> global_zoom_jbegin; 
     1002 
     1003    int zoom_iend = global_zoom_ibegin + global_zoom_ni - 1; 
     1004    int zoom_jend = global_zoom_jbegin + global_zoom_nj - 1; 
     1005 
     1006    zoom_ibegin_srv = global_zoom_ibegin > ibegin_srv ? global_zoom_ibegin : ibegin_srv ; 
    9841007    zoom_iend_srv = zoom_iend < iend_srv ? zoom_iend : iend_srv ; 
    9851008    zoom_ni_srv=zoom_iend_srv-zoom_ibegin_srv+1 ; 
    9861009 
    987     zoom_jbegin_srv = zoom_jbegin.getValue() > jbegin_srv ? zoom_jbegin.getValue() : jbegin_srv ; 
     1010    zoom_jbegin_srv = global_zoom_jbegin > jbegin_srv ? global_zoom_jbegin : jbegin_srv ; 
    9881011    zoom_jend_srv = zoom_jend < jend_srv ? zoom_jend : jend_srv ; 
    9891012    zoom_nj_srv=zoom_jend_srv-zoom_jbegin_srv+1 ; 
     
    11271150  } 
    11281151 
     1152  bool CDomain::hasTransformation() 
     1153  { 
     1154    return (!transformationMap_.empty()); 
     1155  } 
     1156 
     1157  void CDomain::setTransformations(const TransMapTypes& domTrans) 
     1158  { 
     1159    transformationMap_ = domTrans; 
     1160  } 
     1161 
     1162  CDomain::TransMapTypes CDomain::getAllTransformations(void) 
     1163  { 
     1164    return transformationMap_; 
     1165  } 
     1166 
     1167  /*! 
     1168    Check the validity of all transformations applied on domain 
     1169  This functions is called AFTER all inherited attributes are solved 
     1170  */ 
     1171  void CDomain::checkTransformations() 
     1172  { 
     1173    TransMapTypes::const_iterator itb = transformationMap_.begin(), it, 
     1174                                  ite = transformationMap_.end(); 
     1175    for (it = itb; it != ite; ++it) 
     1176    { 
     1177      (it->second)->checkValid(this); 
     1178    } 
     1179  } 
     1180 
     1181  void CDomain::solveInheritanceTransformation() 
     1182  { 
     1183    if (this->hasTransformation()) return; 
     1184 
     1185    std::vector<CDomain*> refDomain; 
     1186    CDomain* refer_sptr; 
     1187    CDomain* refer_ptr = this; 
     1188    while (refer_ptr->hasDirectDomainReference()) 
     1189    { 
     1190      refDomain.push_back(refer_ptr); 
     1191      refer_sptr = refer_ptr->getDirectDomainReference(); 
     1192      refer_ptr  = refer_sptr; 
     1193      if (refer_ptr->hasTransformation()) break; 
     1194    } 
     1195 
     1196    if (refer_ptr->hasTransformation()) 
     1197      for (int idx = 0; idx < refDomain.size(); ++idx) 
     1198        refDomain[idx]->setTransformations(refer_ptr->getAllTransformations()); 
     1199  } 
     1200 
     1201  void CDomain::parse(xml::CXMLNode & node) 
     1202  { 
     1203    SuperClass::parse(node); 
     1204 
     1205    if (node.goToChildElement()) 
     1206    { 
     1207      StdString zoomDomainDefRoot("zoom_domain_definition"); 
     1208      StdString zoom("zoom_domain"); 
     1209      do 
     1210      { 
     1211        if (node.getElementName() == zoom) { 
     1212          CZoomDomain* tmp = (CZoomDomainGroup::get(zoomDomainDefRoot))->createChild(); 
     1213          tmp->parse(node); 
     1214          transformationMap_.push_back(std::make_pair(TRANS_ZOOM_DOMAIN,tmp)); 
     1215        } 
     1216      } while (node.goToNextElement()) ; 
     1217      node.goToParentElement(); 
     1218    } 
     1219  } 
    11291220   //---------------------------------------------------------------- 
    11301221 
  • XIOS/trunk/src/node/domain.hpp

    r622 r631  
    1414#include "attribute_array.hpp" 
    1515#include "attribute_enum.hpp" 
     16#include "transformation.hpp" 
     17#include "transformation_enum.hpp" 
    1618 
    1719namespace xios { 
     
    4951         typedef CDomainAttributes RelAttributes; 
    5052         typedef CDomainGroup      RelGroup; 
     53         typedef CTransformation<CDomain>::TransformationMapTypes TransMapTypes; 
    5154 
    5255         /// Constructeurs /// 
     
    5962         void duplicateAttributes(CDomain* domain); 
    6063 
     64         virtual void parse(xml::CXMLNode & node); 
     65 
    6166         /// Vérifications /// 
    6267         void checkAttributes(void); 
     
    6570 
    6671         void sendCheckedAttributes(); 
     72 
     73         bool hasTransformation(); 
     74         void solveInheritanceTransformation(); 
     75         TransMapTypes getAllTransformations(); 
    6776 
    6877      private : 
     
    122131        CArray<int,2> mapConnectedServer ;  // (ni,nj) => mapped to connected server number, -1 if no server is target 
    123132 
    124  
     133        int global_zoom_ibegin, global_zoom_ni; 
     134        int global_zoom_jbegin, global_zoom_nj; 
    125135//        vector<int> ib_srv, ie_srv, in_srv ; 
    126136//        vector<int> jb_srv, je_srv, jn_srv ; 
     
    160170         bool hasBounds ; 
    161171         bool hasArea; 
     172      private: 
     173         void checkTransformations(); 
     174         void setTransformations(const TransMapTypes&); 
     175 
    162176       private : 
    163  
    164          /// Proriétés protégées /// 
    165177         bool isChecked; 
    166178         std::set<StdString> relFiles; 
     
    171183         std::vector<int> connectedServerRank_; 
    172184         bool isDistributed_; 
     185         TransMapTypes transformationMap_; 
    173186 
    174187         DECLARE_REF_FUNC(Domain,domain) 
  • XIOS/trunk/src/node/grid.cpp

    r624 r631  
    862862            nZoomBegin[indexMap[i]] = domainList[domainId]->zoom_ibegin_srv; 
    863863            nZoomSize[indexMap[i]]  = domainList[domainId]->zoom_ni_srv; 
    864             nZoomBeginGlobal[indexMap[i]] = domainList[domainId]->zoom_ibegin; 
     864            nZoomBeginGlobal[indexMap[i]] = domainList[domainId]->global_zoom_ibegin; 
    865865            nGlob[indexMap[i]] = domainList[domainId]->ni_glo; 
    866866 
    867867            nZoomBegin[indexMap[i] + 1] = domainList[domainId]->zoom_jbegin_srv; 
    868868            nZoomSize[indexMap[i] + 1] = domainList[domainId]->zoom_nj_srv; 
    869             nZoomBeginGlobal[indexMap[i] + 1] = domainList[domainId]->zoom_jbegin; 
     869            nZoomBeginGlobal[indexMap[i] + 1] = domainList[domainId]->global_zoom_jbegin; 
    870870            nGlob[indexMap[i] + 1] = domainList[domainId]->nj_glo; 
    871871            ++domainId; 
     
    11241124        pDom->solveRefInheritance(apply); 
    11251125        pDom->solveBaseReference(); 
     1126        pDom->solveInheritanceTransformation(); 
    11261127        if ((!pDom->domain_ref.isEmpty()) && (pDom->name.isEmpty())) 
    11271128          pDom->name.setValue(pDom->getBaseDomainReference()->getId()); 
  • XIOS/trunk/src/node/node_enum.hpp

    r630 r631  
    2222         eInverseAxis, 
    2323         eZoomAxis, 
    24          eInterpolateAxis 
     24         eInterpolateAxis, 
     25         eZoomDomain 
    2526 
    2627      } ENodeType; 
  • XIOS/trunk/src/node/node_type.hpp

    r630 r631  
    1313#include "zoom_axis.hpp" 
    1414#include "interpolate_axis.hpp" 
     15#include "zoom_domain.hpp" 
    1516 
    1617#endif // __XIOS_NODE_TYPE__ 
  • XIOS/trunk/src/node/transformation_enum.hpp

    r630 r631  
    99        TRANS_ZOOM_AXIS, 
    1010        TRANS_INVERSE_AXIS, 
    11         TRANS_INTERPOLATE_AXIS 
     11        TRANS_INTERPOLATE_AXIS, 
     12        TRANS_ZOOM_DOMAIN 
    1213      } ETranformationType; 
    1314 
  • XIOS/trunk/src/object_factory_decl.cpp

    r630 r631  
    2727  macro(CZoomAxis) 
    2828  macro(CInterpolateAxis) 
     29  macro(CZoomDomain) 
    2930 
    3031  macro(CFieldGroup) 
     
    3839  macro(CZoomAxisGroup) 
    3940  macro(CInterpolateAxisGroup) 
     41  macro(CZoomDomainGroup) 
    4042} 
  • XIOS/trunk/src/object_template_decl.cpp

    r630 r631  
    1212#include "zoom_axis.hpp" 
    1313#include "interpolate_axis.hpp" 
     14#include "zoom_domain.hpp" 
    1415 
    1516namespace xios 
     
    2627  template class CObjectTemplate<CZoomAxis>; 
    2728  template class CObjectTemplate<CInterpolateAxis>; 
     29  template class CObjectTemplate<CZoomDomain>; 
    2830 
    2931  template class CObjectTemplate<CContextGroup>; 
     
    3739  template class CObjectTemplate<CZoomAxisGroup>; 
    3840  template class CObjectTemplate<CInterpolateAxisGroup>; 
     41  template class CObjectTemplate<CZoomDomainGroup>; 
    3942} 
  • XIOS/trunk/src/output/nc4_data_output.cpp

    r629 r631  
    250250              case (ONE_FILE) : 
    251251              { 
    252                  SuperClassWriter::addDimension(dimXid, domain->zoom_ni.getValue()); 
    253                  SuperClassWriter::addDimension(dimYid, domain->zoom_nj.getValue()); 
     252                 SuperClassWriter::addDimension(dimXid, domain->global_zoom_ni); 
     253                 SuperClassWriter::addDimension(dimYid, domain->global_zoom_nj); 
    254254 
    255255                 if (domain->hasBounds) 
     
    322322                     else 
    323323                     { 
    324                        start[1]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start [0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; 
     324                       start[1]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin; 
     325                       start[0]=domain->zoom_jbegin_srv-domain->global_zoom_jbegin; 
    325326                       count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ; 
    326327                     } 
     
    339340                       count[0]=0 ; 
    340341                       SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
    341                        SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);                 } 
     342                       SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count); 
     343                     } 
    342344                     else 
    343345                     { 
    344                        start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; 
     346                       start[0]=domain->zoom_jbegin_srv-domain->global_zoom_jbegin; 
    345347                       count[0]=domain->zoom_nj_srv ; 
    346348                       CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ; 
    347349                       SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0,&start,&count); 
    348350 
    349                        start[0]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; 
     351                       start[0]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin; 
    350352                       count[0]=domain->zoom_ni_srv ; 
    351353                       CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ; 
     
    368370                   { 
    369371                     start[2] = 0; 
    370                      start[1] = domain->zoom_ibegin_srv - domain->zoom_ibegin.getValue(); 
    371                      start[0] = domain->zoom_jbegin_srv - domain->zoom_jbegin.getValue(); 
     372                     start[1] = domain->zoom_ibegin_srv - domain->global_zoom_ibegin; 
     373                     start[0] = domain->zoom_jbegin_srv - domain->global_zoom_jbegin; 
    372374                     count[2] = domain->nvertex; 
    373375                     count[1] = domain->zoom_ni_srv; 
     
    391393                   else 
    392394                   { 
    393                      start[1] = domain->zoom_ibegin_srv - domain->zoom_ibegin.getValue(); 
    394                      start[0] = domain->zoom_jbegin_srv - domain->zoom_jbegin.getValue(); 
     395                     start[1] = domain->zoom_ibegin_srv - domain->global_zoom_ibegin; 
     396                     start[0] = domain->zoom_jbegin_srv - domain->global_zoom_jbegin; 
    395397                     count[1] = domain->zoom_ni_srv; 
    396398                     count[0] = domain->zoom_nj_srv; 
     
    554556                 else 
    555557                 { 
    556                    start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin ; 
     558                   start[0]=domain->zoom_jbegin_srv-domain->global_zoom_jbegin; 
    557559                   count[0]=domain->zoom_nj_srv ; 
    558                    startBounds[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin ; 
     560                   startBounds[0]=domain->zoom_jbegin_srv-domain->global_zoom_jbegin; 
    559561                   startBounds[1]=0 ; 
    560562                   countBounds[0]=domain->zoom_nj_srv ; 
  • XIOS/trunk/src/test/test_new_features.f90

    r630 r631  
    124124!  CALL xios_add_child(file_hdl,field_hdl) 
    125125!  CALL xios_set_attr(field_hdl,field_ref="field_A",name="field_C") 
    126 ! 
    127 !  CALL xios_get_handle("output_All_Axis",file_hdl) 
    128 !  CALL xios_add_child(file_hdl,field_hdl) 
    129 !  CALL xios_set_attr(field_hdl,field_ref="field_All_Axis",name="field_C") 
    130126 
    131127  dtime%second = 3600 
  • XIOS/trunk/src/transformation/axis_algorithm_transformation.cpp

    r630 r631  
    4747                                                                          int axisPositionInGrid, 
    4848                                                                          const std::vector<int>& gridDestGlobalDim, 
     49                                                                          const std::vector<int>& gridSrcGlobalDim, 
    4950                                                                          const CArray<size_t,1>& globalIndexGridDestSendToServer, 
    5051                                                                          CArray<size_t,1>& globalIndexDestGrid, 
  • XIOS/trunk/src/transformation/axis_algorithm_transformation.hpp

    r630 r631  
    3131                                                        int axisPositionInGrid, 
    3232                                                        const std::vector<int>& gridDestGlobalDim, 
     33                                                        const std::vector<int>& gridSrcGlobalDim, 
    3334                                                        const CArray<size_t,1>& globalIndexGridDestSendToServer, 
    3435                                                        CArray<size_t,1>& globalIndexDestGrid, 
  • XIOS/trunk/src/transformation/generic_algorithm_transformation.cpp

    r630 r631  
    2121                then position of axis in grid is 2 (since a domain is considered to contain 2 elements (axis) 
    2222  \param[in] gridDestGlobalDim global size of each dimension of grid source (all dimension must have the same size except of the one on which transformation is performed) 
     23  \param[in] gridSrcGlobalDim dimension size of source grid (it should share the same size for all dimension, maybe except the domain on which transformation is performed) 
    2324  \param[in] globalIndexGridDestSendToServer global index of grid destination on the current client to send to server 
    2425  \param[in/out] globaIndexWeightFromDestToSource mapping between transformed global index of grid destination 
     
    2728void CGenericAlgorithmTransformation::computeGlobalSourceIndex(int elementPositionInGrid, 
    2829                                                             const std::vector<int>& gridDestGlobalDim, 
     30                                                             const std::vector<int>& gridSrcGlobalDim, 
    2931                                                             const CArray<size_t,1>& globalIndexGridDestSendToServer, 
    3032                                                             std::map<size_t, std::vector<std::pair<size_t,double> > >& globaIndexWeightFromDestToSource) 
     
    4547                                                   elementPositionInGrid, 
    4648                                                   gridDestGlobalDim, 
     49                                                   gridSrcGlobalDim, 
    4750                                                   globalIndexGridDestSendToServer, 
    4851                                                   globalIndexDestGrid, 
  • XIOS/trunk/src/transformation/generic_algorithm_transformation.hpp

    r630 r631  
    2828  void computeGlobalSourceIndex(int elementPositionInGrid, 
    2929                                const std::vector<int>& gridDestGlobalDim, 
     30                                const std::vector<int>& gridSrcGlobalDim, 
    3031                                const CArray<size_t,1>& globalIndexGridDestSendToServer, 
    3132                                std::map<size_t, std::vector<std::pair<size_t,double> > >& globaIndexWeightFromDestToSource); 
     
    5152                                                        int elementPositionInGrid, 
    5253                                                        const std::vector<int>& gridDestGlobalDim, 
     54                                                        const std::vector<int>& gridSrcGlobalDim, 
    5355                                                        const CArray<size_t,1>& globalIndexGridDestSendToServer, 
    5456                                                        CArray<size_t,1>& globalIndexDestGrid, 
  • XIOS/trunk/src/transformation/grid_transformation.cpp

    r630 r631  
    1111#include "axis_algorithm_zoom.hpp" 
    1212#include "axis_algorithm_interpolate.hpp" 
     13#include "domain_algorithm_zoom.hpp" 
    1314#include "context.hpp" 
    1415#include "context_client.hpp" 
     
    1920CGridTransformation::CGridTransformation(CGrid* destination, CGrid* source) 
    2021: gridSource_(source), gridDestination_(destination), originalGridSource_(source), 
    21   globalIndexOfCurrentGridSource_(0), globalIndexOfOriginalGridSource_(0), weightOfGlobalIndexOfOriginalGridSource_(0) 
     22  globalIndexOfCurrentGridSource_(0), globalIndexOfOriginalGridSource_(0), weightOfGlobalIndexOfOriginalGridSource_(0), algoTypes_() 
    2223{ 
    2324  //Verify the compatibity between two grids 
     
    105106void CGridTransformation::initializeAlgorithms() 
    106107{ 
    107   initializeAxisAlgorithms(); 
    108   initializeDomainAlgorithms(); 
    109 } 
     108  std::vector<int> axisPositionInGrid; 
     109  std::vector<int> domPositionInGrid; 
     110  std::vector<CAxis*> axisListDestP = gridDestination_->getAxis(); 
     111  std::vector<CDomain*> domListDestP = gridDestination_->getDomains(); 
     112 
     113  int idx = 0; 
     114  for (int i = 0; i < gridDestination_->axis_domain_order.numElements(); ++i) 
     115  { 
     116    if (false == (gridDestination_->axis_domain_order)(i)) 
     117    { 
     118      axisPositionInGrid.push_back(idx); 
     119      ++idx; 
     120    } 
     121    else 
     122    { 
     123      ++idx; 
     124      domPositionInGrid.push_back(idx); 
     125      ++idx; 
     126    } 
     127  } 
     128 
     129  for (int i = 0; i < axisListDestP.size(); ++i) 
     130  { 
     131    elementPosition2AxisPositionInGrid_[axisPositionInGrid[i]] = i; 
     132  } 
     133 
     134  for (int i = 0; i < domListDestP.size(); ++i) 
     135  { 
     136    elementPosition2DomainPositionInGrid_[domPositionInGrid[i]] = i; 
     137  } 
     138 
     139  idx = 0; 
     140  for (int i = 0; i < gridDestination_->axis_domain_order.numElements(); ++i) 
     141  { 
     142    if (false == (gridDestination_->axis_domain_order)(i)) 
     143    { 
     144      initializeAxisAlgorithms(idx); 
     145      ++idx; 
     146    } 
     147    else 
     148    { 
     149      ++idx; 
     150      initializeDomainAlgorithms(idx); 
     151      ++idx; 
     152    } 
     153  } 
     154} 
     155 
     156 
    110157 
    111158/*! 
     
    114161In general, each axis can have several transformations performed on itself. However, should they be done seperately or combinely (of course in order)? 
    115162For now, one approach is to do these combinely but maybe this needs changing. 
    116 */ 
    117 void CGridTransformation::initializeAxisAlgorithms() 
    118 { 
    119   std::vector<int> axisPositionInGrid; 
     163\param [in] axisPositionInGrid position of an axis in grid. (for example: a grid with one domain and one axis, position of domain is 1, position of axis is 2) 
     164*/ 
     165void CGridTransformation::initializeAxisAlgorithms(int axisPositionInGrid) 
     166{ 
    120167  std::vector<CAxis*> axisListDestP = gridDestination_->getAxis(); 
    121   std::vector<CAxis*> axisListSrcP = gridSource_->getAxis(); 
    122168  if (!axisListDestP.empty()) 
    123169  { 
    124     int idx = 0; 
    125     for (int i = 0; i < gridDestination_->axis_domain_order.numElements(); ++i) 
    126     { 
    127       if (false == (gridDestination_->axis_domain_order)(i)) 
     170    if (axisListDestP[elementPosition2AxisPositionInGrid_[axisPositionInGrid]]->hasTransformation()) 
     171    { 
     172      CAxis::TransMapTypes trans = axisListDestP[elementPosition2AxisPositionInGrid_[axisPositionInGrid]]->getAllTransformations(); 
     173      CAxis::TransMapTypes::const_iterator itb = trans.begin(), it, 
     174                                           ite = trans.end(); 
     175      int transformationOrder = 0; 
     176      for (it = itb; it != ite; ++it) 
    128177      { 
    129         axisPositionInGrid.push_back(idx); 
    130         ++idx; 
     178        listAlgos_.push_back(std::make_pair(axisPositionInGrid, std::make_pair(it->first, transformationOrder))); 
     179        algoTypes_.push_back(false); 
     180        ++transformationOrder; 
    131181      } 
    132       else idx += 2; 
    133     } 
    134  
    135     for (int i = 0; i < axisListDestP.size(); ++i) 
    136     { 
    137       elementPosition2AxisPositionInGrid_[axisPositionInGrid[i]] = i; 
    138       if (axisListDestP[i]->hasTransformation()) 
     182    } 
     183  } 
     184} 
     185 
     186/*! 
     187  Initialize the algorithms corresponding to transformation info contained in each domain. 
     188If a domain has transformations, they will be represented in form of vector of CTransformation pointers 
     189In general, each domain can have several transformations performed on itself. 
     190\param [in] domPositionInGrid position of a domain in grid. (for example: a grid with one domain and one axis, position of domain is 1, position of axis is 2) 
     191*/ 
     192void CGridTransformation::initializeDomainAlgorithms(int domPositionInGrid) 
     193{ 
     194  std::vector<CDomain*> domListDestP = gridDestination_->getDomains(); 
     195  if (!domListDestP.empty()) 
     196  { 
     197    if (domListDestP[elementPosition2DomainPositionInGrid_[domPositionInGrid]]->hasTransformation()) 
     198    { 
     199      CDomain::TransMapTypes trans = domListDestP[elementPosition2DomainPositionInGrid_[domPositionInGrid]]->getAllTransformations(); 
     200      CDomain::TransMapTypes::const_iterator itb = trans.begin(), it, 
     201                                             ite = trans.end(); 
     202      int transformationOrder = 0; 
     203      for (it = itb; it != ite; ++it) 
    139204      { 
    140         CAxis::TransMapTypes trans = axisListDestP[i]->getAllTransformations(); 
    141         CAxis::TransMapTypes::const_iterator itb = trans.begin(), it, 
    142                                              ite = trans.end(); 
    143         int transformationOrder = 0; 
    144         for (it = itb; it != ite; ++it) 
    145         { 
    146           listAlgos_.push_back(std::make_pair(axisPositionInGrid[i], std::make_pair(it->first, transformationOrder))); 
    147           ++transformationOrder; 
    148         } 
     205        listAlgos_.push_back(std::make_pair(domPositionInGrid, std::make_pair(it->first, transformationOrder))); 
     206        algoTypes_.push_back(true); 
     207        ++transformationOrder; 
    149208      } 
    150209    } 
    151210  } 
    152 } 
    153  
    154 void CGridTransformation::initializeDomainAlgorithms() 
    155 { 
    156211 
    157212} 
     
    163218  \param [in] transType transformation type, for now we have Zoom_axis, inverse_axis 
    164219  \param [in] transformationOrder position of the transformation in an element (an element can have several transformation) 
    165 */ 
    166 void CGridTransformation::selectAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder) 
    167 { 
    168    selectAxisAlgo(elementPositionInGrid, transType, transformationOrder); 
     220  \param [in] isDomainAlgo flag to specify type of algorithm (for domain or axis) 
     221*/ 
     222void CGridTransformation::selectAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder, bool isDomainAlgo) 
     223{ 
     224   if (isDomainAlgo) selectDomainAlgo(elementPositionInGrid, transType, transformationOrder); 
     225   else selectAxisAlgo(elementPositionInGrid, transType, transformationOrder); 
    169226} 
    170227 
     
    219276void CGridTransformation::selectDomainAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder) 
    220277{ 
     278  std::vector<CDomain*> domainListDestP = gridDestination_->getDomains(); 
     279  std::vector<CDomain*> domainListSrcP = gridSource_->getDomains(); 
     280 
     281  int domainIndex =  elementPosition2DomainPositionInGrid_[elementPositionInGrid]; 
     282  CDomain::TransMapTypes trans = domainListDestP[domainIndex]->getAllTransformations(); 
     283  CDomain::TransMapTypes::const_iterator it = trans.begin(); 
     284 
     285  for (int i = 0; i < transformationOrder; ++i, ++it) {}  // Find the correct transformation 
     286 
     287  CZoomDomain* zoomDomain = 0; 
     288  CGenericAlgorithmTransformation* algo = 0; 
     289  switch (transType) 
     290  { 
     291    case TRANS_ZOOM_DOMAIN: 
     292      zoomDomain = dynamic_cast<CZoomDomain*> (it->second); 
     293      algo = new CDomainAlgorithmZoom(domainListDestP[domainIndex], domainListSrcP[domainIndex], zoomDomain); 
     294      break; 
     295    default: 
     296      break; 
     297  } 
     298  algoTransformation_.push_back(algo); 
    221299} 
    222300 
     
    233311  std::vector<CAxis*> axisListSrcP = gridSource_->getAxis(); 
    234312 
    235   int axisIndex; 
     313  std::vector<CDomain*> domListDestP = gridDestination_->getDomains(); 
     314  std::vector<CDomain*> domListSrcP = gridSource_->getDomains(); 
     315 
     316  int axisIndex, domainIndex; 
    236317  switch (transType) 
    237318  { 
     319    case TRANS_ZOOM_DOMAIN: 
     320      domainIndex = elementPosition2DomainPositionInGrid_[elementPositionInGrid]; 
     321      domListSrcP[domainIndex]->duplicateAttributes(domListDestP[domainIndex]); 
     322      break; 
     323 
    238324    case TRANS_INTERPOLATE_AXIS: 
    239325    case TRANS_ZOOM_AXIS: 
     
    272358 
    273359    // First of all, select an algorithm 
    274     selectAlgo(elementPositionInGrid, transType, transformationOrder); 
     360    selectAlgo(elementPositionInGrid, transType, transformationOrder, algoTypes_[std::distance(itb, it)]); 
    275361    algo = algoTransformation_.back(); 
    276362 
     
    281367    // ComputeTransformation of global index of each element 
    282368    std::vector<int> gridDestinationDimensionSize = gridDestination_->getGlobalDimension(); 
     369    std::vector<int> gridSrcDimensionSize = gridSource_->getGlobalDimension(); 
    283370    int elementPosition = it->first; 
    284371    algo->computeGlobalSourceIndex(elementPosition, 
    285372                                   gridDestinationDimensionSize, 
     373                                   gridSrcDimensionSize, 
    286374                                   globalIndexGridDestSendToServer, 
    287375                                   globaIndexWeightFromDestToSource); 
  • XIOS/trunk/src/transformation/grid_transformation.hpp

    r630 r631  
    4646  void computeTransformation(); 
    4747  void initializeAlgorithms(); 
    48   void initializeAxisAlgorithms(); 
    49   void initializeDomainAlgorithms(); 
     48  void initializeAxisAlgorithms(int axisPositionInGrid); 
     49  void initializeDomainAlgorithms(int domPositionInGrid); 
    5050  void initializeMappingOfOriginalGridSource(); 
    5151 
    5252  void selectAxisAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder); 
    5353  void selectDomainAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder); 
    54   void selectAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder); 
     54  void selectAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder, bool isDomainAlgo); 
    5555  void setUpGrid(int elementPositionInGrid, ETranformationType transType); 
    5656  void computeFinalTransformationMapping(); 
     
    7878  //! List of algorithm types and their order 
    7979  ListAlgoType listAlgos_; 
     80  // true if domain algorithm and false if axis algorithm (can be replaced by tuple with listAlgos_ 
     81  std::vector<bool> algoTypes_; 
    8082 
    8183  // Mapping between position of an element in grid and its transformation (if any) 
  • XIOS/trunk/src/type/type_util.hpp

    r630 r631  
    2626    class CInterpolateAxis; 
    2727    class CInterpolateAxisGroup; 
     28    class CZoomDomain; 
     29    class CZoomDomainGroup; 
    2830 
    2931  template <typename T> inline string getStrType(void); 
     
    6870  macro(CInterpolateAxis) 
    6971  macro(CInterpolateAxisGroup) 
     72  macro(CZoomDomain) 
     73  macro(CZoomDomainGroup) 
    7074#undef macro 
    7175} 
  • XIOS/trunk/src/xml_parser_decl.cpp

    r630 r631  
    77#include "file.hpp" 
    88#include "variable.hpp" 
    9 //#include "transformation.hpp" 
    109#include "inverse_axis.hpp" 
    1110#include "zoom_axis.hpp" 
    1211#include "interpolate_axis.hpp" 
     12#include "zoom_domain.hpp" 
    1313 
    1414namespace xios 
     
    3131    macro( ZoomAxis ) 
    3232    macro( InterpolateAxis ) 
     33    macro( ZoomDomain ) 
    3334  } 
    3435} 
Note: See TracChangeset for help on using the changeset viewer.