Ignore:
Timestamp:
03/10/15 10:49:02 (9 years ago)
Author:
mhnguyen
Message:

Implementing a grid formed by only one axis or group of axis

+) Add several new attributes to axis. From now on, each axis can be distributed on client side
+) Modify mask of grid to make it more flexible to different dimension
+) Fix some bugs relating to calculation of local data index on client
+) Clean some redundant codes

Test
+) On Curie, only test_new_features.f90
+) Test cases:

  • Grid composed of: 1 domain and 1 axis, 3 axis, 1 axis
  • Mode: Attached and connected
  • No of client-server: 6-2(Connected), 2 (Attached)

+) All tests passed and results are correct

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS/trunk/src/node/grid.cpp

    r553 r567  
    2020   CGrid::CGrid(void) 
    2121      : CObjectTemplate<CGrid>(), CGridAttributes() 
    22       , withAxis(false), isChecked(false), isDomainAxisChecked(false), axis(), domain() 
    23       , storeIndex(1), out_i_index(1), out_j_index(1), out_l_index(1), isDomConServerComputed_(false) 
     22      , isChecked(false), isDomainAxisChecked(false), storeIndex(1) 
    2423      , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false) 
    25       , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_() 
     24      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(), writtenDataSize_(0), globalDim_() 
    2625   { 
    2726     setVirtualDomainGroup(); 
    … …  
    3130   CGrid::CGrid(const StdString & id) 
    3231      : CObjectTemplate<CGrid>(id), CGridAttributes() 
    33       , withAxis(false), isChecked(false), isDomainAxisChecked(false), axis(), domain() 
    34       , storeIndex(1), out_i_index(1), out_j_index(1), out_l_index(1), isDomConServerComputed_(false) 
     32      , isChecked(false), isDomainAxisChecked(false), storeIndex(1) 
    3533      , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false) 
    36       , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_() 
     34      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(), writtenDataSize_(0), globalDim_() 
    3735   { 
    3836     setVirtualDomainGroup(); 
    … …  
    4240   CGrid::~CGrid(void) 
    4341   { 
    44  //     this->axis.reset() ; 
    45 //      this->domain.reset() ; 
    4642    deque< CArray<int, 1>* >::iterator it ; 
    4743 
    4844    for(deque< CArray<int,1>* >::iterator it=storeIndex.begin(); it!=storeIndex.end();it++)  delete *it ; 
    49     for(deque< CArray<int,1>* >::iterator it=out_i_index.begin();it!=out_i_index.end();it++) delete *it ; 
    50     for(deque< CArray<int,1>* >::iterator it=out_j_index.begin();it!=out_j_index.end();it++) delete *it ; 
    51     for(deque< CArray<int,1>* >::iterator it=out_l_index.begin();it!=out_l_index.end();it++) delete *it ; 
    52  
    53     for(map<int,CArray<int,1>* >::iterator it=out_i_fromClient.begin();it!=out_i_fromClient.end();it++) delete it->second ; 
    54     for(map<int,CArray<int,1>* >::iterator it=out_j_fromClient.begin();it!=out_j_fromClient.end();it++) delete it->second ; 
    55     for(map<int,CArray<int,1>* >::iterator it=out_l_fromClient.begin();it!=out_l_fromClient.end();it++) delete it->second ; 
    56  
    5745    for(map<int,CArray<size_t,1>* >::iterator it=outIndexFromClient.begin();it!=outIndexFromClient.end();++it) delete (it->second); 
    5846 
    … …  
    6048    if (0 != serverDistribution_) delete serverDistribution_; 
    6149    if (0 != serverDistributionDescription_) delete serverDistributionDescription_; 
    62  
    6350   } 
    6451 
    … …  
    7764 
    7865   //--------------------------------------------------------------- 
    79  
    80    const std::deque< CArray<int,1>* > & CGrid::getOutIIndex(void)  const 
    81    { 
    82       return (this->out_i_index ); 
    83    } 
     66// 
     67//   const std::deque< CArray<int,1>* > & CGrid::getOutIIndex(void)  const 
     68//   { 
     69//      return (this->out_i_index ); 
     70//   } 
     71// 
     72//   //--------------------------------------------------------------- 
     73// 
     74//   const std::deque< CArray<int,1>* > & CGrid::getOutJIndex(void)  const 
     75//   { 
     76//      return (this->out_j_index ); 
     77//   } 
     78// 
     79//   //--------------------------------------------------------------- 
     80// 
     81//   const std::deque< CArray<int,1>* > & CGrid::getOutLIndex(void)  const 
     82//   { 
     83//      return (this->out_l_index ); 
     84//   } 
     85// 
     86//   //--------------------------------------------------------------- 
     87// 
     88//   const CAxis*   CGrid::getRelAxis  (void) const 
     89//   { 
     90//      return (this->axis ); 
     91//   } 
     92 
     93//   //--------------------------------------------------------------- 
     94// 
     95//   const CDomain* CGrid::getRelDomain(void) const 
     96//   { 
     97//      return (this->domain ); 
     98//   } 
    8499 
    85100   //--------------------------------------------------------------- 
    86101 
    87    const std::deque< CArray<int,1>* > & CGrid::getOutJIndex(void) const 
    88    { 
    89       return (this->out_j_index ); 
    90    } 
     102//   bool CGrid::hasAxis(void) const 
     103//   { 
     104//      return (this->withAxis); 
     105//   } 
    91106 
    92107   //--------------------------------------------------------------- 
    93108 
    94    const std::deque< CArray<int,1>* > & CGrid::getOutLIndex(void)  const 
    95    { 
    96       return (this->out_l_index ); 
    97    } 
    98  
    99    //--------------------------------------------------------------- 
    100  
    101    const CAxis*   CGrid::getRelAxis  (void) const 
    102    { 
    103       return (this->axis ); 
    104    } 
    105  
    106    //--------------------------------------------------------------- 
    107  
    108    const CDomain* CGrid::getRelDomain(void) const 
    109    { 
    110       return (this->domain ); 
    111    } 
    112  
    113    //--------------------------------------------------------------- 
    114  
    115    bool CGrid::hasAxis(void) const 
    116    { 
    117       return (this->withAxis); 
    118    } 
    119  
    120    //--------------------------------------------------------------- 
    121  
    122109   StdSize CGrid::getDimension(void) const 
    123110   { 
    124       return ((this->withAxis)?3:2); 
     111      return (globalDim_.size()); 
    125112   } 
    126113 
    … …  
    176163   StdSize CGrid::getDataSize(void) const 
    177164   { 
    178       StdSize retvalue=domain->data_ni.getValue() ; 
    179       if (domain->data_dim.getValue()==2) retvalue*=domain->data_nj.getValue() ; 
    180       if (this->withAxis) retvalue*=this->axis->size.getValue() ; 
    181  
     165      std::vector<int> dataNindex = clientDistribution_->getDataNIndex(); 
     166      StdSize retvalue = 1; 
     167      for (int i = 0; i < dataNindex.size(); ++i) retvalue *= dataNindex[i]; 
    182168      return (retvalue); 
    183169   } 
    … …  
    201187 
    202188 
    203    //--------------------------------------------------------------- 
    204  
    205 //   void CGrid::solveReference(void) 
    206 //   { 
    207 //      if (this->isChecked) return; 
    208 //      CContext* context = CContext::getCurrent() ; 
    209 //      CContextClient* client=context->client ; 
    210 // 
    211 //      this->solveDomainRef() ; 
    212 //      this->solveAxisRef() ; 
    213 // 
    214 //      if (context->hasClient) 
    215 //      { 
    216 //         checkMask() ; 
    217 //         this->computeIndex() ; 
    218 // 
    219 //         this->storeIndex.push_front(new CArray<int,1>() ); 
    220 //         this->out_i_index.push_front(new CArray<int,1>()); 
    221 //         this->out_j_index.push_front(new CArray<int,1>()); 
    222 //         this->out_l_index.push_front(new CArray<int,1>()); 
    223 //      } 
    224 ////      this->computeIndexServer(); 
    225 //      this->isChecked = true; 
    226 //   } 
    227  
    228189   void CGrid::solveDomainAxisRef(bool areAttributesChecked) 
    229190   { 
    … …  
    250211        checkMask() ; 
    251212        this->computeIndex() ; 
    252  
    253213        this->storeIndex.push_front(new CArray<int,1>() ); 
    254         this->out_i_index.push_front(new CArray<int,1>()); 
    255         this->out_j_index.push_front(new CArray<int,1>()); 
    256         this->out_l_index.push_front(new CArray<int,1>()); 
    257214     } 
    258 //      this->computeIndexServer(); 
    259215     this->isChecked = true; 
    260216   } 
    261217 
    262  
    263218   void CGrid::checkMask(void) 
    264219   { 
    265220      using namespace std; 
    266  
    267       unsigned int niu = domain->ni, nju = domain->nj; 
    268       unsigned int nlu = 1 ; 
    269       if (hasAxis()) nlu=axis->size ; 
    270  
    271       if (!mask.isEmpty()) 
    272       { 
    273          if ((mask.extent(0) != niu) || 
    274              (mask.extent(1) != nju) || 
    275              (mask.extent(2) != nlu)) 
    276              ERROR("CGrid::checkAttributes(void)", 
    277                   <<"The mask has not the same size than the local grid"<<endl 
    278                   <<"Local size is "<<niu<<"x"<<nju<<"x"<<nlu<<endl 
    279                   <<"Mask size is "<<mask.extent(0)<<"x"<<mask.extent(1)<<"x"<<mask.extent(2)); 
    280       } 
    281       else 
    282       { 
    283         mask.resize(niu,nju,nlu) ; 
    284         mask=true  ; 
    285       } 
    286  
    287       CArray<bool,2>& domainMask = domain->mask ; 
    288       for (int l=0; l < nlu ; l++) 
    289         for (int j=0; j < nju ; j++) 
    290           for(int i=0; i<niu ; i++) mask(i,j,l) = mask(i,j,l) && domainMask(i,j) ; 
    291  
    292  
    293    } 
    294  
     221      std::vector<CDomain*> domainP = this->getDomains(); 
     222      std::vector<CAxis*> axisP = this->getAxis(); 
     223      int dim = domainP.size() * 2 + axisP.size(); 
     224 
     225      std::vector<CArray<bool,2>* > domainMasks(domainP.size()); 
     226      for (int i = 0; i < domainMasks.size(); ++i) domainMasks[i] = &(domainP[i]->mask); 
     227      std::vector<CArray<bool,1>* > axisMasks(axisP.size()); 
     228      for (int i = 0; i < axisMasks.size(); ++i) axisMasks[i] = &(axisP[i]->mask); 
     229 
     230      switch (dim) { 
     231        case 1: 
     232          checkGridMask(mask1, domainMasks, axisMasks, axisDomainOrder); 
     233          break; 
     234        case 2: 
     235          checkGridMask(mask2, domainMasks, axisMasks, axisDomainOrder); 
     236          break; 
     237        case 3: 
     238          checkGridMask(mask3, domainMasks, axisMasks, axisDomainOrder); 
     239          break; 
     240//        case 4: 
     241//          checkGridMask(mask4, domainMasks, axisMasks, axisDomainOrder); 
     242//          break; 
     243//        case 5: 
     244//          checkGridMask(mask5, domainMasks, axisMasks, axisDomainOrder); 
     245//          break; 
     246//        case 6: 
     247//          checkGridMask(mask6, domainMasks, axisMasks, axisDomainOrder); 
     248//          break; 
     249//        case 7: 
     250//          checkGridMask(mask7, domainMasks, axisMasks, axisDomainOrder); 
     251//          break; 
     252        default: 
     253          break; 
     254      } 
     255   } 
    295256   //--------------------------------------------------------------- 
    296257 
    297 //   void CGrid::solveDomainRef(void) 
    298 //   { 
    299 //      if (!domain_ref.isEmpty()) 
    300 //      { 
    301 //         if (CDomain::has(domain_ref.getValue())) 
    302 //         { 
    303 //            this->domain = CDomain::get(domain_ref.getValue()) ; 
    304 //            domain->checkAttributes() ; 
    305 //         } 
    306 //         else ERROR("CGrid::solveDomainRef(void)", 
    307 //                     << "Wrong domain reference") ; 
    308 //      } 
    309 //      else ERROR("CGrid::solveDomainRef(void)", 
    310 //                  << "Domain reference is not defined") ; 
    311 //   } 
    312 // 
    313 //   //--------------------------------------------------------------- 
    314 // 
    315 //   void CGrid::solveAxisRef(void) 
    316 //   { 
    317 //      if (!axis_ref.isEmpty()) 
    318 //      { 
    319 //         this->withAxis = true ; 
    320 //         if (CAxis::get(axis_ref.getValue())) 
    321 //         { 
    322 //            this->axis = CAxis::get(axis_ref.getValue()) ; 
    323 //            axis->checkAttributes() ; 
    324 //         } 
    325 //         else ERROR("CGrid::solveAxisRef(void)", 
    326 //                    << "Wrong axis reference") ; 
    327 //      } 
    328 //      else withAxis = false ; 
    329 //   } 
    330  
    331  
    332258   void CGrid::solveDomainRef(bool sendAtt) 
    333259   { 
    334 //      if (!domain_ref.isEmpty()) 
    335 //      { 
    336 //         if (CDomain::has(domain_ref.getValue())) 
    337 //         { 
    338 //            this->domain = CDomain::get(domain_ref.getValue()) ; 
    339 //            if (sendAtt) domain->sendCheckedAttributes(); 
    340 //            else domain->checkAttributesOnClient() ; 
    341 //         } 
    342 //         else ERROR("CGrid::solveDomainRef(void)", 
    343 //                     << "Wrong domain reference") ; 
    344 //      } 
    345 //      else ERROR("CGrid::solveDomainRef(void)", 
    346 //                  << "Domain reference is not defined") ; 
    347260      setDomainList(); 
    348       this->domain = CDomain::get(domList_.at(0)); 
    349       if (0 != this->domain) 
    350       { 
    351 //        this->domain = this->getDomain(); 
    352         if (sendAtt) domain->sendCheckedAttributes(); 
    353         else domain->checkAttributesOnClient() ; 
    354       } 
    355       else ERROR("CGrid::solveDomainRef(void)", 
    356                   << "Domain reference is not defined") ; 
     261      std::vector<CDomain*> domListP = this->getDomains(); 
     262      if (!domListP.empty()) 
     263      { 
     264        computeGridGlobalDimension(getDomains(), getAxis(), axisDomainOrder); 
     265        for (int i = 0; i < domListP.size(); ++i) 
     266        { 
     267          if (sendAtt) domListP[i]->sendCheckedAttributes(); 
     268          else domListP[i]->checkAttributesOnClient(); 
     269        } 
     270      } 
    357271   } 
    358272 
    359273   //--------------------------------------------------------------- 
    360274 
    361    void CGrid::solveAxisRef(bool checkAtt) 
    362    { 
    363 //      if (!axis_ref.isEmpty()) 
    364 //      { 
    365 //         this->withAxis = true ; 
    366 //         if (CAxis::get(axis_ref.getValue())) 
    367 //         { 
    368 //            this->axis = CAxis::get(axis_ref.getValue()) ; 
    369 //            axis->checkAttributes() ; 
    370 //         } 
    371 //         else ERROR("CGrid::solveAxisRef(void)", 
    372 //                    << "Wrong axis reference") ; 
    373 //      } 
    374 //      else withAxis = false ; 
    375 //      getAllAxis(); 
     275   void CGrid::solveAxisRef(bool sendAtt) 
     276   { 
    376277      setAxisList(); 
    377       if (!axisList_.empty()) 
    378       { 
    379         int sizeList = axisList_.size(); 
    380         for (int i = 0; i < sizeList; ++i) 
     278      std::vector<CAxis*> axisListP = this->getAxis(); 
     279      if (!axisListP.empty()) 
     280      { 
     281        int idx = 0; 
     282        computeGridGlobalDimension(getDomains(), getAxis(), axisDomainOrder); 
     283        for (int i = 0; i < axisListP.size(); ++i) 
    381284        { 
    382           CAxis::get(axisList_.at(i))->checkAttributes(); 
    383           this->axis = CAxis::get(axisList_.at(i)); 
     285          while (this->axisDomainOrder(idx)) idx += 2; 
     286          if (sendAtt) 
     287            axisListP[i]->sendCheckedAttributes(globalDim_,idx); 
     288          else 
     289            axisListP[i]->checkAttributesOnClient(globalDim_,idx); 
     290          ++idx; 
    384291        } 
    385         withAxis = true; 
    386  
    387       } 
    388 //      if (!axis_ref.isEmpty()) 
    389 //      { 
    390 //         this->withAxis = true ; 
    391 //         if (CAxis::get(axis_ref.getValue())) 
    392 //         { 
    393 //            this->axis = CAxis::get(axis_ref.getValue()) ; 
    394 //            axis->checkAttributes() ; 
    395 //         } 
    396 //         else ERROR("CGrid::solveAxisRef(void)", 
    397 //                    << "Wrong axis reference") ; 
    398 //      } 
    399       else withAxis = false ; 
     292 
     293      } 
    400294   } 
    401295 
    … …  
    415309 
    416310     // Finally, compute index mapping between client(s) and server(s) 
    417      clientServerMap_.computeServerIndexMapping(clientDistribution_->getGlobalIndex(),serverDistributionDescription_->getGlobalIndex()); 
     311     clientServerMap_.computeServerIndexMapping(clientDistribution_->getGlobalIndex(), 
     312                                                clientDistribution_->getLocalDataIndexSendToServerOnClient(), 
     313                                                serverDistributionDescription_->getGlobalIndex()); 
    418314     const std::map<int, std::vector<size_t> >& globalIndexOnServer = clientServerMap_.getGlobalIndexOnServer(); 
    419315     std::vector<int> connectedServerRank; 
    … …  
    427323     storeIndex_client = (clientDistribution_->getLocalDataIndexOnClient()); 
    428324 
    429 /* 
    430       const int ni   = domain->ni.getValue() , 
    431                 nj   = domain->nj.getValue() , 
    432                 size = (this->hasAxis()) ? axis->size.getValue() : 1 , 
    433                 lbegin = (this->hasAxis()) ? axis->zoom_begin.getValue()-1 : 0 , 
    434                 lend = (this->hasAxis()) ? axis->zoom_end.getValue()-1 : 0 ; 
    435  
    436  
    437       const int data_dim     = domain->data_dim.getValue() , 
    438                 data_n_index = domain->data_n_index.getValue() , 
    439                 data_ibegin  = domain->data_ibegin.getValue() , 
    440                 data_jbegin  = (data_dim == 2) 
    441                              ? domain->data_jbegin.getValue() : -1; 
    442  
    443       CArray<int,1> data_i_index = domain->data_i_index ; 
    444       CArray<int,1> data_j_index = domain->data_j_index ; 
    445  
    446  
    447       int indexCount = 0; 
    448  
    449       for(int l = 0; l < size ; l++) 
    450       { 
    451          for(int n = 0, i = 0, j = 0; n < data_n_index; n++) 
    452          { 
    453             int temp_i = data_i_index(n) + data_ibegin, 
    454                 temp_j = (data_dim == 1) ? -1 
    455                        : data_j_index(n) + data_jbegin; 
    456             i = (data_dim == 1) ? (temp_i - 1) % ni 
    457                                 : (temp_i - 1) ; 
    458             j = (data_dim == 1) ? (temp_i - 1) / ni 
    459                                 : (temp_j - 1) ; 
    460  
    461             if ((l >=lbegin && l<= lend) && 
    462                 (i >= 0 && i < ni) && 
    463                 (j >= 0 && j < nj) && mask(i,j,l)) 
    464                indexCount++ ; 
    465          } 
    466       } 
    467  
    468       storeIndex[0]  = new CArray<int,1>(indexCount) ; 
    469       out_i_index[0] = new CArray<int,1>(indexCount) ; 
    470       out_j_index[0] = new CArray<int,1>(indexCount) ; 
    471       out_l_index[0] = new CArray<int,1>(indexCount) ; 
    472  
    473       storeIndex_client.resize(indexCount) ; 
    474       out_i_client.resize(indexCount) ; 
    475       out_j_client.resize(indexCount) ; 
    476       out_l_client.resize(indexCount) ; 
    477  
    478  
    479       for(int count = 0, indexCount = 0,  l = 0; l < size; l++) 
    480       { 
    481          for(int n = 0, i = 0, j = 0; n < data_n_index; n++, count++) 
    482          { 
    483             int temp_i = data_i_index(n) + data_ibegin, 
    484                 temp_j = (data_dim == 1) ? -1 
    485                        : data_j_index(n) + data_jbegin; 
    486             i = (data_dim == 1) ? (temp_i - 1) % ni 
    487                                 : (temp_i - 1) ; 
    488             j = (data_dim == 1) ? (temp_i - 1) / ni 
    489                                 : (temp_j - 1) ; 
    490  
    491             if ((l >= lbegin && l <= lend) && 
    492                 (i >= 0 && i < ni) && 
    493                 (j >= 0 && j < nj) && mask(i,j,l)) 
    494             { 
    495                (*storeIndex[0])(indexCount) = count ; 
    496                (*out_l_index[0])(indexCount) = l ; 
    497                (*out_i_index[0])(indexCount) = i ; 
    498                (*out_j_index[0])(indexCount) = j ; 
    499  
    500                storeIndex_client(indexCount) = count ; 
    501                out_i_client(indexCount)=i+domain->ibegin_client-1 ; 
    502                out_j_client(indexCount)=j+domain->jbegin_client-1 ; 
    503                out_l_client(indexCount)=l-lbegin ; 
    504                indexCount++ ; 
    505             } 
    506          } 
    507       } 
    508 */ 
    509 //      computeDomConServer(); 
    510 //      sendIndex() ; 
    511  
    512  
    513325   } 
    514326 
    … …  
    517329   CGrid* CGrid::createGrid(CDomain* domain) 
    518330   { 
    519       StdString new_id = StdString("__") + domain->getId() + StdString("__") ; 
    520       CGrid* grid = CGridGroup::get("grid_definition")->createChild(new_id) ; 
    521  
    522331      std::vector<CDomain*> vecDom(1,domain); 
    523       grid->setDomainList(vecDom); 
    524 //      grid->domain_ref.setValue(domain->getId()); 
     332      std::vector<CAxis*> vecAxis; 
     333 
     334      CGrid* grid = createGrid(vecDom, vecAxis); 
     335 
    525336      return (grid); 
    526337   } 
    … …  
    528339   CGrid* CGrid::createGrid(CDomain* domain, CAxis* axis) 
    529340   { 
    530       StdString new_id = StdString("__") + domain->getId() + 
    531                          StdString("_") + axis->getId() + StdString("__") ; 
    532       CGrid* grid = CGridGroup::get("grid_definition")->createChild(new_id) ; 
    533  
    534341      std::vector<CDomain*> vecDom(1,domain); 
    535342      std::vector<CAxis*> vecAxis(1,axis); 
    536       grid->setDomainList(vecDom); 
    537       grid->setAxisList(vecAxis); 
    538 //      grid->domain_ref.setValue(domain->getId()); 
    539 //      grid->axis_ref.setValue(axis->getId()); 
     343      CGrid* grid = createGrid(vecDom, vecAxis); 
     344 
    540345      return (grid); 
    541346   } 
    … …  
    564369      } 
    565370 
     371      grid->computeGridGlobalDimension(domains, axis, grid->axisDomainOrder); 
     372 
    566373      return (grid); 
    567374   } 
    … …  
    575382   { 
    576383     return (this->vAxisGroup_); 
    577    } 
    578  
    579    //---------------------------------------------------------------- 
    580  
    581    void CGrid::outputField(int rank, const CArray<double, 1>& stored,  CArray<double, 3>& field) 
    582    { 
    583       CArray<int,1>& out_i=*out_i_fromClient[rank] ; 
    584       CArray<int,1>& out_j=*out_j_fromClient[rank] ; 
    585       CArray<int,1>& out_l=*out_l_fromClient[rank] ; 
    586  
    587       for(StdSize n = 0; n < stored.numElements(); n++) 
    588          field(out_i(n), out_j(n), out_l(n)) = stored(n) ; 
    589    } 
    590  
    591    void CGrid::outputField(int rank, const CArray<double, 1>& stored,  CArray<double, 2>& field) 
    592    { 
    593       CArray<int,1>& out_i=*out_i_fromClient[rank] ; 
    594       CArray<int,1>& out_j=*out_j_fromClient[rank] ; 
    595  
    596       for(StdSize n = 0; n < stored.numElements(); n++) 
    597          field(out_i(n), out_j(n)) = stored(n) ;   } 
    598  
    599    //--------------------------------------------------------------- 
    600  
    601    void CGrid::outputField(int rank,const CArray<double, 1>& stored,  CArray<double, 1>& field) 
    602    { 
    603       CArray<int,1>& out_i=*out_i_fromClient[rank] ; 
    604  
    605       for(StdSize n = 0; n < stored.numElements(); n++) 
    606          field(out_i(n)) = stored(n) ; 
    607384   } 
    608385 
    … …  
    629406   } 
    630407 
    631    //--------------------------------------------------------------- 
    632  
    633 //  void CGrid::sendIndex(void) 
    634 //  { 
    635 //    CContext* context = CContext::getCurrent() ; 
    636 //    CContextClient* client=context->client ; 
    637 // 
    638 //    CEventClient event(getType(),EVENT_ID_INDEX) ; 
    639 //    int rank ; 
    640 //    list<shared_ptr<CMessage> > list_msg ; 
    641 //    list< CArray<int,1>* > list_out_i,list_out_j,list_out_l ; 
    642 // 
    643 //    for(int ns=0;ns<domain->connectedServer.size();ns++) 
    644 //    { 
    645 //       rank=domain->connectedServer[ns] ; 
    646 // 
    647 //       int i,j ; 
    648 //       int nb=0 ; 
    649 //       for(int k=0;k<storeIndex_client.numElements();k++) 
    650 //       { 
    651 //         i=out_i_client(k)- domain->ibegin +1; 
    652 //         j=out_j_client(k)- domain->jbegin +1; 
    653 //         if (domain->mapConnectedServer(i,j)==ns)  nb++ ; 
    654 //       } 
    655 //       CArray<int,1> storeIndex(nb) ; 
    656 //       CArray<int,1> out_i(nb) ; 
    657 //       CArray<int,1> out_j(nb) ; 
    658 //       CArray<int,1> out_l(nb) ; 
    659 // 
    660 // 
    661 //       nb=0 ; 
    662 //       for(int k=0;k<storeIndex_client.numElements();k++) 
    663 //       { 
    664 //         i=out_i_client(k)- domain->ibegin +1 ; 
    665 //         j=out_j_client(k)- domain->jbegin +1 ; 
    666 //         if (domain->mapConnectedServer(i,j)==ns) 
    667 //         { 
    668 //            storeIndex(nb)=k ; 
    669 //            out_i(nb)=domain->i_index(i,j) + domain->ibegin-1; 
    670 //            out_j(nb)=domain->j_index(i,j) + domain->jbegin-1; 
    671 //            out_l(nb)=out_l_client(k) ; 
    672 //            nb++ ; 
    673 //         } 
    674 //       } 
    675 // 
    676 //       storeIndex_toSrv.insert( pair<int,CArray<int,1>* >(rank,new CArray<int,1>(storeIndex) )) ; 
    677 //       nbSenders.insert(pair<int,int>(rank,domain->nbSenders[ns])) ; 
    678 //       list_msg.push_back(shared_ptr<CMessage>(new CMessage)) ; 
    679 //       list_out_i.push_back(new CArray<int,1>(out_i)) ; 
    680 //       list_out_j.push_back(new CArray<int,1>(out_j)) ; 
    681 //       list_out_l.push_back(new CArray<int,1>(out_l)) ; 
    682 // 
    683 //       *list_msg.back()<<getId()<<*list_out_i.back()<<*list_out_j.back()<<*list_out_l.back() ; 
    684 //       event.push(rank,domain->nbSenders[ns],*list_msg.back()) ; 
    685 //    } 
    686 //    client->sendEvent(event) ; 
    687 // 
    688 //    for(list<CArray<int,1>* >::iterator it=list_out_i.begin();it!=list_out_i.end();it++) delete *it ; 
    689 //    for(list<CArray<int,1>* >::iterator it=list_out_j.begin();it!=list_out_j.end();it++) delete *it ; 
    690 //    for(list<CArray<int,1>* >::iterator it=list_out_l.begin();it!=list_out_l.end();it++) delete *it ; 
    691 // 
    692 //  } 
    693  
    694   void CGrid::computeDomConServer() 
    695   { 
    696     if (!isDomConServerComputed_) 
    697     { 
    698       for(int ns=0;ns<domain->connectedServer.size(); ++ns) 
    699       { 
    700          int rank=domain->connectedServer[ns] ; 
    701  
    702          int i,j ; 
    703          int nb=0 ; 
    704          for(int k=0;k<storeIndex_client.numElements();++k) 
    705          { 
    706            i=out_i_client(k)- domain->ibegin +1; 
    707            j=out_j_client(k)- domain->jbegin +1; 
    708            if (domain->mapConnectedServer(i,j)==ns)  ++nb ; 
    709          } 
    710  
    711          domConnectedServerSide_.insert(std::make_pair(rank, nb)); 
    712       } 
    713       isDomConServerComputed_ = true; 
    714     } 
    715   } 
    716  
    717  
    718   std::map<int, int> CGrid::getDomConServerSide() 
    719   { 
    720     return domConnectedServerSide_; 
    721   } 
    722  
    723408  void CGrid::sendIndex(void) 
    724409  { 
    … …  
    739424    itLocal = localIndexSendToServer.begin(); 
    740425 
    741     for (int ns = 0; itGlobal != iteMap; ++itGlobal, ++itLocal, ++ns) 
    742     { 
    743       rank = itGlobal->first; 
    744       int nb = (itGlobal->second).size(); 
    745  
    746       CArray<size_t, 1> outGlobalIndexOnServer(nb); 
    747       CArray<int, 1> outLocalIndexToServer(nb); 
    748       for (int k = 0; k < nb; ++k) 
    749       { 
    750         outGlobalIndexOnServer(k) = itGlobal->second.at(k); 
    751         outLocalIndexToServer(k)  = itLocal->second.at(k); 
    752       } 
    753  
    754       storeIndex_toSrv.insert( pair<int,CArray<int,1>* >(rank,new CArray<int,1>(outLocalIndexToServer) )); 
    755       listOutIndex.push_back(new CArray<size_t,1>(outGlobalIndexOnServer)); 
    756  
    757       list_msg.push_back(shared_ptr<CMessage>(new CMessage)); 
    758       *list_msg.back()<<getId()<<*listOutIndex.back(); 
    759       event.push(rank, nbSenders[rank], *list_msg.back()); 
    760     } 
    761     client->sendEvent(event); 
     426    if (!doGridHaveDataDistributed()) 
     427    { 
     428      if (0 == client->getClientRank()) 
     429      { 
     430       for (int ns = 0; itGlobal != iteMap; ++itGlobal, ++itLocal, ++ns) 
     431        { 
     432          rank = itGlobal->first; 
     433          int nb = (itGlobal->second).size(); 
     434 
     435          CArray<size_t, 1> outGlobalIndexOnServer(nb); 
     436          CArray<int, 1> outLocalIndexToServer(nb); 
     437          for (int k = 0; k < nb; ++k) 
     438          { 
     439            outGlobalIndexOnServer(k) = itGlobal->second.at(k); 
     440            outLocalIndexToServer(k)  = itLocal->second.at(k); 
     441          } 
     442 
     443          storeIndex_toSrv.insert( pair<int,CArray<int,1>* >(rank,new CArray<int,1>(outLocalIndexToServer) )); 
     444          listOutIndex.push_back(new CArray<size_t,1>(outGlobalIndexOnServer)); 
     445 
     446          list_msg.push_back(shared_ptr<CMessage>(new CMessage)); 
     447          *list_msg.back()<<getId()<<*listOutIndex.back(); 
     448          event.push(rank, 1, *list_msg.back()); 
     449        } 
     450        client->sendEvent(event); 
     451      } else client->sendEvent(event); 
     452    } 
     453    else 
     454    { 
     455      for (int ns = 0; itGlobal != iteMap; ++itGlobal, ++itLocal, ++ns) 
     456      { 
     457        rank = itGlobal->first; 
     458        int nb = (itGlobal->second).size(); 
     459 
     460        CArray<size_t, 1> outGlobalIndexOnServer(nb); 
     461        CArray<int, 1> outLocalIndexToServer(nb); 
     462        for (int k = 0; k < nb; ++k) 
     463        { 
     464          outGlobalIndexOnServer(k) = itGlobal->second.at(k); 
     465          outLocalIndexToServer(k)  = itLocal->second.at(k); 
     466        } 
     467 
     468        storeIndex_toSrv.insert( pair<int,CArray<int,1>* >(rank,new CArray<int,1>(outLocalIndexToServer) )); 
     469        listOutIndex.push_back(new CArray<size_t,1>(outGlobalIndexOnServer)); 
     470 
     471        list_msg.push_back(shared_ptr<CMessage>(new CMessage)); 
     472        *list_msg.back()<<getId()<<*listOutIndex.back(); 
     473        event.push(rank, nbSenders[rank], *list_msg.back()); 
     474      } 
     475      client->sendEvent(event); 
     476    } 
     477 
    762478    for(list<CArray<size_t,1>* >::iterator it=listOutIndex.begin();it!=listOutIndex.end();++it) delete *it ; 
    763  
    764 /* 
    765     if (!isDomConServerComputed_) computeDomConServer(); 
    766  
    767     for(int ns=0;ns<domain->connectedServer.size();ns++) 
    768     { 
    769        rank=domain->connectedServer[ns] ; 
    770  
    771        int nb = domConnectedServerSide_.find(rank)->second; 
    772        CArray<int,1> storeIndex(nb) ; 
    773        CArray<int,1> out_i(nb) ; 
    774        CArray<int,1> out_j(nb) ; 
    775        CArray<int,1> out_l(nb) ; 
    776  
    777        int i, j; 
    778        nb=0 ; 
    779        for(int k=0;k<storeIndex_client.numElements();k++) 
    780        { 
    781          i=out_i_client(k)- domain->ibegin +1 ; 
    782          j=out_j_client(k)- domain->jbegin +1 ; 
    783          if (domain->mapConnectedServer(i,j)==ns) 
    784          { 
    785             storeIndex(nb)=k ; 
    786             out_i(nb)=domain->i_index(i,j) + domain->ibegin-1; 
    787             out_j(nb)=domain->j_index(i,j) + domain->jbegin-1; 
    788             out_l(nb)=out_l_client(k) ; 
    789             nb++ ; 
    790          } 
    791        } 
    792  
    793        storeIndex_toSrv.insert( pair<int,CArray<int,1>* >(rank,new CArray<int,1>(storeIndex) )) ; 
    794        nbSenders.insert(pair<int,int>(rank,domain->nbSenders[ns])) ; 
    795        list_msg.push_back(shared_ptr<CMessage>(new CMessage)) ; 
    796        list_out_i.push_back(new CArray<int,1>(out_i)) ; 
    797        list_out_j.push_back(new CArray<int,1>(out_j)) ; 
    798        list_out_l.push_back(new CArray<int,1>(out_l)) ; 
    799  
    800        *list_msg.back()<<getId()<<*list_out_i.back()<<*list_out_j.back()<<*list_out_l.back() ; 
    801        event.push(rank,domain->nbSenders[ns],*list_msg.back()) ; 
    802     } 
    803     client->sendEvent(event) ; 
    804  
    805     for(list<CArray<int,1>* >::iterator it=list_out_i.begin();it!=list_out_i.end();it++) delete *it ; 
    806     for(list<CArray<int,1>* >::iterator it=list_out_j.begin();it!=list_out_j.end();it++) delete *it ; 
    807     for(list<CArray<int,1>* >::iterator it=list_out_l.begin();it!=list_out_l.end();it++) delete *it ; 
    808 */ 
    809479  } 
    810480 
    … …  
    820490      get(gridId)->recvIndex(rank,*buffer) ; 
    821491    } 
     492  } 
     493 
     494  void CGrid::computeGridGlobalDimension(const std::vector<CDomain*>& domains, 
     495                                         const std::vector<CAxis*>& axis, 
     496                                         const CArray<bool,1>& axisDomainOrder) 
     497  { 
     498    globalDim_.resize(domains.size()*2+axis.size()); 
     499    int idx = 0, idxDomain = 0, idxAxis = 0; 
     500    for (int i = 0; i < axisDomainOrder.numElements(); ++i) 
     501    { 
     502      if (axisDomainOrder(i)) 
     503      { 
     504        globalDim_[idx]   = domains[idxDomain]->ni_glo.getValue(); 
     505        globalDim_[idx+1] = domains[idxDomain]->nj_glo.getValue(); 
     506        ++idxDomain; 
     507        idx += 2; 
     508      } 
     509      else 
     510      { 
     511        globalDim_[idx] = axis[idxAxis]->size.getValue(); 
     512        ++idxAxis; 
     513        ++idx; 
     514      } 
     515    } 
     516  } 
     517 
     518  std::vector<int> CGrid::getGlobalDimension() 
     519  { 
     520    return globalDim_; 
     521  } 
     522 
     523  /*! 
     524    Verify whether one server need to write data 
     525    There are some cases on which one server has nodata to write. For example, when we 
     526  just only want to zoom on a domain. 
     527  */ 
     528  bool CGrid::doGridHaveDataToWrite() 
     529  { 
     530    return (0 != serverDistribution_); 
     531  } 
     532 
     533  /*! 
     534    Return size of data which is written on each server 
     535    Whatever dimension of a grid, data which are written on server must be presented as 
     536  an one dimension array. 
     537  \return size of data written on server 
     538  */ 
     539  size_t CGrid::getWrittenDataSize() const 
     540  { 
     541    return writtenDataSize_; 
     542  } 
     543 
     544 
     545  const CDistributionServer* CGrid::getDistributionServer() const 
     546  { 
     547    return serverDistribution_; 
     548  } 
     549 
     550  bool CGrid::doGridHaveDataDistributed() 
     551  { 
     552    return clientDistribution_->isDataDistributed(); 
    822553  } 
    823554 
    … …  
    835566         indexMap[i] = idx; 
    836567         if (true == axisDomainOrder(i)) 
    837         { 
    838           ++ssize; 
    839           idx += 2; 
    840         } 
     568         { 
     569            ++ssize; 
     570            idx += 2; 
     571         } 
     572         else 
     573          ++idx; 
    841574       } 
    842575 
    … …  
    844577       std::vector<CDomain*> domainList = getDomains(); 
    845578       std::vector<CAxis*> axisList = getAxis(); 
    846        std::vector<int> nZoomBegin(ssize), nZoomSize(ssize), nGlob(ssize); 
     579       std::vector<int> nZoomBegin(ssize), nZoomSize(ssize), nGlob(ssize), nZoomBeginGlobal(ssize); 
    847580       for (int i = 0; i < numElement; ++i) 
    848581       { 
    … …  
    851584            nZoomBegin[indexMap[i]]   = domainList[domainId]->zoom_ibegin_srv; 
    852585            nZoomSize[indexMap[i]]    = domainList[domainId]->zoom_ni_srv; 
     586            nZoomBeginGlobal[indexMap[i]] = domainList[domainId]->zoom_ibegin; 
    853587            nGlob[indexMap[i]]    = domainList[domainId]->ni_glo; 
    854588 
    855589            nZoomBegin[indexMap[i]+1] = domainList[domainId]->zoom_jbegin_srv; 
    856590            nZoomSize[indexMap[i]+1]  = domainList[domainId]->zoom_nj_srv; 
     591            nZoomBeginGlobal[indexMap[i]+1] = domainList[domainId]->zoom_jbegin; 
    857592            nGlob[indexMap[i]+1]    = domainList[domainId]->nj_glo; 
    858593            ++domainId; 
    … …  
    860595         else 
    861596         { 
    862             nZoomBegin[indexMap[i]] = axisList[axisId]->zoom_begin; 
    863             nZoomSize[indexMap[i]]  = axisList[axisId]->zoom_size; 
     597            nZoomBegin[indexMap[i]] = axisList[axisId]->zoom_begin_srv; 
     598            nZoomSize[indexMap[i]]  = axisList[axisId]->zoom_size_srv; 
     599            nZoomBeginGlobal[indexMap[i]] = axisList[axisId]->zoom_begin; 
    864600            nGlob[indexMap[i]]      = axisList[axisId]->size; 
    865601            ++axisId; 
    866602         } 
    867603       } 
    868        serverDistribution_ = new CDistributionServer(server->intraCommRank, nZoomBegin, nZoomSize, nGlob); 
     604       writtenDataSize_ = 1; 
     605       for (int i = 0; i < nZoomSize.size(); ++i) 
     606        writtenDataSize_ *= nZoomSize[i]; 
     607 
     608       serverDistribution_ = new CDistributionServer(server->intraCommRank, nZoomBegin, nZoomSize, 
     609                                                     nZoomBeginGlobal, nGlob); 
    869610     } 
    870611 
    … …  
    873614     serverDistribution_->computeLocalIndex(outIndex); 
    874615     outIndexFromClient.insert(std::pair<int, CArray<size_t,1>* >(rank, new CArray<size_t,1>(outIndex))); 
    875  
    876     /* 
    877     CArray<int,1> out_i ; 
    878     CArray<int,1> out_j ; 
    879     CArray<int,1> out_l ; 
    880  
    881     buffer>>out_i>>out_j>>out_l ; 
    882  
    883     out_i -= domain->zoom_ibegin_srv-1 ; 
    884     out_j -= domain->zoom_jbegin_srv-1 ; 
    885  
    886     out_i_fromClient.insert(pair< int,CArray<int,1>* >(rank,new CArray<int,1>(out_i) )) ; 
    887     out_j_fromClient.insert(pair< int,CArray<int,1>* >(rank,new CArray<int,1>(out_j) )) ; 
    888     out_l_fromClient.insert(pair< int,CArray<int,1>* >(rank,new CArray<int,1>(out_l) )) ; 
    889     */ 
    890616  } 
    891617 
    … …  
    1240966  { 
    1241967    SuperClass::parse(node); 
     968 
    1242969    // List order of axis and domain in a grid, if there is a domain, it will take value 1 (true), axis 0 (false) 
    1243 //    std::vector<int> axisOrder; 
    1244970    std::vector<bool> order; 
    1245971 
Note: See TracChangeset for help on using the changeset viewer.