PCPPIntervalUtils.H

Go to the documentation of this file.

#ifndef __PCPP_EXTENT_UTILS__
#define __PCPP_EXTENT_UTILS__

#include "PCPPTypes.H"

namespace pcpp {
  namespace util {

    int SubIntervalFromStream(std::istream &inStream,const pcpp::IndexIntervalType &inInterval,
                              pcpp::IndexIntervalType &subInterval);

    std::deque<size_t> PrimeFactors(size_t inNumber);

    int SimplePartitionInterval(const pcpp::IndexIntervalType &inInterval,
                                std::vector<bool> partDirection,int partID,
                                int numPart,pcpp::IndexIntervalType &outInterval,
                                std::vector<int> &numPartitions);

    int Part1D(const size_t iStart,const size_t iEnd,const size_t numPart,const size_t partIndex,
               size_t &partStart,size_t &partEnd);


    // Deprecated
    int PartitionCartesianExtent(const pcpp::IndexIntervalType &globalExtent,
                                 const std::vector<int> &cartDims,
                                 const std::vector<int> &cartCoords,
                                 pcpp::IndexIntervalType &partExtent,
                                 std::ostream &messageStream);

    int PartitionCartesianInterval(const pcpp::IndexIntervalType &globalExtent,
                                 const std::vector<int> &cartDims,
                                 const std::vector<int> &cartCoords,
                                 pcpp::IndexIntervalType &partExtent,
                                 std::ostream &messageStream);

    void CollapseInterval(size_t &xSize,size_t &ySize,size_t &zSize,
                          const pcpp::IndexIntervalType &inInterval,
                          pcpp::IndexIntervalType &outInterval);
    
    std::vector<pcpp::IndexIntervalType> UniqueUnion(const std::vector<pcpp::IndexIntervalType> &intervalSet);
    
    template<typename BufferDataType>
    void TransferBufferData(size_t numPoints,
                            int numComponents,
                            size_t sourceSize,
                            size_t targetSize,
                            const size_t *sourceIndices,
                            const size_t *targetIndices,
                            const BufferDataType *sourceBuffer,
                            BufferDataType *targetBuffer)
    {
      for(int iComponent = 0;iComponent < numComponents;iComponent++){
        size_t sourceComp = iComponent*sourceSize;
        size_t targComp   = iComponent*targetSize;
        for(size_t iPoint = 0;iPoint < numPoints;iPoint++){
          size_t sourcePoint = sourceComp + sourceIndices[iPoint];
          size_t targPoint   = targComp + targetIndices[iPoint];
          targetBuffer[targPoint] = sourceBuffer[sourcePoint];
        }
      }
    };
    
    
    template<typename BufferDataType>
    int CopyInterval(const std::vector<size_t> &sourceSizes,
                     const pcpp::IndexIntervalType &sourceInterval,
                     const BufferDataType *sourceBuffer,
                     const std::vector<size_t> &destSizes,
                     const pcpp::IndexIntervalType &destInterval,
                     BufferDataType *destData)
    {
      size_t numSourcePoints = sourceInterval.NNodes();
      size_t numDestPoints   = destInterval.NNodes();
      
      if(numSourcePoints != numDestPoints)
        return(1);
      
      pcpp::IndexIntervalType sourceBufferInterval;
      sourceBufferInterval.InitSimple(sourceSizes);
      
      pcpp::IndexIntervalType destBufferInterval;
      destBufferInterval.InitSimple(destSizes);
      
      std::vector<size_t> sourceIndices;
      std::vector<size_t> destIndices;
      
      sourceBufferInterval.GetFlatIndices(sourceInterval,sourceIndices);
      destBufferInterval.GetFlatIndices(destInterval,destIndices);
      
      for(int iPoint = 0;iPoint < numSourcePoints;iPoint++)
        destBufferInterval[destIndices[iPoint]] = 
          sourceBufferInterval[sourceIndices[iPoint]];
    }
   
  }
}
#endif