Ignore:
Timestamp:
01/14/19 13:33:48 (5 years ago)
Author:
oabramkina
Message:

Merging dev to trunk. Major changes:

(1) Grid mask is applied in the source filter of clients: unmasked values are replaced by NaN. It is not reconstructed any more by servers.

(2) Domain/axis mask has been incorporated into data index, with only data index sent to servers.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r1622 r1637  
    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); 
    … …  
    387389 
    388390   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   } 
     403 
     404   template <int n> 
    389405   void CGrid::outputField(const CArray<double,1>& stored, CArray<double,n>& field) const 
    390406   TRY 
    … …  
    424440   TRY 
    425441   { 
    426      if (!gridMask.isEmpty() || createMask) 
    427      { 
    428        int idx = 0; 
    429        int numElement = axisDomainOrder.numElements(); 
    430        int dim = domainMasks.size() * 2 + axisMasks.size(); 
    431        std::vector<CDomain*> domainP = this->getDomains(); 
    432        std::vector<CAxis*> axisP = this->getAxis(); 
    433  
    434        std::vector<int> idxLoop(dim,0), indexMap(numElement), eachDimSize(dim); 
    435        std::vector<int> currentIndex(dim); 
    436        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; 
    437500      for (int i = 0; i < numElement; ++i) 
    438501      { 
    439         indexMap[i] = idx; 
    440         if (2 == axisDomainOrder(i)) { 
    441             eachDimSize[indexMap[i]]   = domainP[idxDomain]->ni; 
    442             eachDimSize[indexMap[i]+1] = domainP[idxDomain]->nj; 
    443             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; 
    444510        } 
    445         else if (1 == axisDomainOrder(i)) { 
    446   //        eachDimSize[indexMap[i]] = axisMasks[idxAxis]->numElements(); 
    447           eachDimSize[indexMap[i]] = axisP[idxAxis]->n; 
    448           ++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; 
    449520        } 
    450         else {}; 
    451       } 
    452  
    453 //      if (!gridMask.isEmpty() && !createMask) 
    454       if (!createMask) 
     521      } 
     522 
     523      int maskIndex = idxLoop[0]; 
     524      int mulDim = 1; 
     525      for (int k = 1; k < dim; ++k) 
    455526      { 
    456         for (int i = 0; i < dim; ++i) 
    457         { 
    458           if (gridMask.extent(i) != eachDimSize[i]) 
    459             ERROR("CGrid::checkMask(void)", 
    460                   << "The mask has one dimension whose size is different from the one of the local grid." << std::endl 
    461                   << "Local size of dimension " << i << " is " << eachDimSize[i] << "." << std::endl 
    462                   << "Mask size for dimension " << i << " is " << gridMask.extent(i) << "." << std::endl 
    463                   << "Grid = " << this->getId()) 
    464         } 
    465       } 
    466       else { 
    467           CArrayBoolTraits<CArray<bool,N> >::resizeArray(gridMask,eachDimSize); 
    468           gridMask = true; 
    469       } 
    470  
    471       int ssize = gridMask.numElements(); 
    472       idx = 0; 
    473       while (idx < ssize) 
    474       { 
    475         for (int i = 0; i < dim-1; ++i) 
    476         { 
    477           if (idxLoop[i] == eachDimSize[i]) 
    478           { 
    479             idxLoop[i] = 0; 
    480             ++idxLoop[i+1]; 
    481           } 
    482         } 
    483  
    484         // Find out outer index 
    485         idxDomain = idxAxis = 0; 
    486         bool maskValue = true; 
    487         for (int i = 0; i < numElement; ++i) 
    488         { 
    489           if (2 == axisDomainOrder(i)) 
    490           { 
    491             int idxTmp = idxLoop[indexMap[i]] + idxLoop[indexMap[i]+1] * eachDimSize[indexMap[i]]; 
    492             if (idxTmp < (*domainMasks[idxDomain]).numElements()) 
    493               maskValue = maskValue && (*domainMasks[idxDomain])(idxTmp); 
    494             else 
    495               maskValue = false; 
    496             ++idxDomain; 
    497           } 
    498           else if (1 == axisDomainOrder(i)) 
    499           { 
    500             int idxTmp = idxLoop[indexMap[i]]; 
    501             if (idxTmp < (*axisMasks[idxAxis]).numElements()) 
    502               maskValue = maskValue && (*axisMasks[idxAxis])(idxTmp); 
    503             else 
    504               maskValue = false; 
    505  
    506             ++idxAxis; 
    507           } 
    508         } 
    509  
    510         int maskIndex = idxLoop[0]; 
    511         int mulDim = 1; 
    512         for (int k = 1; k < dim; ++k) 
    513         { 
    514           mulDim *= eachDimSize[k-1]; 
    515           maskIndex += idxLoop[k]*mulDim; 
    516         } 
    517         *(gridMask.dataFirst()+maskIndex) &= maskValue; 
    518  
    519         ++idxLoop[0]; 
    520         ++idx; 
    521       } 
    522      } 
     527        mulDim *= eachDimSize[k-1]; 
     528        maskIndex += idxLoop[k]*mulDim; 
     529      } 
     530      *(gridMask.dataFirst()+maskIndex) &= maskValue; 
     531 
     532      ++idxLoop[0]; 
     533      ++idx; 
     534    } 
    523535   } 
    524536   CATCH_DUMP_ATTR 
    … …  
    565577   ///-------------------------------------------------------------- 
    566578 
    567   /*! 
    568     A grid can have multiple dimension, so can its mask in the form of multi-dimension array. 
    569   It's not a good idea to store all multi-dimension arrays corresponding to each mask. 
    570   One of the ways is to convert this array into 1-dimension one and every process is taken place on it. 
    571     \param [in] multi-dimension array grid mask 
    572   */ 
    573   template<int N> 
    574   void CGrid::getLocalMask(const CArray<bool,N>& gridMask, CArray<bool,1>& localMask) 
    575   TRY 
    576   { 
    577     if (gridMask.isEmpty()) return ; 
    578     int dim = gridMask.dimensions(); 
    579     std::vector<int> dimensionSizes(dim); 
    580     for (int i = 0; i < dim; ++i) dimensionSizes[i] = gridMask.extent(i); 
    581  
    582     std::vector<int> idxLoop(dim,0); 
    583     int ssize = gridMask.numElements(), idx = 0; 
    584     localMask.resize(ssize); 
    585     while (idx < ssize) 
    586     { 
    587       for (int i = 0; i < dim-1; ++i) 
    588       { 
    589         if (idxLoop[i] == dimensionSizes[i]) 
    590         { 
    591           idxLoop[i] = 0; 
    592           ++idxLoop[i+1]; 
    593         } 
    594       } 
    595  
    596       int maskIndex = idxLoop[0]; 
    597       int mulDim = 1; 
    598       for (int k = 1; k < dim; ++k) 
    599       { 
    600         mulDim *= dimensionSizes[k-1]; 
    601         maskIndex += idxLoop[k]*mulDim; 
    602       } 
    603       localMask(maskIndex) = *(gridMask.dataFirst()+maskIndex); 
    604  
    605       ++idxLoop[0]; 
    606       ++idx; 
    607     } 
    608   } 
    609    CATCH_DUMP_ATTR 
     579 
    610580 
    611581   // Declare/Define CGridGroup and CGridDefinition 
Note: See TracChangeset for help on using the changeset viewer.