Changeset 1023


Ignore:
Timestamp:
01/11/17 12:23:22 (4 years ago)
Author:
mhnguyen
Message:

Try committing with rapidSvn

File:
1 edited

Legend:

Unmodified
Added
Removed
  • XIOS/dev/dev_olga/src/node/grid.cpp

    r1021 r1023  
    273273   { 
    274274     CContext* context = CContext::getCurrent(); 
    275      CContextClient* client; 
     275     CContextClient* client= context->hasServer ? context->clientPrimServer : context->client; 
    276276 
    277277     int nbSrvPools = (context->hasServer) ? context->clientPrimServer.size() : 1; 
    278278     for (int i = 0; i < nbSrvPools; ++i) 
    279279     { 
    280        if (context->hasClient) 
    281        { 
    282          if (context->hasServer) 
    283            client = context->clientPrimServer[i]; 
    284          else 
    285            client = context->client; 
    286        } 
    287  
    288        if (isScalarGrid()) 
    289        { 
    290          if (context->hasClient && !context->hasServer) 
    291   //         if (context->hasClient) 
    292             if (this->isChecked && doSendingIndex && !isIndexSent) { sendIndexScalarGrid(); this->isIndexSent = true; } 
    293  
    294          if (this->isChecked) return; 
    295          if (context->hasClient && !context->hasServer) 
    296   //       if (context->hasClient) 
    297          { 
    298             this->computeIndexScalarGrid(); 
    299          } 
     280                 if (isScalarGrid()) 
     281                 { 
     282                   // if (context->hasClient && !context->hasServer) 
     283                        if (context->hasClient) 
     284                          if (this->isChecked && doSendingIndex && !isIndexSent) { sendIndexScalarGrid(); this->isIndexSent = true; } 
     285 
     286                   if (this->isChecked) return; 
     287                   // if (context->hasClient && !context->hasServer) 
     288                   if (context->hasClient) 
     289                   { 
     290                          this->computeIndexScalarGrid(); 
     291                   } 
    300292 
    301293//         this->isChecked = true; 
    302294         if (!(this->hasTransform() && !this->isTransformed())) 
    303295          this->isChecked = true; 
    304          return; 
    305        } 
    306  
    307        if (context->hasClient && !context->hasServer) 
    308   //     if (context->hasClient) 
    309         if (this->isChecked && doSendingIndex && !isIndexSent) { sendIndex(); this->isIndexSent = true; } 
    310  
    311        if (this->isChecked) return; 
    312  
    313        if (context->hasClient && !context->hasServer) 
    314   //     if (context->hasClient) 
    315        { 
    316           this->checkAttributesAfterTransformation(); 
    317           this->checkMask(); 
    318           this->computeIndex(); 
    319        } 
    320 //       this->isChecked = true; 
    321        if (!(this->hasTransform() && !this->isTransformed())) 
    322         this->isChecked = true; 
    323  
    324        if (!(this->hasTransform() && (!this->isGenerated()))) 
    325         this->isChecked = true; 
     296                   return; 
     297                 } 
     298 
     299                 // if (context->hasClient && !context->hasServer) 
     300                // if (context->hasClient) 
     301                //   if (doSendingIndex && !isIndexSent)  
     302                  { 
     303                        if (context->hasClient)  
     304                        { 
     305                          if (this->isChecked && doSendingIndex && !isIndexSent)  
     306                            {sendIndex(); this->isIndexSent = true;} 
     307                        } 
     308 
     309                        if (this->isChecked) return; 
     310                        this->checkAttributesAfterTransformation(); 
     311                        this->checkMask(); 
     312                        this->computeIndex();      
     313        //       this->isChecked = true; 
     314                   if (!(this->hasTransform() && !this->isTransformed())) 
     315                    this->isChecked = true; 
     316 
     317                   if (!(this->hasTransform() && (!this->isGenerated()))) 
     318                    this->isChecked = true; 
     319                         
     320 
     321                  } 
     322 
     323                //  if (this->isChecked) return; 
     324 
     325                //  // if (context->hasClient && !context->hasServer) 
     326                // // if (context->hasClient) 
     327                //  { 
     328                //     this->checkAttributesAfterTransformation(); 
     329                //     this->checkMask(); 
     330                //     this->computeIndex(); 
     331                //  } 
     332                //  this->isChecked = true; 
    326333     } 
    327334   } 
     
    423430          break; 
    424431        case 4: 
    425           modifyGridMask(mask_1d, indexToModify); 
     432          modifyGridMask(mask_4d, indexToModify); 
    426433          break; 
    427434        case 5: 
    428           modifyGridMask(mask_2d, indexToModify); 
     435          modifyGridMask(mask_5d, indexToModify); 
    429436          break; 
    430437        case 6: 
    431           modifyGridMask(mask_3d, indexToModify); 
     438          modifyGridMask(mask_6d, indexToModify); 
    432439          break; 
    433440        case 7: 
    434           modifyGridMask(mask_3d, indexToModify); 
     441          modifyGridMask(mask_7d, indexToModify); 
    435442          break; 
    436443        default: 
     
    509516 
    510517   //--------------------------------------------------------------- 
     518 
     519   void CGrid::computeClientIndex() 
     520   { 
     521     CContext* context = CContext::getCurrent(); 
     522 
     523     CContextClient* client = (context->hasServer) ? context->clientPrimServer : context->client; 
     524     CContextServer* server = (context->hasServer) ? context->server : 0 ; 
     525     int rank = (server && !client) ? server->intraCommRank : client->clientRank; 
     526 
     527     // First of all, compute distribution on client side 
     528     if (0 != serverDistribution_) 
     529       clientDistribution_ = new CDistributionClient(rank, this, serverDistribution_->getGlobalLocalIndex()); 
     530     else 
     531       clientDistribution_ = new CDistributionClient(rank, this); 
     532 
     533     // Get local data index on client      
     534     storeIndex_client.resize(clientDistribution_->getLocalDataIndexOnClient().size()); 
     535     int nbStoreIndex = storeIndex_client.numElements(); 
     536     for (int idx = 0; idx < nbStoreIndex; ++idx) storeIndex_client(idx) = (clientDistribution_->getLocalDataIndexOnClient())[idx]; 
     537     isDataDistributed_= clientDistribution_->isDataDistributed(); 
     538   } 
     539 
     540   void CGrid::computeConnectedClients() 
     541   { 
     542     CContext* context = CContext::getCurrent(); 
     543     CContextClient* client = (context->hasServer) ? context->clientPrimServer : context->client; 
     544 
     545     connectedServerRank_.clear(); 
     546 
     547     if (!doGridHaveDataDistributed()) 
     548     { 
     549        if (client->isServerLeader()) 
     550        { 
     551          size_t ssize = clientDistribution_->getLocalDataIndexOnClient().size(); 
     552          const std::list<int>& ranks = client->getRanksServerLeader(); 
     553          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     554          { 
     555            connectedServerRank_.push_back(*itRank); 
     556            connectedDataSize_[*itRank] = ssize; 
     557          } 
     558        } 
     559        return; 
     560     } 
     561 
     562     // Compute mapping between client and server 
     563     std::vector<boost::unordered_map<size_t,std::vector<int> > > indexServerOnElement; 
     564     CServerDistributionDescription serverDistributionDescription(globalDim_, client->serverSize); 
     565     serverDistributionDescription.computeServerGlobalByElement(indexServerOnElement, 
     566                                                                client->clientRank, 
     567                                                                client->clientSize, 
     568                                                                axis_domain_order, 
     569                                                                positionDimensionDistributed_); 
     570     computeIndexByElement(indexServerOnElement, globalIndexOnServer_); 
     571 
     572     const CDistributionClient::GlobalLocalDataMap& globalLocalIndexSendToServer = clientDistribution_->getGlobalLocalDataSendToServer(); 
     573     CDistributionClient::GlobalLocalDataMap::const_iterator iteGlobalLocalIndexMap = globalLocalIndexSendToServer.end(), itGlobalLocalIndexMap; 
     574     CClientServerMapping::GlobalIndexMap::const_iterator iteGlobalMap, itbGlobalMap, itGlobalMap; 
     575     itGlobalMap  = itbGlobalMap = globalIndexOnServer_.begin(); 
     576     iteGlobalMap = globalIndexOnServer_.end(); 
     577 
     578     for (; itGlobalMap != iteGlobalMap; ++itGlobalMap) 
     579     { 
     580       int serverRank = itGlobalMap->first; 
     581       int indexSize = itGlobalMap->second.size(); 
     582       const std::vector<size_t>& indexVec = itGlobalMap->second; 
     583       for (int idx = 0; idx < indexSize; ++idx) 
     584       { 
     585          itGlobalLocalIndexMap = globalLocalIndexSendToServer.find(indexVec[idx]); 
     586          if (iteGlobalLocalIndexMap != itGlobalLocalIndexMap) 
     587          { 
     588             if (connectedDataSize_.end() == connectedDataSize_.find(serverRank)) 
     589               connectedDataSize_[serverRank] = 1; 
     590             else 
     591               ++connectedDataSize_[serverRank]; 
     592          } 
     593       } 
     594     } 
     595 
     596     for (itGlobalMap = itbGlobalMap; itGlobalMap != iteGlobalMap; ++itGlobalMap) { 
     597       connectedServerRank_.push_back(itGlobalMap->first); 
     598     } 
     599 
     600     nbSenders = clientServerMap_->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_); 
     601   } 
    511602 
    512603   /*! 
     
    521612     CContext* context = CContext::getCurrent(); 
    522613//     CContextClient* client = context->client; 
     614     // CContextClient* client = (context->hasServer) ? context->clientPrimServer : context->client; 
     615      
     616 
     617     // // First of all, compute distribution on client side 
     618     // if (0 != serverDistribution_) 
     619     //   clientDistribution_ = new CDistributionClient(client->clientRank, this, serverDistribution_->getGlobalLocalIndex()); 
     620     // else 
     621     //   clientDistribution_ = new CDistributionClient(client->clientRank, this); 
     622 
     623     // // Get local data index on client 
     624     // int tmp = clientDistribution_->getLocalDataIndexOnClient().size(); 
     625     // storeIndex_client.resize(clientDistribution_->getLocalDataIndexOnClient().size()); 
     626     // int nbStoreIndex = storeIndex_client.numElements(); 
     627     // for (int idx = 0; idx < nbStoreIndex; ++idx) storeIndex_client(idx) = (clientDistribution_->getLocalDataIndexOnClient())[idx]; 
     628     // isDataDistributed_= clientDistribution_->isDataDistributed(); 
     629 
    523630     int nbSrvPools = (context->hasServer) ? context->clientPrimServer.size() : 1; 
    524631     for (int i = 0; i < nbSrvPools; ++i) 
    525632     { 
    526633       CContextClient* client = (context->hasServer) ? context->clientPrimServer[i] : context->client; 
    527  
    528  
    529        // First of all, compute distribution on client side 
    530        if (0 != serverDistribution_) 
    531          clientDistribution_ = new CDistributionClient(client->clientRank, serverDistribution_->getGlobalLocalIndex()); 
    532        else 
    533          clientDistribution_ = new CDistributionClient(client->clientRank, this); 
    534  
    535        // Get local data index on client 
    536        int tmp = clientDistribution_->getLocalDataIndexOnClient().size(); 
    537        storeIndex_client.resize(clientDistribution_->getLocalDataIndexOnClient().size()); 
    538        int nbStoreIndex = storeIndex_client.numElements(); 
    539        for (int idx = 0; idx < nbStoreIndex; ++idx) storeIndex_client(idx) = (clientDistribution_->getLocalDataIndexOnClient())[idx]; 
    540        isDataDistributed_= clientDistribution_->isDataDistributed(); 
    541  
    542        connectedServerRank_.clear(); 
    543  
    544        if (!doGridHaveDataDistributed()) 
    545        { 
    546           if (client->isServerLeader()) 
    547           { 
    548             size_t ssize = clientDistribution_->getLocalDataIndexOnClient().size(); 
    549             const std::list<int>& ranks = client->getRanksServerLeader(); 
    550             for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    551             { 
    552               connectedServerRank_.push_back(*itRank); 
    553               connectedDataSize_[*itRank] = ssize; 
    554             } 
    555           } 
    556           return; 
    557        } 
    558  
    559        // Compute mapping between client and server 
    560        std::vector<boost::unordered_map<size_t,std::vector<int> > > indexServerOnElement; 
    561        CServerDistributionDescription serverDistributionDescription(globalDim_, client->serverSize); 
    562        serverDistributionDescription.computeServerGlobalByElement(indexServerOnElement, 
    563                                                                   client->clientRank, 
    564                                                                   client->clientSize, 
    565                                                                   axis_domain_order, 
    566                                                                   positionDimensionDistributed_); 
    567        computeIndexByElement(indexServerOnElement, globalIndexOnServer_); 
    568  
    569        const CDistributionClient::GlobalLocalDataMap& globalLocalIndexSendToServer = clientDistribution_->getGlobalLocalDataSendToServer(); 
    570        CDistributionClient::GlobalLocalDataMap::const_iterator iteGlobalLocalIndexMap = globalLocalIndexSendToServer.end(), itGlobalLocalIndexMap; 
    571        CClientServerMapping::GlobalIndexMap::const_iterator iteGlobalMap, itbGlobalMap, itGlobalMap; 
    572        itGlobalMap  = itbGlobalMap = globalIndexOnServer_.begin(); 
    573        iteGlobalMap = globalIndexOnServer_.end(); 
    574  
    575        for (; itGlobalMap != iteGlobalMap; ++itGlobalMap) 
    576        { 
    577          int serverRank = itGlobalMap->first; 
    578          int indexSize = itGlobalMap->second.size(); 
    579          const std::vector<size_t>& indexVec = itGlobalMap->second; 
    580          for (int idx = 0; idx < indexSize; ++idx) 
    581          { 
    582             itGlobalLocalIndexMap = globalLocalIndexSendToServer.find(indexVec[idx]); 
    583             if (iteGlobalLocalIndexMap != itGlobalLocalIndexMap) 
    584             { 
    585                if (connectedDataSize_.end() == connectedDataSize_.find(serverRank)) 
    586                  connectedDataSize_[serverRank] = 1; 
    587                else 
    588                  ++connectedDataSize_[serverRank]; 
    589             } 
    590          } 
    591        } 
    592  
    593        for (itGlobalMap = itbGlobalMap; itGlobalMap != iteGlobalMap; ++itGlobalMap) { 
    594          connectedServerRank_.push_back(itGlobalMap->first); 
    595        } 
    596  
    597        nbSenders = clientServerMap_->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_); 
    598      } 
     634       computeClientIndex(); 
     635       if (context->hasClient) 
     636        computeConnectedClients(); 
     637         } 
     638 
     639     // connectedServerRank_.clear(); 
     640 
     641     // if (!doGridHaveDataDistributed()) 
     642     // { 
     643     //    if (client->isServerLeader()) 
     644     //    { 
     645     //      size_t ssize = clientDistribution_->getLocalDataIndexOnClient().size(); 
     646     //      const std::list<int>& ranks = client->getRanksServerLeader(); 
     647     //      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     648     //      { 
     649     //        connectedServerRank_.push_back(*itRank); 
     650     //        connectedDataSize_[*itRank] = ssize; 
     651     //      } 
     652     //    } 
     653     //    return; 
     654     // } 
     655 
     656     // // Compute mapping between client and server 
     657     // std::vector<boost::unordered_map<size_t,std::vector<int> > > indexServerOnElement; 
     658     // CServerDistributionDescription serverDistributionDescription(globalDim_, client->serverSize); 
     659     // serverDistributionDescription.computeServerGlobalByElement(indexServerOnElement, 
     660     //                                                            client->clientRank, 
     661     //                                                            client->clientSize, 
     662     //                                                            axis_domain_order, 
     663     //                                                            positionDimensionDistributed_); 
     664     // computeIndexByElement(indexServerOnElement, globalIndexOnServer_); 
     665 
     666     // const CDistributionClient::GlobalLocalDataMap& globalLocalIndexSendToServer = clientDistribution_->getGlobalLocalDataSendToServer(); 
     667     // CDistributionClient::GlobalLocalDataMap::const_iterator iteGlobalLocalIndexMap = globalLocalIndexSendToServer.end(), itGlobalLocalIndexMap; 
     668     // CClientServerMapping::GlobalIndexMap::const_iterator iteGlobalMap, itbGlobalMap, itGlobalMap; 
     669     // itGlobalMap  = itbGlobalMap = globalIndexOnServer_.begin(); 
     670     // iteGlobalMap = globalIndexOnServer_.end(); 
     671 
     672     // for (; itGlobalMap != iteGlobalMap; ++itGlobalMap) 
     673     // { 
     674     //   int serverRank = itGlobalMap->first; 
     675     //   int indexSize = itGlobalMap->second.size(); 
     676     //   const std::vector<size_t>& indexVec = itGlobalMap->second; 
     677     //   for (int idx = 0; idx < indexSize; ++idx) 
     678     //   { 
     679     //      itGlobalLocalIndexMap = globalLocalIndexSendToServer.find(indexVec[idx]); 
     680     //      if (iteGlobalLocalIndexMap != itGlobalLocalIndexMap) 
     681     //      { 
     682     //         if (connectedDataSize_.end() == connectedDataSize_.find(serverRank)) 
     683     //           connectedDataSize_[serverRank] = 1; 
     684     //         else 
     685     //           ++connectedDataSize_[serverRank]; 
     686     //      } 
     687     //   } 
     688     // } 
     689 
     690     // for (itGlobalMap = itbGlobalMap; itGlobalMap != iteGlobalMap; ++itGlobalMap) { 
     691     //   connectedServerRank_.push_back(itGlobalMap->first); 
     692     // } 
     693 
     694     // nbSenders = clientServerMap_->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_); 
    599695   } 
    600696 
     
    10051101   void CGrid::restoreField_arr(const CArray<double, 1>& stored, double* const data) const 
    10061102   { 
    1007       const StdSize size = storeIndex_client.numElements(); 
    1008  
    1009       for(StdSize i = 0; i < size; i++) data[storeIndex_client(i)] = stored(i); 
     1103      // const StdSize size = storeIndex_client.numElements(); 
     1104 
     1105      // for(StdSize i = 0; i < size; i++) data[storeIndex_client(i)] = stored(i); 
     1106       
     1107      const StdSize size = indexFromClients.numElements(); 
     1108 
     1109      for(StdSize i = 0; i < size; i++) data[indexFromClients(i)] = stored(i); 
     1110 
    10101111   } 
    10111112 
     
    12141315 
    12151316        for (int ns = 0; ns < connectedServerRank_.size(); ++ns) 
    1216 //        for (int ns = 0; ns < client->serverSize; ++ns) 
    12171317        { 
    12181318          rank = connectedServerRank_[ns]; 
     
    12601360    } 
    12611361    get(gridId)->recvIndex(ranks, buffers); 
    1262  
     1362  } 
     1363 
     1364  void CGrid::recvIndex(vector<int> ranks, vector<CBufferIn*> buffers) 
     1365  { 
    12631366    CContext* context = CContext::getCurrent(); 
    1264     if (context->hasClient && context->hasServer) 
    1265     { 
    1266       get(gridId)->computeIndex(); 
    1267       get(gridId)->sendIndex(); 
    1268     } 
    1269   } 
    1270  
    1271   void CGrid::recvIndex(vector<int> ranks, vector<CBufferIn*> buffers) 
    1272   { 
    1273     CContext* context = CContext::getCurrent(); 
    1274 //    CContextServer* server = (context->hasServer) ? context->server : context->serverPrimServer; 
    1275 //    CContextClient* client = (context->hasServer) ? context->client : context->clientPrimServer; 
    1276     CContextServer* server = context->server; 
    1277     CContextClient* client = context->client; 
     1367    CContextServer* server = (context->hasServer) ? context->server : context->serverPrimServer; 
     1368    CContextClient* client = (context->hasServer) ? context->client : context->clientPrimServer; 
    12781369    numberWrittenIndexes_ = totalNumberWrittenIndexes_ = offsetWrittenIndexes_ = 0; 
    12791370    connectedServerRank_ = ranks; 
     
    13041395        } 
    13051396 
    1306         int axisId = 0, domainId = 0, scalarId = 0; 
     1397        int axisId = 0, domainId = 0, scalarId = 0, globalSize = 1; 
    13071398        std::vector<CDomain*> domainList = getDomains(); 
    13081399        std::vector<CAxis*> axisList = getAxis(); 
    1309         std::vector<int> nZoomBegin(ssize), nZoomSize(ssize), nGlob(ssize), nZoomBeginGlobal(ssize); 
     1400        std::vector<int> nZoomBegin(ssize), nZoomSize(ssize), nGlob(ssize), nZoomBeginGlobal(ssize), nGlobElement(numElement); 
     1401        std::vector<CArray<int,1> > zoomIndex;  
    13101402        for (int i = 0; i < numElement; ++i) 
    13111403        { 
     1404          nGlobElement[i] = globalSize;  
    13121405          if (2 == axis_domain_order(i)) //domain 
    13131406          { 
    1314             nZoomBegin[indexMap[i]] = domainList[domainId]->zoom_ibegin_srv; 
    1315             nZoomSize[indexMap[i]]  = domainList[domainId]->zoom_ni_srv; 
    1316             nZoomBeginGlobal[indexMap[i]] = domainList[domainId]->global_zoom_ibegin; 
    1317             nGlob[indexMap[i]] = domainList[domainId]->ni_glo; 
    1318  
    1319             nZoomBegin[indexMap[i] + 1] = domainList[domainId]->zoom_jbegin_srv; 
    1320             nZoomSize[indexMap[i] + 1] = domainList[domainId]->zoom_nj_srv; 
    1321             nZoomBeginGlobal[indexMap[i] + 1] = domainList[domainId]->global_zoom_jbegin; 
    1322             nGlob[indexMap[i] + 1] = domainList[domainId]->nj_glo; 
     1407            // nZoomBegin[indexMap[i]] = domainList[domainId]->zoom_ibegin_srv; 
     1408            // nZoomSize[indexMap[i]]  = domainList[domainId]->zoom_ni_srv; 
     1409            // nZoomBeginGlobal[indexMap[i]] = domainList[domainId]->global_zoom_ibegin; 
     1410            // zoomIndex.push_back(domainList[domainId]->zoom_i_index); 
     1411            // nGlob[indexMap[i]] = domainList[domainId]->ni_glo; 
     1412 
     1413            // nZoomBegin[indexMap[i] + 1] = domainList[domainId]->zoom_jbegin_srv; 
     1414            // nZoomSize[indexMap[i] + 1] = domainList[domainId]->zoom_nj_srv; 
     1415            // nZoomBeginGlobal[indexMap[i] + 1] = domainList[domainId]->global_zoom_jbegin; 
     1416            // zoomIndex.push_back(domainList[domainId]->zoom_j_index); 
     1417            // nGlob[indexMap[i] + 1] = domainList[domainId]->nj_glo; 
     1418 
     1419            int nbZoom = domainList[domainId]->zoom_i_index.numElements();             
     1420            zoomIndex.push_back(CArray<int,1>(nbZoom)); 
     1421            CArray<int,1>& zoomDomain = zoomIndex.back(); 
     1422            for (int ind = 0; ind < nbZoom; ++ind) 
     1423            { 
     1424              zoomDomain(ind) = domainList[domainId]->zoom_i_index(ind) + domainList[domainId]->zoom_j_index(ind) * domainList[domainId]->ni_glo;   
     1425            } 
     1426 
     1427            globalSize *= domainList[domainId]->ni_glo * domainList[domainId]->nj_glo; 
    13231428            ++domainId; 
    13241429          } 
    13251430          else if (1 == axis_domain_order(i)) // axis 
    13261431          { 
    1327             nZoomBegin[indexMap[i]] = axisList[axisId]->zoom_begin_srv; 
    1328             nZoomSize[indexMap[i]]  = axisList[axisId]->zoom_size_srv; 
    1329             nZoomBeginGlobal[indexMap[i]] = axisList[axisId]->global_zoom_begin; 
    1330             nGlob[indexMap[i]] = axisList[axisId]->n_glo; 
     1432            // nZoomBegin[indexMap[i]] = axisList[axisId]->zoom_begin_srv; 
     1433            // nZoomSize[indexMap[i]]  = axisList[axisId]->zoom_size_srv; 
     1434            // nZoomBeginGlobal[indexMap[i]] = axisList[axisId]->global_zoom_begin; 
     1435            zoomIndex.push_back(axisList[axisId]->zoom_index);             
     1436            // nGlob[indexMap[i]] = axisList[axisId]->n_glo; 
     1437            globalSize *= axisList[axisId]->n_glo; 
    13311438            ++axisId; 
    13321439          } 
    13331440          else // scalar 
    13341441          { 
    1335             nZoomBegin[indexMap[i]] = 0; 
    1336             nZoomSize[indexMap[i]]  = 1; 
    1337             nZoomBeginGlobal[indexMap[i]] = 0; 
    1338             nGlob[indexMap[i]] = 1; 
     1442            CArray<int,1> zoomScalar(1); 
     1443            zoomScalar(0) = 0; 
     1444            // nZoomBegin[indexMap[i]] = 0; 
     1445            // nZoomSize[indexMap[i]]  = 1; 
     1446            // nZoomBeginGlobal[indexMap[i]] = 0; 
     1447            zoomIndex.push_back(zoomScalar); 
     1448            // nGlob[indexMap[i]] = 1; 
    13391449            ++scalarId; 
    13401450          } 
    13411451        } 
    13421452        dataSize = 1; 
    1343         for (int i = 0; i < nZoomSize.size(); ++i) 
    1344           dataSize *= nZoomSize[i]; 
    1345  
    1346         serverDistribution_ = new CDistributionServer(server->intraCommRank, nZoomBegin, nZoomSize, 
    1347                                                       nZoomBeginGlobal, nGlob); 
     1453 
     1454        // for (int i = 0; i < nZoomSize.size(); ++i) 
     1455        //   dataSize *= nZoomSize[i]; 
     1456        // serverDistribution_ = new CDistributionServer(server->intraCommRank, nZoomBegin, nZoomSize, 
     1457        //                                               nZoomBeginGlobal, nGlob); 
     1458        for (int i = 0; i < zoomIndex.size(); ++i) 
     1459        { 
     1460          dataSize *= zoomIndex[i].numElements(); 
     1461        } 
     1462        serverDistribution_ = new CDistributionServer(server->intraCommRank, zoomIndex, nGlobElement); 
    13481463      } 
    13491464 
     
    13621477      connectedDataSize_[rank] = outIndex.numElements(); 
    13631478      numberWrittenIndexes_ += outIndex.numElements(); 
     1479    } 
     1480     
     1481    int sizeData = 0; 
     1482    for (map<int, CArray<size_t, 1> >::iterator it = outIndexFromClient.begin(); it != outIndexFromClient.end(); ++it) 
     1483    { 
     1484      sizeData += it->second.numElements(); 
     1485    } 
     1486    indexFromClients.resize(sizeData); 
     1487    sizeData = 0; 
     1488    for (map<int, CArray<size_t, 1> >::iterator it = outIndexFromClient.begin(); it != outIndexFromClient.end(); ++it) 
     1489    { 
     1490       CArray<size_t, 1>& tmp0 = it->second; 
     1491       CArray<size_t, 1> tmp1 = indexFromClients(Range(sizeData, sizeData + tmp0.numElements() - 1)); 
     1492       tmp1 = tmp0; 
     1493       sizeData += tmp0.numElements(); 
    13641494    } 
    13651495 
     
    17521882    { 
    17531883      CDomain* pDom = CDomain::get(*it); 
    1754       if (context->hasClient && !context->hasServer) 
    1755 //      if (context->hasClient) 
     1884      // if (context->hasClient && !context->hasServer) 
     1885     if (context->hasClient) 
    17561886      { 
    17571887        pDom->solveRefInheritance(apply); 
     
    17651895    { 
    17661896      CAxis* pAxis = CAxis::get(*it); 
    1767       if (context->hasClient && !context->hasServer) 
    1768 //      if (context->hasClient) 
     1897      // if (context->hasClient && !context->hasServer) 
     1898     if (context->hasClient) 
    17691899      { 
    17701900        pAxis->solveRefInheritance(apply); 
     
    17781908    { 
    17791909      CScalar* pScalar = CScalar::get(*it); 
    1780       if (context->hasClient && !context->hasServer) 
    1781 //      if (context->hasClient) 
     1910      // if (context->hasClient && !context->hasServer) 
     1911     if (context->hasClient) 
    17821912      { 
    17831913        pScalar->solveRefInheritance(apply); 
Note: See TracChangeset for help on using the changeset viewer.