Ignore:
Timestamp:
01/31/19 12:12:52 (5 years ago)
Author:
yushan
Message:

branch merged with trunk @1645. arch file (ep&mpi) added for ADA

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS/dev/dev_trunk_omp/src/node/grid.hpp

    r1564 r1646  
    9494         template <int n> 
    9595         void inputField(const CArray<double,n>& field, CArray<double,1>& stored) const; 
     96         template <int n> 
     97         void maskField(const CArray<double,n>& field, CArray<double,1>& stored) const; 
    9698         template <int n> 
    9799         void outputField(const CArray<double,1>& stored, CArray<double,n>& field) const;   
    … …  
    203205         bool hasTransform(); 
    204206         size_t getGlobalWrittenSize(void) ; 
    205          void getLocalMask(CArray<bool,1>& localMask) ; 
    206          template<int N> 
    207          void getLocalMask(const CArray<bool,N>& gridMask, CArray<bool,1>& localMask) ; 
    208207      public: 
    209208         CArray<int, 1> storeIndex_client; 
     209         CArray<bool, 1> storeMask_client; 
    210210 
    211211/** Map containing indexes that will be sent in sendIndex(). */ 
    … …  
    247247         CArray<size_t,1> indexFromClients; 
    248248 
     249         bool hasMask(void) const; 
    249250         void checkMask(void); 
    250251         void createMask(void); 
    … …  
    273274        void restoreField_arr(const CArray<double, 1>& stored, double* const data) const; 
    274275        void uncompressField_arr(const double* const data, CArray<double, 1>& outData) const; 
     276        void maskField_arr(const double* const data, CArray<double, 1>& stored) const; 
    275277 
    276278        void setVirtualDomainGroup(CDomainGroup* newVDomainGroup); 
    … …  
    372374   template <int n> 
    373375   void CGrid::inputField(const CArray<double,n>& field, CArray<double,1>& stored) const 
     376   TRY 
    374377   { 
    375378//#ifdef __XIOS_DEBUG 
    … …  
    383386      this->storeField_arr(field.dataFirst(), stored); 
    384387   } 
     388   CATCH 
     389 
     390   template <int n> 
     391   void CGrid::maskField(const CArray<double,n>& field, CArray<double,1>& stored) const 
     392   { 
     393//#ifdef __XIOS_DEBUG 
     394      if (this->getDataSize() != field.numElements()) 
     395         ERROR("void CGrid::inputField(const  CArray<double,n>& field, CArray<double,1>& stored) const", 
     396                << "[ Awaiting data of size = " << this->getDataSize() << ", " 
     397                << "Received data size = "      << field.numElements() << " ] " 
     398                << "The data array does not have the right size! " 
     399                << "Grid = " << this->getId()) 
     400//#endif 
     401      this->maskField_arr(field.dataFirst(), stored); 
     402   } 
    385403 
    386404   template <int n> 
    387405   void CGrid::outputField(const CArray<double,1>& stored, CArray<double,n>& field) const 
     406   TRY 
    388407   { 
    389408//#ifdef __XIOS_DEBUG 
    … …  
    397416      this->restoreField_arr(stored, field.dataFirst()); 
    398417   } 
     418   CATCH 
    399419 
    400420   /*! 
    … …  
    406426   template <int N> 
    407427   void CGrid::uncompressField(const CArray<double,N>& data, CArray<double,1>& outData) const 
     428   TRY 
    408429   {       
    409430     uncompressField_arr(data.dataFirst(), outData); 
    410431   } 
     432   CATCH 
    411433 
    412434   template<int N> 
    … …  
    416438                             const CArray<int,1>& axisDomainOrder, 
    417439                             bool createMask) 
     440   TRY 
    418441   { 
    419      if (!gridMask.isEmpty() || createMask) 
    420      { 
    421        int idx = 0; 
    422        int numElement = axisDomainOrder.numElements(); 
    423        int dim = domainMasks.size() * 2 + axisMasks.size(); 
    424        std::vector<CDomain*> domainP = this->getDomains(); 
    425        std::vector<CAxis*> axisP = this->getAxis(); 
    426  
    427        std::vector<int> idxLoop(dim,0), indexMap(numElement), eachDimSize(dim); 
    428        std::vector<int> currentIndex(dim); 
    429        int idxDomain = 0, idxAxis = 0; 
     442     int idx = 0; 
     443     int numElement = axisDomainOrder.numElements(); 
     444     int dim = domainMasks.size() * 2 + axisMasks.size(); 
     445     std::vector<CDomain*> domainP = this->getDomains(); 
     446     std::vector<CAxis*> axisP = this->getAxis(); 
     447 
     448     std::vector<int> idxLoop(dim,0), indexMap(numElement), eachDimSize(dim); 
     449     std::vector<int> currentIndex(dim); 
     450     int idxDomain = 0, idxAxis = 0; 
     451    for (int i = 0; i < numElement; ++i) 
     452    { 
     453      indexMap[i] = idx; 
     454      if (2 == axisDomainOrder(i)) { 
     455          eachDimSize[indexMap[i]]   = domainP[idxDomain]->ni; 
     456          eachDimSize[indexMap[i]+1] = domainP[idxDomain]->nj; 
     457          idx += 2; ++idxDomain; 
     458      } 
     459      else if (1 == axisDomainOrder(i)) { 
     460//        eachDimSize[indexMap[i]] = axisMasks[idxAxis]->numElements(); 
     461        eachDimSize[indexMap[i]] = axisP[idxAxis]->n; 
     462        ++idx; ++idxAxis; 
     463      } 
     464      else {}; 
     465    } 
     466 
     467    if (!gridMask.isEmpty() && !createMask) 
     468    { 
     469      for (int i = 0; i < dim; ++i) 
     470      { 
     471        if (gridMask.extent(i) != eachDimSize[i]) 
     472          ERROR("CGrid::checkMask(void)", 
     473                << "The mask has one dimension whose size is different from the one of the local grid." << std::endl 
     474                << "Local size of dimension " << i << " is " << eachDimSize[i] << "." << std::endl 
     475                << "Mask size for dimension " << i << " is " << gridMask.extent(i) << "." << std::endl 
     476                << "Grid = " << this->getId()) 
     477      } 
     478    } 
     479    else { 
     480        CArrayBoolTraits<CArray<bool,N> >::resizeArray(gridMask,eachDimSize); 
     481        gridMask = true; 
     482    } 
     483 
     484    int ssize = gridMask.numElements(); 
     485    idx = 0; 
     486    while (idx < ssize) 
     487    { 
     488      for (int i = 0; i < dim-1; ++i) 
     489      { 
     490        if (idxLoop[i] == eachDimSize[i]) 
     491        { 
     492          idxLoop[i] = 0; 
     493          ++idxLoop[i+1]; 
     494        } 
     495      } 
     496 
     497      // Find out outer index 
     498      idxDomain = idxAxis = 0; 
     499      bool maskValue = true; 
    430500      for (int i = 0; i < numElement; ++i) 
    431501      { 
    432         indexMap[i] = idx; 
    433         if (2 == axisDomainOrder(i)) { 
    434             eachDimSize[indexMap[i]]   = domainP[idxDomain]->ni; 
    435             eachDimSize[indexMap[i]+1] = domainP[idxDomain]->nj; 
    436             idx += 2; ++idxDomain; 
     502        if (2 == axisDomainOrder(i)) 
     503        { 
     504          int idxTmp = idxLoop[indexMap[i]] + idxLoop[indexMap[i]+1] * eachDimSize[indexMap[i]]; 
     505          if (idxTmp < (*domainMasks[idxDomain]).numElements()) 
     506            maskValue = maskValue && (*domainMasks[idxDomain])(idxTmp); 
     507          else 
     508            maskValue = false; 
     509          ++idxDomain; 
    437510        } 
    438         else if (1 == axisDomainOrder(i)) { 
    439   //        eachDimSize[indexMap[i]] = axisMasks[idxAxis]->numElements(); 
    440           eachDimSize[indexMap[i]] = axisP[idxAxis]->n; 
    441           ++idx; ++idxAxis; 
     511        else if (1 == axisDomainOrder(i)) 
     512        { 
     513          int idxTmp = idxLoop[indexMap[i]]; 
     514          if (idxTmp < (*axisMasks[idxAxis]).numElements()) 
     515            maskValue = maskValue && (*axisMasks[idxAxis])(idxTmp); 
     516          else 
     517            maskValue = false; 
     518 
     519          ++idxAxis; 
    442520        } 
    443         else {}; 
    444       } 
    445  
    446 //      if (!gridMask.isEmpty() && !createMask) 
    447       if (!createMask) 
     521      } 
     522 
     523      int maskIndex = idxLoop[0]; 
     524      int mulDim = 1; 
     525      for (int k = 1; k < dim; ++k) 
    448526      { 
    449         for (int i = 0; i < dim; ++i) 
    450         { 
    451           if (gridMask.extent(i) != eachDimSize[i]) 
    452             ERROR("CGrid::checkMask(void)", 
    453                   << "The mask has one dimension whose size is different from the one of the local grid." << std::endl 
    454                   << "Local size of dimension " << i << " is " << eachDimSize[i] << "." << std::endl 
    455                   << "Mask size for dimension " << i << " is " << gridMask.extent(i) << "." << std::endl 
    456                   << "Grid = " << this->getId()) 
    457         } 
    458       } 
    459       else { 
    460           CArrayBoolTraits<CArray<bool,N> >::resizeArray(gridMask,eachDimSize); 
    461           gridMask = true; 
    462       } 
    463  
    464       int ssize = gridMask.numElements(); 
    465       idx = 0; 
    466       while (idx < ssize) 
    467       { 
    468         for (int i = 0; i < dim-1; ++i) 
    469         { 
    470           if (idxLoop[i] == eachDimSize[i]) 
    471           { 
    472             idxLoop[i] = 0; 
    473             ++idxLoop[i+1]; 
    474           } 
    475         } 
    476  
    477         // Find out outer index 
    478         idxDomain = idxAxis = 0; 
    479         bool maskValue = true; 
    480         for (int i = 0; i < numElement; ++i) 
    481         { 
    482           if (2 == axisDomainOrder(i)) 
    483           { 
    484             int idxTmp = idxLoop[indexMap[i]] + idxLoop[indexMap[i]+1] * eachDimSize[indexMap[i]]; 
    485             if (idxTmp < (*domainMasks[idxDomain]).numElements()) 
    486               maskValue = maskValue && (*domainMasks[idxDomain])(idxTmp); 
    487             else 
    488               maskValue = false; 
    489             ++idxDomain; 
    490           } 
    491           else if (1 == axisDomainOrder(i)) 
    492           { 
    493             int idxTmp = idxLoop[indexMap[i]]; 
    494             if (idxTmp < (*axisMasks[idxAxis]).numElements()) 
    495               maskValue = maskValue && (*axisMasks[idxAxis])(idxTmp); 
    496             else 
    497               maskValue = false; 
    498  
    499             ++idxAxis; 
    500           } 
    501         } 
    502  
    503         int maskIndex = idxLoop[0]; 
    504         int mulDim = 1; 
    505         for (int k = 1; k < dim; ++k) 
    506         { 
    507           mulDim *= eachDimSize[k-1]; 
    508           maskIndex += idxLoop[k]*mulDim; 
    509         } 
    510         *(gridMask.dataFirst()+maskIndex) &= maskValue; 
    511  
    512         ++idxLoop[0]; 
    513         ++idx; 
    514       } 
    515      } 
    516    } 
     527        mulDim *= eachDimSize[k-1]; 
     528        maskIndex += idxLoop[k]*mulDim; 
     529      } 
     530      *(gridMask.dataFirst()+maskIndex) &= maskValue; 
     531 
     532      ++idxLoop[0]; 
     533      ++idx; 
     534    } 
     535   } 
     536   CATCH_DUMP_ATTR 
    517537 
    518538   template<int N> 
    … …  
    520540                                  const std::vector<int>& eachDimSize, 
    521541                                  bool newValue) 
     542   TRY 
    522543   { 
    523544      if (N != eachDimSize.size()) 
    … …  
    534555      gridMask = newValue; 
    535556   } 
     557   CATCH_DUMP_ATTR 
    536558                                  
    537559 
    … …  
    543565   template<int N> 
    544566   void CGrid::modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify, bool valueToModify) 
     567   TRY 
    545568   {      
    546569     int num = indexToModify.numElements(); 
    … …  
    550573     } 
    551574   } 
     575   CATCH_DUMP_ATTR 
     576 
    552577   ///-------------------------------------------------------------- 
    553578 
    554579 
    555 /*! 
    556   A grid can have multiple dimension, so can its mask in the form of multi-dimension array. 
    557 It's not a good idea to store all multi-dimension arrays corresponding to each mask. 
    558 One of the ways is to convert this array into 1-dimension one and every process is taken place on it. 
    559   \param [in] multi-dimension array grid mask 
    560 */ 
    561 template<int N> 
    562 void CGrid::getLocalMask(const CArray<bool,N>& gridMask, CArray<bool,1>& localMask) 
    563 { 
    564   if (gridMask.isEmpty()) return ; 
    565   int dim = gridMask.dimensions(); 
    566   std::vector<int> dimensionSizes(dim); 
    567   for (int i = 0; i < dim; ++i) dimensionSizes[i] = gridMask.extent(i); 
    568  
    569   std::vector<int> idxLoop(dim,0); 
    570   int ssize = gridMask.numElements(), idx = 0; 
    571   localMask.resize(ssize); 
    572   while (idx < ssize) 
    573   { 
    574     for (int i = 0; i < dim-1; ++i) 
    575     { 
    576       if (idxLoop[i] == dimensionSizes[i]) 
    577       { 
    578         idxLoop[i] = 0; 
    579         ++idxLoop[i+1]; 
    580       } 
    581     } 
    582  
    583     int maskIndex = idxLoop[0]; 
    584     int mulDim = 1; 
    585     for (int k = 1; k < dim; ++k) 
    586     { 
    587       mulDim *= dimensionSizes[k-1]; 
    588       maskIndex += idxLoop[k]*mulDim; 
    589     } 
    590     localMask(maskIndex) = *(gridMask.dataFirst()+maskIndex); 
    591  
    592     ++idxLoop[0]; 
    593     ++idx; 
    594   } 
    595 } 
    596580 
    597581   // Declare/Define CGridGroup and CGridDefinition 
Note: See TracChangeset for help on using the changeset viewer.