WeightsFileIO.hpp

#ifndef WEIGHTSFILEIO_HPP_
#define WEIGHTSFILEIO_HPP_

#include "components/Weights.hpp"
#include "io/FileStream.hpp"
#include "structures/MPIBlock.hpp"
#include "utils/BufferUtilsPvp.hpp"
#include <vector>

namespace PV {

class WeightsFileIO {
  public:
   WeightsFileIO(FileStream *fileStream, MPIBlock const *mpiBlock, Weights *weights);

   ~WeightsFileIO() {}

   double readWeights(int frameNumber);

   void writeWeights(double timestamp, bool compress);

   static void
   moveToFrame(BufferUtils::WeightHeader &header, FileStream &fileStream, int frameNumber);

  private:
   BufferUtils::WeightHeader readHeader(int frameNumber);

   void checkHeader(BufferUtils::WeightHeader const &header);

   bool isCompressedHeader(BufferUtils::WeightHeader const &header);

   double readSharedWeights(int frameNumber, BufferUtils::WeightHeader const &header);

   double readNonsharedWeights(int frameNumber, BufferUtils::WeightHeader const &header);

   void writeSharedWeights(double timestamp, bool compress);

   void writeNonsharedWeights(double timestamp, bool compress);

   long calcArborSizeFile(bool compressed);

   long calcArborSizeLocal(bool compressed);

   void calcPatchBox(int &startPatchX, int &endPatchX, int &startPatchY, int &endPatchY);

   void calcPatchRange(
         int nPre,
         int nPost,
         int preStartBorder,
         int preEndBorder,
         int patchSize,
         int &startPatch,
         int &endPatch);

   int calcNeededBorder(int nPre, int nPost, int patchSize);

   void loadWeightsFromBuffer(
         std::vector<unsigned char> const &dataFromFile,
         int arbor,
         float minValue,
         float maxValue,
         bool compressed);

   void decompressPatch(
         unsigned char const *dataFromFile,
         float *destWeights,
         int count,
         float minValue,
         float maxValue);

   void storeSharedPatches(
         std::vector<unsigned char> &dataFromFile,
         int arbor,
         float minValue,
         float maxValue,
         bool compressed);

   void storeNonsharedPatches(
         std::vector<unsigned char> &dataFromFile,
         int arbor,
         float minValue,
         float maxValue,
         bool compressed);

   void compressPatch(
         unsigned char *dataForFile,
         float const *sourceWeights,
         int count,
         float minValue,
         float maxValue);

   void writePatch(unsigned char const *patchBuffer, bool compressed);

   // Data members
  private:
   FileStream *mFileStream   = nullptr;
   MPIBlock const *mMPIBlock = nullptr;
   Weights *mWeights         = nullptr;

   int const mRootProcess = 0;
   int const tagbase      = 500;
}; // class WeightsFileIO

} // namespace PV

#endif // WEIGHTSFILEIO_HPP_