PatchGeometry.hpp

/*
 * PatchGeometry.hpp
 *
 *  Created on: Jul 21, 2017
 *      Author: Pete Schultz
 */

#ifndef PATCHGEOMETRY_HPP_
#define PATCHGEOMETRY_HPP_

#include "components/Patch.hpp"
#include "include/PVLayerLoc.h"
#include <string>
#include <vector>

namespace PV {

class PatchGeometry {

  public:
   PatchGeometry(
         std::string const &name,
         int patchSizeX,
         int patchSizeY,
         int patchSizeF,
         PVLayerLoc const *preLoc,
         PVLayerLoc const *postLoc);

   ~PatchGeometry() {}

   void setMargins(PVHalo const &preHalo, PVHalo const &postHalo);

   void allocateDataStructures();

   int getPatchSizeX() const { return mPatchSizeX; }

   int getPatchSizeY() const { return mPatchSizeY; }

   int getPatchSizeF() const { return mPatchSizeF; }

   int getPatchSizeOverall() const { return mPatchSizeX * mPatchSizeY * mPatchSizeF; }

   PVLayerLoc const &getPreLoc() const { return mPreLoc; }

   PVLayerLoc const &getPostLoc() const { return mPostLoc; }

   int getNumPatchesX() const { return mNumPatchesX; }

   int getNumPatchesY() const { return mNumPatchesY; }

   int getNumPatchesF() const { return mNumPatchesF; }

   int getNumPatches() const { return getNumPatchesX() * getNumPatchesY() * getNumPatchesF(); }

   int getNumKernelsX() const { return mNumKernelsX; }

   int getNumKernelsY() const { return mNumKernelsY; }

   int getNumKernelsF() const { return mNumKernelsF; }

   int getNumKernels() const { return getNumKernelsX() * getNumKernelsY() * getNumKernelsF(); }

   Patch const &getPatch(int patchIndex) const { return mPatchVector[patchIndex]; }

   std::size_t getGSynPatchStart(int patchIndex) const { return mGSynPatchStart[patchIndex]; }

   std::vector<std::size_t> const &getGSynPatchStart() const { return mGSynPatchStart; }

   std::size_t getAPostOffset(int patchIndex) const { return mAPostOffset[patchIndex]; }

   long getUnshrunkenStart(int patchIndex) const { return mUnshrunkenStart[patchIndex]; }

   std::size_t getTransposeItemIndex(int kernelIndex, int itemInPatch) const {
      return mTransposeItemIndex[kernelIndex][itemInPatch];
   }

   std::vector<std::size_t> const &getAPostOffset() const { return mAPostOffset; }

   int getPatchStrideX() const { return mPatchStrideX; }
   int getPatchStrideY() const { return mPatchStrideY; }
   int getPatchStrideF() const { return mPatchStrideF; }

   int getLog2ScaleDiffX() const { return mLog2ScaleDiffX; }

   int getLog2ScaleDiffY() const { return mLog2ScaleDiffY; }

   bool getSelfConnectionFlag() const { return mSelfConnectionFlag; }

   static int calcPatchStartInPost(
         int indexRestrictedPre,
         int patchSize,
         int numNeuronsPre,
         int numNeuronsPost);

  private:
   void initialize(
         std::string const &name,
         int patchSizeX,
         int patchSizeY,
         int patchSizeF,
         PVLayerLoc const *preLoc,
         PVLayerLoc const *postLoc);

   static int verifyPatchSize(int numPreRestricted, int numPostRestricted, int patchSize);

   void verifyPatchSize();

   void setPatchGeometry();

   void setTransposeItemIndices();

   static void calcPatchData(
         int index,
         int numPreRestricted,
         int preStartBorder,
         int preEndBorder,
         int numPostRestricted,
         int postStartBorder,
         int postEndBorder,
         int patchSize,
         int *patchDim,
         int *patchStart,
         int *postPatchStartRestricted,
         int *postPatchStartExtended,
         int *postPatchUnshrunkenStart);

  private:
   int mPatchSizeX;
   int mPatchSizeY;
   int mPatchSizeF;
   PVLayerLoc mPreLoc;
   PVLayerLoc mPostLoc;
   int mNumPatchesX;
   int mNumPatchesY;
   int mNumPatchesF;
   int mNumKernelsX;
   int mNumKernelsY;
   int mNumKernelsF;

   std::vector<Patch> mPatchVector;
   std::vector<std::size_t> mGSynPatchStart;
   std::vector<std::size_t> mAPostOffset;
   std::vector<long> mUnshrunkenStart;
   std::vector<std::vector<int>> mTransposeItemIndex;

   int mPatchStrideX;
   int mPatchStrideY;
   int mPatchStrideF;

   int mLog2ScaleDiffX;
   int mLog2ScaleDiffY;
   bool mSelfConnectionFlag; // True if instantiated with preLoc and postLoc pointers equal
}; // end class PatchGeometry

} // end namespace PV

#endif // PATCHGEOMETRY_HPP_