Stencil.H

Go to the documentation of this file.

#ifndef __STENCIL_H__
#define __STENCIL_H__

#include "PCPPTypes.H"

#include <cstdlib>
#include <vector>
#include <cmath>
#include <list>

namespace plascom2 {

  namespace operators {
    
    struct stencilset {
      stencilset() : numStencils(0), numValues(0), ownData(false),
                     stencilSizes(NULL),  stencilStarts(NULL), 
                     stencilOffsets(NULL),stencilWeights(NULL),
                     overallOrder(0), stencilOrders(NULL) {};
      
      void Copy(const stencilset &inStencilSet) {

        Destroy();
        
        numStencils  = inStencilSet.numStencils;
        numValues    = inStencilSet.numValues;
        ownData      = true;
        overallOrder = inStencilSet.overallOrder;

        stencilSizes   = new int    [numStencils];
        stencilStarts  = new int    [numStencils];
        stencilOffsets = new int    [numValues];
        stencilWeights = new double [numValues];
        
        for(int iStencil = 0;iStencil < numStencils;iStencil++){
          stencilSizes[iStencil]  = inStencilSet.stencilSizes[iStencil];
          stencilStarts[iStencil] = inStencilSet.stencilStarts[iStencil];
        }

        // some things that use stencilset don't care about stencilOrders
        if (inStencilSet.stencilOrders) {
          stencilOrders  = new int [numStencils];
          for(int iStencil = 0;iStencil < numStencils;iStencil++){
            stencilOrders[iStencil] = inStencilSet.stencilOrders[iStencil];
          }
        }
        
        for(int iVal = 0;iVal < numValues;iVal++){
          stencilOffsets[iVal] = inStencilSet.stencilOffsets[iVal];
          stencilWeights[iVal] = inStencilSet.stencilWeights[iVal];
        }
        
        boundaryWeight = inStencilSet.boundaryWeight;
        boundaryDepth  = inStencilSet.boundaryDepth;
        boundaryWidth  = inStencilSet.boundaryWidth;

      }
      
      void Destroy() { 
        if(ownData) {
          delete [] stencilSizes;
          delete [] stencilStarts;
          delete [] stencilOffsets;
          delete [] stencilWeights;
          delete [] stencilOrders;
          stencilSizes   = NULL;
          stencilStarts  = NULL;
          stencilOffsets = NULL;
          stencilWeights = NULL;
          stencilOrders  = NULL;
          boundaryWeight = 0.0;
          boundaryDepth = 0;
          boundaryWidth = 0;
          overallOrder = 0;
        }
      };
      
      ~stencilset() { Destroy(); };
      
      int     numStencils;
      int     numValues;
      bool    ownData;
      int    *stencilSizes;
      int    *stencilStarts;
      int    *stencilOffsets;
      double *stencilWeights;
      int    *stencilOrders;
      double boundaryWeight;
      int boundaryDepth;
      int boundaryWidth;
      int overallOrder;
    };
    
    namespace sbp {

      bool IsValidOrder(int overallOrder);

      typedef stencilset base;

      int Initialize(base &stencilSet,int interiorOrder);

      void OperatorSetup(base &stencilSet, int interiorOrder, int boundaryDepth,
          int boundaryWidth, double boundaryWeight, std::vector<double> centralWeightsRight,
          std::vector<std::vector<double> > leftWeights, std::vector<int> leftOrders);

      int BruteTest1(base &inOperator,int interiorOrder,int numDim,
                     int numComponents,int numTrials,std::vector<bool> &testResults);

      int CreateStencilConnectivity(int numDim,size_t *dimSizes,size_t *opInterval,int boundaryDepth,
                                    int *stencilID, bool fortranInterval=false);


      int CreateStencilConnectivity(int numDim,size_t *dimSizes,size_t *opInterval,int boundaryDepth,
                                    int *periodicDirs,int *stencilID, bool fortranInterval=false);

      int InvertStencilConnectivity(int numDim,size_t *dimSizes,size_t *opInterval,int numStencils,int *stencilID,
                                    size_t *dualStencilConn,size_t *numPointsStencil,bool fortranInterval=false);

      int BoundaryStencilConnectivity(std::vector<size_t> &bufferSizes,
                                      pcpp::IndexIntervalType &partitionInterval,
                                      pcpp::IndexIntervalType &partitionBufferInterval,
                                      pcpp::IndexIntervalType &boundaryInterval,
                                      int boundaryDepth,int boundaryDirection,
                                      int *stencilConnectivity);


      int HoleStencilConnectivity(std::vector<size_t> &bufferSizes,
                                  pcpp::IndexIntervalType &partitionInterval,
                                  pcpp::IndexIntervalType &partitionBufferInterval,
                                  pcpp::IndexIntervalType &holeInterval,
                                  int holeStencil,
                                  int *stencilConnectivity);
      
      
      int MaskStencilConnectivity(int numDim,size_t *dimSizes,size_t *opInterval,
                                  int boundaryDepth,int boundaryStart,int holeBit,
                                  int *inMask,int *stencilID);

      int DetectHoles(int numDim,size_t *dimSizes,size_t *opInterval,
                      int boundaryDepth,int holeBit,int *inMask,int *stencilID);

    }

    namespace dissipation {
      int Initialize(stencilset &stencilSet1,stencilset &stencilSet2,int interiorOrder);
    }

  }

}
namespace mask {

  enum maskbits {HOLE=0,NUMMASK};

  void SetMask(const std::vector<size_t> &opIndices,int maskBits,int *inMask);
  void SetMask(const std::vector<size_t>     &bufferSizes,
               const pcpp::IndexIntervalType &opInterval,
               int maskBits,int *inMask);
  void UnSetMask(const std::vector<size_t> &opIndices,int maskBits,int *inMask);
  void UnSetMask(const std::vector<size_t>     &bufferSizes,
                 const pcpp::IndexIntervalType &opInterval,
                 int maskBits,int *inMask);
}




#endif