DiffusionLayerND.h

/*
 *   Repast for High Performance Computing (Repast HPC)
 *
 *   Copyright (c) 2010 Argonne National Laboratory
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with
 *   or without modification, are permitted provided that the following
 *   conditions are met:
 *
 *       Redistributions of source code must retain the above copyright notice,
 *       this list of conditions and the following disclaimer.
 *
 *       Redistributions in binary form must reproduce the above copyright notice,
 *       this list of conditions and the following disclaimer in the documentation
 *       and/or other materials provided with the distribution.
 *
 *       Neither the name of the Argonne National Laboratory nor the names of its
 *     contributors may be used to endorse or promote products derived from
 *     this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 *   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES OR
 *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 *   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 *   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 *  DiffusionLayerND.h
 *
 *  Created on: July 25, 2015
 *      Author: jtm
 */
 
#ifndef DIFFUSIONLAYERND_H_
#define DIFFUSIONLAYERND_H_
 
#include <fstream>
#include <vector>
#include <map>
 
#include "mpi.h"
 
#include "RelativeLocation.h"
#include "CartesianTopology.h"
#include "RepastProcess.h"
#include "ValueLayerND.h"
 
using namespace std;
 
namespace repast {
 
template<typename T>
class Diffusor{
 
public:
 
  Diffusor();
  virtual ~Diffusor();
 
  virtual int getRadius();
 
  virtual T getNewValue(T* values) = 0;
};
 
 
template<typename T>
Diffusor<T>::Diffusor(){}
 
template<typename T>
Diffusor<T>::~Diffusor(){}
 
template<typename T>
int Diffusor<T>::getRadius(){
  return 1;
}
 
template<typename T>
class DiffusionLayerND: public ValueLayerNDSU<T>{
 
private:
 
public:
 
  DiffusionLayerND(vector<int> processesPerDim, GridDimensions globalBoundaries, int bufferSize, bool periodic, T initialValue = 0, T initialBufferZoneValue = 0);
  virtual ~DiffusionLayerND();
 
  void diffuse(Diffusor<T>* diffusor, bool omitSynchronize = false);
 
private:
 
  void diffuseDimension(T* currentDataSpacePointer, T* otherDataSpacePointer, T* vals, Diffusor<T>* diffusor, int dimIndex);
 
  void grabDimensionData(T*& destinationPointer, T* startPointer, int radius, int dimIndex);
};
 
 
template<typename T>
DiffusionLayerND<T>::DiffusionLayerND(vector<int> processesPerDim, GridDimensions globalBoundaries, int bufferSize, bool periodic,
    T initialValue, T initialBufferZoneValue): ValueLayerNDSU<T>(processesPerDim, globalBoundaries, bufferSize, periodic,
        initialValue, initialBufferZoneValue){
 
}
 
template<typename T>
DiffusionLayerND<T>::~DiffusionLayerND(){
}
 
template<typename T>
void DiffusionLayerND<T>::diffuse(Diffusor<T>* diffusor, bool omitSynchronize){
  int countOfVals = (int)(pow(diffusor->getRadius() * 2 + 1, AbstractValueLayerND<T>::numDims));
  T* vals = new T[countOfVals];
 
  diffuseDimension(ValueLayerNDSU<T>::currentDataSpace, ValueLayerNDSU<T>::otherDataSpace, vals, diffusor, AbstractValueLayerND<T>::numDims - 1);
 
  this->switchValueLayer();
 
  if(!omitSynchronize) this->synchronize();
 
  delete[] vals;
}
 
template<typename T>
void DiffusionLayerND<T>::diffuseDimension(T* currentDataSpacePointer, T* otherDataSpacePointer, T* vals, Diffusor<T>* diffusor, int dimIndex){
  int bufferEdge = AbstractValueLayerND<T>::dimensionData[dimIndex].leftBufferSize;
  int localEdge  = bufferEdge + AbstractValueLayerND<T>::dimensionData[dimIndex].localWidth;
 
  int pointerIncrement = AbstractValueLayerND<T>::places[dimIndex];
 
  int i = 0;
  for(; i < bufferEdge; i++){
    // Increment the pointers
    currentDataSpacePointer += pointerIncrement;
    otherDataSpacePointer   += pointerIncrement;
  }
  for(; i < localEdge; i++){
    if(dimIndex == 0){
      // Populate the vals array
      T* destLocation = vals; // Note: This gets passed as a handle and changed
      grabDimensionData(destLocation, currentDataSpacePointer, diffusor->getRadius(), AbstractValueLayerND<T>::numDims - 1);
      *otherDataSpacePointer = diffusor->getNewValue(vals);
    }
    else{
      diffuseDimension(currentDataSpacePointer, otherDataSpacePointer, vals, diffusor, dimIndex - 1);
    }
    // Increment the pointers
    currentDataSpacePointer += pointerIncrement;
    otherDataSpacePointer   += pointerIncrement;
  }
}
 
template<typename T>
void DiffusionLayerND<T>::grabDimensionData(T*& destinationPointer, T* startPointer, int radius, int dimIndex){
  int pointerIncrement = AbstractValueLayerND<T>::places[dimIndex];
  startPointer -= pointerIncrement * radius; // Go back
  int size = 2 * radius + 1;
  for(int i = 0; i < size; i++){
    if(dimIndex == 0){
      *destinationPointer = 1;
      double myVal = *startPointer;
      *destinationPointer = myVal;
      destinationPointer++;                 // Handle; all recursive instances share
    }
    else{
      grabDimensionData(destinationPointer, startPointer, radius, dimIndex - 1);
    }
    startPointer += pointerIncrement;
  }
 
}
 
 
 
}
 
#endif /* DIFFUSIONLAYERND_H_ */