Changeset 1129


Ignore:
Timestamp:
05/11/17 18:25:20 (3 years ago)
Author:
mhnguyen
Message:

Updating two-level server.
Each client now can play the role of server: It can forward data to other clients or write data like a server.
Each client must combine all data received from other client(s) before forward them or write them on files

+) Correct some bugs of exchange data_index in domain and axis
+) Reorder some functions in context.cpp to make sure that all necessary attributes are available before computing index
+) Add the mapping index for client to write data.

Test
+) On Curie
+) test_client and test_complete
+) Mode:

  • Only one level: Correct
  • Two levels: Work if using ddt (bug)

+) Only zoom is tested but other transformations should work
+) No reading test

Location:
XIOS/dev/dev_olga
Files:
22 edited

Legend:

Unmodified
Added
Removed
  • XIOS/dev/dev_olga/bld.cfg

    r1099 r1129  
    3636#bld::target test_regular.exe 
    3737#bld::target test_new_features.exe test_unstruct_complete.exe  
    38 #bld::target test_client.exe test_complete.exe 
     38#bld::target test_client.exe  
     39bld::target test_complete.exe 
    3940bld::target test_client.exe 
    4041bld::exe_dep 
  • XIOS/dev/dev_olga/inputs/COMPLETE/iodef.xml

    r718 r1129  
    88  <context id="xios"> 
    99      <variable_definition> 
     10        <variable_group id="server"> 
     11            <variable id="using_server2" type="bool">true</variable> 
     12            <variable id="ratio_server2" type="int">50</variable> 
     13        </variable_group> 
     14 
    1015        <variable_group id="buffer"> 
    1116            <variable id="optimal_buffer_size" type="string">memory</variable> 
  • XIOS/dev/dev_olga/src/distribution.cpp

    r887 r1129  
    1818} 
    1919 
     20const CArray<size_t,1>& CDistribution:: getGlobalIndex() const  
     21{  
     22  return globalIndex_;  
     23} 
     24 
    2025CDistribution::~CDistribution() 
    2126{ /* Nothing to do */ } 
  • XIOS/dev/dev_olga/src/distribution.hpp

    r930 r1129  
    3535    int getDims() const; //! Get dimension size 
    3636    int getRank() const; //! Get rank of current process 
    37  
     37    const CArray<size_t,1>& getGlobalIndex() const; 
     38     
    3839  protected: 
    3940    virtual void createGlobalIndex() {}; 
  • XIOS/dev/dev_olga/src/distribution_client.cpp

    r1025 r1129  
    291291      nBeginLocal_.at(indexMap_[idx]+1) = 0; 
    292292      nBeginGlobal_.at(indexMap_[idx]+1) = domList[domIndex]->jbegin; 
    293       nZoomBegin_.at((indexMap_[idx]+1)) = domList[domIndex]->global_zoom_jbegin; 
    294       nZoomEnd_.at((indexMap_[idx]+1))   = domList[domIndex]->global_zoom_jbegin + domList[domIndex]->global_zoom_nj-1; 
     293      nZoomBegin_.at((indexMap_[idx]+1)) = 0; //domList[domIndex]->global_zoom_jbegin; 
     294      nZoomEnd_.at((indexMap_[idx]+1))   = domList[domIndex]->nj_glo.getValue()- 1; //domList[domIndex]->global_zoom_jbegin + domList[domIndex]->global_zoom_nj-1; 
    295295 
    296296      dataBegin_.at(indexMap_[idx]+1) = domList[domIndex]->data_jbegin.getValue(); 
     
    303303      nBeginLocal_.at(indexMap_[idx]) = 0; 
    304304      nBeginGlobal_.at(indexMap_[idx]) = domList[domIndex]->ibegin; 
    305       nZoomBegin_.at((indexMap_[idx])) = domList[domIndex]->global_zoom_ibegin; 
    306       nZoomEnd_.at((indexMap_[idx]))   = domList[domIndex]->global_zoom_ibegin + domList[domIndex]->global_zoom_ni-1; 
     305      nZoomBegin_.at((indexMap_[idx])) = 0; // domList[domIndex]->global_zoom_ibegin; 
     306      nZoomEnd_.at((indexMap_[idx]))   = domList[domIndex]->ni_glo.getValue() -1; //domList[domIndex]->global_zoom_ibegin + domList[domIndex]->global_zoom_ni-1; 
    307307 
    308308      dataBegin_.at(indexMap_[idx]) = domList[domIndex]->data_ibegin.getValue(); 
     
    325325      nBeginLocal_.at(indexMap_[idx]) = 0; 
    326326      nBeginGlobal_.at(indexMap_[idx]) = axisList[axisIndex]->begin.getValue(); 
    327       nZoomBegin_.at((indexMap_[idx])) = axisList[axisIndex]->global_zoom_begin; 
    328       nZoomEnd_.at((indexMap_[idx])) = axisList[axisIndex]->global_zoom_begin + axisList[axisIndex]->global_zoom_n-1; 
     327      nZoomBegin_.at((indexMap_[idx])) = 0; //axisList[axisIndex]->global_zoom_begin; 
     328      nZoomEnd_.at((indexMap_[idx])) = axisList[axisIndex]->n_glo.getValue() - 1; //axisList[axisIndex]->global_zoom_begin + axisList[axisIndex]->global_zoom_n-1; 
    329329 
    330330      dataBegin_.at(indexMap_[idx]) = axisList[axisIndex]->data_begin.getValue(); 
     
    587587  localDataIndex_.resize(indexLocalDataOnClientCount); 
    588588  localMaskIndex_.resize(indexSend2ServerCount); 
     589  globalDataIndex_.rehash(std::ceil(indexLocalDataOnClientCount/globalDataIndex_.max_load_factor())); //globalLocalDataSendToServerMap_.reserve(indexSend2ServerCount); 
    589590  globalLocalDataSendToServerMap_.rehash(std::ceil(indexSend2ServerCount/globalLocalDataSendToServerMap_.max_load_factor())); //globalLocalDataSendToServerMap_.reserve(indexSend2ServerCount); 
    590591 
     
    652653          if (gridMask_(gridMaskIndex)) 
    653654          { 
     655            size_t globalIndex = 0; 
     656            for (int k = 0; k < numElement_; ++k) 
     657            { 
     658              globalIndex += (currentGlobalIndex[k])*elementNGlobal_[k]; 
     659            } 
     660            globalDataIndex_[globalIndex] = indexLocalDataOnClientCount; 
    654661            localDataIndex_[indexLocalDataOnClientCount] = countLocalData; 
    655662            bool isIndexOnServer = true; 
     
    661668            if (isIndexOnServer) 
    662669            { 
    663               size_t globalIndex = 0; 
    664               for (int k = 0; k < numElement_; ++k) 
    665               { 
    666                 globalIndex += (currentGlobalIndex[k])*elementNGlobal_[k]; 
    667               } 
    668670              globalLocalDataSendToServerMap_[globalIndex] = indexLocalDataOnClientCount; 
    669671              localMaskIndex_[indexSend2ServerCount] = gridMaskIndex; 
     
    736738} 
    737739 
     740CDistributionClient::GlobalLocalDataMap& CDistributionClient::getGlobalDataIndexOnClient() 
     741{ 
     742  if (!isComputed_) createGlobalIndexSendToServer(); 
     743  return globalDataIndex_; 
     744} 
     745 
    738746/*! 
    739747  Return local data index of client 
  • XIOS/dev/dev_olga/src/distribution_client.hpp

    r1025 r1129  
    4545    virtual const std::vector<int>& getLocalDataIndexOnClient(); 
    4646    GlobalLocalDataMap& getGlobalLocalDataSendToServer(); 
     47    GlobalLocalDataMap& getGlobalDataIndexOnClient(); 
    4748    const std::vector<int>& getLocalMaskIndexOnClient(); 
    4849 
     
    8081    //!< LocalData index on client 
    8182    GlobalLocalDataMap globalLocalDataSendToServerMap_; 
     83    GlobalLocalDataMap globalDataIndex_; 
    8284    std::vector<int> localDataIndex_; 
    8385    std::vector<int> localMaskIndex_; 
  • XIOS/dev/dev_olga/src/distribution_server.cpp

    r1099 r1129  
    3737} 
    3838 
    39 CDistributionServer::CDistributionServer(int rank,  
    40                                          const std::vector<CArray<int,1> >& globalIndexEachDimension, 
    41                                          const std::vector<int>& nGlobal) 
    42   : CDistribution(rank, nGlobal.size()), nGlobal_(nGlobal), nZoomBeginGlobal_(), 
    43     nZoomSize_(), nZoomBegin_(), globalLocalIndexMap_(),  
    44     globalIndexEachDimension_(globalIndexEachDimension) 
    45 { 
    46   createGlobalIndexFromIndex(globalIndexEachDimension, nGlobal); 
    47 } 
     39// CDistributionServer::CDistributionServer(int rank,  
     40//                                          const std::vector<CArray<int,1> >& globalIndexEachDimension, 
     41//                                          const std::vector<int>& nGlobal) 
     42//   : CDistribution(rank, nGlobal.size()), nGlobal_(nGlobal), nZoomBeginGlobal_(), 
     43//     nZoomSize_(), nZoomBegin_(), globalLocalIndexMap_(),  
     44//     globalIndexEachDimension_(globalIndexEachDimension) 
     45// { 
     46//   createGlobalIndexFromIndex(globalIndexEachDimension, nGlobal); 
     47// } 
    4848 
    4949CDistributionServer::~CDistributionServer() 
     
    101101} 
    102102 
    103 void CDistributionServer::createGlobalIndexFromIndex(const std::vector<CArray<int,1> >& globalIndexOnEachDimension, 
    104                                                      const std::vector<int>& nbGlobal) 
    105 { 
    106   size_t idx = 0, ssize = 1; 
    107   for (int i = 0; i < globalIndexOnEachDimension.size(); ++i) ssize *= globalIndexOnEachDimension[i].numElements(); 
    108  
    109   this->globalIndex_.resize(ssize); 
    110   size_t nbDim = nbGlobal.size(); 
    111   std::vector<int> idxLoop(nbDim,0); 
    112   std::vector<int> currentIndex(nbDim); 
    113   int innerLoopSize = globalIndexOnEachDimension[0].numElements(); 
    114  
    115   globalLocalIndexMap_.rehash(std::ceil(ssize/globalLocalIndexMap_.max_load_factor())); 
    116   while (idx<ssize) 
    117   { 
    118     for (int i = 0; i < nbDim-1; ++i) 
    119     { 
    120       if (idxLoop[i] == globalIndexOnEachDimension[i].numElements()) 
    121       { 
    122         idxLoop[i] = 0; 
    123         ++idxLoop[i+1]; 
    124       } 
    125     } 
    126  
    127     for (int i = 1; i < nbDim; ++i) 
    128       currentIndex[i] = globalIndexOnEachDimension[i](idxLoop[i]); 
    129  
    130     size_t mulDim, globalIndex; 
    131     for (int i = 0; i < innerLoopSize; ++i) 
    132     { 
    133       mulDim = 1; 
    134       globalIndex = globalIndexOnEachDimension[0](i); 
    135  
    136       for (int k = 0; k < nbDim; ++k) 
    137       { 
    138         mulDim *= nbGlobal[k]; 
    139         globalIndex += (currentIndex[k])*mulDim; 
    140       } 
    141       globalLocalIndexMap_[globalIndex] = idx; 
    142       this->globalIndex_(idx) = globalIndex; 
    143  
    144       ++idx; 
    145     } 
    146     idxLoop[0] += innerLoopSize; 
    147   } 
    148  
    149 } 
     103// void CDistributionServer::createGlobalIndexFromIndex(const std::vector<CArray<int,1> >& globalIndexOnEachDimension, 
     104//                                                      const std::vector<int>& nbGlobal) 
     105// { 
     106//   size_t idx = 0, ssize = 1; 
     107//   for (int i = 0; i < globalIndexOnEachDimension.size(); ++i) ssize *= globalIndexOnEachDimension[i].numElements(); 
     108 
     109//   this->globalIndex_.resize(ssize); 
     110//   size_t nbDim = nbGlobal.size(); 
     111//   std::vector<int> idxLoop(nbDim,0); 
     112//   std::vector<int> currentIndex(nbDim); 
     113//   int innerLoopSize = globalIndexOnEachDimension[0].numElements(); 
     114 
     115//   globalLocalIndexMap_.rehash(std::ceil(ssize/globalLocalIndexMap_.max_load_factor())); 
     116//   while (idx<ssize) 
     117//   { 
     118//     for (int i = 0; i < nbDim-1; ++i) 
     119//     { 
     120//       if (idxLoop[i] == globalIndexOnEachDimension[i].numElements()) 
     121//       { 
     122//         idxLoop[i] = 0; 
     123//         ++idxLoop[i+1]; 
     124//       } 
     125//     } 
     126 
     127//     for (int i = 1; i < nbDim; ++i) 
     128//       currentIndex[i] = globalIndexOnEachDimension[i](idxLoop[i]); 
     129 
     130//     size_t mulDim, globalIndex; 
     131//     for (int i = 0; i < innerLoopSize; ++i) 
     132//     { 
     133//       mulDim = 1; 
     134//       globalIndex = globalIndexOnEachDimension[0](i); 
     135 
     136//       for (int k = 0; k < nbDim; ++k) 
     137//       { 
     138//         mulDim *= nbGlobal[k]; 
     139//         globalIndex += (currentIndex[k])*mulDim; 
     140//       } 
     141//       globalLocalIndexMap_[globalIndex] = idx; 
     142//       this->globalIndex_(idx) = globalIndex; 
     143 
     144//       ++idx; 
     145//     } 
     146//     idxLoop[0] += innerLoopSize; 
     147//   } 
     148 
     149// } 
    150150 
    151151/*! 
     
    156156CArray<size_t,1> CDistributionServer::computeLocalIndex(const CArray<size_t,1>& globalIndex) 
    157157{ 
    158   int ssize = globalIndex.numElements(); 
    159   CArray<size_t,1> localIndex(ssize); 
     158  size_t ssize = globalIndex.numElements(); 
     159  size_t localIndexSize = std::min(globalIndex_.numElements(), ssize); 
     160  CArray<size_t,1> localIndex(localIndexSize); 
    160161  GlobalLocalMap::const_iterator ite = globalLocalIndexMap_.end(), it; 
    161   for (int idx = 0; idx < ssize; ++idx) 
     162  for (int idx = 0, i = 0; idx < ssize; ++idx) 
    162163  { 
    163164    it = globalLocalIndexMap_.find(globalIndex(idx)); 
    164165    if (ite != it) 
     166    { 
    165167      localIndex(idx) = it->second; 
     168      ++i; 
     169    } 
    166170  } 
    167171 
  • XIOS/dev/dev_olga/src/io/nc4_data_output.cpp

    r1099 r1129  
    5050      void CNc4DataOutput::writeDomain_(CDomain* domain) 
    5151      { 
     52        domain->computeWrittenIndex(); 
    5253        if (domain->type == CDomain::type_attr::unstructured) 
    5354        { 
     
    5960        } 
    6061 
     62         
    6163         CContext* context = CContext::getCurrent() ; 
    6264         CContextServer* server=context->server ; 
     
    107109                             : latid; 
    108110*/ 
     111 
     112         CArray<size_t, 1>& indexToWrite = domain->localIndexToWriteOnServer; 
     113         int nbWritten = indexToWrite.numElements(); 
     114         CArray<double,1> writtenLat, writtenLon; 
     115         CArray<double,2> writtenBndsLat, writtenBndsLon; 
     116         CArray<double,1> writtenArea; 
     117 
     118         if (domain->hasLonLat) 
     119         { 
     120           writtenLat.resize(nbWritten); 
     121           writtenLon.resize(nbWritten); 
     122           for (int idx = 0; idx < nbWritten; ++idx) 
     123           { 
     124              writtenLat(idx) = domain->latvalue(indexToWrite(idx)); 
     125              writtenLon(idx) = domain->lonvalue(indexToWrite(idx)); 
     126           } 
     127          
     128 
     129           if (domain->hasBounds) 
     130           {          
     131             int nvertex = domain->nvertex, idx; 
     132             writtenBndsLat.resize(nvertex, nbWritten); 
     133             writtenBndsLon.resize(nvertex, nbWritten); 
     134             CArray<double,2>& boundslat = domain->bounds_latvalue; 
     135             CArray<double,2>& boundslon = domain->bounds_lonvalue;    
     136             for (idx = 0; idx < nbWritten; ++idx) 
     137               for (int nv = 0; nv < nvertex; ++nv) 
     138               { 
     139                 writtenBndsLat(nv, idx) = boundslat(nv, int(indexToWrite(idx))); 
     140                 writtenBndsLon(nv, idx) = boundslon(nv, int(indexToWrite(idx))); 
     141               } 
     142           } 
     143         } 
     144 
     145         if (domain->hasArea) 
     146         { 
     147           writtenArea.resize(nbWritten);            
     148           for (int idx = 0; idx < nbWritten; ++idx) 
     149           { 
     150              writtenArea(idx) = domain->areavalue(indexToWrite(idx));                       
     151           } 
     152         } 
    109153 
    110154         try 
     
    225269                 if (domain->hasLonLat) 
    226270                 { 
     271                   // CArray<size_t, 1>& indexToWrite = domain->localIndexToWriteOnServer; 
     272                   // int nbWritten = indexToWrite.numElements(); 
     273                   // CArray<double,1> writtenLat(nbWritten), writtenLon(nbWritten); 
     274                   // for (int idx = 0; idx < nbWritten; ++idx) 
     275                   // { 
     276                   //    writtenLat(idx) = domain->latvalue(indexToWrite(idx)); 
     277                   //    writtenLon(idx) = domain->lonvalue(indexToWrite(idx)); 
     278                   // } 
    227279                   switch (domain->type) 
    228280                   { 
    229                      case CDomain::type_attr::curvilinear : 
    230                        SuperClassWriter::writeData(domain->latvalue, latid, isCollective, 0); 
    231                        SuperClassWriter::writeData(domain->lonvalue, lonid, isCollective, 0); 
     281                     case CDomain::type_attr::curvilinear :                        
     282                         
     283                       // SuperClassWriter::writeData(domain->latvalue, latid, isCollective, 0); 
     284                       // SuperClassWriter::writeData(domain->lonvalue, lonid, isCollective, 0); 
     285                       SuperClassWriter::writeData(writtenLat, latid, isCollective, 0); 
     286                       SuperClassWriter::writeData(writtenLon, lonid, isCollective, 0); 
    232287                       break; 
    233288                     case CDomain::type_attr::rectilinear : 
    234                        CArray<double,1> lat = domain->latvalue(Range(fromStart,toEnd,domain->zoom_ni)) ; 
     289//                        CArray<double,1> lat = domain->latvalue(Range(fromStart,toEnd,domain->zoom_ni)) ; 
     290//                        SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0); 
     291//                        CArray<double,1> lon = domain->lonvalue(Range(0,domain->zoom_ni-1)) ; 
     292// //                       CArray<double,1> lon = domain->lonvalue(Range(0,local_size_write[1]-1)) ; 
     293//                        SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0); 
     294 
     295                       CArray<double,1> lat = writtenLat(Range(fromStart,toEnd,domain->zoom_ni)) ; 
    235296                       SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0); 
    236                        CArray<double,1> lon = domain->lonvalue(Range(0,domain->zoom_ni-1)) ; 
     297                       CArray<double,1> lon = writtenLon(Range(0,domain->zoom_ni-1)) ; 
    237298//                       CArray<double,1> lon = domain->lonvalue(Range(0,local_size_write[1]-1)) ; 
    238299                       SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0); 
     
    242303                   if (domain->hasBounds) 
    243304                   { 
    244                      SuperClassWriter::writeData(domain->bounds_lonvalue, bounds_lonid, isCollective, 0); 
    245                      SuperClassWriter::writeData(domain->bounds_latvalue, bounds_latid, isCollective, 0); 
     305                     // CArray<double,2> writtenBndsLat(nbWritten,2), writtenBndsLon(nbWritten,2); 
     306                     // for (int idx = 0; idx < nbWritten; ++idx) 
     307                     //   for (int nv = 0; nv < domain->nvertex; ++nv) 
     308                     //   { 
     309                     //     writtenBndsLat(idx) = domain->bounds_latvalue(nv, indexToWrite(idx)); 
     310                     //     writtenBndsLon(idx) = domain->bounds_lonvalue(nv, indexToWrite(idx)); 
     311                     //   } 
     312 
     313                     // SuperClassWriter::writeData(domain->bounds_lonvalue, bounds_lonid, isCollective, 0); 
     314                     // SuperClassWriter::writeData(domain->bounds_latvalue, bounds_latid, isCollective, 0); 
     315                     SuperClassWriter::writeData(writtenBndsLon, bounds_lonid, isCollective, 0); 
     316                     SuperClassWriter::writeData(writtenBndsLat, bounds_latid, isCollective, 0); 
    246317                   } 
    247318                 } 
    248319 
    249320                 if (domain->hasArea) 
    250                    SuperClassWriter::writeData(domain->areavalue, areaId, isCollective, 0); 
     321                 { 
     322                   // CArray<size_t, 1>& indexToWrite = domain->localIndexToWriteOnServer; 
     323                   // int nbWritten = indexToWrite.numElements(); 
     324                   // CArray<double,1> writtenArea(nbWritten); 
     325                   // for (int idx = 0; idx < nbWritten; ++idx) 
     326                   // { 
     327                   //    writtenArea(idx) = domain->areavalue(indexToWrite(idx));                       
     328                   // } 
     329 
     330                   SuperClassWriter::writeData(writtenArea, areaId, isCollective, 0); 
     331                   // SuperClassWriter::writeData(domain->areavalue, areaId, isCollective, 0); 
     332                 } 
    251333 
    252334                 SuperClassWriter::definition_start(); 
     
    334416                       start[0]=domain->zoom_jbegin-domain->global_zoom_jbegin; 
    335417                       count[1]=domain->zoom_ni ; count[0]=domain->zoom_nj ; 
    336                        // start[1]= start_write[0]; 
    337                        // start[0]= start_write[1]; 
    338                        // count[1]= count_write[0]; 
    339                        // count[0]= count_write[1]; 
    340418                     } 
    341419 
    342420                     if (domain->hasLonLat) 
    343421                     { 
    344                        SuperClassWriter::writeData(domain->latvalue, latid, isCollective, 0,&start,&count); 
    345                        SuperClassWriter::writeData(domain->lonvalue, lonid, isCollective, 0,&start,&count); 
     422                       // SuperClassWriter::writeData(domain->latvalue, latid, isCollective, 0,&start,&count); 
     423                       // SuperClassWriter::writeData(domain->lonvalue, lonid, isCollective, 0,&start,&count); 
     424                       SuperClassWriter::writeData(writtenLat, latid, isCollective, 0,&start,&count); 
     425                       SuperClassWriter::writeData(writtenLon, lonid, isCollective, 0,&start,&count); 
    346426                     } 
    347427                     break; 
     
    357437                         start[0]=0 ; 
    358438                         count[0]=0 ; 
    359                          SuperClassWriter::writeData(domain->latvalue, latid, isCollective, 0,&start,&count); 
    360                          SuperClassWriter::writeData(domain->lonvalue, lonid, isCollective, 0,&start,&count); 
    361  
     439                         // SuperClassWriter::writeData(domain->latvalue, latid, isCollective, 0,&start,&count); 
     440                         // SuperClassWriter::writeData(domain->lonvalue, lonid, isCollective, 0,&start,&count); 
     441 
     442                         SuperClassWriter::writeData(writtenLat, latid, isCollective, 0,&start,&count); 
     443                         SuperClassWriter::writeData(writtenLon, lonid, isCollective, 0,&start,&count); 
    362444                       } 
    363445                       else 
    364                        { 
    365                          // start[0]= start_write[1]; 
    366                          // count[0]= count_write[1]; 
     446                       {  
    367447                         start[0]=domain->zoom_jbegin-domain->global_zoom_jbegin; 
    368448                         count[0]=domain->zoom_nj; 
    369                          CArray<double,1> lat = domain->latvalue(Range(fromStart,toEnd,domain->zoom_ni)) ; 
     449                         // CArray<double,1> lat = domain->latvalue(Range(fromStart,toEnd,domain->zoom_ni)); 
     450                         CArray<double,1> lat = writtenLat(Range(fromStart,toEnd,domain->zoom_ni)); 
    370451                         SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0,&start,&count); 
    371452 
    372                          // start[0]= start_write[0]; 
    373                          // count[0]= count_write[0]; 
    374453                         start[0]=domain->zoom_ibegin-domain->global_zoom_ibegin; 
    375454                         count[0]=domain->zoom_ni; 
    376                          CArray<double,1> lon=domain->lonvalue(Range(0,domain->zoom_ni-1)) ; 
     455                         // CArray<double,1> lon=domain->lonvalue(Range(0,domain->zoom_ni-1)); 
     456                         CArray<double,1> lon = writtenLon(Range(0,domain->zoom_ni-1)); 
    377457                         SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0,&start,&count); 
    378458                       } 
     
    401481                   } 
    402482 
    403                  SuperClassWriter::writeData(domain->bounds_lonvalue, bounds_lonid, isCollective, 0, &start, &count); 
    404                  SuperClassWriter::writeData(domain->bounds_latvalue, bounds_latid, isCollective, 0, &start, &count); 
     483                 // SuperClassWriter::writeData(domain->bounds_lonvalue, bounds_lonid, isCollective, 0, &start, &count); 
     484                 // SuperClassWriter::writeData(domain->bounds_latvalue, bounds_latid, isCollective, 0, &start, &count); 
     485                   SuperClassWriter::writeData(writtenBndsLon, bounds_lonid, isCollective, 0, &start, &count); 
     486                   SuperClassWriter::writeData(writtenBndsLat, bounds_latid, isCollective, 0, &start, &count); 
    405487                 } 
    406488 
     
    421503                     count[1] = domain->zoom_ni; 
    422504                     count[0] = domain->zoom_nj; 
    423  
    424                      // start[1]= start_write[0]; 
    425                      // start[0]= start_write[1]; 
    426                      // count[1]= count_write[0]; 
    427                      // count[0]= count_write[1]; 
    428505                   } 
    429506 
    430                    SuperClassWriter::writeData(domain->areavalue, areaId, isCollective, 0, &start, &count); 
     507                   // SuperClassWriter::writeData(domain->areavalue, areaId, isCollective, 0, &start, &count); 
     508                   SuperClassWriter::writeData(writtenArea, areaId, isCollective, 0, &start, &count); 
    431509                 } 
    432510 
     
    10561134        axis->checkAttributes(); 
    10571135 
    1058         // int local_size_write  = axis->getLocalWriteSize(); 
    1059         // int global_size_write = axis->getGlobalWriteSize(); 
    1060         // int start_write = axis->getStartWriteIndex(); 
    1061         // int count_write = axis->getCountWriteIndex(); 
    1062  
    1063  
    1064         // if ((0 == local_size_write) && (MULTI_FILE == SuperClass::type)) return; 
    1065  
     1136        axis->computeWrittenIndex(); 
     1137        
    10661138        int zoom_size  = (MULTI_FILE == SuperClass::type) ? axis->zoom_n 
    10671139                                                          : axis->global_zoom_n; 
     
    11141186            SuperClassWriter::definition_end(); 
    11151187 
     1188            CArray<size_t, 1>& indexToWrite = axis->localIndexToWriteOnServer; 
     1189            int nbWritten = indexToWrite.numElements(); 
     1190            CArray<double,1> axis_value(indexToWrite.numElements()); 
     1191            for (int i = 0; i < nbWritten; i++) axis_value(i) = axis->value(indexToWrite(i)); 
     1192            CArray<double,2> axis_bounds; 
     1193 
    11161194            switch (SuperClass::type) 
    11171195            { 
    11181196              case MULTI_FILE: 
    11191197              { 
    1120                 CArray<double,1> axis_value(axis->zoom_n); 
    1121                 for (int i = 0; i < axis->zoom_n; i++) axis_value(i) = axis->value(i); 
     1198                // CArray<double,1> axis_value(axis->zoom_n); 
     1199                // for (int i = 0; i < axis->zoom_n; i++) axis_value(i) = axis->value(i); 
    11221200                SuperClassWriter::writeData(axis_value, axisid, isCollective, 0); 
    11231201 
     
    11311209              case ONE_FILE: 
    11321210              { 
    1133                 CArray<double,1> axis_value(axis->zoom_n); 
    1134                 axis_value = axis->value; 
     1211                // CArray<double,1> axis_value(axis->zoom_n); 
     1212                // axis_value = axis->value; 
    11351213                std::vector<StdSize> start(1), startBounds(2) ; 
    11361214                std::vector<StdSize> count(1), countBounds(2) ; 
     
    11421220 
    11431221                if (!axis->bounds.isEmpty()) 
     1222                { 
     1223                  axis_bounds.resize(2, indexToWrite.numElements()); 
     1224                  for (int i = 0; i < nbWritten; ++i) 
     1225                  { 
     1226                    axis_bounds(0, i) = axis->bounds(0, int(indexToWrite(i))); 
     1227                    axis_bounds(1, i) = axis->bounds(1, int(indexToWrite(i))); 
     1228                  } 
    11441229                  SuperClassWriter::writeData(axis->bounds, axisBoundsId, isCollective, 0, &startBounds, &countBounds); 
     1230                } 
    11451231 
    11461232                SuperClassWriter::definition_start(); 
     
    23712457           msg.append(context->getId()); msg.append("\n"); 
    23722458           msg.append(e.what()); 
    2373            ERROR("CNc4DataOutput::writeFieldData_ (CField*  field)", << msg); 
     2459               ERROR("CNc4DataOutput::writeFieldData_ (CField*  field)", << msg); 
    23742460         } 
    23752461      } 
  • XIOS/dev/dev_olga/src/node/axis.cpp

    r1099 r1129  
    2828      , numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0) 
    2929      , transformationMap_(), hasValue(false), doZoomByIndex_(false) 
     30      , computedWrittenIndex_(false) 
    3031   { 
    3132   } 
     
    3839      , numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0) 
    3940      , transformationMap_(), hasValue(false), doZoomByIndex_(false) 
     41      , computedWrittenIndex_(false) 
    4042   { 
    4143   } 
     
    129131   { 
    130132     return offsetWrittenIndexes_; 
    131    } 
    132  
    133    /*! 
    134      Returns the start of indexes written by each server. 
    135      \return the start of indexes written by each server 
    136    */ 
    137    int CAxis::getStartWriteIndex() const 
    138    { 
    139      return start_write_index_; 
    140    } 
    141  
    142    /*! 
    143      Returns the count of indexes written by each server. 
    144      \return the count of indexes written by each server 
    145    */ 
    146    int CAxis::getCountWriteIndex() const 
    147    { 
    148      return count_write_index_; 
    149    } 
    150  
    151    /*! 
    152      Returns the local data written by each server.      
    153    */ 
    154    int CAxis::getLocalWriteSize() const 
    155    { 
    156      return local_write_size_; 
    157    } 
    158  
    159    /*! 
    160      Returns the global data written by all server.      
    161    */ 
    162    int CAxis::getGlobalWriteSize() const 
    163    { 
    164      return global_write_size_; 
    165133   } 
    166134 
     
    454422     else 
    455423     { 
    456        sendDistributedAttributes(); 
    457        sendDistributionAttribute(globalDim, orderPositionInGrid, distType); 
     424       sendDistributedAttributes();        
    458425     } 
     426     sendDistributionAttribute(globalDim, orderPositionInGrid, distType); 
    459427  } 
    460428 
     
    639607    } 
    640608  } 
     609 
     610   void CAxis::computeWrittenIndex() 
     611   {   
     612      if (computedWrittenIndex_) return; 
     613      computedWrittenIndex_ = true; 
     614 
     615      CContext* context=CContext::getCurrent() ; 
     616      CContextClient* client = context->client;  
     617 
     618      std::vector<int> nBegin(1), nSize(1), nBeginGlobal(1), nGlob(1); 
     619      nBegin[0]       = zoom_begin; 
     620      nSize[0]        = zoom_n;    
     621      nBeginGlobal[0] = 0;  
     622      nGlob[0]        = n_glo; 
     623      CDistributionServer srvDist(client->clientSize, nBegin, nSize, nBeginGlobal, nGlob);  
     624      const CArray<size_t,1>& writtenGlobalIndex  = srvDist.getGlobalIndex(); 
     625 
     626      size_t nbWritten = 0, indGlo;       
     627      boost::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(), 
     628                                                          ite = globalLocalIndexMap_.end(), it;           
     629      CArray<size_t,1>::const_iterator itSrvb = writtenGlobalIndex.begin(), 
     630                                       itSrve = writtenGlobalIndex.end(), itSrv; 
     631      localIndexToWriteOnServer.resize(writtenGlobalIndex.numElements()); 
     632      for (itSrv = itSrvb; itSrv != itSrve; ++itSrv) 
     633      { 
     634        indGlo = *itSrv; 
     635        if (ite != globalLocalIndexMap_.find(indGlo)) 
     636        { 
     637          localIndexToWriteOnServer(nbWritten) = globalLocalIndexMap_[indGlo]; 
     638          ++nbWritten; 
     639        }                  
     640      } 
     641 
     642   } 
     643 
    641644 
    642645 
     
    875878          CMessage& msg = msgs.back(); 
    876879          msg << this->getId(); 
    877           msg << index.getValue() << dataIndex << zoom_index.getValue() << mask.getValue(); 
     880          msg << index.getValue() << dataIndex << mask.getValue(); 
     881 
     882          msg << doZoomByIndex_; 
     883          if (doZoomByIndex_) msg << zoom_index.getValue(); 
    878884          msg << hasValue; 
    879885          if (hasValue) msg << value.getValue(); 
    880  
    881886          msg << hasBounds_; 
    882887          if (hasBounds_) msg << bounds.getValue(); 
     
    913918    buffer >> tmp_data_index; 
    914919    data_index.reference(tmp_data_index); 
    915     buffer >> tmp_zoom_index; 
    916     zoom_index.reference(tmp_zoom_index); 
    917920    buffer >> tmp_mask; 
    918921    mask.reference(tmp_mask); 
     922 
     923    buffer >> doZoomByIndex_; 
     924    if (doZoomByIndex_) 
     925    { 
     926      buffer >> tmp_zoom_index; 
     927      zoom_index.reference(tmp_zoom_index); 
     928    } 
     929 
    919930    buffer >> hasValue; 
    920931    if (hasValue) 
     
    931942    } 
    932943 
    933     {       
    934       count_write_index_ = zoom_index.numElements();             
    935       start_write_index_ = 0; 
    936       local_write_size_ = count_write_index_; 
    937       global_write_size_ = count_write_index_; 
    938     } 
     944    data_begin.setValue(0); 
     945    globalLocalIndexMap_.rehash(std::ceil(index.numElements()/globalLocalIndexMap_.max_load_factor())); 
     946    for (int idx = 0; idx < index.numElements(); ++idx) globalLocalIndexMap_[idx] = index(idx); 
    939947  } 
    940948 
     
    10651073    get(axisId)->recvDistributedAttributes(ranks, buffers); 
    10661074  } 
     1075 
    10671076 
    10681077  void CAxis::recvDistributedAttributes(vector<int>& ranks, vector<CBufferIn*> buffers) 
     
    10991108      nbData += vec_indi[idx].numElements(); 
    11001109    } 
    1101      
     1110 
    11021111    index.resize(nbData); 
     1112    globalLocalIndexMap_.rehash(std::ceil(index.numElements()/globalLocalIndexMap_.max_load_factor())); 
    11031113    CArray<int,1> nonCompressedData(nbData);     
    11041114    mask.resize(nbData); 
     
    11181128      { 
    11191129        index(nbData) = indi(n); 
     1130        globalLocalIndexMap_[indi(n)] = nbData; 
    11201131        nonCompressedData(nbData) = (0 <= dataIndi(n)) ? nbData : -1; 
    11211132        mask(nbData) = maskIndi(n); 
     
    11491160      } 
    11501161    } 
     1162    data_begin.setValue(0); 
    11511163 
    11521164    if (doZoomByIndex_) 
     
    11701182      } 
    11711183    } 
    1172  
    1173  
    1174     // { 
    1175     //   CContextServer* server = CContext::getCurrent()->server; 
    1176     //   count_write_index_ = zoom_index.numElements();       
    1177     //   MPI_Scan(&count_write_index_, &start_write_index_, 1, MPI_INT, MPI_SUM, server->intraComm); 
    1178     //   global_write_size_ = start_write_index_; 
    1179     //   start_write_index_ -= count_write_index_; 
    1180     //   local_write_size_ = count_write_index_;       
    1181     // } 
    11821184  } 
    11831185 
  • XIOS/dev/dev_olga/src/node/axis.hpp

    r1099 r1129  
    7878         int getOffsetWrittenIndexes() const; 
    7979 
    80          int getStartWriteIndex() const; 
    81          int getCountWriteIndex() const; 
    82          int getLocalWriteSize() const; 
    83          int getGlobalWriteSize() const; 
    84  
    8580         std::map<int, StdSize> getAttributesBufferSize(); 
    8681 
     
    119114         void checkEligibilityForCompressedOutput(); 
    120115 
     116         void computeWrittenIndex(); 
    121117         bool hasTransformation(); 
    122118         void solveInheritanceTransformation(); 
     
    134130        CArray<int,1> globalDimGrid; 
    135131        int orderPosInGrid; 
     132        CArray<size_t,1> localIndexToWriteOnServer; 
    136133 
    137134      private: 
     
    176173         bool hasBounds_; 
    177174 
    178          int start_write_index_; 
    179          int count_write_index_; 
    180          int local_write_size_; 
    181          int global_write_size_; 
    182  
    183175         bool doZoomByIndex_; 
     176         bool computedWrittenIndex_; 
    184177 
    185178       private: 
  • XIOS/dev/dev_olga/src/node/context.cpp

    r1099 r1129  
    572572    postProcessingGlobalAttributes(); 
    573573 
    574     if (hasClient) sendPostProcessingGlobalAttributes(); 
    575  
    576     // There are some processings that should be done after all of above. For example: check mask or index 
     574    if (hasClient) sendPostProcessingGlobalAttributes();    
     575     
    577576    this->buildFilterGraphOfEnabledFields(); 
    578577     
    579      if (hasClient && !hasServer) 
     578    if (hasClient && !hasServer) 
    580579    { 
    581       buildFilterGraphOfFieldsWithReadAccess(); 
     580      buildFilterGraphOfFieldsWithReadAccess();       
    582581    } 
    583582 
     
    623622     { 
    624623       this->enabledFiles[i]->solveOnlyRefOfEnabledFields(false); 
     624       // this->enabledFiles[i]->solveAllReferenceEnabledField(false); 
    625625     } 
    626626 
     
    663663       this->enabledFiles[i]->generateNewTransformationGridDest(); 
    664664     } 
    665  
    666      for (int i = 0; i < size; ++i) 
    667      { 
    668        //this->enabledFiles[i]->checkGridOfEnabledFields(); 
    669      } 
    670    } 
    671  
    672    void CContext::solveAllRefOfEnabledFields(bool sendToServer) 
     665   } 
     666 
     667   void CContext::solveAllRefOfEnabledFieldsAndTransform(bool sendToServer) 
    673668   { 
    674669     int size = this->enabledFiles.size(); 
    675670     for (int i = 0; i < size; ++i) 
    676671     { 
    677        this->enabledFiles[i]->solveAllRefOfEnabledFields(sendToServer); 
     672       this->enabledFiles[i]->solveAllRefOfEnabledFieldsAndTransform(sendToServer); 
    678673     } 
    679674   } 
     
    11681163 
    11691164      // Search and rebuild all reference object of enabled fields, and transform 
    1170       this->solveAllEnabledFields(); 
    1171  
     1165      // this->solveAllEnabledFields 
     1166      this->solveAllRefOfEnabledFieldsAndTransform(false); 
    11721167      // // Check grid and calculate its distribution 
    11731168      // if (hasClient) checkGridEnabledFields(); 
  • XIOS/dev/dev_olga/src/node/context.hpp

    r1099 r1129  
    114114         void checkAxisDomainsGridsEligibilityForCompressedOutput(); 
    115115         void prepareTimeseries(void); 
    116          void solveOnlyRefOfEnabledFields(bool sendToServer); 
    117          void solveAllRefOfEnabledFields(bool sendToServer); 
     116         void solveOnlyRefOfEnabledFields(bool sendToServer);          
    118117         void buildFilterGraphOfEnabledFields(); 
    119118         void startPrefetchingOfEnabledReadModeFiles(); 
     
    125124         void postProcessingGlobalAttributes();          
    126125 
     126         void solveAllRefOfEnabledFieldsAndTransform(bool sendToServer); 
    127127         void solveAllEnabledFields(); 
    128128         void checkGridEnabledFields(); 
  • XIOS/dev/dev_olga/src/node/domain.cpp

    r1099 r1129  
    2626namespace xios { 
    2727 
    28    /// ////////////////////// Définitions ////////////////////// /// 
     28   /// ////////////////////// Dfinitions ////////////////////// /// 
    2929 
    3030   CDomain::CDomain(void) 
    3131      : CObjectTemplate<CDomain>(), CDomainAttributes() 
    32       , isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_() 
     32      , isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_(), connectedServerZoomRank_() 
    3333      , hasBounds(false), hasArea(false), isDistributed_(false), isCompressible_(false), isUnstructed_(false) 
    3434      , isClientAfterTransformationChecked(false), hasLonLat(false) 
    3535      , isRedistributed_(false), hasPole(false), doZoomByIndex_(false) 
    3636      , lonvalue(), latvalue(), bounds_lonvalue(), bounds_latvalue() 
    37       , globalLocalIndexMap_() 
     37      , globalLocalIndexMap_(), computedWrittenIndex_(false) 
    3838   { 
    3939   } 
     
    4141   CDomain::CDomain(const StdString & id) 
    4242      : CObjectTemplate<CDomain>(id), CDomainAttributes() 
    43       , isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_() 
     43      , isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_(), connectedServerZoomRank_() 
    4444      , hasBounds(false), hasArea(false), isDistributed_(false), isCompressible_(false), isUnstructed_(false) 
    4545      , isClientAfterTransformationChecked(false), hasLonLat(false) 
    4646      , isRedistributed_(false), hasPole(false), doZoomByIndex_(false) 
    4747      , lonvalue(), latvalue(), bounds_lonvalue(), bounds_latvalue() 
    48       , globalLocalIndexMap_() 
     48      , globalLocalIndexMap_(), computedWrittenIndex_(false) 
    4949   { 
    5050         } 
     
    10821082   //---------------------------------------------------------------- 
    10831083 
     1084   /* 
     1085     Fill in longitude and latitude value from clients (or models) into internal values lonvalue, latvalue which 
     1086     will be used by XIOS. 
     1087   */ 
    10841088   void CDomain::completeLonLatClient(void) 
    10851089   { 
     
    11811185   } 
    11821186 
     1187   /* 
     1188     Convert internal longitude latitude value used by XIOS to "lonvalue_*" which can be retrieved with Fortran interface 
     1189   */ 
     1190   void CDomain::convertLonLatValue(void) 
     1191   { 
     1192     bool lonlatValueExisted = (0 != lonvalue.numElements()) || (0 != latvalue.numElements()); 
     1193     if (!lonvalue_2d.isEmpty() && lonlatValueExisted) 
     1194     { 
     1195       lonvalue_2d.resize(ni,nj); 
     1196       latvalue_2d.resize(ni,nj); 
     1197       if (hasBounds) 
     1198       { 
     1199         bounds_lon_2d.resize(nvertex, ni, nj); 
     1200         bounds_lat_2d.resize(nvertex, ni, nj); 
     1201       } 
     1202 
     1203       for (int j = 0; j < nj; ++j) 
     1204       { 
     1205         for (int i = 0; i < ni; ++i) 
     1206         { 
     1207           int k = j * ni + i; 
     1208 
     1209           lonvalue_2d(i,j) = lonvalue(k); 
     1210           latvalue_2d(i,j) = latvalue(k); 
     1211 
     1212           if (hasBounds) 
     1213           { 
     1214             for (int n = 0; n < nvertex; ++n) 
     1215             { 
     1216               bounds_lon_2d(n,i,j) = bounds_lonvalue(n,k); 
     1217               bounds_lat_2d(n,i,j) = bounds_latvalue(n,k); 
     1218             } 
     1219           } 
     1220         } 
     1221       } 
     1222     } 
     1223     else if (!lonvalue_1d.isEmpty()  && lonlatValueExisted) 
     1224     { 
     1225       if (type_attr::rectilinear == type) 
     1226       { 
     1227         if (ni == lonvalue_1d.numElements() && nj == latvalue_1d.numElements()) 
     1228         { 
     1229           lonvalue.resize(ni * nj); 
     1230           latvalue.resize(ni * nj); 
     1231           if (hasBounds) 
     1232           { 
     1233             bounds_lonvalue.resize(nvertex, ni * nj); 
     1234             bounds_latvalue.resize(nvertex, ni * nj); 
     1235           } 
     1236 
     1237           for (int j = 0; j < nj; ++j) 
     1238           { 
     1239             for (int i = 0; i < ni; ++i) 
     1240             { 
     1241               int k = j * ni + i; 
     1242 
     1243               lonvalue(k) = lonvalue_1d(i); 
     1244               latvalue(k) = latvalue_1d(j); 
     1245 
     1246               if (hasBounds) 
     1247               { 
     1248                 for (int n = 0; n < nvertex; ++n) 
     1249                 { 
     1250                   bounds_lonvalue(n,k) = bounds_lon_1d(n,i); 
     1251                   bounds_latvalue(n,k) = bounds_lat_1d(n,j); 
     1252                 } 
     1253               } 
     1254             } 
     1255           } 
     1256         } 
     1257         else if (i_index.numElements() == lonvalue_1d.numElements() && j_index.numElements() == latvalue_1d.numElements()  && !lonlatValueExisted) 
     1258         { 
     1259           lonvalue.reference(lonvalue_1d); 
     1260           latvalue.reference(latvalue_1d); 
     1261            if (hasBounds) 
     1262           { 
     1263             bounds_lonvalue.reference(bounds_lon_1d); 
     1264             bounds_latvalue.reference(bounds_lat_1d); 
     1265           } 
     1266         } 
     1267         else 
     1268           ERROR("CDomain::completeLonClient(void)", 
     1269                 << "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] " 
     1270                 << "'lonvalue_1d' and 'latvalue_1d' does not have the same size as the local domain." << std::endl 
     1271                 << "'lonvalue_1d' size is " << lonvalue_1d.numElements()  
     1272                 << " and 'latvalue_1d' size is " << latvalue_1d.numElements() << std::endl  
     1273                 << " They should be correspondingly " << ni.getValue() << " and "  << nj.getValue() << " or " << std::endl 
     1274                 << i_index.numElements() << " and "  << j_index.numElements() << "."); 
     1275       } 
     1276       else if (type == type_attr::curvilinear || type == type_attr::unstructured  && !lonlatValueExisted) 
     1277       { 
     1278         lonvalue.reference(lonvalue_1d); 
     1279         latvalue.reference(latvalue_1d); 
     1280         if (hasBounds) 
     1281         { 
     1282           bounds_lonvalue.reference(bounds_lon_1d); 
     1283           bounds_latvalue.reference(bounds_lat_1d); 
     1284         } 
     1285       } 
     1286     } 
     1287   } 
     1288 
     1289 
    11831290   void CDomain::checkBounds(void) 
    11841291   { 
     
    13951502 
    13961503      if (context->hasClient && !context->hasServer) 
    1397       { // CÃŽté client uniquement 
     1504      { // Ct client uniquement 
    13981505         this->checkMask(); 
    13991506         this->checkDomainData(); 
     
    14021509      } 
    14031510      else 
    1404       { // CÃŽté serveur uniquement 
     1511      { // Ct serveur uniquement 
    14051512      } 
    14061513 
     
    14351542 
    14361543      if (context->hasClient) 
    1437       { // CÃŽté client uniquement 
     1544      { // Ct client uniquement 
    14381545         this->checkMask(); 
    14391546         this->checkDomainData(); 
     
    14431550      } 
    14441551      else 
    1445       { // CÃŽté serveur uniquement 
     1552      { // Ct serveur uniquement 
    14461553      } 
    14471554 
     
    15491656        for (i = 0; i < nbIndex; ++i) 
    15501657          globalLocalIndexMap_[globalIndexDomain(i)] = i; 
    1551  
    15521658      } 
    15531659 
     
    15981704          zoom_nj     = zoom_jend-zoom_jbegin+1; 
    15991705      } 
     1706 
     1707      // if (globalLocalIndexZoomMap_.empty()) 
     1708      // { 
     1709      //   int nbIndexZoom = globalIndexDomainZoom.numElements(); 
     1710      //   for (i = 0; i < nbIndex; ++i) 
     1711      //     globalLocalIndexZoomMap_[globalIndexDomainZoom(i)] = i; 
     1712      // } 
    16001713 
    16011714 
     
    16901803      for (it = globalIndexDomainOnServer.begin(); it != ite; ++it) { 
    16911804        connectedServerRank_.push_back(it->first); 
    1692         // std::vector<size_t> vec = it->second; 
    1693         // std::sort(vec.begin(), vec.end()); 
    1694         // indSrv_[it->first] = vec; 
    16951805      } 
    16961806 
     
    17001810      clientServerMap->computeServerIndexMapping(globalIndexDomainZoom); 
    17011811      CClientServerMapping::GlobalIndexMap& globalIndexDomainZoomOnServer = clientServerMap->getGlobalIndexOnServer(); 
    1702 //      indZoomSrv_.swap(globalIndexDomainZoomOnServer); 
    1703       std::vector<int> connectedServerZoomRank; //(indZoomSrv_.size()); 
    1704 //      for (it = indZoomSrv_.begin(); it != indZoomSrv_.end(); ++it) 
    1705 //        connectedServerZoomRank.push_back(it->first); 
    1706       for (it = globalIndexDomainZoomOnServer.begin(); it != globalIndexDomainZoomOnServer.end(); ++it) 
    1707       { 
    1708         connectedServerZoomRank.push_back(it->first); 
    1709         std::vector<size_t> vec = it->second; 
    1710         std::sort(vec.begin(), vec.end()); 
    1711         indZoomSrv_[it->first] = vec; 
    1712       } 
    1713       nbConnectedClientsZoom_ = clientServerMap->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerZoomRank); 
     1812      indZoomSrv_.swap(globalIndexDomainZoomOnServer); 
     1813       
     1814     for (it = indZoomSrv_.begin(); it != indZoomSrv_.end(); ++it) 
     1815       connectedServerZoomRank_.push_back(it->first); 
     1816 
     1817      nbConnectedClientsZoom_ = clientServerMap->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerZoomRank_); 
    17141818 
    17151819      delete clientServerMap; 
     
    17211825    return indSrv_; 
    17221826  } 
     1827 
     1828   void CDomain::computeWrittenIndex() 
     1829   {   
     1830      if (computedWrittenIndex_) return; 
     1831      computedWrittenIndex_ = true; 
     1832 
     1833      CContext* context=CContext::getCurrent() ; 
     1834      CContextClient* client = context->client;  
     1835 
     1836      std::vector<int> nBegin(2), nSize(2), nBeginGlobal(2), nGlob(2); 
     1837      nBegin[0]       = zoom_ibegin;  nBegin[1] = zoom_jbegin; 
     1838      nSize[0]        = zoom_ni;      nSize[1]  = zoom_nj; 
     1839      nBeginGlobal[0] = 0; nBeginGlobal[1] = 0; 
     1840      nGlob[0]        = ni_glo;   nGlob[1] = nj_glo; 
     1841      CDistributionServer srvDist(client->clientSize, nBegin, nSize, nBeginGlobal, nGlob);  
     1842      const CArray<size_t,1>& writtenGlobalIndex  = srvDist.getGlobalIndex(); 
     1843 
     1844      size_t nbWritten = 0, indGlo;       
     1845      boost::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(), 
     1846                                                          ite = globalLocalIndexMap_.end(), it;           
     1847      CArray<size_t,1>::const_iterator itSrvb = writtenGlobalIndex.begin(), 
     1848                                       itSrve = writtenGlobalIndex.end(), itSrv; 
     1849      localIndexToWriteOnServer.resize(writtenGlobalIndex.numElements()); 
     1850      for (itSrv = itSrvb; itSrv != itSrve; ++itSrv) 
     1851      { 
     1852        indGlo = *itSrv; 
     1853        if (ite != globalLocalIndexMap_.find(indGlo)) 
     1854        { 
     1855          localIndexToWriteOnServer(nbWritten) = globalLocalIndexMap_[indGlo]; 
     1856          ++nbWritten; 
     1857        }                  
     1858      } 
     1859   } 
    17231860 
    17241861  /*! 
     
    17291866  { 
    17301867    sendDistributionAttributes(); 
    1731     sendIndex(); 
    1732     sendIndex();     
     1868    sendIndex();    
     1869    // sendIndexZoom();  
    17331870    sendMask(); 
    17341871    sendLonLat(); 
     
    17571894      list<CArray<int,1> > list_indZoom, list_writtenInd, list_indGlob; 
    17581895 
    1759       boost::unordered_map<int, vector<size_t> >::const_iterator itIndex, iteIndex, itZoom, iteZoom; 
    1760       iteIndex = indSrv_.end(); iteZoom = indZoomSrv_.end(); 
     1896      boost::unordered_map<int, vector<size_t> >::const_iterator itIndex, iteIndex; 
     1897      iteIndex = indSrv_.end(); 
    17611898      for (int k = 0; k < connectedServerRank_.size(); ++k) 
    17621899      { 
     
    17661903        if (iteIndex != itIndex) 
    17671904          nbIndGlob = itIndex->second.size(); 
    1768         int nbIndZoom = 0; 
    1769         itZoom = indZoomSrv_.find(rank); 
    1770         if (iteZoom != itZoom) 
    1771           nbIndZoom = itZoom->second.size(); 
    1772  
    1773         list_indGlob.push_back(CArray<int,1>(nbIndGlob)); 
    1774         list_indZoom.push_back(CArray<int,1>(nbIndZoom)); 
    1775  
    1776         CArray<int,1>& indZoom = list_indZoom.back(); 
     1905 
     1906        list_indGlob.push_back(CArray<int,1>(nbIndGlob));         
     1907 
    17771908        CArray<int,1>& indGlob = list_indGlob.back(); 
    17781909        for (n = 0; n < nbIndGlob; ++n) 
    17791910        { 
    17801911          indGlob(n) = static_cast<int>(itIndex->second[n]); 
    1781         } 
    1782  
    1783         for (n = 0; n < nbIndZoom; ++n) 
    1784         { 
    1785           indZoom(n) = static_cast<int>(itZoom->second[n]); 
    17861912        } 
    17871913 
     
    17891915        list_msgsIndex.back() << this->getId() << (int)type; // enum ne fonctionne pour les message => ToFix 
    17901916        list_msgsIndex.back() << isCurvilinear; 
    1791         list_msgsIndex.back() << list_indGlob.back() << list_indZoom.back() << doZoomByIndex_; //list_indi.back() << list_indj.back(); 
    1792         if (!doZoomByIndex_)  
    1793         { 
    1794           //list_msgsIndex.back() << zoom_ni.getValue() << zoom_ibegin.getValue() << zoom_nj.getValue() << zoom_jbegin.getValue(); 
    1795         } 
     1917        list_msgsIndex.back() << list_indGlob.back(); //list_indi.back() << list_indj.back(); 
    17961918        
    17971919        // if (isCompressible_) 
     
    18111933 
    18121934      client->sendEvent(eventIndex); 
     1935    } 
     1936  } 
     1937 
     1938  /*! 
     1939    Send global index and zoom index from client to connected client(s) 
     1940    zoom index can be smaller than global index 
     1941  */ 
     1942  void CDomain::sendIndexZoom() 
     1943  { 
     1944    int ns, n, i, j, ind, nv, idx; 
     1945    CContext* context = CContext::getCurrent(); 
     1946 
     1947    // int nbSrvPools = (context->hasServer) ? context->clientPrimServer.size() : 1; 
     1948    int nbSrvPools = (context->hasServer) ? (context->hasClient ? context->clientPrimServer.size() : 0) : 1; 
     1949    for (int p = 0; p < nbSrvPools; ++p) 
     1950    { 
     1951      CContextClient* client = (0 != context->clientPrimServer.size()) ? context->clientPrimServer[p] : context->client; 
     1952      CEventClient eventIndexZoom(getType(), EVENT_ID_INDEX_ZOOM); 
     1953 
     1954      list<CMessage> list_msgsIndex; 
     1955      list<CArray<int,1> > list_indZoom; 
     1956 
     1957      boost::unordered_map<int, vector<size_t> >::const_iterator itZoom, iteZoom; 
     1958      iteZoom = indZoomSrv_.end(); 
     1959      for (int k = 0; k < connectedServerZoomRank_.size(); ++k) 
     1960      { 
     1961        int nbIndGlob = 0; 
     1962        int rank = connectedServerZoomRank_[k]; 
     1963        int nbIndZoom = 0; 
     1964        itZoom = indZoomSrv_.find(rank); 
     1965        if (iteZoom != itZoom) 
     1966          nbIndZoom = itZoom->second.size(); 
     1967         
     1968        list_indZoom.push_back(CArray<int,1>(nbIndZoom)); 
     1969        CArray<int,1>& indZoom = list_indZoom.back(); 
     1970        for (n = 0; n < nbIndZoom; ++n) 
     1971        { 
     1972          indZoom(n) = static_cast<int>(itZoom->second[n]); 
     1973        } 
     1974 
     1975        list_msgsIndex.push_back(CMessage()); 
     1976        list_msgsIndex.back() << this->getId(); // enum ne fonctionne pour les message => ToFix         
     1977        list_msgsIndex.back() << list_indZoom.back() << doZoomByIndex_; //list_indi.back() << list_indj.back       
     1978 
     1979        eventIndexZoom.push(rank, nbConnectedClientsZoom_[rank], list_msgsIndex.back()); 
     1980      } 
     1981 
     1982      client->sendEvent(eventIndexZoom); 
    18131983    } 
    18141984  } 
     
    20362206        list_msgsLat.push_back(CMessage()); 
    20372207 
    2038         list_msgsLon.back() << this->getId() << hasLonLat << list_lon.back() << hasBounds; 
    2039         list_msgsLat.back() << this->getId() << hasLonLat << list_lat.back() << hasBounds; 
    2040  
     2208        list_msgsLon.back() << this->getId() << hasLonLat; 
     2209        if (hasLonLat)  
     2210          list_msgsLon.back() << list_lon.back(); 
     2211        list_msgsLon.back()  << hasBounds; 
    20412212        if (hasBounds) 
    20422213        { 
    20432214          list_msgsLon.back() << list_boundslon.back(); 
     2215        } 
     2216 
     2217        list_msgsLat.back() << this->getId() << hasLonLat; 
     2218        if (hasLonLat) 
     2219          list_msgsLat.back() << list_lat.back(); 
     2220        list_msgsLat.back() << hasBounds; 
     2221        if (hasBounds) 
     2222        {           
    20442223          list_msgsLat.back() << list_boundslat.back(); 
    20452224        } 
     
    20762255 
    20772256      int nbIndex = i_index.numElements(); 
     2257      int niByIndex = max(i_index) - min(i_index) + 1; 
     2258      int njByIndex = max(j_index) - min(j_index) + 1;  
     2259      int dataIindexBound = (1 == data_dim) ? (niByIndex * njByIndex) : niByIndex; 
     2260      int dataJindexBound = (1 == data_dim) ? (niByIndex * njByIndex) : njByIndex; 
     2261 
     2262       
    20782263      CArray<int,1> dataIIndex(nbIndex), dataJIndex(nbIndex); 
    2079       dataIIndex = -1; dataJIndex = -1, ind = 0; 
     2264      dataIIndex = -1;  
     2265      dataJIndex = -1; 
     2266      ind = 0; 
     2267 
    20802268      for (idx = 0; idx < data_i_index.numElements(); ++idx) 
    20812269      { 
    2082         if ((0 <= data_i_index(idx)) && (data_i_index(idx) < ni) && (ind < nbIndex)) 
    2083         { 
    2084           dataIIndex(ind) = data_i_index(idx); 
    2085           dataJIndex(ind) = data_j_index(idx); 
    2086           ++ind; 
     2270        int dataIidx = data_i_index(idx) + data_ibegin; 
     2271        int dataJidx = data_j_index(idx) + data_jbegin; 
     2272        if ((0 <= dataIidx) && (dataIidx < dataIindexBound) && 
     2273            (0 <= dataJidx) && (dataJidx < dataJindexBound)) 
     2274        { 
     2275          dataIIndex((1 == data_dim) ? dataIidx : dataJidx * ni + dataIidx) = 1; //i_index(dataIidx);//dataIidx; 
     2276          dataJIndex((1 == data_dim) ? dataIidx : dataJidx * ni + dataIidx) = 1; //j_index(dataJidx);//           
    20872277        } 
    20882278      } 
     
    21312321        case EVENT_ID_INDEX: 
    21322322          recvIndex(event); 
     2323          return true; 
     2324          break; 
     2325        case EVENT_ID_INDEX_ZOOM: 
     2326          recvIndexZoom(event); 
    21332327          return true; 
    21342328          break; 
     
    21982392  { 
    21992393    int nbReceived = rankBuffers.size(), i, ind, index, type_int; 
    2200     recvClientRanks_.resize(nbReceived); 
    2201     vector<CArray<int,1> > recvZoomInd(nbReceived); 
    2202     int ni_zoom_tmp, ibegin_zoom_tmp, nj_zoom_tmp, jbegin_zoom_tmp; 
     2394    recvClientRanks_.resize(nbReceived);         
    22032395 
    22042396    std::map<int, CBufferIn*>::iterator it = rankBuffers.begin(), ite = rankBuffers.end(); 
     
    22082400       recvClientRanks_[ind] = it->first; 
    22092401       CBufferIn& buffer = *(it->second); 
    2210        buffer >> type_int >> isCurvilinear >> indGlob_[it->first] >> recvZoomInd[ind] >> doZoomByIndex_;  
    2211        if (!doZoomByIndex_) 
    2212        { 
    2213         //buffer >> ni_zoom_tmp >> ibegin_zoom_tmp >> nj_zoom_tmp >> jbegin_zoom_tmp; 
    2214        } 
     2402       buffer >> type_int >> isCurvilinear >> indGlob_[it->first];  
    22152403       type.setValue((type_attr::t_enum)type_int); // probleme des type enum avec les buffers : ToFix 
    22162404    } 
     
    22242412    j_index.resize(nbIndGlob); 
    22252413 
     2414    globalLocalIndexMap_.rehash(std::ceil(nbIndGlob/globalLocalIndexMap_.max_load_factor())); 
    22262415    nbIndGlob = 0; 
    22272416    for (i = 0; i < nbReceived; ++i) 
     
    22332422         i_index(nbIndGlob) = index % ni_glo; 
    22342423         j_index(nbIndGlob) = index / ni_glo; 
     2424         globalLocalIndexMap_[index] = nbIndGlob;   
    22352425         ++nbIndGlob; 
    22362426      }  
    2237     } 
    2238  
    2239     int nbZoomInd = 0; 
    2240     for (i = 0; i < nbReceived; ++i) 
    2241     { 
    2242       nbZoomInd += recvZoomInd[i].numElements(); 
    2243     } 
    2244  
    2245     if (doZoomByIndex_) 
    2246     { 
    2247       zoom_i_index.resize(nbZoomInd); 
    2248       zoom_j_index.resize(nbZoomInd); 
    2249        
    2250       nbZoomInd = 0; 
    2251       for (i = 0; i < nbReceived; ++i) 
    2252       { 
    2253         CArray<int,1>& tmp = recvZoomInd[i]; 
    2254         for (ind = 0; ind < tmp.numElements(); ++ind) 
    2255         { 
    2256            index = tmp(ind); 
    2257            zoom_i_index(nbZoomInd) = index % ni_glo; 
    2258            zoom_j_index(nbZoomInd) = index / ni_glo; 
    2259            ++nbZoomInd; 
    2260         }  
    2261       }       
    2262     } 
    2263     else  
    2264     { 
    2265       // zoom_ni.setValue(ni_zoom_tmp); 
    2266       // zoom_ibegin.setValue(ibegin_zoom_tmp); 
    2267       // zoom_nj.setValue(nj_zoom_tmp); 
    2268       // zoom_jbegin.setValue(jbegin_zoom_tmp); 
    2269       // int nbZoom = ni_zoom_tmp * nj_zoom_tmp; 
    2270       // zoom_i_index.resize(nbZoom); 
    2271       // zoom_j_index.resize(nbZoom); 
    2272       // nbZoom = 0; 
    2273       // for (int j = 0; j < nj_zoom_tmp; ++j)  
    2274       //   for (int i = 0; i < ni_zoom_tmp; ++i) 
    2275       //   { 
    2276       //     zoom_i_index(nbZoom) = ibegin_zoom_tmp + i; 
    2277       //     zoom_j_index(nbZoom) = jbegin_zoom_tmp + j; 
    2278       //     ++nbZoom; 
    2279       //   } 
    2280     } 
    2281  
    2282     globalLocalIndexMap_.rehash(std::ceil(nbIndGlob/globalLocalIndexMap_.max_load_factor())); 
    2283     nbIndGlob = 0; 
    2284     for (int j = 0; j < nj; ++j)  
    2285       for (int i = 0; i < ni; ++i) 
    2286       { 
    2287         globalLocalIndexMap_[(i + ibegin) + (j + jbegin) * ni_glo] = nbIndGlob; 
    2288         ++nbIndGlob; 
    2289       } 
    2290  
    2291  
     2427    }    
    22922428     
    22932429    // { 
     
    23682504 
    23692505  /*! 
     2506    Receive index event from clients(s) 
     2507    \param[in] event event contain info about rank and associated index 
     2508  */ 
     2509  void CDomain::recvIndexZoom(CEventServer& event) 
     2510  { 
     2511    string domainId; 
     2512    std::map<int, CBufferIn*> rankBuffers; 
     2513 
     2514    list<CEventServer::SSubEvent>::iterator it; 
     2515    for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it) 
     2516    {       
     2517      CBufferIn* buffer = it->buffer; 
     2518      *buffer >> domainId; 
     2519      rankBuffers[it->rank] = buffer;         
     2520    } 
     2521    get(domainId)->recvIndexZoom(rankBuffers); 
     2522  } 
     2523 
     2524  /*! 
     2525    Receive index information from client(s) 
     2526    \param[in] rankBuffers rank of sending client and the corresponding receive buffer   
     2527  */ 
     2528  void CDomain::recvIndexZoom(std::map<int, CBufferIn*>& rankBuffers) 
     2529  { 
     2530    int nbReceived = rankBuffers.size(), i, ind, index, type_int; 
     2531    recvClientZoomRanks_.resize(nbReceived);     
     2532    int ni_zoom_tmp, ibegin_zoom_tmp, nj_zoom_tmp, jbegin_zoom_tmp; 
     2533 
     2534    std::map<int, CBufferIn*>::iterator it = rankBuffers.begin(), ite = rankBuffers.end(); 
     2535    ind = 0; 
     2536    for (ind = 0; it != ite; ++it, ++ind) 
     2537    {        
     2538       recvClientZoomRanks_[ind] = it->first; 
     2539       CBufferIn& buffer = *(it->second); 
     2540       buffer >> indGlobZoom_[it->first] >> doZoomByIndex_;         
     2541    } 
     2542 
     2543    int nbZoomInd = 0; 
     2544    for (i = 0; i < nbReceived; ++i) 
     2545    { 
     2546      nbZoomInd += indGlobZoom_[recvClientZoomRanks_[i]].numElements(); 
     2547    } 
     2548 
     2549    if (doZoomByIndex_) 
     2550    { 
     2551      zoom_i_index.resize(nbZoomInd); 
     2552      zoom_j_index.resize(nbZoomInd); 
     2553       
     2554      nbZoomInd = 0; 
     2555      for (i = 0; i < nbReceived; ++i) 
     2556      { 
     2557        CArray<int,1>& tmp = indGlobZoom_[recvClientRanks_[i]]; 
     2558        for (ind = 0; ind < tmp.numElements(); ++ind) 
     2559        { 
     2560           index = tmp(ind); 
     2561           zoom_i_index(nbZoomInd) = index % ni_glo; 
     2562           zoom_j_index(nbZoomInd) = index / ni_glo; 
     2563           ++nbZoomInd; 
     2564        }  
     2565      }       
     2566    } 
     2567    else  
     2568    { 
     2569    } 
     2570 
     2571    // globalLocalIndexZoomMap_.rehash(std::ceil(nbZoomInd/globalLocalIndexZoomMap_.max_load_factor())); 
     2572    // nbZoomInd = 0; 
     2573    // for (int j = 0; j < zoom_nj; ++j)  
     2574    //   for (int i = 0; i < zoom_ni; ++i) 
     2575    //   { 
     2576    //     globalLocalIndexZoomMap_[(i + zoom_ibegin) + (j + zoom_jbegin) * ni_glo] = nbZoomInd; 
     2577    //     ++nbZoomInd; 
     2578    //   } 
     2579  } 
     2580 
     2581  /*! 
    23702582    Receive attributes event from clients(s) 
    23712583    \param[in] event event contain info about rank and associated attributes 
     
    25062718  void CDomain::recvLon(std::map<int, CBufferIn*>& rankBuffers) 
    25072719  { 
    2508     int nbReceived = rankBuffers.size(), i, ind, index, iindex, jindex; 
     2720    int nbReceived = rankBuffers.size(), i, ind, index, iindex, jindex, lInd; 
    25092721    if (nbReceived != recvClientRanks_.size()) 
    25102722      ERROR("void CDomain::recvLon(std::map<int, CBufferIn*>& rankBuffers)", 
     
    25192731      CBufferIn& buffer = *(rankBuffers[rank]); 
    25202732      buffer >> hasLonLat; 
    2521       buffer >> recvLonValue[i]; 
     2733      if (hasLonLat) 
     2734        buffer >> recvLonValue[i]; 
    25222735      buffer >> hasBounds; 
    25232736      if (hasBounds) 
     
    25252738    } 
    25262739 
    2527     lonvalue.resize(zoom_ni*zoom_nj); 
    2528     lonvalue = 0; 
    2529  
    2530     if (hasBounds) 
     2740    if (hasLonLat) 
    25312741    { 
    2532       bounds_lonvalue.resize(nvertex,zoom_ni*zoom_nj); 
    2533       bounds_lonvalue = 0.; 
    2534     } 
     2742      int nbLonInd = 0; 
     2743      for (i = 0; i < nbReceived; ++i) 
     2744      { 
     2745        nbLonInd += recvLonValue[i].numElements(); 
     2746      } 
    25352747     
    2536     for (i = 0; i < nbReceived; ++i) 
    2537     { 
    2538       int rank = recvClientRanks_[i]; 
    2539       CArray<int,1> &indi = indGlob_[rank], &indj = indGlob_[rank];       
    2540       for (ind = 0; ind < indi.numElements(); ++ind) 
    2541       { 
    2542          iindex = indi(ind) % ni_glo; jindex = indj(ind) / ni_glo; 
    2543          index = (iindex - zoom_ibegin) + (jindex - zoom_jbegin) * zoom_ni; 
    2544          lonvalue(index) = recvLonValue[i](ind); 
    2545          if (hasBounds) 
    2546          {           
    2547           for (int nv = 0; nv < nvertex; ++nv) 
    2548             bounds_lonvalue(nv, index) = recvBoundsLonValue[i](nv, ind); 
    2549          }          
    2550       } 
    2551     } 
     2748      if (nbLonInd != globalLocalIndexMap_.size()) 
     2749        info (0) << "Something wrong with longitude index "<< std::endl; 
     2750 
     2751      lonvalue.resize(nbLonInd); 
     2752      if (hasBounds) 
     2753      { 
     2754        bounds_lonvalue.resize(nvertex,nbLonInd); 
     2755        bounds_lonvalue = 0.; 
     2756      } 
     2757 
     2758      nbLonInd = 0; 
     2759      for (i = 0; i < nbReceived; ++i) 
     2760      { 
     2761        CArray<int,1>& tmpInd = indGlob_[recvClientRanks_[i]]; 
     2762        CArray<double,1>& tmp = recvLonValue[i]; 
     2763        for (ind = 0; ind < tmp.numElements(); ++ind) 
     2764        { 
     2765          lInd = globalLocalIndexMap_[size_t(tmpInd(ind))]; 
     2766          lonvalue(lInd) = tmp(ind);  
     2767           if (hasBounds) 
     2768           {           
     2769            for (int nv = 0; nv < nvertex; ++nv) 
     2770              bounds_lonvalue(nv, lInd) = recvBoundsLonValue[i](nv, ind); 
     2771           }                   
     2772        } 
     2773      }        
     2774    } 
     2775 
     2776 
     2777 
     2778    // lonvalue.resize(zoom_ni*zoom_nj); 
     2779    // lonvalue = 0; 
     2780 
     2781    // if (hasBounds) 
     2782    // { 
     2783    //   bounds_lonvalue.resize(nvertex,zoom_ni*zoom_nj); 
     2784    //   bounds_lonvalue = 0.; 
     2785    // } 
     2786     
     2787    // if (0 == lonvalue.numElements()) return; 
     2788 
     2789    // for (i = 0; i < nbReceived; ++i) 
     2790    // { 
     2791    //   int rank = recvClientRanks_[i]; 
     2792    //   CArray<int,1> &indi = indGlob_[rank], &indj = indGlob_[rank];       
     2793    //   for (ind = 0; ind < indi.numElements(); ++ind) 
     2794    //   { 
     2795    //      iindex = indi(ind) % ni_glo; jindex = indj(ind) / ni_glo; 
     2796    //      index = (iindex - zoom_ibegin) + (jindex - zoom_jbegin) * zoom_ni; 
     2797    //      lonvalue(index) = recvLonValue[i](ind); 
     2798    //      if (hasBounds) 
     2799    //      {           
     2800    //       for (int nv = 0; nv < nvertex; ++nv) 
     2801    //         bounds_lonvalue(nv, index) = recvBoundsLonValue[i](nv, ind); 
     2802    //      }          
     2803    //   } 
     2804    // } 
    25522805  } 
    25532806 
     
    25772830  void CDomain::recvLat(std::map<int, CBufferIn*>& rankBuffers) 
    25782831  { 
    2579     int nbReceived = rankBuffers.size(), i, ind, index, iindex, jindex; 
     2832    int nbReceived = rankBuffers.size(), i, ind, index, iindex, jindex, lInd; 
    25802833    if (nbReceived != recvClientRanks_.size()) 
    25812834      ERROR("void CDomain::recvLat(std::map<int, CBufferIn*>& rankBuffers)", 
     
    25902843      CBufferIn& buffer = *(rankBuffers[rank]); 
    25912844      buffer >> hasLonLat; 
    2592       buffer >> recvLatValue[i]; 
     2845      if (hasLonLat) 
     2846        buffer >> recvLatValue[i]; 
    25932847      buffer >> hasBounds; 
    25942848      if (hasBounds) 
     
    25962850    } 
    25972851 
    2598     latvalue.resize(zoom_ni*zoom_nj); 
    2599     latvalue = 0; 
    2600  
    2601     if (hasBounds) 
     2852    if (hasLonLat) 
    26022853    { 
    2603       bounds_latvalue.resize(nvertex,zoom_ni*zoom_nj); 
    2604       bounds_latvalue = 0. ; 
    2605     } 
     2854      int nbLatInd = 0; 
     2855      for (i = 0; i < nbReceived; ++i) 
     2856      { 
     2857        nbLatInd += recvLatValue[i].numElements(); 
     2858      } 
    26062859     
    2607     for (i = 0; i < nbReceived; ++i) 
    2608     { 
    2609       int rank = recvClientRanks_[i]; 
    2610       CArray<int,1> &indi = indGlob_[rank], &indj = indGlob_[rank]; 
    2611       CArray<double,1>& lat = recvLatValue[i]; 
    2612       for (ind = 0; ind < indi.numElements(); ++ind) 
    2613       { 
    2614          iindex = indi(ind) % ni_glo; jindex = indj(ind) / ni_glo; 
    2615          index = (iindex - zoom_ibegin) + (jindex - zoom_jbegin) * zoom_ni; 
    2616          latvalue(index) = lat(ind); 
    2617          if (hasBounds) 
    2618          { 
    2619           CArray<double,2>& boundslat = recvBoundsLatValue[i]; 
    2620           for (int nv = 0; nv < nvertex; ++nv) 
    2621             bounds_latvalue(nv, index) = boundslat(nv, ind); 
    2622          }          
    2623       } 
     2860      if (nbLatInd != globalLocalIndexMap_.size()) 
     2861        info (0) << "Something wrong with latitude index "<< std::endl; 
     2862 
     2863      latvalue.resize(nbLatInd); 
     2864      if (hasBounds) 
     2865      { 
     2866        bounds_latvalue.resize(nvertex,nbLatInd); 
     2867        bounds_latvalue = 0. ; 
     2868      } 
     2869 
     2870      nbLatInd = 0; 
     2871      for (i = 0; i < nbReceived; ++i) 
     2872      { 
     2873        CArray<int,1>& tmpInd = indGlob_[recvClientRanks_[i]]; 
     2874        CArray<double,1>& tmp = recvLatValue[i]; 
     2875        for (ind = 0; ind < tmp.numElements(); ++ind) 
     2876        { 
     2877          lInd = globalLocalIndexMap_[size_t(tmpInd(ind))]; 
     2878          latvalue(lInd) = tmp(ind);     
     2879           if (hasBounds) 
     2880           { 
     2881            CArray<double,2>& boundslat = recvBoundsLatValue[i]; 
     2882            for (int nv = 0; nv < nvertex; ++nv) 
     2883              bounds_latvalue(nv, lInd) = boundslat(nv, ind); 
     2884           }    
     2885          ++nbLatInd; 
     2886        } 
     2887      }        
    26242888    } 
    26252889  } 
     
    26512915  void CDomain::recvArea(std::map<int, CBufferIn*>& rankBuffers) 
    26522916  { 
    2653     int nbReceived = rankBuffers.size(), i, ind, index; 
     2917    int nbReceived = rankBuffers.size(), i, ind, index, lInd; 
    26542918    if (nbReceived != recvClientRanks_.size()) 
    26552919      ERROR("void CDomain::recvArea(std::map<int, CBufferIn*>& rankBuffers)", 
     
    26692933    int nbAreaInd = 0; 
    26702934    for (i = 0; i < nbReceived; ++i) 
    2671     { 
    2672       if (hasArea) 
    2673         nbAreaInd += recvAreaValue[i].numElements(); 
     2935    {       
     2936      nbAreaInd += recvAreaValue[i].numElements(); 
    26742937    } 
    26752938   
    2676     areavalue.resize(nbAreaInd); 
    2677     nbAreaInd = 0; 
     2939    if (nbAreaInd != globalLocalIndexMap_.size()) 
     2940      info (0) << "Something wrong with latitude index "<< std::endl; 
     2941 
    26782942    if (hasArea) 
    26792943    { 
     2944      areavalue.resize(nbAreaInd); 
     2945      nbAreaInd = 0;       
    26802946      for (i = 0; i < nbReceived; ++i) 
    26812947      { 
     2948        CArray<int,1>& tmpInd = indGlob_[recvClientRanks_[i]]; 
    26822949        CArray<double,1>& tmp = recvAreaValue[i]; 
    26832950        for (ind = 0; ind < tmp.numElements(); ++ind) 
    26842951        { 
    2685           area(nbAreaInd) = tmp(ind);       
    2686           ++nbAreaInd; 
    2687         } 
    2688       } 
     2952          lInd = globalLocalIndexMap_[size_t(tmpInd(ind))]; 
     2953          areavalue(lInd) = tmp(ind);           
     2954        } 
     2955      } 
     2956       
    26892957    } 
    26902958  } 
     
    27282996  void CDomain::recvDataIndex(std::map<int, CBufferIn*>& rankBuffers) 
    27292997  { 
    2730     int nbReceived = rankBuffers.size(), i, ind, index, indexI, type_int;     
     2998    int nbReceived = rankBuffers.size(), i, ind, index, indexI, indexJ, type_int, lInd;     
    27312999    if (nbReceived != recvClientRanks_.size()) 
    2732       ERROR("void CDomain::recvLat(std::map<int, CBufferIn*>& rankBuffers)", 
     3000      ERROR("void CDomain::recvDataIndex(std::map<int, CBufferIn*>& rankBuffers)", 
    27333001           << "The number of sending clients is not correct." 
    27343002           << "Expected number: " << recvClientRanks_.size() << " but received " << nbReceived); 
     
    27433011    } 
    27443012    
    2745     int nbCompressedData = 0;  
     3013    int nbIndex = i_index.numElements(); 
     3014    CArray<int,1> dataIIndex(nbIndex), dataJIndex(nbIndex); 
     3015    dataIIndex = -1; dataJIndex = -1; 
     3016 
     3017    nbIndex = 0; 
    27463018    for (i = 0; i < nbReceived; ++i) 
     3019    {       
     3020      CArray<int,1>& tmpInd = indGlob_[recvClientRanks_[i]]; 
     3021      CArray<int,1>& tmpI = recvDataIIndex[i];     
     3022      CArray<int,1>& tmpJ = recvDataJIndex[i];      
     3023      if ((tmpI.numElements() != tmpInd.numElements()) || (tmpJ.numElements() != tmpInd.numElements())) 
     3024          ERROR("void CDomain::recvDataIndex(std::map<int, CBufferIn*>& rankBuffers)", 
     3025             << "The number of global received index is not coherent with the number of received data index." 
     3026             << "Expected number of global index: " << tmpI.numElements() << " but received " << tmpInd.numElements()); 
     3027 
     3028      for (ind = 0; ind < tmpI.numElements(); ++ind) 
     3029      { 
     3030         lInd = globalLocalIndexMap_[size_t(tmpInd(ind))]; 
     3031         dataIIndex(lInd) = tmpI(ind); 
     3032         dataJIndex(lInd) = tmpJ(ind);          
     3033      }  
     3034    } 
     3035 
     3036    int nbCompressedData = 0;   
     3037    for (ind = 0; ind < dataIIndex.numElements(); ++ind) 
    27473038    { 
    2748       CArray<int,1>& tmp = recvDataIIndex[i]; 
    2749       for (ind = 0; ind < tmp.numElements(); ++ind) 
    2750       { 
    2751          index = tmp(ind); 
    2752          if (0 <= index) 
    2753            ++nbCompressedData; 
    2754       }         
    2755     } 
    2756  
     3039       indexI = dataIIndex(ind); indexJ = dataJIndex(ind); 
     3040       if ((0 <= indexI) && (0 <= indexJ)) 
     3041         ++nbCompressedData; 
     3042    }         
     3043   
    27573044    data_i_index.resize(nbCompressedData); 
    27583045    data_j_index.resize(nbCompressedData); 
    27593046 
    2760     nbCompressedData = 0; 
    2761     for (i = 0; i < nbReceived; ++i) 
     3047    nbCompressedData = 0;   
     3048    for (ind = 0; ind < dataIIndex.numElements(); ++ind) 
    27623049    { 
    2763       CArray<int,1>& tmpI = recvDataIIndex[i];       
    2764       CArray<int,1>& tmpIndex = indGlob_[recvClientRanks_[i]]; 
    2765       for (ind = 0; ind < tmpI.numElements(); ++ind) 
    2766       { 
    2767          indexI = tmpI(ind); 
    2768          index  = tmpIndex(ind); 
    2769          if (0 <= indexI) 
    2770          { 
    2771           data_i_index(nbCompressedData) = index % ni_glo - ibegin; 
    2772           data_j_index(nbCompressedData) = index / ni_glo - jbegin; 
    2773           ++nbCompressedData; 
    2774          }          
    2775       }  
    2776     } 
     3050       indexI = dataIIndex(ind); indexJ = dataJIndex(ind); 
     3051       if ((0 <= indexI) && (0 <= indexJ)) 
     3052       { 
     3053          data_i_index(nbCompressedData) = (1 == data_dim) ? ind : i_index(ind) - i_index(0); 
     3054          data_j_index(nbCompressedData) = (1 == data_dim) ? 0   : j_index(ind) - j_index(0);   
     3055         ++nbCompressedData; 
     3056       } 
     3057    } 
     3058 
     3059    // Reset data_ibegin, data_jbegin 
     3060    data_ibegin.setValue(0); 
     3061    data_jbegin.setValue(0); 
    27773062  } 
    27783063 
  • XIOS/dev/dev_olga/src/node/domain.hpp

    r1099 r1129  
    5151           EVENT_ID_INDEX, EVENT_ID_LON, EVENT_ID_LAT,  
    5252           EVENT_ID_AREA, EVENT_ID_MASK, 
    53            EVENT_ID_DATA_INDEX, EVENT_ID_SERVER_ATTRIBUT 
     53           EVENT_ID_DATA_INDEX, EVENT_ID_SERVER_ATTRIBUT, 
     54           EVENT_ID_INDEX_ZOOM 
    5455         } ; 
    5556 
     
    106107 
    107108         std::map<int, StdSize> getAttributesBufferSize(); 
     109         CArray<size_t,1> localIndexToWriteOnServer; 
    108110 
    109111         bool isEmpty(void) const; 
     
    127129         void completeLonLatClient(void);          
    128130         void computeConnectedClients(); 
     131         void computeWrittenIndex(); 
    129132 
    130133         void AllgatherRectilinearLonLat(CArray<double,1>& lon, CArray<double,1>& lat, 
     
    138141         static void recvDistributionAttributes(CEventServer& event); 
    139142         static void recvIndex(CEventServer& event); 
     143         static void recvIndexZoom(CEventServer& event); 
    140144         static void recvMask(CEventServer& event); 
    141145         static void recvZoom(CEventServer& event); 
     
    144148         static void recvArea(CEventServer& event); 
    145149         static void recvDataIndex(CEventServer& event); 
    146          void recvDistributionAttributes(CBufferIn& buffer);          
    147          void recvZoom(std::vector<int>& rank, std::vector<CBufferIn*>& buffers); 
     150         void recvDistributionAttributes(CBufferIn& buffer);                   
    148151         void recvIndex(std::map<int, CBufferIn*>& rankBuffers); 
     152         void recvIndexZoom(std::map<int, CBufferIn*>& rankBuffers); 
    149153         void recvMask(std::map<int, CBufferIn*>& rankBuffers); 
    150154         void recvLon(std::map<int, CBufferIn*>& rankBuffers); 
     
    192196         void sendArea(); 
    193197         void sendLonLat(); 
    194          void sendZoom(); 
     198         void sendIndexZoom(); 
    195199         void sendDataIndex(); 
     200 
     201         void convertLonLatValue(); 
    196202 
    197203       private:          
     
    202208 
    203209         bool doZoomByIndex_; 
    204          bool isChecked; 
     210         bool isChecked, computedWrittenIndex_; 
    205211         std::set<StdString> relFiles, relFilesCompressed; 
    206212         bool isClientChecked; // Verify whether all attributes of domain on the client side are good 
    207213         bool isClientAfterTransformationChecked; 
    208          std::map<int, CArray<int,1> > indiSrv, indjSrv, indGlob_; 
     214         std::map<int, CArray<int,1> > indiSrv, indjSrv, indGlob_, indGlobZoom_; 
    209215         std::map<int,int> nbConnectedClients_, nbConnectedClientsZoom_; // Mapping of number of communicating client to a server 
    210216 
     
    213219         std::map<int, vector<int> > indWrittenSrv_; // Global written index of each client sent to server 
    214220         std::vector<int> indexesToWrite; 
    215          std::vector<int> recvClientRanks_; 
     221         std::vector<int> recvClientRanks_, recvClientZoomRanks_; 
    216222         int numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_; 
    217          std::vector<int> connectedServerRank_; 
     223         std::vector<int> connectedServerRank_, connectedServerZoomRank_; 
    218224         bool isDistributed_; 
    219225         //! True if and only if the data defined on the domain can be outputted in a compressed way 
     
    222228         TransMapTypes transformationMap_;          
    223229         bool isUnstructed_; 
    224          boost::unordered_map<size_t,size_t> globalLocalIndexMap_; 
     230         boost::unordered_map<size_t,size_t> globalLocalIndexMap_, globalLocalIndexZoomMap_; 
    225231        
    226232       private: 
  • XIOS/dev/dev_olga/src/node/field.cpp

    r1099 r1129  
    3535      , nstep(0), nstepMax(0) 
    3636      , hasOutputFile(false) 
    37       , domAxisScalarIds_(vector<StdString>(3,"")), areAllReferenceSolved(false), isReferenceSolved(false) 
     37      , domAxisScalarIds_(vector<StdString>(3,"")) 
     38      , areAllReferenceSolved(false), isReferenceSolved(false), isReferenceSolvedAndTransformed(false) 
    3839      , useCompressedOutput(false) 
    3940      , wasDataAlreadyReceivedFromServer(false) 
     
    4647      , nstep(0), nstepMax(0) 
    4748      , hasOutputFile(false) 
    48       , domAxisScalarIds_(vector<StdString>(3,"")), areAllReferenceSolved(false), isReferenceSolved(false) 
     49      , domAxisScalarIds_(vector<StdString>(3,"")) 
     50      , areAllReferenceSolved(false), isReferenceSolved(false), isReferenceSolvedAndTransformed(false) 
    4951      , useCompressedOutput(false) 
    5052      , wasDataAlreadyReceivedFromServer(false) 
     
    257259    size_t sizeData = 0; 
    258260    if (0 == recvDataSrv.numElements()) 
    259     {       
    260       for (map<int, CArray<size_t, 1> >::iterator it = grid->outIndexFromClient.begin(); it != grid->outIndexFromClient.end(); ++it) 
    261       { 
    262         sizeData += it->second.numElements(); 
    263         data_srv.insert(std::make_pair(it->first, CArray<double,1>(it->second.numElements()))); 
    264       } 
     261    {             
     262      CArray<int,1>& storeClient = grid->storeIndex_client; 
     263      // for (map<int, CArray<size_t, 1> >::iterator it = grid->outIndexFromClient.begin(); it != grid->outIndexFromClient.end(); ++it) 
     264      // { 
     265      //   // sizeData += it->second.numElements(); 
     266      //   data_srv.insert(std::make_pair(it->first, CArray<double,1>(it->second.numElements()))); 
     267      // } 
     268 
     269      // for (map<int, CArray<size_t, 1> >::iterator it = grid->outLocalIndexStoreOnClient.begin(); it != grid->outLocalIndexStoreOnClient.end(); ++it) 
     270      // { 
     271      //   // sizeData += it->second.numElements(); 
     272      //   data_srv.insert(std::make_pair(it->first, CArray<double,1>(it->second.numElements()))); 
     273      // } 
    265274 
    266275      // Gather all data from different clients 
    267       recvDataSrv.resize(sizeData); 
     276      // recvDataSrv.resize(sizeData); 
     277      recvDataSrv.resize(storeClient.numElements()); 
    268278      recvFoperationSrv = boost::shared_ptr<func::CFunctor>(new func::CInstant(recvDataSrv)); 
    269279    } 
     
    276286    if (opeDate <= currDate) 
    277287    { 
    278       for (map<int, CArray<size_t, 1> >::iterator it = grid->outIndexFromClient.begin(); it != grid->outIndexFromClient.end(); ++it) 
    279       {         
     288       for (map<int, CArray<size_t, 1> >::iterator it = grid->outLocalIndexStoreOnClient.begin(); it != grid->outLocalIndexStoreOnClient.end(); ++it) 
     289      { 
    280290        CArray<double,1> tmp; 
    281291        CArray<size_t,1>& indexTmp = it->second; 
     
    288298        // sizeData += it->second.numElements();       
    289299      } 
     300 
     301      // for (map<int, CArray<size_t, 1> >::iterator it = grid->outIndexFromClient.begin(); it != grid->outIndexFromClient.end(); ++it) 
     302      // {         
     303      //   CArray<double,1> tmp; 
     304      //   CArray<size_t,1>& indexTmp = it->second; 
     305      //   *(rankBuffers[it->first]) >> tmp; 
     306      //   for (int idx = 0; idx < indexTmp.numElements(); ++idx) 
     307      //   { 
     308      //     recv_data_tmp(indexTmp(idx)) = tmp(idx); 
     309      //   } 
     310      //   // recv_data_tmp(Range(sizeData,sizeData+it->second.numElements()-1)) = tmp;   
     311      //   // sizeData += it->second.numElements();       
     312      // } 
    290313    } 
    291314 
     
    316339      recvFoperationSrv->final(); 
    317340      last_Write_srv = writeDate; 
     341      grid->computeWrittenIndex(); 
    318342      writeField(); 
    319343      lastlast_Write_srv = last_Write_srv; 
     
    813837   } 
    814838    
    815    void CField::solveAllEnabledFields() 
     839   /*! 
     840     Solve reference of all enabled fields even the source fields . 
     841     In this step, we do transformations. 
     842   */ 
     843   void CField::solveAllEnabledFieldsAndTransform() 
    816844   { 
    817845     CContext* context = CContext::getCurrent(); 
     
    819847     bool hasServer = context->hasServer; 
    820848 
    821      if (!isReferenceSolved) 
    822      { 
    823         isReferenceSolved = true; 
     849     if (!isReferenceSolvedAndTransformed) 
     850     { 
     851        isReferenceSolvedAndTransformed = true; 
    824852 
    825853        if (hasClient && !hasServer) 
    826854        { 
    827855          solveRefInheritance(true); 
    828           if (hasDirectFieldReference()) getDirectFieldReference()->solveAllEnabledFields(); 
     856          if (hasDirectFieldReference()) getDirectFieldReference()->solveAllEnabledFieldsAndTransform(); 
    829857        } 
    830858 
     
    9921020   { 
    9931021     // if (!areAllReferenceSolved) solveAllReferenceEnabledField(false); 
    994     if (!isReferenceSolved) solveAllEnabledFields(); 
     1022    if (!isReferenceSolvedAndTransformed) solveAllEnabledFieldsAndTransform(); 
    9951023     CContext* context = CContext::getCurrent(); 
    9961024     bool hasWriterServer = context->hasServer && !context->hasClient; 
     
    14281456   void CField::outputField(CArray<double,1>& fieldOut) 
    14291457   { 
    1430       map<int, CArray<double,1> >::iterator it; 
    1431        
    1432       fieldOut = recvDataSrv; 
    1433        
     1458      map<int, CArray<double,1> >::iterator it;       
     1459      
     1460      CArray<size_t,1>& outIndexClient = grid->localIndexToWriteOnClient; 
     1461      CArray<size_t,1>& outIndexServer = grid->localIndexToWriteOnServer; 
     1462      for (size_t idx = 0; idx < outIndexServer.numElements(); ++idx) 
     1463      { 
     1464        fieldOut(outIndexServer(idx)) = recvDataSrv(outIndexClient(idx)); 
     1465      } 
     1466 
    14341467      // for (it = data_srv.begin(); it != data_srv.end(); it++) 
    14351468      // { 
  • XIOS/dev/dev_olga/src/node/field.hpp

    r1099 r1129  
    122122         void solveGridDomainAxisBaseRef(); 
    123123 
    124          void solveAllEnabledFields(); 
     124         void solveAllEnabledFieldsAndTransform(); 
    125125         void checkGridOfEnabledFields(); 
    126126         void sendGridOfEnabledFields(); 
     
    216216         string content; 
    217217 
    218          bool areAllReferenceSolved; 
    219          bool isReferenceSolved; 
    220218         std::vector<StdString> domAxisScalarIds_; 
    221219         bool useCompressedOutput; 
     
    225223         bool hasTimeCentered; 
    226224 
     225 
    227226         DECLARE_REF_FUNC(Field,field) 
     227 
     228      private: 
     229         bool areAllReferenceSolved; 
     230         bool isReferenceSolved; 
     231         bool isReferenceSolvedAndTransformed; 
    228232 
    229233      private: 
  • XIOS/dev/dev_olga/src/node/file.cpp

    r1071 r1129  
    695695     for (int i = 0; i < size; ++i) 
    696696     { 
    697        // this->enabledFields[i]->solveOnlyReferenceEnabledField(sendToServer); 
    698        this->enabledFields[i]->solveAllEnabledFields(); 
     697       this->enabledFields[i]->solveOnlyReferenceEnabledField(sendToServer); 
     698       // this->enabledFields[i]->solveAllEnabledFields(); 
    699699//       this->enabledFields[i]->buildGridTransformationGraph(); 
    700700     } 
     
    736736   \param [in] sendToServer: Send all info to server (true) or only a part of it (false) 
    737737   */ 
    738    void CFile::solveAllRefOfEnabledFields(bool sendToServer) 
     738   void CFile::solveAllRefOfEnabledFieldsAndTransform(bool sendToServer) 
    739739   { 
    740740     int size = this->enabledFields.size(); 
    741741     for (int i = 0; i < size; ++i) 
    742742     { 
    743        this->enabledFields[i]->solveAllReferenceEnabledField(sendToServer); 
     743       // this->enabledFields[i]->solveAllReferenceEnabledField(sendToServer); 
     744      this->enabledFields[i]->solveAllEnabledFieldsAndTransform(); 
    744745     } 
    745746   } 
  • XIOS/dev/dev_olga/src/node/file.hpp

    r1071 r1129  
    105105         void solveOnlyRefOfEnabledFields(bool sendToServer); 
    106106         void generateNewTransformationGridDest(); 
    107          void solveAllRefOfEnabledFields(bool sendToServer); 
     107          
    108108         void buildFilterGraphOfEnabledFields(CGarbageCollector& gc); 
    109109         void prefetchEnabledReadModeFields(); 
    110110         void prefetchEnabledReadModeFieldsIfNeeded(); 
    111111 
     112         void solveAllRefOfEnabledFieldsAndTransform(bool sendToServer); 
    112113         void checkGridOfEnabledFields(); 
    113114         void sendGridOfEnabledFields(); 
  • XIOS/dev/dev_olga/src/node/grid.cpp

    r1099 r1129  
    3535      , axisPositionInGrid_(), positionDimensionDistributed_(1), hasDomainAxisBaseRef_(false) 
    3636      , gridSrc_(), hasTransform_(false), isGenerated_(false), order_(), globalIndexOnServer_() 
     37      , computedWrittenIndex_(false) 
    3738   { 
    3839     setVirtualDomainGroup(CDomainGroup::create(getId() + "_virtual_domain_group")); 
     
    5354      , axisPositionInGrid_(), positionDimensionDistributed_(1), hasDomainAxisBaseRef_(false) 
    5455      , gridSrc_(), hasTransform_(false), isGenerated_(false), order_(), globalIndexOnServer_() 
     56      , computedWrittenIndex_(false) 
    5557   { 
    5658     setVirtualDomainGroup(CDomainGroup::create(getId() + "_virtual_domain_group")); 
     
    403405   } 
    404406 
    405    void CGrid::modifyMask(const CArray<int,1>& indexToModify) 
     407   void CGrid::modifyMask(const CArray<int,1>& indexToModify, bool modifyValue) 
    406408   { 
    407409      using namespace std; 
     
    412414      switch (dim) { 
    413415        case 1: 
    414           modifyGridMask(mask_1d, indexToModify); 
     416          modifyGridMask(mask_1d, indexToModify, modifyValue); 
    415417          break; 
    416418        case 2: 
    417           modifyGridMask(mask_2d, indexToModify); 
     419          modifyGridMask(mask_2d, indexToModify, modifyValue); 
    418420          break; 
    419421        case 3: 
    420           modifyGridMask(mask_3d, indexToModify); 
     422          modifyGridMask(mask_3d, indexToModify, modifyValue); 
    421423          break; 
    422424        case 4: 
    423           modifyGridMask(mask_4d, indexToModify); 
     425          modifyGridMask(mask_4d, indexToModify, modifyValue); 
    424426          break; 
    425427        case 5: 
    426           modifyGridMask(mask_5d, indexToModify); 
     428          modifyGridMask(mask_5d, indexToModify, modifyValue); 
    427429          break; 
    428430        case 6: 
    429           modifyGridMask(mask_6d, indexToModify); 
     431          modifyGridMask(mask_6d, indexToModify, modifyValue); 
    430432          break; 
    431433        case 7: 
    432           modifyGridMask(mask_7d, indexToModify); 
     434          modifyGridMask(mask_7d, indexToModify, modifyValue); 
     435          break; 
     436        default: 
     437          break; 
     438      } 
     439   } 
     440 
     441   void CGrid::modifyMaskSize(const std::vector<int>& newDimensionSize, bool newValue) 
     442   {       
     443      std::vector<CDomain*> domainP = this->getDomains(); 
     444      std::vector<CAxis*> axisP = this->getAxis(); 
     445      int dim = domainP.size() * 2 + axisP.size(); 
     446 
     447      switch (dim) { 
     448        case 1: 
     449          modifyGridMaskSize(mask_1d, newDimensionSize, newValue); 
     450          break; 
     451        case 2: 
     452          modifyGridMaskSize(mask_2d, newDimensionSize, newValue); 
     453          break; 
     454        case 3: 
     455          modifyGridMaskSize(mask_3d, newDimensionSize, newValue); 
     456          break; 
     457        case 4: 
     458          modifyGridMaskSize(mask_4d, newDimensionSize, newValue); 
     459          break; 
     460        case 5: 
     461          modifyGridMaskSize(mask_5d, newDimensionSize, newValue); 
     462          break; 
     463        case 6: 
     464          modifyGridMaskSize(mask_6d, newDimensionSize, newValue); 
     465          break; 
     466        case 7: 
     467          modifyGridMaskSize(mask_7d, newDimensionSize, newValue); 
    433468          break; 
    434469        default: 
     
    504539   { 
    505540     return axisPositionInGrid_; 
     541   } 
     542 
     543   void CGrid::computeWrittenIndex() 
     544   {       
     545      if (computedWrittenIndex_) return; 
     546      computedWrittenIndex_ = true; 
     547 
     548      size_t nbWritten = 0, indGlo; 
     549      CDistributionClient::GlobalLocalDataMap& globalDataIndex = clientDistribution_->getGlobalDataIndexOnClient(); 
     550      CDistributionClient::GlobalLocalDataMap::const_iterator itb = globalDataIndex.begin(), 
     551                                                              ite = globalDataIndex.end(), it;     
     552      const CDistributionServer::GlobalLocalMap& globalLocalIndex = serverDistribution_->getGlobalLocalIndex();                                                               
     553      CDistributionServer::GlobalLocalMap::const_iterator itSrvb = globalLocalIndex.begin(), 
     554                                                          itSrve = globalLocalIndex.end(), itSrv; 
     555      for (it = itb; it != ite; ++it) 
     556      { 
     557        indGlo = it->first; 
     558        if (globalLocalIndex.end() != globalLocalIndex.find(indGlo)) ++nbWritten;                 
     559      } 
     560 
     561      localIndexToWriteOnClient.resize(nbWritten);   
     562      localIndexToWriteOnServer.resize(nbWritten); 
     563 
     564      nbWritten = 0;  
     565      for (it = itb; it != ite; ++it) 
     566      { 
     567        indGlo = it->first; 
     568        itSrv = globalLocalIndex.find(indGlo); 
     569        if (itSrve != itSrv) 
     570        { 
     571          localIndexToWriteOnServer(nbWritten) = itSrv->second; 
     572          localIndexToWriteOnClient(nbWritten) = it->second; 
     573          ++nbWritten;                 
     574        }  
     575      } 
     576 
    506577   } 
    507578 
     
    526597 
    527598       // First of all, compute distribution on client side 
    528        if (0 != serverDistribution_) 
    529        { 
    530          clientDistribution_ = new CDistributionClient(rank, this, serverDistribution_->getGlobalLocalIndex()); 
    531          storeIndex_client.resize(serverDistribution_->getGridSize()); 
    532          int nbStoreIndex = storeIndex_client.numElements(); 
    533          for (int idx = 0; idx < nbStoreIndex; ++idx) storeIndex_client(idx) = idx; 
    534        } 
    535        else 
    536        { 
     599       // if (0 != serverDistribution_) 
     600       // { 
     601       //   // clientDistribution_ = new CDistributionClient(rank, this, serverDistribution_->getGlobalLocalIndex()); 
     602       //   clientDistribution_ = new CDistributionClient(rank, this); 
     603       //   storeIndex_client.resize(clientDistribution_->getLocalDataIndexOnClient().size()); 
     604       //   // storeIndex_client.resize(serverDistribution_->getGridSize()); 
     605       //   int nbStoreIndex = storeIndex_client.numElements(); 
     606       //   for (int idx = 0; idx < nbStoreIndex; ++idx) storeIndex_client(idx) = idx; 
     607       // } 
     608       // else 
     609       // { 
    537610         clientDistribution_ = new CDistributionClient(rank, this); 
    538611         // Get local data index on client 
     
    540613         int nbStoreIndex = storeIndex_client.numElements(); 
    541614         for (int idx = 0; idx < nbStoreIndex; ++idx) storeIndex_client(idx) = (clientDistribution_->getLocalDataIndexOnClient())[idx]; 
    542        } 
     615       // } 
    543616      
    544        if (0 == serverDistribution_)  
    545         isDataDistributed_= clientDistribution_->isDataDistributed(); 
     617       if (0 == serverDistribution_) isDataDistributed_= clientDistribution_->isDataDistributed(); 
     618       else           
     619       { 
     620           
     621          // Mapping global index received from clients to the storeIndex_client 
     622          CDistributionClient::GlobalLocalDataMap& globalDataIndex = clientDistribution_->getGlobalDataIndexOnClient(); 
     623          CDistributionClient::GlobalLocalDataMap::const_iterator itGloe = globalDataIndex.end(); 
     624          map<int, CArray<size_t, 1> >::iterator itb = outGlobalIndexFromClient.begin(), 
     625                                                 ite = outGlobalIndexFromClient.end(), it; 
     626                   
     627          for (it = itb; it != ite; ++it) 
     628          { 
     629            int rank = it->first; 
     630            CArray<size_t,1>& globalIndex = outGlobalIndexFromClient[rank]; 
     631            outLocalIndexStoreOnClient.insert(make_pair(rank, CArray<size_t,1>(globalIndex.numElements())));             
     632            CArray<size_t,1>& localIndex = outLocalIndexStoreOnClient[rank]; 
     633            size_t nbIndex = 0; 
     634            for (size_t idx = 0; idx < globalIndex.numElements(); ++idx) 
     635            { 
     636              if (itGloe != globalDataIndex.find(globalIndex(idx))) 
     637              { 
     638                ++nbIndex;                            
     639              }               
     640            } 
     641 
     642            if (nbIndex != localIndex.numElements()) 
     643                 ERROR("void CGrid::computeClientIndex()", 
     644                    << "Number of local index on client is different from number of received global index"  
     645                    << "Rank of sent client " << rank <<"." 
     646                    << "Number of local index " << nbIndex << ". " 
     647                    << "Number of received global index " << localIndex.numElements() << "."); 
     648 
     649            nbIndex = 0; 
     650            for (size_t idx = 0; idx < globalIndex.numElements(); ++idx) 
     651            { 
     652              if (itGloe != globalDataIndex.find(globalIndex(idx))) 
     653              {             
     654                localIndex(idx) = globalDataIndex[globalIndex(idx)];                 
     655              }               
     656            } 
     657 
     658 
     659          }           
     660        } 
    546661      } 
    547662   } 
     
    13411456      else 
    13421457      { 
    1343         CClientServerMapping::GlobalIndexMap::const_iterator iteGlobalMap, itGlobalMap, itbGlobalMap; 
    1344         itbGlobalMap = globalIndexOnServer_.begin(), itGlobalMap; 
     1458        // CClientServerMapping::GlobalIndexMap::const_iterator iteGlobalMap, itGlobalMap, itbGlobalMap; 
     1459        // itbGlobalMap = globalIndexOnServer_.begin(), itGlobalMap; 
     1460        // iteGlobalMap = globalIndexOnServer_.end(); 
     1461         
     1462        // std::map<int,int > nbGlobalLocalTmp; 
     1463        // for (itGlobalMap = itbGlobalMap; itGlobalMap != iteGlobalMap; ++itGlobalMap) 
     1464        // { 
     1465        //   int serverRank = itGlobalMap->first; 
     1466        //   nbGlobalLocalTmp[serverRank] = 0; 
     1467        //   const std::vector<size_t>& indexVec = itGlobalMap->second; 
     1468        //   int indexSize = indexVec.size();           
     1469        //   for (int idx = 0; idx < indexSize; ++idx) 
     1470        //   { 
     1471        //     itIndex = globalLocalIndexSendToServer.find(indexVec[idx]); 
     1472        //     if (iteIndex != itIndex) 
     1473        //     { 
     1474        //       ++nbGlobalLocalTmp[serverRank]; 
     1475        //     } 
     1476        //   } 
     1477        // } 
     1478 
     1479        // std::map<int,std::vector<int> >localIndexTmp; 
     1480        // std::map<int,std::vector<size_t> > globalIndexTmp; 
     1481        // for (std::map<int,int>::iterator it = nbGlobalLocalTmp.begin(); it != nbGlobalLocalTmp.end(); ++it) 
     1482        // { 
     1483        //   localIndexTmp[it->first].resize(it->second); 
     1484        //   globalIndexTmp[it->first].resize(it->second); 
     1485        //   it->second = 0; 
     1486        // } 
     1487 
     1488        // for (itGlobalMap = itbGlobalMap; itGlobalMap != iteGlobalMap; ++itGlobalMap) 
     1489        // { 
     1490        //   int serverRank = itGlobalMap->first;           
     1491        //   const std::vector<size_t>& indexVec = itGlobalMap->second; 
     1492        //   int indexSize = indexVec.size();           
     1493        //   int ind = 0; 
     1494        //   for (int idx = 0; idx < indexSize; ++idx) 
     1495        //   { 
     1496        //     itIndex = globalLocalIndexSendToServer.find(indexVec[idx]); 
     1497        //     if (iteIndex != itIndex) 
     1498        //     {               
     1499        //       ind = nbGlobalLocalTmp[serverRank]; 
     1500        //       globalIndexTmp[serverRank][ind] = itIndex->first; 
     1501        //       localIndexTmp[serverRank][ind]  = itIndex->second; 
     1502        //       ++nbGlobalLocalTmp[serverRank]; 
     1503        //     } 
     1504        //   } 
     1505        // } 
     1506 
     1507        CClientServerMapping::GlobalIndexMap::const_iterator iteGlobalMap, itGlobalMap; 
     1508        itGlobalMap = globalIndexOnServer_.begin(); 
    13451509        iteGlobalMap = globalIndexOnServer_.end(); 
    1346          
    1347         std::map<int,int > nbGlobalLocalTmp; 
    1348         for (itGlobalMap = itbGlobalMap; itGlobalMap != iteGlobalMap; ++itGlobalMap) 
     1510 
     1511        std::map<int,std::vector<int> >localIndexTmp; 
     1512        std::map<int,std::vector<size_t> > globalIndexTmp; 
     1513        for (; itGlobalMap != iteGlobalMap; ++itGlobalMap) 
    13491514        { 
    13501515          int serverRank = itGlobalMap->first; 
    1351           nbGlobalLocalTmp[serverRank] = 0; 
     1516          int indexSize = itGlobalMap->second.size(); 
    13521517          const std::vector<size_t>& indexVec = itGlobalMap->second; 
    1353           int indexSize = indexVec.size();           
    13541518          for (int idx = 0; idx < indexSize; ++idx) 
    13551519          { 
     
    13571521            if (iteIndex != itIndex) 
    13581522            { 
    1359               ++nbGlobalLocalTmp[serverRank]; 
    1360             } 
    1361           } 
    1362         } 
    1363  
    1364         std::map<int,std::vector<int> >localIndexTmp; 
    1365         std::map<int,std::vector<size_t> > globalIndexTmp; 
    1366         for (std::map<int,int>::iterator it = nbGlobalLocalTmp.begin(); it != nbGlobalLocalTmp.end(); ++it) 
    1367         { 
    1368           localIndexTmp[it->first].resize(it->second); 
    1369           globalIndexTmp[it->first].resize(it->second); 
    1370           it->second = 0; 
    1371         } 
    1372  
    1373         for (itGlobalMap = itbGlobalMap; itGlobalMap != iteGlobalMap; ++itGlobalMap) 
    1374         { 
    1375           int serverRank = itGlobalMap->first;           
    1376           const std::vector<size_t>& indexVec = itGlobalMap->second; 
    1377           int indexSize = indexVec.size();           
    1378           int ind = 0; 
    1379           for (int idx = 0; idx < indexSize; ++idx) 
    1380           { 
    1381             itIndex = globalLocalIndexSendToServer.find(indexVec[idx]); 
    1382             if (iteIndex != itIndex) 
    1383             {               
    1384               ind = nbGlobalLocalTmp[serverRank]; 
    1385               globalIndexTmp[serverRank][ind] = itIndex->first; 
    1386               localIndexTmp[serverRank][ind]  = itIndex->second; 
    1387               ++nbGlobalLocalTmp[serverRank]; 
     1523              globalIndexTmp[serverRank].push_back(itIndex->first); 
     1524              localIndexTmp[serverRank].push_back(itIndex->second); 
    13881525            } 
    13891526          } 
     
    14551592      //connectedServerRank_[p] = ranks; 
    14561593 
     1594      int idx = 0, numElement = axis_domain_order.numElements(); 
     1595      int ssize = numElement; 
     1596      std::vector<int> indexMap(numElement); 
     1597      for (int i = 0; i < numElement; ++i) 
     1598      { 
     1599        indexMap[i] = idx; 
     1600        if (2 == axis_domain_order(i)) 
     1601        { 
     1602          ++ssize; 
     1603          idx += 2; 
     1604        } 
     1605        else 
     1606          ++idx; 
     1607      } 
     1608 
    14571609      for (int n = 0; n < ranks.size(); n++) 
    14581610      { 
     
    14651617        if (0 == serverDistribution_) 
    14661618        { 
    1467           int idx = 0, numElement = axis_domain_order.numElements(); 
    1468           int ssize = numElement; 
    1469           std::vector<int> indexMap(numElement); 
    1470           for (int i = 0; i < numElement; ++i) 
    1471           { 
    1472             indexMap[i] = idx; 
    1473             if (2 == axis_domain_order(i)) 
    1474             { 
    1475               ++ssize; 
    1476               idx += 2; 
    1477             } 
    1478             else 
    1479               ++idx; 
    1480           } 
    1481  
    14821619          int axisId = 0, domainId = 0, scalarId = 0, globalSize = 1; 
    14831620          std::vector<CDomain*> domainList = getDomains(); 
     
    14921629              nZoomBegin[indexMap[i]] = domainList[domainId]->zoom_ibegin; 
    14931630              nZoomSize[indexMap[i]]  = domainList[domainId]->zoom_ni; 
    1494               nZoomBeginGlobal[indexMap[i]] = domainList[domainId]->global_zoom_ibegin; 
    1495               // zoomIndex.push_back(domainList[domainId]->zoom_i_index); 
     1631              nZoomBeginGlobal[indexMap[i]] = domainList[domainId]->global_zoom_ibegin;               
    14961632              nGlob[indexMap[i]] = domainList[domainId]->ni_glo; 
    14971633 
    14981634              nZoomBegin[indexMap[i] + 1] = domainList[domainId]->zoom_jbegin; 
    14991635              nZoomSize[indexMap[i] + 1] = domainList[domainId]->zoom_nj; 
    1500               nZoomBeginGlobal[indexMap[i] + 1] = domainList[domainId]->global_zoom_jbegin; 
    1501               // zoomIndex.push_back(domainList[domainId]->zoom_j_index); 
     1636              nZoomBeginGlobal[indexMap[i] + 1] = domainList[domainId]->global_zoom_jbegin;               
    15021637              nGlob[indexMap[i] + 1] = domainList[domainId]->nj_glo; 
    15031638 
    1504               // int nbZoom = domainList[domainId]->zoom_i_index.numElements(); 
    1505               // zoomIndex.push_back(CArray<int,1>(nbZoom)); 
    1506               // CArray<int,1>& zoomDomain = zoomIndex.back(); 
    1507               // for (int ind = 0; ind < nbZoom; ++ind) 
    1508               // { 
    1509               //   zoomDomain(ind) = domainList[domainId]->zoom_i_index(ind) + domainList[domainId]->zoom_j_index(ind) * domainList[domainId]->ni_glo; 
    1510               // } 
    1511  
    1512               // globalSize *= domainList[domainId]->ni_glo * domainList[domainId]->nj_glo; 
    15131639              ++domainId; 
    15141640            } 
     
    15171643              nZoomBegin[indexMap[i]] = axisList[axisId]->zoom_begin; 
    15181644              nZoomSize[indexMap[i]]  = axisList[axisId]->zoom_n; 
    1519               nZoomBeginGlobal[indexMap[i]] = axisList[axisId]->global_zoom_begin; 
    1520               // zoomIndex.push_back(axisList[axisId]->zoom_index); 
    1521               nGlob[indexMap[i]] = axisList[axisId]->n_glo; 
    1522               // globalSize *= axisList[axisId]->n_glo; 
     1645              nZoomBeginGlobal[indexMap[i]] = axisList[axisId]->global_zoom_begin;               
     1646              nGlob[indexMap[i]] = axisList[axisId]->n_glo;               
    15231647              ++axisId; 
    15241648            } 
    15251649            else // scalar 
    1526             { 
    1527               // CArray<int,1> zoomScalar(1); 
    1528               // zoomScalar(0) = 0; 
     1650            {  
    15291651              nZoomBegin[indexMap[i]] = 0; 
    15301652              nZoomSize[indexMap[i]]  = 1; 
    1531               nZoomBeginGlobal[indexMap[i]] = 0; 
    1532               // zoomIndex.push_back(zoomScalar); 
     1653              nZoomBeginGlobal[indexMap[i]] = 0;               
    15331654              nGlob[indexMap[i]] = 1; 
     1655 
    15341656              ++scalarId; 
    15351657            } 
     
    15411663          serverDistribution_ = new CDistributionServer(server->intraCommRank, nZoomBegin, nZoomSize, 
    15421664                                                        nZoomBeginGlobal, nGlob); 
    1543           // for (int i = 0; i < zoomIndex.size(); ++i) 
    1544           // { 
    1545           //   dataSize *= zoomIndex[i].numElements(); 
    1546           // } 
    1547           // serverDistribution_ = new CDistributionServer(server->intraCommRank, zoomIndex, nGlobElement); 
    15481665        } 
    15491666 
    15501667        CArray<size_t,1> outIndex; 
    15511668        buffer >> outIndex; 
    1552         serverDistribution_->computeLocalIndex(outIndex); 
     1669        outGlobalIndexFromClient.insert(std::make_pair(rank, outIndex));         
    15531670 
    15541671        if (isDataDistributed_) 
     
    15681685        writtenDataSize_ += dataSize; 
    15691686 
    1570         outIndexFromClient.insert(std::make_pair(rank, outIndex)); 
     1687        // outIndexFromClient.insert(std::make_pair(rank, outIndex)); 
    15711688        // connectedDataSize_[p][rank] = outIndex.numElements(); 
    15721689        numberWrittenIndexes_ += outIndex.numElements(); 
    15731690      } 
    15741691 
    1575       // int sizeData = 0; 
    1576       // for (map<int, CArray<size_t, 1> >::iterator it = outIndexFromClient.begin(); it != outIndexFromClient.end(); ++it) 
    1577       // { 
    1578       //   sizeData += it->second.numElements(); 
    1579       // } 
    1580       // indexFromClients.resize(sizeData); 
    1581       // sizeData = 0; 
    1582       // for (map<int, CArray<size_t, 1> >::iterator it = outIndexFromClient.begin(); it != outIndexFromClient.end(); ++it) 
    1583       // { 
    1584       //    CArray<size_t, 1>& tmp0 = it->second; 
    1585       //    CArray<size_t, 1> tmp1 = indexFromClients(Range(sizeData, sizeData + tmp0.numElements() - 1)); 
    1586       //    tmp1 = tmp0; 
    1587       //    sizeData += tmp0.numElements(); 
    1588       // } 
     1692 
     1693      // Compute mask of the current grid 
     1694      { 
     1695        int axisId = 0, domainId = 0, scalarId = 0, globalSize = 1; 
     1696        std::vector<CDomain*> domainList = getDomains(); 
     1697        std::vector<CAxis*> axisList = getAxis(); 
     1698        std::vector<int> nBegin(ssize), nSize(ssize), nGlob(ssize), nBeginGlobal(ssize);         
     1699        for (int i = 0; i < numElement; ++i) 
     1700        {           
     1701          if (2 == axis_domain_order(i)) //domain 
     1702          { 
     1703            nBegin[indexMap[i]] = domainList[domainId]->ibegin; 
     1704            nSize[indexMap[i]]  = domainList[domainId]->ni; 
     1705            nBeginGlobal[indexMap[i]] = 0;               
     1706            nGlob[indexMap[i]] = domainList[domainId]->ni_glo; 
     1707 
     1708            nBegin[indexMap[i] + 1] = domainList[domainId]->jbegin; 
     1709            nSize[indexMap[i] + 1] = domainList[domainId]->nj; 
     1710            nBeginGlobal[indexMap[i] + 1] = 0;               
     1711            nGlob[indexMap[i] + 1] = domainList[domainId]->nj_glo; 
     1712 
     1713            ++domainId; 
     1714          } 
     1715          else if (1 == axis_domain_order(i)) // axis 
     1716          { 
     1717            nBegin[indexMap[i]] = axisList[axisId]->begin; 
     1718            nSize[indexMap[i]]  = axisList[axisId]->n; 
     1719            nBeginGlobal[indexMap[i]] = 0;               
     1720            nGlob[indexMap[i]] = axisList[axisId]->n_glo;               
     1721            ++axisId; 
     1722          } 
     1723          else // scalar 
     1724          {  
     1725            nBegin[indexMap[i]] = 0; 
     1726            nSize[indexMap[i]]  = 1; 
     1727            nBeginGlobal[indexMap[i]] = 0;               
     1728            nGlob[indexMap[i]] = 1; 
     1729 
     1730            ++scalarId; 
     1731          } 
     1732        } 
     1733         
     1734        modifyMaskSize(nSize, true); 
     1735        // These below codes are reserved for future 
     1736        // CDistributionServer srvDist(server->intraCommRank, nBegin, nSize, nBeginGlobal, nGlob);  
     1737        // map<int, CArray<size_t, 1> >::iterator itb = outGlobalIndexFromClient.begin(), 
     1738        //                                        ite = outGlobalIndexFromClient.end(), it;   
     1739        // const CDistributionServer::GlobalLocalMap&  globalLocalMask = srvDist.getGlobalLocalIndex(); 
     1740        // CDistributionServer::GlobalLocalMap::const_iterator itSrv; 
     1741        // size_t nb = 0; 
     1742        // for (it = itb; it != ite; ++it) 
     1743        // { 
     1744        //   CArray<size_t,1>& globalInd = it->second; 
     1745        //   for (size_t idx = 0; idx < globalInd.numElements(); ++idx) 
     1746        //   { 
     1747        //     if (globalLocalMask.end() != globalLocalMask.find(globalInd(idx))) ++nb; 
     1748        //   } 
     1749        // } 
     1750         
     1751        // CArray<int,1> indexToModify(nb); 
     1752        // nb = 0;     
     1753        // for (it = itb; it != ite; ++it) 
     1754        // { 
     1755        //   CArray<size_t,1>& globalInd = it->second; 
     1756        //   for (size_t idx = 0; idx < globalInd.numElements(); ++idx) 
     1757        //   { 
     1758        //     itSrv = globalLocalMask.find(globalInd(idx)); 
     1759        //     if (globalLocalMask.end() != itSrv)  
     1760        //     { 
     1761        //       indexToModify(nb) = itSrv->second; 
     1762        //       ++nb; 
     1763        //     } 
     1764        //   } 
     1765        // } 
     1766 
     1767        // modifyMask(indexToModify, true); 
     1768      } 
    15891769 
    15901770      // if (isScalarGrid()) return; 
  • XIOS/dev/dev_olga/src/node/grid.hpp

    r1099 r1129  
    140140         void computeIndexScalarGrid(); 
    141141         void computeCompressedIndex(); 
     142         void computeWrittenIndex(); 
    142143 
    143144         void solveDomainRef(bool checkAtt); 
     
    224225         std::vector<map<int,int> > nbSenders; 
    225226 
    226          map<int, CArray<size_t, 1> > outIndexFromClient, compressedOutIndexFromClient; 
     227         map<int, CArray<size_t, 1> > outIndexFromClient, compressedOutIndexFromClient, outGlobalIndexFromClient; 
     228 
     229         // A client receives global index from other clients (via recvIndex) 
     230         // then does mapping these index into local index of STORE_CLIENTINDEX 
     231         // In this way, store_clientIndex can be used as an input of a source filter 
     232         // Maybe we need a flag to determine whether a client wants to write. TODO 
     233         map<int, CArray<size_t, 1> > outLocalIndexStoreOnClient;  
     234 
     235         // If a client wants to write out data, it'll use this index. 
     236         // A client receives global index of data from other clients (via recvIndex), 
     237         // then does remapping these index into local index to WRITE into a file 
     238         CArray<size_t,1> localIndexToWriteOnClient, localIndexToWriteOnServer; 
     239 
    227240         CArray<size_t,1> indexFromClients; 
    228241         void checkMask(void); 
    229242         void createMask(void); 
    230          void modifyMask(const CArray<int,1>& indexToModify); 
     243         void modifyMask(const CArray<int,1>& indexToModify, bool valueToModify = false); 
     244         void modifyMaskSize(const std::vector<int>& newDimensionSize, bool newValue = false); 
    231245 
    232246         void computeGridGlobalDimension(const std::vector<CDomain*>& domains, 
     
    243257                          bool createMask = false); 
    244258        template<int N> 
    245         void modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify); 
     259        void modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify, bool valueToModify); 
     260 
     261        template<int N> 
     262        void modifyGridMaskSize(CArray<bool,N>& gridMask, const std::vector<int>& eachDimSize, bool newValue); 
    246263 
    247264        void setVirtualDomainGroup(CDomainGroup* newVDomainGroup); 
     
    285302        std::set<std::string> relFilesCompressed; 
    286303 
    287         bool isTransformed_; 
    288         bool isGenerated_; 
     304        bool isTransformed_, isGenerated_; 
     305        bool computedWrittenIndex_; 
    289306        std::vector<int> axisPositionInGrid_; 
    290307        CGridTransformation* transformations_; 
     
    416433   } 
    417434 
     435   template<int N> 
     436   void CGrid::modifyGridMaskSize(CArray<bool,N>& gridMask, 
     437                                  const std::vector<int>& eachDimSize, 
     438                                  bool newValue) 
     439   { 
     440      if (N != eachDimSize.size()) 
     441      { 
     442        // ERROR("CGrid::modifyGridMaskSize(CArray<bool,N>& gridMask, 
     443        //                                  const std::vector<int>& eachDimSize, 
     444        //                                  bool newValue)", 
     445        //       << "Dimension size of the mask is different from input dimension size." << std::endl 
     446        //       << "Mask dimension is " << N << "." << std::endl 
     447        //       << "Input dimension is " << eachDimSize.size() << "." << std::endl 
     448        //       << "Grid = " << this->GetName()) 
     449      } 
     450      CArrayBoolTraits<CArray<bool,N> >::resizeArray(gridMask,eachDimSize); 
     451      gridMask = newValue; 
     452   } 
     453                                  
     454 
    418455   /*! 
    419456     Modify the current mask of grid, the local index to be modified will take value false 
     
    422459   */ 
    423460   template<int N> 
    424    void CGrid::modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify) 
    425    { 
    426      bool valueToModify = false; 
     461   void CGrid::modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify, bool valueToModify) 
     462   {      
    427463     int num = indexToModify.numElements(); 
    428464     for (int idx = 0; idx < num; ++idx) 
  • XIOS/dev/dev_olga/src/transformation/axis_algorithm_zoom.cpp

    r933 r1129  
    6060void CAxisAlgorithmZoom::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
    6161{ 
     62  // We use all index of source and destination to calculate the mapping index of zoom. 
     63  // The server who receives the "zoomed" fields will decide whether it will forward these fields or write "real zoomed" fields into file 
     64  // That means servers need to change to cover this problem. 
    6265  StdSize niSource = axisSrc_->n.getValue(); 
    6366  StdSize ibeginSource = axisSrc_->begin.getValue(); 
     
    6669  StdSize ibegin = std::max(ibeginSource, zoomBegin_); 
    6770  StdSize iend = std::min(iendSource, zoomEnd_); 
     71  // StdSize ibegin = ibeginSource; 
     72  // StdSize iend = iendSource; 
    6873  StdSize ni = iend + 1 - ibegin; 
    6974  if (iend < ibegin) ni = 0; 
     
    8287 
    8388  updateZoom(); 
    84   updateAxisDestinationMask(); 
     89  // updateAxisDestinationMask(); 
    8590} 
    8691 
  • XIOS/dev/dev_olga/src/transformation/domain_algorithm_zoom.cpp

    r933 r1129  
    113113 
    114114  updateZoom(); 
    115   updateDomainDestinationMask(); 
     115  // updateDomainDestinationMask(); 
    116116} 
    117117 
Note: See TracChangeset for help on using the changeset viewer.