Changeset 1553


Ignore:
Timestamp:
06/28/18 17:53:42 (2 years ago)
Author:
oabramkina
Message:

The zoom is dead, long live the zoom.

Replacing domain_zoom transformation by copying it from domain_extract. From now on, only the zoomed part of a domain is sent to servers. On the user's side all definitions stay the same.

To do soon: axis_zoom.

Location:
XIOS/trunk/src
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/src/config/domain_attribute.conf

    r1549 r1553  
    6262DECLARE_ATTRIBUTE(StdString, domain_ref) 
    6363DECLARE_ATTRIBUTE(int,       prec) 
    64  
    65 DECLARE_ATTRIBUTE_PRIVATE(int,  global_zoom_ibegin) 
    66 DECLARE_ATTRIBUTE_PRIVATE(int,  global_zoom_ni) 
    67 DECLARE_ATTRIBUTE_PRIVATE(int,  global_zoom_jbegin) 
    68 DECLARE_ATTRIBUTE_PRIVATE(int,  global_zoom_nj) 
  • XIOS/trunk/src/config/domain_attribute_private.conf

    r1549 r1553  
    2525DECLARE_ARRAY_PRIVATE(double, 2, bounds_lonvalue_unstructured_read_from_file) 
    2626DECLARE_ARRAY_PRIVATE(double, 2, bounds_latvalue_unstructured_read_from_file) 
    27  
    28 //DECLARE_ATTRIBUTE_PRIVATE(int,  global_zoom_ibegin) 
    29 //DECLARE_ATTRIBUTE_PRIVATE(int,  global_zoom_ni) 
    30 //DECLARE_ATTRIBUTE_PRIVATE(int,  global_zoom_jbegin) 
    31 //DECLARE_ATTRIBUTE_PRIVATE(int,  global_zoom_nj) 
    32  
    33 // Local zoom information 
    34 DECLARE_ATTRIBUTE_PRIVATE(int,  zoom_ibegin) 
    35 DECLARE_ATTRIBUTE_PRIVATE(int,  zoom_ni) 
    36 DECLARE_ATTRIBUTE_PRIVATE(int,  zoom_jbegin) 
    37 DECLARE_ATTRIBUTE_PRIVATE(int,  zoom_nj) 
    38  
    39  
    40 DECLARE_ARRAY_PRIVATE(int    ,   1 , zoom_i_index, false) 
    41 DECLARE_ARRAY_PRIVATE(int    ,   1 , zoom_j_index, false) 
  • XIOS/trunk/src/distribution_server.cpp

    r1340 r1553  
    1212namespace xios { 
    1313 
    14 CDistributionServer::CDistributionServer(int rank, const std::vector<int>& nZoomBegin, 
    15                                          const std::vector<int>& nZoomSize, 
    16                                          const std::vector<int>& nZoomBeginGlobal, 
     14CDistributionServer::CDistributionServer(int rank, const std::vector<int>& nBegin, 
     15                                         const std::vector<int>& nSize, 
     16                                         const std::vector<int>& nBeginGlobal, 
    1717                                         const std::vector<int>& nGlobal) 
    18   : CDistribution(rank, nGlobal.size()), nGlobal_(nGlobal), nZoomBeginGlobal_(nZoomBeginGlobal), 
    19     nZoomSize_(nZoomSize), nZoomBegin_(nZoomBegin), globalLocalIndexMap_() 
     18  : CDistribution(rank, nGlobal.size()), nGlobal_(nGlobal), nBeginGlobal_(nBeginGlobal), 
     19    nSize_(nSize), nBegin_(nBegin), globalLocalIndexMap_() 
    2020{ 
    2121  createGlobalIndex(); 
    2222} 
    2323 
    24 CDistributionServer::CDistributionServer(int rank,  
     24CDistributionServer::CDistributionServer(int rank, 
    2525                                        const std::vector<CArray<int,1> >& globalIndexElements, 
    2626                                        const CArray<int,1>& elementOrder, 
    27                                         const std::vector<int>& nZoomBegin, 
    28                                         const std::vector<int>& nZoomSize, 
    29                                         const std::vector<int>& nZoomBeginGlobal, 
     27                                        const std::vector<int>& nBegin, 
     28                                        const std::vector<int>& nSize, 
     29                                        const std::vector<int>& nBeginGlobal, 
    3030                                        const std::vector<int>& nGlobal) 
    31   : CDistribution(rank, nGlobal.size()), nGlobal_(nGlobal), nZoomBeginGlobal_(nZoomBeginGlobal), 
    32     nZoomSize_(nZoomSize), nZoomBegin_(nZoomBegin), globalLocalIndexMap_() 
     31  : CDistribution(rank, nGlobal.size()), nGlobal_(nGlobal), nBeginGlobal_(nBeginGlobal), 
     32    nSize_(nSize), nBegin_(nBegin), globalLocalIndexMap_() 
    3333{ 
    3434  createGlobalIndex(globalIndexElements, elementOrder); 
     
    4848{ 
    4949  size_t idx = 0, ssize = 1; 
    50   for (int i = 0; i < nZoomSize_.size(); ++i) ssize *= nZoomSize_[i]; 
     50  for (int i = 0; i < nSize_.size(); ++i) ssize *= nSize_[i]; 
    5151 
    5252  this->globalIndex_.resize(ssize); 
    5353  std::vector<int> idxLoop(this->getDims(),0); 
    5454  std::vector<int> currentIndex(this->getDims()); 
    55   int innerLoopSize = nZoomSize_[0]; 
     55  int innerLoopSize = nSize_[0]; 
    5656 
    5757  globalLocalIndexMap_.rehash(std::ceil(ssize/globalLocalIndexMap_.max_load_factor())); 
     
    6060    for (int i = 0; i < this->dims_-1; ++i) 
    6161    { 
    62       if (idxLoop[i] == nZoomSize_[i]) 
     62      if (idxLoop[i] == nSize_[i]) 
    6363      { 
    6464        idxLoop[i] = 0; 
     
    6767    } 
    6868 
    69     for (int i = 1; i < this->dims_; ++i)  currentIndex[i] = idxLoop[i] + nZoomBegin_[i]; 
     69    for (int i = 1; i < this->dims_; ++i)  currentIndex[i] = idxLoop[i] + nBegin_[i]; 
    7070 
    7171    size_t mulDim, globalIndex; 
     
    7373    { 
    7474      mulDim = 1; 
    75       globalIndex = i + nZoomBegin_[0]; 
     75      globalIndex = i + nBegin_[0]; 
    7676 
    7777      for (int k = 1; k < this->dims_; ++k) 
     
    215215} 
    216216 
    217 const std::vector<int>& CDistributionServer::getZoomBeginGlobal() const 
    218 { 
    219   return nZoomBeginGlobal_; 
    220 } 
    221  
    222 const std::vector<int>& CDistributionServer::getZoomBeginServer() const 
    223 { 
    224   return nZoomBegin_; 
    225 } 
    226  
    227 const std::vector<int>& CDistributionServer::getZoomSizeServer() const 
    228 { 
    229   return nZoomSize_; 
    230 } 
    231  
    232217void CDistributionServer::partialClear(void) 
    233218{ 
  • XIOS/trunk/src/distribution_server.hpp

    r1340 r1553  
    2424    /** Default constructor */ 
    2525    CDistributionServer(int rank, int dims, const CArray<size_t,1>& globalIndex = CArray<size_t,1>()); 
    26     CDistributionServer(int rank, const std::vector<int>& nZoomBeginServer, 
    27                         const std::vector<int>& nZoomSizeServer, const std::vector<int>& nGlobal); 
    28     CDistributionServer(int rank, const std::vector<int>& nZoomBeginServer, 
    29                         const std::vector<int>& nZoomSizeServer, 
    30                         const std::vector<int>& nZoomBeginGlobal, 
     26    CDistributionServer(int rank, const std::vector<int>& nBeginServer, 
     27                        const std::vector<int>& nSizeServer, const std::vector<int>& nGlobal); 
     28    CDistributionServer(int rank, const std::vector<int>& nBeginServer, 
     29                        const std::vector<int>& nSizeServer, 
     30                        const std::vector<int>& nBeginGlobal, 
    3131                        const std::vector<int>& nGlobal); 
    3232 
    33     CDistributionServer(int rank,  
     33    CDistributionServer(int rank, 
    3434                        const std::vector<CArray<int,1> >& globalIndexElements, 
    3535                        const CArray<int,1>& elementOrder, 
    36                         const std::vector<int>& nZoomBeginServer, 
    37                         const std::vector<int>& nZoomSizeServer, 
    38                         const std::vector<int>& nZoomBeginGlobal, 
     36                        const std::vector<int>& nBeginServer, 
     37                        const std::vector<int>& nSizeServer, 
     38                        const std::vector<int>& nBeginGlobal, 
    3939                        const std::vector<int>& nGlobal); 
    4040 
     
    4242    virtual ~CDistributionServer(); 
    4343 
    44     const std::vector<int>& getZoomBeginGlobal() const; 
    45     const std::vector<int>& getZoomBeginServer() const; 
    46     const std::vector<int>& getZoomSizeServer() const; 
    4744    const GlobalLocalMap& getGlobalLocalIndex() const { return globalLocalIndexMap_; }     
    4845    int getGridSize() const; 
     
    6259  private: 
    6360    std::vector<int> nGlobal_; 
    64     std::vector<int> nZoomBeginGlobal_; 
    65     std::vector<int> nZoomSize_; 
    66     std::vector<int> nZoomBegin_; 
     61    std::vector<int> nBeginGlobal_; 
     62    std::vector<int> nSize_; 
     63    std::vector<int> nBegin_; 
    6764 
    6865}; 
  • XIOS/trunk/src/io/nc4_data_input.cpp

    r1486 r1553  
    6363      case ONE_FILE: 
    6464      { 
    65 /* 
    66         std::vector<int> nZoomBeginGlobal = grid->getDistributionServer()->getZoomBeginGlobal(); 
    67         std::vector<int> nZoomBeginServer = grid->getDistributionServer()->getZoomBeginServer(); 
    68         std::vector<int> nZoomSizeServer  = grid->getDistributionServer()->getZoomSizeServer(); 
    69  
    70         int ssize = nZoomBeginGlobal.size(); 
    71  
    72         std::vector<StdSize> start(ssize); 
    73         std::vector<StdSize> count(ssize); 
    74  
    75         for (int i = 0; i < ssize; ++i) 
    76         { 
    77           start[i] = nZoomBeginServer[ssize - i - 1] - nZoomBeginGlobal[ssize - i - 1]; 
    78           count[i] = nZoomSizeServer[ssize - i - 1]; 
    79         } 
    80 */ 
    81  
    82         std::vector<int> nZoomBeginGlobal = grid->getDistributionServer()->getZoomBeginGlobal(); 
    83         std::vector<int> nZoomBeginServer = grid->getDistributionServer()->getZoomBeginServer(); 
    84         std::vector<int> nZoomSizeServer  = grid->getDistributionServer()->getZoomSizeServer(); 
    85  
    8665        std::vector<StdSize> start, count; 
    8766 
     
    9170        int numElement = axisDomainOrder.numElements(); 
    9271        int idxDomain = domainList.size() - 1, idxAxis = axisList.size() - 1; 
    93         int idx = nZoomBeginGlobal.size() - 1; 
    94  
    95         start.reserve(nZoomBeginGlobal.size()); 
    96         count.reserve(nZoomBeginGlobal.size()); 
     72        int idx = domainList.size() * 2 + axisList.size() - 1; 
     73 
     74        start.reserve(idx+1); 
     75        count.reserve(idx+1); 
    9776 
    9877        for (int i = numElement - 1; i >= 0; --i) 
     
    10382            if ((domain->type) != CDomain::type_attr::unstructured) 
    10483            { 
    105               start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]); 
    106               count.push_back(nZoomSizeServer[idx]); 
     84              start.push_back(domain->jbegin); 
     85              count.push_back(domain->nj); 
    10786            } 
    10887            --idx ; 
    109             start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]); 
    110             count.push_back(nZoomSizeServer[idx]); 
     88            start.push_back(domain->ibegin); 
     89            count.push_back(domain->ni); 
     90 
    11191            --idx ; 
    11292            --idxDomain; 
     
    11494          else if (1 == axisDomainOrder(i)) 
    11595          { 
    116             start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]); 
    117             count.push_back(nZoomSizeServer[idx]); 
     96            CAxis* axis = CAxis::get(axisList[idxAxis]); 
     97            start.push_back(axis->begin); 
     98            count.push_back(axis->n); 
    11899            --idx; 
    119100          } 
  • XIOS/trunk/src/io/nc4_data_output.cpp

    r1542 r1553  
    221221              case (MULTI_FILE) : 
    222222              { 
    223   //               if (domain->isEmpty()) return; 
    224  
    225                  if (server->intraCommSize > 1) 
    226                  { 
    227   //                 SuperClassWriter::addDimension(lonid, domain->zoom_ni.getValue()); 
    228   //                 SuperClassWriter::addDimension(latid, domain->zoom_nj.getValue()); 
    229                  } 
    230  
    231223                 switch (domain->type) 
    232224                 { 
     
    248240                 else bounds_latid = "bounds_"+latName+appendDomid; 
    249241 
    250                  SuperClassWriter::addDimension(dimXid, domain->zoom_ni); 
    251                  SuperClassWriter::addDimension(dimYid, domain->zoom_nj); 
     242                 SuperClassWriter::addDimension(dimXid, domain->ni); 
     243                 SuperClassWriter::addDimension(dimYid, domain->nj); 
    252244 
    253245                 if (domain->hasBounds) 
     
    256248                 if (server->intraCommSize > 1) 
    257249                 { 
    258                    this->writeLocalAttributes(domain->zoom_ibegin, 
    259                                               domain->zoom_ni, 
    260                                               domain->zoom_jbegin, 
    261                                               domain->zoom_nj, 
     250                   this->writeLocalAttributes(domain->ibegin, 
     251                                              domain->ni, 
     252                                              domain->jbegin, 
     253                                              domain->nj, 
    262254                                              appendDomid); 
    263255 
    264256                   if (singleDomain) 
    265257                    this->writeLocalAttributes_IOIPSL(dimXid, dimYid, 
    266                                                       domain->zoom_ibegin, 
    267                                                       domain->zoom_ni, 
    268                                                       domain->zoom_jbegin, 
    269                                                       domain->zoom_nj, 
     258                                                      domain->ibegin, 
     259                                                      domain->ni, 
     260                                                      domain->jbegin, 
     261                                                      domain->nj, 
    270262                                                      domain->ni_glo,domain->nj_glo, 
    271263                                                      server->intraCommRank,server->intraCommSize); 
     
    340332                       break; 
    341333                     case CDomain::type_attr::rectilinear : 
    342                        CArray<double,1> lat = writtenLat(Range(fromStart,toEnd,domain->zoom_ni)) ; 
     334                       CArray<double,1> lat = writtenLat(Range(fromStart,toEnd,domain->ni)) ; 
    343335                       SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0); 
    344                        CArray<double,1> lon = writtenLon(Range(0,domain->zoom_ni-1)) ; 
     336                       CArray<double,1> lon = writtenLon(Range(0,domain->ni-1)) ; 
    345337                       SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0); 
    346338                       break; 
     
    365357              case (ONE_FILE) : 
    366358              { 
    367                  SuperClassWriter::addDimension(dimXid, domain->global_zoom_ni); 
    368                  SuperClassWriter::addDimension(dimYid, domain->global_zoom_nj); 
     359                SuperClassWriter::addDimension(dimXid, domain->ni_glo); 
     360                SuperClassWriter::addDimension(dimYid, domain->nj_glo); 
    369361 
    370362                 if (domain->hasBounds) 
     
    441433                     else 
    442434                     { 
    443                        start[1]=domain->zoom_ibegin-domain->global_zoom_ibegin; 
    444                        start[0]=domain->zoom_jbegin-domain->global_zoom_jbegin; 
    445                        count[1]=domain->zoom_ni ; count[0]=domain->zoom_nj ; 
     435                       start[1]=domain->ibegin; 
     436                       start[0]=domain->jbegin; 
     437                       count[1]=domain->ni ; count[0]=domain->nj ; 
    446438                     } 
    447439 
     
    468460                       else 
    469461                       {  
    470                          start[0]=domain->zoom_jbegin-domain->global_zoom_jbegin; 
    471                          count[0]=domain->zoom_nj;                          
    472                          CArray<double,1> lat = writtenLat(Range(fromStart,toEnd,domain->zoom_ni)); 
     462                         start[0]=domain->jbegin; 
     463                         count[0]=domain->nj; 
     464                         CArray<double,1> lat = writtenLat(Range(fromStart,toEnd,domain->ni)); 
    473465                         SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0,&start,&count); 
    474466 
    475                          start[0]=domain->zoom_ibegin-domain->global_zoom_ibegin; 
    476                          count[0]=domain->zoom_ni;                          
    477                          CArray<double,1> lon = writtenLon(Range(0,domain->zoom_ni-1)); 
     467                         start[0]=domain->ibegin; 
     468                         count[0]=domain->ni; 
     469                         CArray<double,1> lon = writtenLon(Range(0,domain->ni-1)); 
    478470                         SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0,&start,&count); 
    479471                       } 
     
    495487                   { 
    496488                     start[2] = 0; 
    497                      start[1] = domain->zoom_ibegin - domain->global_zoom_ibegin; 
    498                      start[0] = domain->zoom_jbegin - domain->global_zoom_jbegin; 
     489                     start[1] = domain->ibegin; 
     490                     start[0] = domain->jbegin; 
    499491                     count[2] = domain->nvertex; 
    500                      count[1] = domain->zoom_ni; 
    501                      count[0] = domain->zoom_nj; 
     492                     count[1] = domain->ni; 
     493                     count[0] = domain->nj; 
    502494                   } 
    503495                  
     
    518510                   else 
    519511                   { 
    520                      start[1] = domain->zoom_ibegin - domain->global_zoom_ibegin; 
    521                      start[0] = domain->zoom_jbegin - domain->global_zoom_jbegin; 
    522                      count[1] = domain->zoom_ni; 
    523                      count[0] = domain->zoom_nj; 
     512                     start[1] = domain->ibegin; 
     513                     start[0] = domain->jbegin; 
     514                     count[1] = domain->ni; 
     515                     count[0] = domain->nj; 
    524516                   } 
    525517                    
     
    786778               else 
    787779               { 
    788                  startNodes[0] = domain->zoom_ibegin-domain->global_zoom_ibegin; 
    789                  countNodes[0] = domain->zoom_ni ; 
     780                 startNodes[0] = domain->ibegin; 
     781                 countNodes[0] = domain->ni ; 
    790782               } 
    791783 
     
    809801               else 
    810802               { 
    811                  startEdges[0] = domain->zoom_ibegin-domain->global_zoom_ibegin; 
    812                  countEdges[0] = domain->zoom_ni; 
     803                 startEdges[0] = domain->ibegin; 
     804                 countEdges[0] = domain->ni; 
    813805                 startNodes[0] = domain->mesh->node_start; 
    814806                 countNodes[0] = domain->mesh->node_count; 
    815                  startEdgeNodes[0] = domain->zoom_ibegin-domain->global_zoom_ibegin; 
     807                 startEdgeNodes[0] = domain->ibegin; 
    816808                 startEdgeNodes[1] = 0; 
    817                  countEdgeNodes[0] = domain->zoom_ni; 
     809                 countEdgeNodes[0] = domain->ni; 
    818810                 countEdgeNodes[1] = 2; 
    819811               } 
     
    845837               else 
    846838               { 
    847                  startFaces[0] = domain->zoom_ibegin-domain->global_zoom_ibegin; 
    848                  countFaces[0] = domain->zoom_ni ; 
     839                 startFaces[0] = domain->ibegin; 
     840                 countFaces[0] = domain->ni ; 
    849841                 startNodes[0] = domain->mesh->node_start; 
    850842                 countNodes[0] = domain->mesh->node_count; 
     
    859851                 countEdgeFaces[0] = domain->mesh->edge_count; 
    860852                 countEdgeFaces[1]= 2; 
    861                  startFaceConctv[0] = domain->zoom_ibegin-domain->global_zoom_ibegin; 
     853                 startFaceConctv[0] = domain->ibegin; 
    862854                 startFaceConctv[1] = 0; 
    863                  countFaceConctv[0] = domain->zoom_ni; 
     855                 countFaceConctv[0] = domain->ni; 
    864856                 countFaceConctv[1] = domain->nvertex; 
    865857               } 
     
    10171009              { 
    10181010                 dim0.push_back(dimXid); 
    1019                  SuperClassWriter::addDimension(dimXid, domain->zoom_ni); 
     1011                 SuperClassWriter::addDimension(dimXid, domain->ni); 
    10201012 
    10211013                 lonid = lonName+appendDomid; 
     
    11301122                 else 
    11311123                 { 
    1132                    start[0]=domain->zoom_ibegin - domain->global_zoom_ibegin; 
    1133                    count[0]=domain->zoom_ni; 
    1134                    startBounds[0]=domain->zoom_ibegin-domain->global_zoom_ibegin; 
     1124                   start[0]=domain->ibegin; 
     1125                   count[0]=domain->ni; 
     1126                   startBounds[0]=domain->ibegin; 
    11351127                   startBounds[1]=0 ; 
    1136                    countBounds[0]=domain->zoom_ni; 
     1128                   countBounds[0]=domain->ni; 
    11371129                   countBounds[1]=nvertex ; 
    11381130                 } 
     
    11881180        int zoom_count = axis->zoom_n;                                                  
    11891181        int zoom_begin = axis->zoom_begin; 
    1190         // int zoom_begin = (MULTI_FILE == SuperClass::type) ? axis->global_zoom_begin  
    1191         //                                                   : axis->zoom_begin; 
    11921182 
    11931183        if ((0 == axis->zoom_n) && (MULTI_FILE == SuperClass::type)) return; 
     
    25122502                   if ( wtimeData) 
    25132503                   { 
    2514 //                     SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep() - 1); 
    2515 //                     SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep() - 1); 
    25162504                       SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep() - 1, isRoot); 
    25172505                       SuperClassWriter::writeTimeAxisDataBounds(time_data_bound, timeAxisBoundId, isCollective, field->getNStep() - 1, isRoot); 
     
    25192507                   if (wtimeCounter) 
    25202508                   { 
    2521 //                     SuperClassWriter::writeData(time_counter, getTimeCounterName(), isCollective, field->getNStep() - 1); 
    2522 //                     if (timeCounterType!=record) SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep() - 1); 
    25232509                     SuperClassWriter::writeTimeAxisData(time_counter, getTimeCounterName(), isCollective, field->getNStep() - 1,isRoot); 
    25242510                     if (timeCounterType!=record) SuperClassWriter::writeTimeAxisDataBounds(time_counter_bound, timeBoundId, isCollective, field->getNStep() - 1, isRoot); 
     
    25302516              case (ONE_FILE) : 
    25312517              { 
    2532                 const std::vector<int>& nZoomBeginGlobal = grid->getDistributionServer()->getZoomBeginGlobal(); 
    2533                 const std::vector<int>& nZoomBeginServer = grid->getDistributionServer()->getZoomBeginServer(); 
    2534                 const std::vector<int>& nZoomSizeServer  = grid->getDistributionServer()->getZoomSizeServer(); 
    25352518 
    25362519                std::vector<StdSize> start, count; 
     
    25502533                    int numElement = axisDomainOrder.numElements(); 
    25512534                    int idxDomain = domainList.size() - 1, idxAxis = axisList.size() - 1; 
    2552                     int idx = nZoomBeginGlobal.size() - 1; 
    2553  
    2554                     start.reserve(nZoomBeginGlobal.size()); 
    2555                     count.reserve(nZoomBeginGlobal.size()); 
    2556  
     2535                    int idx = domainList.size() * 2 + axisList.size() - 1; 
     2536 
     2537                    start.reserve(idx+1); 
     2538                    count.reserve(idx+1); 
    25572539 
    25582540                    for (int i = numElement - 1; i >= 0; --i) 
     
    25722554                          if ((domain->type) != CDomain::type_attr::unstructured) 
    25732555                          { 
    2574                             start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]); 
    2575                             count.push_back(nZoomSizeServer[idx]); 
     2556                            start.push_back(domain->jbegin); 
     2557                            count.push_back(domain->nj); 
    25762558                          } 
    25772559                          --idx; 
    2578                           start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]); 
    2579                           count.push_back(nZoomSizeServer[idx]); 
     2560                          start.push_back(domain->ibegin); 
     2561                          count.push_back(domain->ni); 
    25802562                          --idx; 
    25812563                        } 
     
    25932575                        else 
    25942576                        { 
    2595                           start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]); 
    2596                           count.push_back(nZoomSizeServer[idx]); 
     2577                          start.push_back(axis->begin); 
     2578                          count.push_back(axis->n); 
    25972579                        } 
    2598  
    25992580                        --idxAxis; 
    26002581                        --idx; 
     
    26102591                  int numElement = axisDomainOrder.numElements(); 
    26112592                  int idxDomain = domainList.size() - 1, idxAxis = axisList.size() - 1; 
    2612                   int idx = domainList.size() * 2 + axisList.size() - 1;// nZoomBeginGlobal.size() - 1; 
    2613  
    2614                   start.reserve(nZoomBeginGlobal.size()); 
    2615                   count.reserve(nZoomBeginGlobal.size()); 
     2593                  int idx = domainList.size() * 2 + axisList.size() - 1; 
     2594 
     2595                  start.reserve(idx+1); 
     2596                  count.reserve(idx+1); 
    26162597 
    26172598                  for (int i = numElement - 1; i >= 0; --i) 
     
    26222603                      if ((domain->type) != CDomain::type_attr::unstructured) 
    26232604                      { 
    2624                         start.push_back(domain->zoom_jbegin - domain->global_zoom_jbegin); 
    2625                         count.push_back(domain->zoom_nj); 
     2605                        start.push_back(domain->jbegin); 
     2606                        count.push_back(domain->nj); 
    26262607                      } 
    26272608                      --idx ; 
    26282609 
    2629                         start.push_back(domain->zoom_ibegin - domain->global_zoom_ibegin); 
    2630                         count.push_back(domain->zoom_ni); 
     2610                        start.push_back(domain->ibegin); 
     2611                        count.push_back(domain->ni); 
    26312612                      --idx ; 
    26322613                      --idxDomain; 
     
    26622643                   if ( wtimeData) 
    26632644                   { 
    2664 //                     SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep() - 1); 
    2665 //                     SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep() - 1); 
    26662645                     SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep() - 1, isRoot); 
    26672646                     SuperClassWriter::writeTimeAxisDataBounds(time_data_bound, timeAxisBoundId, isCollective, field->getNStep() - 1, isRoot); 
     
    26692648                   if (wtimeCounter) 
    26702649                   { 
    2671 //                     SuperClassWriter::writeData(time_counter, getTimeCounterName(), isCollective, field->getNStep() - 1); 
    2672 //                     if (timeCounterType!=record) SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep() - 1); 
    26732650                     SuperClassWriter::writeTimeAxisData(time_counter, getTimeCounterName(), isCollective, field->getNStep() - 1,isRoot); 
    26742651                     if (timeCounterType!=record) SuperClassWriter::writeTimeAxisDataBounds(time_counter_bound, timeBoundId, isCollective, field->getNStep() - 1, isRoot); 
  • XIOS/trunk/src/node/domain.cpp

    r1549 r1553  
    3030      , hasBounds(false), hasArea(false), isCompressible_(false), isUnstructed_(false) 
    3131      , isClientAfterTransformationChecked(false), hasLonLat(false) 
    32       , isRedistributed_(false), hasPole(false), doZoomByIndex_(false) 
     32      , isRedistributed_(false), hasPole(false) 
    3333      , lonvalue(), latvalue(), bounds_lonvalue(), bounds_latvalue() 
    3434      , globalLocalIndexMap_(), computedWrittenIndex_(false) 
    35           , clients() 
     35      , clients() 
    3636   { 
    3737   } 
     
    4242      , hasBounds(false), hasArea(false), isCompressible_(false), isUnstructed_(false) 
    4343      , isClientAfterTransformationChecked(false), hasLonLat(false) 
    44       , isRedistributed_(false), hasPole(false), doZoomByIndex_(false) 
     44      , isRedistributed_(false), hasPole(false) 
    4545      , lonvalue(), latvalue(), bounds_lonvalue(), bounds_latvalue() 
    4646      , globalLocalIndexMap_(), computedWrittenIndex_(false) 
    47           , clients() 
     47      , clients() 
    4848   { 
    4949    } 
     
    185185   bool CDomain::isEmpty(void) const 
    186186   { 
    187       return ((this->zoom_i_index.isEmpty()) || (0 == this->zoom_i_index.numElements())); 
    188  
     187     return ((this->i_index.isEmpty()) || (0 == this->i_index.numElements())); 
    189188   } 
    190189 
     
    866865         for (int i = 0; i < ni; ++i) j_index(i+j*ni) = j+jbegin; 
    867866     } 
    868       
    869      checkZoom(); 
    870    } 
    871  
    872    // Check global zoom of a domain 
    873    // If there is no zoom defined for the domain, zoom will have value of global doamin 
    874    void CDomain::checkZoom(void) 
    875    { 
    876      if (global_zoom_ibegin.isEmpty()) 
    877       global_zoom_ibegin.setValue(0); 
    878      if (global_zoom_ni.isEmpty()) 
    879       global_zoom_ni.setValue(ni_glo); 
    880      if (global_zoom_jbegin.isEmpty()) 
    881       global_zoom_jbegin.setValue(0); 
    882      if (global_zoom_nj.isEmpty()) 
    883       global_zoom_nj.setValue(nj_glo); 
    884     if (zoom_i_index.isEmpty()) zoom_i_index.setValue(i_index.getValue()); 
    885     if (zoom_j_index.isEmpty()) zoom_j_index.setValue(j_index.getValue()); 
    886     if (zoom_ibegin.isEmpty()) zoom_ibegin.setValue(ibegin); 
    887     if (zoom_ni.isEmpty()) zoom_ni.setValue(ni); 
    888     if (zoom_jbegin.isEmpty()) zoom_jbegin.setValue(jbegin); 
    889     if (zoom_nj.isEmpty()) zoom_nj.setValue(nj); 
    890867   } 
    891868 
    892869   size_t CDomain::getGlobalWrittenSize(void) 
    893870   { 
    894       return global_zoom_ni*global_zoom_nj ; 
     871     return ni_glo*nj_glo ; 
    895872   } 
    896873   //---------------------------------------------------------------- 
     
    17381715        if (indSrv_.find(nbServer) == indSrv_.end()) 
    17391716        { 
    1740           int i,j,i_ind,j_ind, nbIndex, nbIndexZoom; 
    1741           int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1; 
    1742           int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1; 
    1743  
    1744            // Precompute number of index 
    1745            int globalIndexCountZoom = 0; 
    1746            nbIndex = i_index.numElements(); 
    1747  
    1748            if (doZoomByIndex_) 
    1749            { 
    1750              globalIndexCountZoom = zoom_i_index.numElements(); 
    1751            } 
    1752            else 
    1753            { 
    1754              for (i = 0; i < nbIndex; ++i) 
    1755              { 
    1756                i_ind=i_index(i); 
    1757                j_ind=j_index(i); 
    1758  
    1759                if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend) 
    1760                { 
    1761                   ++globalIndexCountZoom; 
    1762                } 
    1763              } 
    1764            } 
    1765  
    1766            // Fill in index 
    1767            CArray<size_t,1> globalIndexDomainZoom(globalIndexCountZoom); 
    1768            CArray<size_t,1> localIndexDomainZoom(globalIndexCountZoom); 
    1769            CArray<size_t,1> globalIndexDomain(nbIndex); 
    1770            size_t globalIndex; 
    1771            int globalIndexCount = 0; 
    1772  
    1773            for (i = 0; i < nbIndex; ++i) 
    1774            { 
    1775              i_ind=i_index(i); 
    1776              j_ind=j_index(i); 
    1777              globalIndex = i_ind + j_ind * ni_glo; 
    1778              globalIndexDomain(i) = globalIndex; 
    1779            } 
    1780  
    1781            if (globalLocalIndexMap_.empty()) 
    1782            { 
    1783              for (i = 0; i < nbIndex; ++i) 
    1784                globalLocalIndexMap_[globalIndexDomain(i)] = i; 
    1785            } 
    1786  
    1787            globalIndexCountZoom = 0; 
    1788            if (doZoomByIndex_) 
    1789            { 
    1790              int nbIndexZoom = zoom_i_index.numElements(); 
    1791  
    1792              for (i = 0; i < nbIndexZoom; ++i) 
    1793              { 
    1794                i_ind=zoom_i_index(i); 
    1795                j_ind=zoom_j_index(i); 
    1796                globalIndex = i_ind + j_ind * ni_glo; 
    1797                globalIndexDomainZoom(globalIndexCountZoom) = globalIndex; 
    1798                ++globalIndexCountZoom; 
    1799              } 
    1800            } 
    1801            else 
    1802            { 
    1803              int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1; 
    1804              int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1; 
    1805              for (i = 0; i < nbIndex; ++i) 
    1806              { 
    1807                i_ind=i_index(i); 
    1808                j_ind=j_index(i); 
    1809                globalIndex = i_ind + j_ind * ni_glo; 
    1810                if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend) 
    1811                { 
    1812                   globalIndexDomainZoom(globalIndexCountZoom) = globalIndex; 
    1813                   ++globalIndexCountZoom; 
    1814                } 
    1815              } 
    1816  
    1817              int iend = ibegin + ni -1; 
    1818              int jend = jbegin + nj -1; 
    1819              zoom_ibegin = global_zoom_ibegin > ibegin ? global_zoom_ibegin.getValue() : ibegin; 
    1820              int zoom_iend  = global_zoom_iend < iend ? zoom_iend : iend ; 
    1821              zoom_ni     = zoom_iend-zoom_ibegin+1 ; 
    1822  
    1823              zoom_jbegin = global_zoom_jbegin > jbegin ? global_zoom_jbegin.getValue() : jbegin ; 
    1824              int zoom_jend   = global_zoom_jend < jend ? zoom_jend : jend; 
    1825              zoom_nj     = zoom_jend-zoom_jbegin+1; 
    1826            } 
    1827  
    1828            size_t globalSizeIndex = 1, indexBegin, indexEnd; 
    1829            int range, clientSize = client->clientSize; 
    1830            std::vector<int> nGlobDomain(2); 
    1831            nGlobDomain[0] = this->ni_glo; 
    1832            nGlobDomain[1] = this->nj_glo; 
    1833            for (int i = 0; i < nGlobDomain.size(); ++i) globalSizeIndex *= nGlobDomain[i]; 
    1834            indexBegin = 0; 
    1835            if (globalSizeIndex <= clientSize) 
    1836            { 
    1837              indexBegin = rank%globalSizeIndex; 
    1838              indexEnd = indexBegin; 
    1839            } 
    1840            else 
    1841            { 
    1842              for (int i = 0; i < clientSize; ++i) 
    1843              { 
    1844                range = globalSizeIndex / clientSize; 
    1845                if (i < (globalSizeIndex%clientSize)) ++range; 
    1846                if (i == client->clientRank) break; 
    1847                indexBegin += range; 
    1848              } 
    1849              indexEnd = indexBegin + range - 1; 
    1850            } 
    1851  
    1852            // Even if servers have no index, they must received something from client 
    1853            // We only use several client to send "empty" message to these servers 
    1854            CServerDistributionDescription serverDescription(nGlobDomain, nbServer); 
    1855            std::vector<int> serverZeroIndex; 
    1856            if (isUnstructed_) serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t&,size_t&>(indexBegin, indexEnd), 0); 
    1857            else serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t&,size_t&>(indexBegin, indexEnd), 1); 
    1858  
    1859            std::list<int> serverZeroIndexLeader; 
    1860            std::list<int> serverZeroIndexNotLeader; 
    1861            CContextClient::computeLeader(client->clientRank, client->clientSize, serverZeroIndex.size(), serverZeroIndexLeader, serverZeroIndexNotLeader); 
    1862            for (std::list<int>::iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it) 
    1863               *it = serverZeroIndex[*it]; 
    1864  
    1865            CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(), 
    1866                  client->intraComm); 
    1867            clientServerMap->computeServerIndexMapping(globalIndexDomain, nbServer); 
    1868            CClientServerMapping::GlobalIndexMap& globalIndexDomainOnServer = clientServerMap->getGlobalIndexOnServer(); 
    1869  
    1870            CClientServerMapping::GlobalIndexMap::const_iterator it  = globalIndexDomainOnServer.begin(), 
     1717          int i,j,i_ind,j_ind, nbIndex=i_index.numElements(); 
     1718          int globalIndexCount = i_index.numElements(); 
     1719          // Fill in index 
     1720          CArray<size_t,1> globalIndexDomain(nbIndex); 
     1721          size_t globalIndex; 
     1722 
     1723          for (i = 0; i < nbIndex; ++i) 
     1724          { 
     1725            i_ind=i_index(i); 
     1726            j_ind=j_index(i); 
     1727            globalIndex = i_ind + j_ind * ni_glo; 
     1728            globalIndexDomain(i) = globalIndex; 
     1729          } 
     1730 
     1731          if (globalLocalIndexMap_.empty()) 
     1732          { 
     1733            for (i = 0; i < nbIndex; ++i) 
     1734              globalLocalIndexMap_[globalIndexDomain(i)] = i; 
     1735          } 
     1736 
     1737          size_t globalSizeIndex = 1, indexBegin, indexEnd; 
     1738          int range, clientSize = client->clientSize; 
     1739          std::vector<int> nGlobDomain(2); 
     1740          nGlobDomain[0] = this->ni_glo; 
     1741          nGlobDomain[1] = this->nj_glo; 
     1742          for (int i = 0; i < nGlobDomain.size(); ++i) globalSizeIndex *= nGlobDomain[i]; 
     1743          indexBegin = 0; 
     1744          if (globalSizeIndex <= clientSize) 
     1745          { 
     1746            indexBegin = rank%globalSizeIndex; 
     1747            indexEnd = indexBegin; 
     1748          } 
     1749          else 
     1750          { 
     1751            for (int i = 0; i < clientSize; ++i) 
     1752            { 
     1753              range = globalSizeIndex / clientSize; 
     1754              if (i < (globalSizeIndex%clientSize)) ++range; 
     1755              if (i == client->clientRank) break; 
     1756              indexBegin += range; 
     1757            } 
     1758            indexEnd = indexBegin + range - 1; 
     1759          } 
     1760 
     1761          // Even if servers have no index, they must received something from client 
     1762          // We only use several client to send "empty" message to these servers 
     1763          CServerDistributionDescription serverDescription(nGlobDomain, nbServer); 
     1764          std::vector<int> serverZeroIndex; 
     1765          if (isUnstructed_) serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t&,size_t&>(indexBegin, indexEnd), 0); 
     1766          else serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t&,size_t&>(indexBegin, indexEnd), 1); 
     1767 
     1768          std::list<int> serverZeroIndexLeader; 
     1769          std::list<int> serverZeroIndexNotLeader; 
     1770          CContextClient::computeLeader(client->clientRank, client->clientSize, serverZeroIndex.size(), serverZeroIndexLeader, serverZeroIndexNotLeader); 
     1771          for (std::list<int>::iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it) 
     1772            *it = serverZeroIndex[*it]; 
     1773 
     1774          CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(), client->intraComm); 
     1775          clientServerMap->computeServerIndexMapping(globalIndexDomain, nbServer); 
     1776          CClientServerMapping::GlobalIndexMap& globalIndexDomainOnServer = clientServerMap->getGlobalIndexOnServer(); 
     1777 
     1778          CClientServerMapping::GlobalIndexMap::const_iterator it  = globalIndexDomainOnServer.begin(), 
    18711779                 ite = globalIndexDomainOnServer.end(); 
    1872            indSrv_[nbServer].swap(globalIndexDomainOnServer); 
    1873            connectedServerRank_[nbServer].clear(); 
    1874            for (it = indSrv_[nbServer].begin(); it != ite; ++it) 
    1875              connectedServerRank_[nbServer].push_back(it->first); 
    1876  
    1877            for (std::list<int>::const_iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it) 
    1878               connectedServerRank_[nbServer].push_back(*it); 
    1879  
    1880            // Even if a client has no index, it must connect to at least one server and 
    1881            // send an "empty" data to this server 
    1882            if (connectedServerRank_[nbServer].empty()) 
    1883               connectedServerRank_[nbServer].push_back(client->clientRank % client->serverSize); 
    1884  
    1885            nbSenders[nbServer] = clientServerMap->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_[nbServer]); 
    1886            delete clientServerMap; 
     1780          indSrv_[nbServer].swap(globalIndexDomainOnServer); 
     1781          connectedServerRank_[nbServer].clear(); 
     1782          for (it = indSrv_[nbServer].begin(); it != ite; ++it) 
     1783            connectedServerRank_[nbServer].push_back(it->first); 
     1784 
     1785          for (std::list<int>::const_iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it) 
     1786            connectedServerRank_[nbServer].push_back(*it); 
     1787 
     1788          // Even if a client has no index, it must connect to at least one server and 
     1789          // send an "empty" data to this server 
     1790          if (connectedServerRank_[nbServer].empty()) 
     1791            connectedServerRank_[nbServer].push_back(client->clientRank % client->serverSize); 
     1792 
     1793          nbSenders[nbServer] = clientServerMap->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_[nbServer]); 
     1794          delete clientServerMap; 
    18871795        } 
    18881796      } 
     
    19041812 
    19051813      std::vector<int> nBegin(2), nSize(2), nBeginGlobal(2), nGlob(2); 
    1906       nBegin[0]       = zoom_ibegin;  nBegin[1] = zoom_jbegin; 
    1907       nSize[0]        = zoom_ni;      nSize[1]  = zoom_nj; 
     1814      nBegin[0]       = ibegin;  nBegin[1] = jbegin; 
     1815      nSize[0]        = ni;      nSize[1]  = nj; 
    19081816      nBeginGlobal[0] = 0; nBeginGlobal[1] = 0; 
    19091817      nGlob[0]        = ni_glo;   nGlob[1] = nj_glo; 
     
    20051913 
    20061914      std::vector<int> nBegin(2), nSize(2), nBeginGlobal(2), nGlob(2); 
    2007       nBegin[0]       = zoom_ibegin;  nBegin[1] = zoom_jbegin; 
    2008       nSize[0]        = zoom_ni;      nSize[1]  = zoom_nj; 
     1915      nBegin[0]       = ibegin;  nBegin[1] = jbegin; 
     1916      nSize[0]        = ni;      nSize[1]  = nj; 
    20091917      nBeginGlobal[0] = 0; nBeginGlobal[1] = 0; 
    20101918      nGlob[0]        = ni_glo;   nGlob[1] = nj_glo; 
     
    20751983 
    20761984  /*! 
    2077     Send global index and zoom index from client to connected client(s) 
    2078     zoom index can be smaller than global index 
     1985    Send global index from client to connected client(s) 
    20791986  */ 
    20801987  void CDomain::sendIndex() 
     
    20901997 
    20911998      list<CMessage> list_msgsIndex; 
    2092       list<CArray<int,1> > list_indZoom, list_writtenInd, list_indGlob; 
     1999      list<CArray<int,1> > list_indGlob; 
    20932000 
    20942001      std::unordered_map<int, vector<size_t> >::const_iterator itIndex, iteIndex; 
     
    21642071          msg << isUnstructed_; 
    21652072          msg << ni_srv << ibegin_srv << nj_srv << jbegin_srv; 
    2166           msg << global_zoom_ni.getValue() << global_zoom_ibegin.getValue() << global_zoom_nj.getValue() << global_zoom_jbegin.getValue();         
     2073          msg << ni_glo.getValue() << nj_glo.getValue(); 
    21672074          msg << isCompressible_; 
    21682075 
     
    25842491 
    25852492  /*! 
    2586     Receive attributes from client(s): zoom info and begin and n of each server 
     2493    Receive attributes from client(s) 
    25872494    \param[in] rank rank of client source 
    25882495    \param[in] buffer message containing attributes info 
     
    25912498  { 
    25922499    int ni_tmp, ibegin_tmp, nj_tmp, jbegin_tmp; 
    2593     int global_zoom_ni_tmp, global_zoom_ibegin_tmp, global_zoom_nj_tmp, global_zoom_jbegin_tmp; 
     2500    int ni_glo_tmp, nj_glo_tmp; 
    25942501    buffer >> isUnstructed_ >> ni_tmp >> ibegin_tmp >> nj_tmp >> jbegin_tmp 
    2595            >> global_zoom_ni_tmp >> global_zoom_ibegin_tmp >> global_zoom_nj_tmp >> global_zoom_jbegin_tmp            
     2502           >> ni_glo_tmp >> nj_glo_tmp 
    25962503           >> isCompressible_; 
     2504 
    25972505    ni.setValue(ni_tmp); 
    25982506    ibegin.setValue(ibegin_tmp); 
    25992507    nj.setValue(nj_tmp); 
    26002508    jbegin.setValue(jbegin_tmp); 
    2601  
    2602     global_zoom_ni.setValue(global_zoom_ni_tmp); 
    2603     global_zoom_ibegin.setValue(global_zoom_ibegin_tmp); 
    2604     global_zoom_nj.setValue(global_zoom_nj_tmp); 
    2605     global_zoom_jbegin.setValue(global_zoom_jbegin_tmp); 
    2606  
    2607     int iend = ibegin + ni  - 1; 
    2608     int jend = jbegin + nj  - 1; 
    2609     int zoom_iend_glob = global_zoom_ibegin + global_zoom_ni - 1; 
    2610     int zoom_jend_glob = global_zoom_jbegin + global_zoom_nj - 1; 
    2611  
    2612     zoom_ibegin.setValue(global_zoom_ibegin > ibegin ? global_zoom_ibegin.getValue() : ibegin); 
    2613     int zoom_iend = zoom_iend_glob < iend ? zoom_iend_glob : iend ; 
    2614     zoom_ni.setValue(zoom_iend-zoom_ibegin+1); 
    2615  
    2616     zoom_jbegin.setValue(global_zoom_jbegin > jbegin ? global_zoom_jbegin.getValue() : jbegin); 
    2617     int zoom_jend = zoom_jend_glob < jend ? zoom_jend_glob : jend ; 
    2618     zoom_nj.setValue(zoom_jend-zoom_jbegin+1); 
    2619  
    2620     if (zoom_ni<=0 || zoom_nj<=0) 
    2621     { 
    2622       zoom_ni=0 ; zoom_ibegin=global_zoom_ibegin ; //=0; zoom_iend=0 ;  
    2623       zoom_nj=0 ; zoom_jbegin=global_zoom_jbegin ; //=0; zoom_jend=0 ; 
    2624     } 
     2509    ni_glo.setValue(ni_glo_tmp); 
     2510    nj_glo.setValue(nj_glo_tmp); 
    26252511 
    26262512  } 
  • XIOS/trunk/src/node/domain.hpp

    r1542 r1553  
    165165         void checkArea(void); 
    166166         void checkLonLat(); 
    167          void checkZoom(void); 
    168167 
    169168         void setTransformations(const TransMapTypes&);          
     
    183182         static void recvDistributionAttributes(CEventServer& event); 
    184183         static void recvIndex(CEventServer& event); 
    185          static void recvIndexZoom(CEventServer& event); 
    186184         static void recvMask(CEventServer& event);          
    187185         static void recvLon(CEventServer& event); 
     
    206204         std::set<CContextClient*> clientsSet; 
    207205 
    208          bool doZoomByIndex_; 
    209206         bool isChecked, computedWrittenIndex_; 
    210207         std::set<StdString> relFiles, relFilesCompressed; 
  • XIOS/trunk/src/node/grid.cpp

    r1542 r1553  
    16321632          std::vector<CAxis*> axisList = getAxis(); 
    16331633          std::vector<int> nZoomBegin(ssize), nZoomSize(ssize), nGlob(ssize), nZoomBeginGlobal(ssize), nGlobElement(numElement); 
    1634           std::vector<CArray<int,1> > globalZoomIndex(numElement); 
     1634          std::vector<CArray<int,1> > globalZoomIndex(numElement);  // RENAME INTO globalIndex 
    16351635          for (int i = 0; i < numElement; ++i) 
    16361636          { 
     
    16381638            if (2 == axis_domain_order(i)) //domain 
    16391639            { 
    1640               nZoomBegin[indexMap[i]] = domainList[domainId]->zoom_ibegin; 
    1641               nZoomSize[indexMap[i]]  = domainList[domainId]->zoom_ni; 
    1642               nZoomBeginGlobal[indexMap[i]] = domainList[domainId]->global_zoom_ibegin;               
     1640              nZoomBegin[indexMap[i]] = domainList[domainId]->ibegin; 
     1641              nZoomSize[indexMap[i]]  = domainList[domainId]->ni; 
     1642              nZoomBeginGlobal[indexMap[i]] = 0; 
    16431643              nGlob[indexMap[i]] = domainList[domainId]->ni_glo; 
    16441644 
    1645               nZoomBegin[indexMap[i] + 1] = domainList[domainId]->zoom_jbegin; 
    1646               nZoomSize[indexMap[i] + 1] = domainList[domainId]->zoom_nj; 
    1647               nZoomBeginGlobal[indexMap[i] + 1] = domainList[domainId]->global_zoom_jbegin;               
     1645              nZoomBegin[indexMap[i] + 1] = domainList[domainId]->jbegin; 
     1646              nZoomSize[indexMap[i] + 1] = domainList[domainId]->nj; 
     1647              nZoomBeginGlobal[indexMap[i] + 1] = 0; 
    16481648              nGlob[indexMap[i] + 1] = domainList[domainId]->nj_glo; 
    16491649 
  • XIOS/trunk/src/transformation/domain_algorithm_expand.cpp

    r1311 r1553  
    228228  domainDestination->ni.setValue(niDst); 
    229229  domainDestination->nj.setValue(njDst); 
    230   domainDestination->global_zoom_ni.setValue(domainSource->global_zoom_ni+2); 
    231   domainDestination->global_zoom_nj.setValue(domainSource->global_zoom_nj+2); 
    232230 
    233231  CArray<bool,1>& mask_1d_dst = domainDestination->domainMask; 
  • XIOS/trunk/src/transformation/domain_algorithm_extract.cpp

    r1549 r1553  
    140140  } 
    141141  if (domainSrc_->hasArea) domainDest_->area.resize(niDest,njDest); 
    142  
    143   domainDest_->global_zoom_ni.setValue(extractNi_); 
    144   domainDest_->global_zoom_ibegin.setValue(0); 
    145   domainDest_->global_zoom_nj.setValue(extractNj_); 
    146   domainDest_->global_zoom_jbegin.setValue(0); 
    147142 
    148143  this->transformationMapping_.resize(1); 
  • XIOS/trunk/src/transformation/domain_algorithm_zoom.cpp

    r1281 r1553  
    1 /*! 
    2    \file domain_algorithm_zoom.cpp 
    3    \author Ha NGUYEN 
    4    \since 02 Jul 2015 
    5    \date 02 Jul 2015 
    6  
    7    \brief Algorithm for zooming on an domain. 
    8  */ 
    91#include "domain_algorithm_zoom.hpp" 
    102#include "zoom_domain.hpp" 
     
    124#include "grid.hpp" 
    135#include "grid_transformation_factory_impl.hpp" 
     6#include "attribute_template.hpp" 
    147 
    158namespace xios { 
     
    6760           << "Zoom size is " << zoomNj_ ); 
    6861  } 
     62 
     63  // Calculate the size of local domain 
     64  int ind, indLocSrc, indLocDest, iIdxSrc, jIdxSrc, destIBegin = -1, destJBegin = -1, niDest = 0, njDest = 0, ibeginDest, jbeginDest ; 
     65  int indGloDest, indGloSrc, niGloSrc = domainSrc_->ni_glo, iSrc, jSrc; 
     66  for (int j = 0; j < domainSrc_->nj.getValue(); j++) 
     67  { 
     68    for (int i = 0; i < domainSrc_->ni.getValue(); i++) 
     69    { 
     70      ind = j*domainSrc_->ni + i; 
     71      iIdxSrc = domainSrc_->i_index(ind); 
     72      if ((iIdxSrc >= zoomIBegin_) && (iIdxSrc <= zoomIEnd_)) 
     73      { 
     74        jIdxSrc = domainSrc_->j_index(ind); 
     75        if ((jIdxSrc >= zoomJBegin_) && (jIdxSrc <= zoomJEnd_)) 
     76        { 
     77          if ((niDest == 0) && (njDest == 0)) 
     78          { 
     79            destIBegin = i; 
     80            destJBegin = j; 
     81          } 
     82          if (i == destIBegin) ++njDest; 
     83        } 
     84        if (j == destJBegin) ++niDest; 
     85 
     86      } 
     87    } 
     88  } 
     89  ibeginDest = destIBegin + domainSrc_->ibegin - zoomIBegin_; 
     90  jbeginDest = destJBegin + domainSrc_->jbegin - zoomJBegin_; 
     91  domainDest_->ni_glo.setValue(zoomNi_); 
     92  domainDest_->nj_glo.setValue(zoomNj_); 
     93  domainDest_->ni.setValue(niDest); 
     94  domainDest_->nj.setValue(njDest); 
     95  domainDest_->ibegin.setValue(ibeginDest); 
     96  domainDest_->jbegin.setValue(jbeginDest); 
     97  domainDest_->i_index.resize(niDest*njDest); 
     98  domainDest_->j_index.resize(niDest*njDest); 
     99 
     100  domainDest_->data_ni.setValue(niDest); 
     101  domainDest_->data_nj.setValue(njDest); 
     102  domainDest_->data_ibegin.setValue(0);  // local position 
     103  domainDest_->data_jbegin.setValue(0);  // local position 
     104  domainDest_->data_i_index.resize(niDest*njDest); // local position 
     105  domainDest_->data_j_index.resize(niDest*njDest); // local position 
     106 
     107  domainDest_->domainMask.resize(niDest*njDest); 
     108 
     109  if (!domainSrc_->lonvalue_1d.isEmpty()) 
     110  { 
     111    if (domainDest_->type == CDomain::type_attr::rectilinear) 
     112    { 
     113      domainDest_->lonvalue_1d.resize(niDest); 
     114      domainDest_->latvalue_1d.resize(njDest); 
     115    } 
     116    else if (domainDest_->type == CDomain::type_attr::unstructured) 
     117    { 
     118      domainDest_->lonvalue_1d.resize(niDest); 
     119      domainDest_->latvalue_1d.resize(niDest); 
     120    } 
     121  } 
     122  else if (!domainSrc_->lonvalue_2d.isEmpty()) 
     123  { 
     124    domainDest_->lonvalue_2d.resize(niDest,njDest); 
     125    domainDest_->latvalue_2d.resize(niDest,njDest); 
     126  } 
     127 
     128  if (domainSrc_->hasBounds) 
     129  { 
     130    if (!domainSrc_->bounds_lon_2d.isEmpty()) 
     131    { 
     132      domainDest_->bounds_lon_2d.resize(domainDest_->nvertex, niDest, njDest); 
     133      domainDest_->bounds_lon_2d.resize(domainDest_->nvertex, niDest, njDest); 
     134    } 
     135    else if (!domainSrc_->bounds_lon_1d.isEmpty()) 
     136    { 
     137      domainDest_->bounds_lon_1d.resize(domainDest_->nvertex, niDest); 
     138      domainDest_->bounds_lon_1d.resize(domainDest_->nvertex, niDest); 
     139    } 
     140  } 
     141  if (domainSrc_->hasArea) domainDest_->area.resize(niDest,njDest); 
     142 
     143  this->transformationMapping_.resize(1); 
     144  this->transformationWeight_.resize(1); 
     145  TransformationIndexMap& transMap = this->transformationMapping_[0]; 
     146  TransformationWeightMap& transWeight = this->transformationWeight_[0]; 
     147 
     148  for (int iDest = 0; iDest < niDest; iDest++) 
     149  { 
     150    iSrc = iDest + destIBegin; 
     151    for (int jDest = 0; jDest < njDest; jDest++) 
     152    { 
     153      jSrc = jDest + destJBegin; 
     154      ind = jSrc * domainSrc_->ni + iSrc; 
     155      iIdxSrc = domainSrc_->i_index(ind); 
     156      jIdxSrc = domainSrc_->j_index(ind); 
     157      indLocDest = jDest*niDest + iDest; 
     158      indGloDest = (jDest + jbeginDest)*zoomNi_ + (iDest + ibeginDest); 
     159      indLocSrc = (jDest+destJBegin)*domainSrc_->ni + (iDest+destIBegin); 
     160      indGloSrc = (jIdxSrc )* niGloSrc + iIdxSrc; 
     161      domainDest_->i_index(indLocDest) = iDest + ibeginDest;                                             // i_index contains global positions 
     162      domainDest_->j_index(indLocDest) = jDest + jbeginDest;                                             // i_index contains global positions 
     163      domainDest_->data_i_index(indLocDest) = (domainSrc_->data_dim == 1) ? indLocDest : iDest;          // data_i_index contains local positions 
     164      domainDest_->data_j_index(indLocDest) = (domainSrc_->data_dim == 1) ? 0 :jDest;                    // data_i_index contains local positions 
     165      domainDest_->domainMask(indLocDest) = domainSrc_->domainMask(indLocSrc); 
     166 
     167      if (domainSrc_->hasArea) 
     168        domainDest_->area(iDest,jDest) = domainSrc_->area(iSrc,jSrc); 
     169 
     170      if (domainSrc_->hasBounds) 
     171      { 
     172        if (!domainSrc_->bounds_lon_2d.isEmpty()) 
     173        { 
     174          for (int n = 0; n < domainSrc_->nvertex; ++n) 
     175          { 
     176            domainDest_->bounds_lon_2d(n,iDest,jDest) = domainSrc_->bounds_lon_2d(n,iSrc,jSrc); 
     177            domainDest_->bounds_lat_2d(n,iDest,jDest) = domainSrc_->bounds_lat_2d(n,iSrc,jSrc); 
     178          } 
     179        } 
     180        else if (!domainSrc_->bounds_lon_1d.isEmpty()) 
     181        { 
     182          for (int n = 0; n < domainSrc_->nvertex; ++n) 
     183          { 
     184            domainDest_->bounds_lon_1d(n,iDest) = domainSrc_->bounds_lon_1d(n,iSrc); 
     185            domainDest_->bounds_lat_1d(n,iDest) = domainSrc_->bounds_lat_1d(n,iSrc); 
     186          } 
     187        } 
     188      } 
     189 
     190      if (domainSrc_->hasLonLat) 
     191      { 
     192        if (domainDest_->type == CDomain::type_attr::rectilinear) 
     193        { 
     194          domainDest_->latvalue_1d(jDest) = domainSrc_->latvalue_1d(jSrc); 
     195        } 
     196        else if (domainDest_->type == CDomain::type_attr::curvilinear) 
     197        { 
     198          domainDest_->lonvalue_2d(iDest,jDest) = domainSrc_->lonvalue_2d(iSrc,jSrc); 
     199          domainDest_->latvalue_2d(iDest,jDest) = domainSrc_->latvalue_2d(iSrc,jSrc); 
     200        } 
     201      } 
     202 
     203      transMap[indGloDest].push_back(indGloSrc); 
     204      transWeight[indGloDest].push_back(1.0); 
     205 
     206    } 
     207    if (domainSrc_->hasLonLat) 
     208    { 
     209      if (domainDest_->type == CDomain::type_attr::unstructured) 
     210      { 
     211        domainDest_->lonvalue_1d(iDest) = domainSrc_->lonvalue_1d(iSrc); 
     212        domainDest_->latvalue_1d(iDest) = domainSrc_->latvalue_1d(iSrc); 
     213      } 
     214      else if (domainDest_->type == CDomain::type_attr::rectilinear) 
     215      { 
     216        domainDest_->lonvalue_1d(iDest) = domainSrc_->lonvalue_1d(iSrc); 
     217      } 
     218    } 
     219  } 
     220 
    69221} 
    70222 
     
    74226void CDomainAlgorithmZoom::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
    75227{ 
    76  
    77   int niGlob = domainSrc_->ni_glo.getValue(); 
    78   int njGlob = domainSrc_->nj_glo.getValue(); 
    79  
    80   this->transformationMapping_.resize(1); 
    81   this->transformationWeight_.resize(1); 
    82  
    83   TransformationIndexMap& transMap = this->transformationMapping_[0]; 
    84   TransformationWeightMap& transWeight = this->transformationWeight_[0]; 
    85  
    86   int domainGlobalIndex; 
    87   int iglob ; 
    88   int jglob ; 
    89   const CArray<int,1>& i_index = domainSrc_->i_index.getValue() ; 
    90   const CArray<int,1>& j_index = domainSrc_->j_index.getValue() ; 
    91  
    92   int nglo = i_index.numElements() ; 
    93   for (size_t i = 0; i < nglo ; ++i) 
    94   { 
    95     iglob=i_index(i) ; jglob=j_index(i) ; 
    96     if (iglob>=zoomIBegin_ && iglob<=zoomIEnd_ && jglob>=zoomJBegin_ && jglob<=zoomJEnd_) 
    97     { 
    98       domainGlobalIndex = jglob*niGlob + iglob; 
    99       transMap[domainGlobalIndex].push_back(domainGlobalIndex); 
    100       transWeight[domainGlobalIndex].push_back(1.0); 
    101     } 
    102   } 
    103   updateZoom(); 
    104 } 
    105  
    106 /*! 
    107   After a zoom on domain, it should be certain that (global) zoom begin and (global) zoom size are updated 
    108 */ 
    109 void CDomainAlgorithmZoom::updateZoom() 
    110 { 
    111   domainDest_->global_zoom_ibegin = zoomIBegin_; 
    112   domainDest_->global_zoom_jbegin = zoomJBegin_; 
    113   domainDest_->global_zoom_ni  = zoomNi_; 
    114   domainDest_->global_zoom_nj  = zoomNj_; 
    115 } 
    116  
    117 /*! 
    118   Update mask on domain 
    119   Because only zoomed region on domain is not masked, the remaining must be masked to make sure 
    120 correct index be extracted 
    121 */ 
    122 // void CDomainAlgorithmZoom::updateDomainDestinationMask() 
    123 // { 
    124 //   int niMask     = domainDest_->ni.getValue(); 
    125 //   int iBeginMask = domainDest_->ibegin.getValue(); 
    126 //   int njMask     = domainDest_->nj.getValue(); 
    127 //   int jBeginMask = domainDest_->jbegin.getValue(); 
    128 //   int niGlob = domainDest_->ni_glo.getValue(); 
    129 //   int globalIndexMask = 0; 
    130  
    131 //   TransformationIndexMap& transMap = this->transformationMapping_[0]; 
    132 //   TransformationIndexMap::const_iterator ite = (transMap).end(); 
    133 //   for (int j = 0; j < njMask; ++j) 
    134 //   { 
    135 //     for (int i = 0; i < niMask; ++i) 
    136 //     { 
    137 //       globalIndexMask = (j+jBeginMask) * niGlob + (i + iBeginMask); 
    138 //       if (transMap.find(globalIndexMask) == ite) 
    139 //         (domainDest_->mask_1d)(i+j*niMask) = false; 
    140 //     } 
    141 //   } 
    142 // } 
    143  
    144 } 
     228} 
     229 
     230 
     231} 
  • XIOS/trunk/src/transformation/domain_algorithm_zoom.hpp

    r1144 r1553  
    1 /*! 
    2    \file domain_algorithm_zoom.hpp 
    3    \author Ha NGUYEN 
    4    \since 03 June 2015 
    5    \date 12 June 2015 
    61 
    7    \brief Algorithm for zooming on an domain. 
    8  */ 
    92#ifndef __XIOS_DOMAIN_ALGORITHM_ZOOM_HPP__ 
    103#define __XIOS_DOMAIN_ALGORITHM_ZOOM_HPP__ 
     
    2013/*! 
    2114  \class CDomainAlgorithmZoom 
    22   Implementing zoom on domain 
    23   A zoomed region can be considered as region that isnt masked. 
    24   Only this zoomed region is extracted to write on Netcdf. 
     15  Implementing zoom (alternative zoom) on domain 
    2516*/ 
    2617class CDomainAlgorithmZoom : public CDomainAlgorithmTransformation 
     
    3324  static bool registerTrans(); 
    3425protected: 
     26  void updateDomainAttributes(); 
    3527  void computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs); 
    3628 
    3729private: 
    38   // void updateDomainDestinationMask(); 
    3930  void updateZoom(); 
    4031 
Note: See TracChangeset for help on using the changeset viewer.