Ignore:
Timestamp:
02/10/16 14:35:03 (8 years ago)
Author:
mhnguyen
Message:

Making some improvements of transformation algorithm

+) Correct the way to enlisting transformations in an element (domain, axis)
+) Optimize generic transformation to make sure temporary grid to be created on demand
+) Update some mpi tag to prevent conflict
+) Correct some minor stuffs
+) Update documents

Test
+) On Curie
+) all test pass

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS/trunk/src/transformation/grid_transformation.cpp

    r795 r821  
    1818#include "axis_algorithm_transformation.hpp" 
    1919#include "distribution_client.hpp" 
     20#include "mpi_tag.hpp" 
    2021 
    2122namespace xios { 
    2223CGridTransformation::CGridTransformation(CGrid* destination, CGrid* source) 
    2324: gridSource_(source), gridDestination_(destination), originalGridSource_(source), 
    24   globalIndexOfCurrentGridSource_(), globalIndexOfOriginalGridSource_(), weightOfGlobalIndexOfOriginalGridSource_(0), algoTypes_() 
     25  algoTypes_(), nbAlgos_(0), currentGridIndexToOriginalGridIndex_() 
     26 
    2527{ 
    2628  //Verify the compatibity between two grids 
    … …  
    4143  } 
    4244 
    43   std::vector<CAxis*> axisSrcTmp = gridSource_->getAxis(), axisSrc; 
    44   std::vector<CDomain*> domainSrcTmp = gridSource_->getDomains(), domainSrc; 
    45   for (int idx = 0; idx < axisSrcTmp.size(); ++idx) 
    46   { 
    47     CAxis* axis = CAxis::createAxis(); 
    48     axis->axis_ref.setValue(axisSrcTmp[idx]->getId()); 
    49     axis->solveRefInheritance(true); 
    50     axis->solveInheritanceTransformation(); 
    51     axis->checkAttributesOnClient(); 
    52     axisSrc.push_back(axis); 
    53   } 
    54  
    55   for (int idx = 0; idx < domainSrcTmp.size(); ++idx) 
    56   { 
    57     CDomain* domain = CDomain::createDomain(); 
    58     domain->domain_ref.setValue(domainSrcTmp[idx]->getId()); 
    59     domain->solveRefInheritance(true); 
    60     domain->solveInheritanceTransformation(); 
    61     domain->checkAttributesOnClient(); 
    62     domainSrc.push_back(domain); 
    63   } 
    64  
    65   gridSource_ = CGrid::createGrid(domainSrc, axisSrc, gridDestination_->axis_domain_order); 
    66   gridSource_->computeGridGlobalDimension(domainSrc, axisSrc, gridDestination_->axis_domain_order); 
     45//  std::vector<CAxis*> axisSrcTmp = gridSource_->getAxis(), axisSrc; 
     46//  std::vector<CDomain*> domainSrcTmp = gridSource_->getDomains(), domainSrc; 
     47//  for (int idx = 0; idx < axisSrcTmp.size(); ++idx) 
     48//  { 
     49//    CAxis* axis = CAxis::createAxis(); 
     50//    axis->axis_ref.setValue(axisSrcTmp[idx]->getId()); 
     51//    axis->solveRefInheritance(true); 
     52//    axis->solveInheritanceTransformation(); 
     53//    axis->checkAttributesOnClient(); 
     54//    axisSrc.push_back(axis); 
     55//  } 
     56// 
     57//  for (int idx = 0; idx < domainSrcTmp.size(); ++idx) 
     58//  { 
     59//    CDomain* domain = CDomain::createDomain(); 
     60//    domain->domain_ref.setValue(domainSrcTmp[idx]->getId()); 
     61//    domain->solveRefInheritance(true); 
     62//    domain->solveInheritanceTransformation(); 
     63//    domain->checkAttributesOnClient(); 
     64//    domainSrc.push_back(domain); 
     65//  } 
     66// 
     67//  gridSource_ = CGrid::createGrid(domainSrc, axisSrc, gridDestination_->axis_domain_order); 
     68//  gridSource_->computeGridGlobalDimension(domainSrc, axisSrc, gridDestination_->axis_domain_order); 
    6769 
    6870  initializeMappingOfOriginalGridSource(); 
    69   initializeAlgorithms(); 
     71//  initializeAlgorithms(); 
    7072} 
    7173 
    … …  
    8183  CContextClient* client = context->client; 
    8284 
    83   CDistributionClient distribution(client->clientRank, originalGridSource_); 
    84   const std::vector<size_t>& globalIndexGridSrcSendToServer = distribution.getGlobalDataIndexSendToServer(); 
    85  
    86   weightOfGlobalIndexOfOriginalGridSource_.resize(globalIndexGridSrcSendToServer.size()); 
    87   globalIndexOfCurrentGridSource_  = globalIndexGridSrcSendToServer; 
    88   globalIndexOfOriginalGridSource_ = globalIndexGridSrcSendToServer; 
    89   weightOfGlobalIndexOfOriginalGridSource_ = 1.0; 
     85  // Initialize algorithms 
     86  initializeAlgorithms(); 
     87 
     88  ListAlgoType::const_iterator itb = listAlgos_.begin(), 
     89                               ite = listAlgos_.end(), it; 
     90 
     91  for (it = itb; it != ite; ++it) 
     92  { 
     93    ETranformationType transType = (it->second).first; 
     94    if (!isSpecialTransformation(transType)) ++nbAlgos_; 
     95  } 
     96 
     97  if (1<nbAlgos_)  // Only when there are more than 1 algorithm, will we create temporary grid source 
     98  { 
     99    std::vector<CAxis*> axisSrcTmp = gridSource_->getAxis(), axisSrc; 
     100    std::vector<CDomain*> domainSrcTmp = gridSource_->getDomains(), domainSrc; 
     101    for (int idx = 0; idx < axisSrcTmp.size(); ++idx) 
     102    { 
     103      CAxis* axis = CAxis::createAxis(); 
     104      axis->axis_ref.setValue(axisSrcTmp[idx]->getId()); 
     105      axis->solveRefInheritance(true); 
     106      axis->solveInheritanceTransformation(); 
     107      axis->checkAttributesOnClient(); 
     108      axisSrc.push_back(axis); 
     109    } 
     110 
     111    for (int idx = 0; idx < domainSrcTmp.size(); ++idx) 
     112    { 
     113      CDomain* domain = CDomain::createDomain(); 
     114      domain->domain_ref.setValue(domainSrcTmp[idx]->getId()); 
     115      domain->solveRefInheritance(true); 
     116      domain->solveInheritanceTransformation(); 
     117      domain->checkAttributesOnClient(); 
     118      domainSrc.push_back(domain); 
     119    } 
     120 
     121    gridSource_ = CGrid::createGrid(domainSrc, axisSrc, gridDestination_->axis_domain_order); 
     122    gridSource_->computeGridGlobalDimension(domainSrc, axisSrc, gridDestination_->axis_domain_order); 
     123  } 
    90124} 
    91125 
    … …  
    149183  } 
    150184} 
    151  
    152  
    153185 
    154186/*! 
    … …  
    335367      break; 
    336368  } 
     369  gridSource_->createMask(); 
     370  gridSource_->computeGridGlobalDimension(domListSrcP, axisListSrcP, gridSource_->axis_domain_order); 
    337371} 
    338372 
    … …  
    352386  ListAlgoType::const_iterator itb = listAlgos_.begin(), 
    353387                               ite = listAlgos_.end(), it; 
     388 
    354389  CGenericAlgorithmTransformation* algo = 0; 
    355390  int nbAgloTransformation = 0; // Only count for executed transformation. Generate domain is a special one, not executed in the list 
    … …  
    381416                                     globaIndexWeightFromDestToSource); 
    382417 
    383       // Compute transformation of global indexes among grids 
    384       computeTransformationFromOriginalGridSource(globaIndexWeightFromDestToSource); 
    385  
    386       // Now grid destination becomes grid source in a new transformation 
    387       setUpGrid(elementPositionInGrid, transType); 
     418      if (1 < nbAlgos_) 
     419      { 
     420        // Compute transformation of global indexes among grids 
     421        computeTransformationFromOriginalGridSource(globaIndexWeightFromDestToSource); 
     422 
     423        // Now grid destination becomes grid source in a new transformation 
     424        if (nbAgloTransformation != (nbAlgos_-1)) setUpGrid(elementPositionInGrid, transType); 
     425      } 
     426      else 
     427      { 
     428        currentGridIndexToOriginalGridIndex_.swap(globaIndexWeightFromDestToSource); 
     429      } 
     430 
    388431      ++nbAgloTransformation; 
    389432    } 
    … …  
    416459  iteArr = globalIndexOnClientDest.end(); 
    417460 
    418   // Then find out which index became invalid (become masked after being applied the algorithms, or demande some masked points from grid source) 
    419   int num = globalIndexOfOriginalGridSource_.size(); 
     461  GlobalIndexMap::const_iterator iteGlobalMap = currentGridIndexToOriginalGridIndex_.end(); 
    420462  const size_t sfmax = NumTraits<unsigned long>::sfmax(); 
    421463  int maskIndexNum = 0; 
    422   for (int idx = 0; idx < num; ++idx) 
    423   { 
    424     if (sfmax == globalIndexOfOriginalGridSource_[idx]) 
    425     { 
    426       size_t maskedGlobalIndex = globalIndexOfCurrentGridSource_[idx]; 
    427       itArr = std::find(itbArr, iteArr, maskedGlobalIndex); 
    428       if (iteArr != itArr) ++maskIndexNum; 
     464  for (itArr = itbArr; itArr != iteArr; ++itArr) 
     465  { 
     466    if (iteGlobalMap != currentGridIndexToOriginalGridIndex_.find(*itArr)) 
     467    { 
     468      const std::vector<std::pair<size_t,double> >& vecIndex = currentGridIndexToOriginalGridIndex_[*itArr]; 
     469      for (int idx = 0; idx < vecIndex.size(); ++idx) 
     470      { 
     471        if (sfmax == vecIndex[idx].first) 
     472        { 
     473          ++maskIndexNum; 
     474          break; 
     475        } 
     476      } 
    429477    } 
    430478  } 
    … …  
    432480  CArray<int,1> maskIndexToModify(maskIndexNum); 
    433481  maskIndexNum = 0; 
    434   for (int idx = 0; idx < num; ++idx) 
    435   { 
    436     if (sfmax == globalIndexOfOriginalGridSource_[idx]) 
    437     { 
    438       size_t maskedGlobalIndex = globalIndexOfCurrentGridSource_[idx]; 
    439       itArr = std::find(itbArr, iteArr, maskedGlobalIndex); 
    440       if (iteArr != itArr) 
     482  for (itArr = itbArr; itArr != iteArr; ++itArr) 
     483  { 
     484    if (iteGlobalMap != currentGridIndexToOriginalGridIndex_.find(*itArr)) 
     485    { 
     486      const std::vector<std::pair<size_t,double> >& vecIndex = currentGridIndexToOriginalGridIndex_[*itArr]; 
     487      for (int idx = 0; idx < vecIndex.size(); ++idx) 
    441488      { 
    442         int localIdx = std::distance(itbArr, itArr); 
    443         maskIndexToModify(maskIndexNum) = localMaskIndexOnClientDest[localIdx]; 
    444         ++maskIndexNum; 
     489        if (sfmax == vecIndex[idx].first) 
     490        { 
     491          int localIdx = std::distance(itbArr, itArr); 
     492          maskIndexToModify(maskIndexNum) = localMaskIndexOnClientDest[localIdx]; 
     493          ++maskIndexNum; 
     494          break; 
     495        } 
    445496      } 
    446497    } 
    … …  
    460511  CContextClient* client = context->client; 
    461512 
     513  if (currentGridIndexToOriginalGridIndex_.empty()) 
     514  { 
     515    currentGridIndexToOriginalGridIndex_ = globaIndexMapFromDestToSource; 
     516    return; 
     517  } 
     518 
    462519  CTransformationMapping transformationMap(gridDestination_, gridSource_); 
    463520 
    … …  
    471528  std::map<int,std::vector<size_t> >::const_iterator itbSend = globalIndexToSend.begin(), itSend, 
    472529                                                     iteSend = globalIndexToSend.end(); 
    473   std::vector<size_t>::const_iterator itbArr = globalIndexOfCurrentGridSource_.begin(), itArr, 
    474                                       iteArr = globalIndexOfCurrentGridSource_.end(); 
    475530 int sendBuffSize = 0; 
    476531 for (itSend = itbSend; itSend != iteSend; ++itSend) sendBuffSize += (itSend->second).size(); 
     532 // We use the first element of each block to send number of element in this block 
     533 sendBuffSize += globalIndexToSend.size(); 
     534 
    477535 
    478536 typedef unsigned long Scalar; 
    479  unsigned long* sendBuff, *currentSendBuff; 
    480  if (0 != sendBuffSize) sendBuff = new unsigned long [sendBuffSize]; 
     537 Scalar* sendBuff, *currentSendBuff; 
     538 if (0 != sendBuffSize) sendBuff = new Scalar [sendBuffSize]; 
    481539 for (StdSize idx = 0; idx < sendBuffSize; ++idx) sendBuff[idx] = NumTraits<Scalar>::sfmax(); 
    482540 
    483  std::map<int, MPI_Request> requests; 
    484  
    485  std::vector<int> permutIndex(globalIndexOfCurrentGridSource_.size()); 
    486  typedef XIOSBinarySearchWithIndex<size_t> BinarySearch; 
    487  XIOSAlgorithms::fillInIndex(globalIndexOfCurrentGridSource_.size(), permutIndex); 
    488  XIOSAlgorithms::sortWithIndex<size_t, CVectorStorage>(globalIndexOfCurrentGridSource_, permutIndex); 
    489  BinarySearch searchCurrentSrc(globalIndexOfCurrentGridSource_); 
    490  std::vector<int>::iterator itbIndex = permutIndex.begin(), itIndex, 
    491                             iteIndex = permutIndex.end(); 
    492  
    493   // Find out local index on grid destination (received) 
     541 std::map<int, MPI_Request> requestsCurrentGrid, requestsOriginalGrid, requestsWeightGrid; 
     542 GlobalIndexMap::const_iterator iteGlobalIndex = currentGridIndexToOriginalGridIndex_.end(); 
     543 
     544  // Only send global index of original source corresponding to non-masked index 
     545  // Use first position of each block to specify the number of elemnt in this block 
     546 int globalIndexOriginalSrcSendBuffSize = 0; 
    494547 int currentBuffPosition = 0; 
    495548 for (itSend = itbSend; itSend != iteSend; ++itSend) 
    … …  
    497550   int destRank = itSend->first; 
    498551   const std::vector<size_t>& globalIndexOfCurrentGridSourceToSend = itSend->second; 
    499    int countSize = globalIndexOfCurrentGridSourceToSend.size(); 
    500    for (int idx = 0; idx < (countSize); ++idx) 
     552   int countSize  = globalIndexOfCurrentGridSourceToSend.size(); 
     553   size_t countBlock = 0; 
     554   for (int idx = 0; idx < countSize; ++idx) 
    501555   { 
    502      if (searchCurrentSrc.search(itbIndex, iteIndex, globalIndexOfCurrentGridSourceToSend[idx], itIndex)) 
     556     size_t index = globalIndexOfCurrentGridSourceToSend[idx]; 
     557     if (iteGlobalIndex != currentGridIndexToOriginalGridIndex_.find(index))// searchCurrentSrc.search(itbIndex, iteIndex, globalIndexOfCurrentGridSourceToSend[idx], itIndex)) 
    503558     { 
    504        sendBuff[idx+currentBuffPosition] = globalIndexOfOriginalGridSource_[*itIndex]; 
     559       globalIndexOriginalSrcSendBuffSize += currentGridIndexToOriginalGridIndex_[index].size() + 1; // 1 for number of elements in this block 
     560       sendBuff[idx+currentBuffPosition+1] = index; 
     561       countBlock += currentGridIndexToOriginalGridIndex_[index].size() + 1; 
    505562     } 
    506563   } 
     564   sendBuff[currentBuffPosition] = countBlock; 
    507565   currentSendBuff = sendBuff + currentBuffPosition; 
    508    MPI_Isend(currentSendBuff, countSize, MPI_UNSIGNED_LONG, destRank, 14, client->intraComm, &requests[destRank]); 
    509    currentBuffPosition += countSize; 
     566   MPI_Isend(currentSendBuff, countSize +1, MPI_UNSIGNED_LONG, destRank, MPI_GRID_TRANSFORMATION_CURRENT_GRID_INDEX, client->intraComm, &requestsCurrentGrid[destRank]); 
     567   currentBuffPosition += countSize + 1; 
    510568 } 
     569 
     570 Scalar* sendOriginalIndexBuff, *currentOriginalIndexSendBuff; 
     571 if (0 != globalIndexOriginalSrcSendBuffSize) sendOriginalIndexBuff = new Scalar [globalIndexOriginalSrcSendBuffSize]; 
     572 double* sendOriginalWeightBuff, *currentOriginalWeightSendBuff; 
     573 if (0 != globalIndexOriginalSrcSendBuffSize) sendOriginalWeightBuff = new double [globalIndexOriginalSrcSendBuffSize]; 
     574 
     575 currentBuffPosition = 0; 
     576 for (itSend = itbSend; itSend != iteSend; ++itSend) 
     577 { 
     578   int destRank = itSend->first; 
     579   const std::vector<size_t>& globalIndexOfCurrentGridSourceToSend = itSend->second; 
     580   int countSize = globalIndexOfCurrentGridSourceToSend.size(); 
     581   int increaseStep = 0; 
     582   for (int idx = 0; idx < countSize; ++idx) 
     583   { 
     584     size_t index = globalIndexOfCurrentGridSourceToSend[idx]; 
     585     if (iteGlobalIndex != currentGridIndexToOriginalGridIndex_.find(index)) 
     586     { 
     587       size_t vectorSize = currentGridIndexToOriginalGridIndex_[index].size(); 
     588       sendOriginalIndexBuff[currentBuffPosition+increaseStep]  = vectorSize; 
     589       sendOriginalWeightBuff[currentBuffPosition+increaseStep] = (double)vectorSize; 
     590       const std::vector<std::pair<size_t,double> >& indexWeightPair = currentGridIndexToOriginalGridIndex_[index]; 
     591       for (size_t i = 0; i < vectorSize; ++i) 
     592       { 
     593         ++increaseStep; 
     594         sendOriginalIndexBuff[currentBuffPosition+increaseStep]  = indexWeightPair[i].first; 
     595         sendOriginalWeightBuff[currentBuffPosition+increaseStep] = indexWeightPair[i].second; 
     596       } 
     597       ++increaseStep; 
     598     } 
     599   } 
     600 
     601   currentOriginalIndexSendBuff = sendOriginalIndexBuff + currentBuffPosition; 
     602   currentOriginalWeightSendBuff = sendOriginalWeightBuff + currentBuffPosition; 
     603   if (0 != increaseStep) 
     604   { 
     605     MPI_Isend(currentOriginalIndexSendBuff, increaseStep, MPI_UNSIGNED_LONG, destRank, MPI_GRID_TRANSFORMATION_ORIGINAL_GRID_INDEX, client->intraComm, &requestsOriginalGrid[destRank]); 
     606     MPI_Isend(currentOriginalWeightSendBuff, increaseStep, MPI_DOUBLE, destRank, MPI_GRID_TRANSFORMATION_ORIGINAL_GRID_WEIGHT, client->intraComm, &requestsWeightGrid[destRank]); 
     607   } 
     608   currentBuffPosition += increaseStep; 
     609 } 
     610 
    511611 
    512612 // Receiving global index of grid source sending from current grid source 
    … …  
    515615 int recvBuffSize = 0; 
    516616 for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv) recvBuffSize += (itRecv->second).size(); 
    517  
    518  unsigned long* recvBuff, *currentRecvBuff; 
    519  if (0 != recvBuffSize) recvBuff = new unsigned long [recvBuffSize]; 
     617 recvBuffSize += globalIndexToReceive.size(); 
     618 
     619 Scalar* recvBuff, *currentRecvBuff; 
     620 if (0 != recvBuffSize) recvBuff = new Scalar [recvBuffSize]; 
    520621 for (StdSize idx = 0; idx < recvBuffSize; ++idx) recvBuff[idx] = NumTraits<Scalar>::sfmax(); 
    521622 
     623 std::map<int,int> countBlockMap; 
     624 int globalIndexOriginalSrcRecvBuffSize = 0; 
    522625 int currentRecvBuffPosition = 0; 
    523626 for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv) 
    … …  
    527630   int countSize = (itRecv->second).size(); 
    528631   currentRecvBuff = recvBuff + currentRecvBuffPosition; 
    529    MPI_Recv(currentRecvBuff, countSize, MPI_UNSIGNED_LONG, srcRank, 14, client->intraComm, &status); 
    530    currentRecvBuffPosition += countSize; 
     632   MPI_Recv(currentRecvBuff, countSize +1, MPI_UNSIGNED_LONG, srcRank, MPI_GRID_TRANSFORMATION_CURRENT_GRID_INDEX, client->intraComm, &status); 
     633   globalIndexOriginalSrcRecvBuffSize += *currentRecvBuff; 
     634   countBlockMap[srcRank] = *currentRecvBuff; 
     635   currentRecvBuffPosition += countSize +1; 
    531636 } 
    532637 
    533  int nbCurrentGridSource = 0; 
     638 Scalar* recvOriginalIndexBuff, *currentOriginalIndexRecvBuff; 
     639 if (0 != globalIndexOriginalSrcRecvBuffSize) recvOriginalIndexBuff = new Scalar [globalIndexOriginalSrcRecvBuffSize]; 
     640 double* recvOriginalWeightBuff, *currentOriginalWeightRecvBuff; 
     641 if (0 != globalIndexOriginalSrcRecvBuffSize) recvOriginalWeightBuff = new double [globalIndexOriginalSrcRecvBuffSize]; 
     642 
     643 int countBlock = 0; 
     644 currentRecvBuffPosition = 0; 
     645 currentBuffPosition = 0; 
    534646 for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv) 
    535647 { 
    536    int ssize = (itRecv->second).size(); 
    537    for (int idx = 0; idx < ssize; ++idx) 
     648   MPI_Status statusIndex, statusWeight; 
     649   int srcRank = itRecv->first; 
     650   countBlock = countBlockMap[srcRank]; 
     651   currentOriginalIndexRecvBuff = recvOriginalIndexBuff + currentBuffPosition; 
     652   currentOriginalWeightRecvBuff = recvOriginalWeightBuff + currentBuffPosition; 
     653   if (0 != countBlock) 
    538654   { 
    539      nbCurrentGridSource += (itRecv->second)[idx].size(); 
     655     MPI_Recv(currentOriginalIndexRecvBuff, countBlock, MPI_UNSIGNED_LONG, srcRank, MPI_GRID_TRANSFORMATION_ORIGINAL_GRID_INDEX, client->intraComm, &statusIndex); 
     656     MPI_Recv(currentOriginalWeightRecvBuff, countBlock, MPI_DOUBLE, srcRank, MPI_GRID_TRANSFORMATION_ORIGINAL_GRID_WEIGHT, client->intraComm, &statusWeight); 
     657   } 
     658   currentBuffPosition += countBlock; 
     659 } 
     660 
     661 // We process everything in here, even case of masked index 
     662 // The way to process masked index needs discussing 
     663 const size_t sfmax = NumTraits<unsigned long>::sfmax(); 
     664 GlobalIndexMap currentToOriginalTmp; 
     665 
     666 currentRecvBuffPosition = 0; 
     667 currentRecvBuff = recvBuff; 
     668 currentOriginalIndexRecvBuff  = recvOriginalIndexBuff; 
     669 currentOriginalWeightRecvBuff = recvOriginalWeightBuff; 
     670 for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv) 
     671 { 
     672   int countBlockRank = countBlockMap[itRecv->first]; 
     673 
     674   ++currentRecvBuff;  // it's very subtle here, pay attention 
     675   int countSize = (itRecv->second).size(); 
     676   for (int idx = 0; idx < countSize; ++idx) 
     677   { 
     678      ++currentRecvBuff; 
     679     int ssize = (itRecv->second)[idx].size(); 
     680     if (sfmax != *currentRecvBuff) 
     681     { 
     682       if (0 != countBlockRank) 
     683       { 
     684         countBlock = *(currentOriginalIndexRecvBuff+currentRecvBuffPosition); 
     685         for (int i = 0; i < ssize; ++i) 
     686         { 
     687           for (int j = 0; j < countBlock; ++j) 
     688           { 
     689             size_t globalOriginalIndex = *(currentOriginalIndexRecvBuff+currentRecvBuffPosition+j+1); 
     690             double weightGlobal = *(currentOriginalWeightRecvBuff+currentRecvBuffPosition+j+1) * (itRecv->second)[idx][i].second; 
     691             currentToOriginalTmp[(itRecv->second)[idx][i].first].push_back(make_pair(globalOriginalIndex,weightGlobal)); 
     692           } 
     693         } 
     694         currentRecvBuffPosition += countBlock+1; 
     695       } 
     696     } 
     697//     else 
     698//     { 
     699//       for (int i = 0; i < ssize; ++i) 
     700//       { 
     701//         currentToOriginalTmp[(itRecv->second)[idx][i].first].push_back(make_pair(sfmax,1.0)); 
     702//       } 
     703//     } 
    540704   } 
    541705 } 
    542706 
    543  if (globalIndexOfCurrentGridSource_.size() != nbCurrentGridSource) 
    544  { 
    545    globalIndexOfCurrentGridSource_.resize(nbCurrentGridSource); 
    546    globalIndexOfOriginalGridSource_.resize(nbCurrentGridSource); 
    547    weightOfGlobalIndexOfOriginalGridSource_.resize(nbCurrentGridSource); 
    548  } 
    549  
    550  int k = 0; 
    551  currentRecvBuff = recvBuff; 
    552  for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv) 
    553  { 
    554    int countSize = (itRecv->second).size(); 
    555    for (int idx = 0; idx < countSize; ++idx, ++currentRecvBuff) 
    556    { 
    557      int ssize = (itRecv->second)[idx].size(); 
    558      for (int i = 0; i < ssize; ++i) 
    559      { 
    560        globalIndexOfCurrentGridSource_[k] = ((itRecv->second)[idx][i]).first; 
    561        weightOfGlobalIndexOfOriginalGridSource_(k) = ((itRecv->second)[idx][i]).second; 
    562        globalIndexOfOriginalGridSource_[k] = *currentRecvBuff; 
    563        ++k; 
    564      } 
    565    } 
    566  } 
     707 currentGridIndexToOriginalGridIndex_.swap(currentToOriginalTmp); 
    567708 
    568709 std::map<int, MPI_Request>::iterator itRequest; 
    569  for (itRequest = requests.begin(); itRequest != requests.end(); ++itRequest) 
     710 for (itRequest = requestsCurrentGrid.begin(); itRequest != requestsCurrentGrid.end(); ++itRequest) 
     711   MPI_Wait(&itRequest->second, MPI_STATUS_IGNORE); 
     712 for (itRequest = requestsOriginalGrid.begin(); itRequest != requestsOriginalGrid.end(); ++itRequest) 
     713   MPI_Wait(&itRequest->second, MPI_STATUS_IGNORE); 
     714 for (itRequest = requestsWeightGrid.begin(); itRequest != requestsWeightGrid.end(); ++itRequest) 
    570715   MPI_Wait(&itRequest->second, MPI_STATUS_IGNORE); 
    571716 
    572717 if (0 != sendBuffSize) delete [] sendBuff; 
    573718 if (0 != recvBuffSize) delete [] recvBuff; 
     719 if (0 != globalIndexOriginalSrcSendBuffSize) delete [] sendOriginalIndexBuff; 
     720 if (0 != globalIndexOriginalSrcSendBuffSize) delete [] sendOriginalWeightBuff; 
     721 if (0 != globalIndexOriginalSrcRecvBuffSize) delete [] recvOriginalIndexBuff; 
     722 if (0 != globalIndexOriginalSrcRecvBuffSize) delete [] recvOriginalWeightBuff; 
    574723} 
    575724 
    … …  
    586735  CTransformationMapping transformationMap(gridDestination_, originalGridSource_); 
    587736 
    588   std::map<size_t, std::vector<std::pair<size_t,double> > > globaIndexWeightFromDestToSource; 
    589   int nb = globalIndexOfCurrentGridSource_.size(); 
    590   const size_t sfmax = NumTraits<unsigned long>::sfmax(); 
    591   for (int idx = 0; idx < nb; ++idx) 
    592   { 
    593     if (sfmax != globalIndexOfOriginalGridSource_[idx]) 
    594       globaIndexWeightFromDestToSource[globalIndexOfCurrentGridSource_[idx]].push_back(make_pair(globalIndexOfOriginalGridSource_[idx], weightOfGlobalIndexOfOriginalGridSource_(idx))) ; 
    595   } 
    596  
    597   // Then compute transformation mapping among clients 
    598   transformationMap.computeTransformationMapping(globaIndexWeightFromDestToSource); 
     737  transformationMap.computeTransformationMapping(currentGridIndexToOriginalGridIndex_); 
    599738 
    600739  const std::map<int,std::vector<std::vector<std::pair<size_t,double> > > >& globalIndexToReceive = transformationMap.getGlobalIndexReceivedOnGridDestMapping(); 
    … …  
    667806} 
    668807 
     808bool CGridTransformation::isSpecialTransformation(ETranformationType transType) 
     809{ 
     810  bool res; 
     811  switch (transType) 
     812  { 
     813    case TRANS_GENERATE_RECTILINEAR_DOMAIN: 
     814     res = true; 
     815     break; 
     816    default: 
     817     res = false; 
     818     break; 
     819  } 
     820 
     821  return res; 
     822} 
     823 
    669824/*! 
    670825  Local index of data which need sending from the grid source 
Note: See TracChangeset for help on using the changeset viewer.