BaseProbe.hpp

/*
 * BaseProbe.hpp
 *
 *      Author: slundquist
 */

#ifndef BASEPROBE_HPP_
#define BASEPROBE_HPP_

#include "columns/BaseObject.hpp"
#include "include/pv_common.h"
#include "io/FileStream.hpp"
#include "io/io.hpp"
#include <stdio.h>
#include <vector>

namespace PV {

class HyPerCol;
class HyPerLayer;

class BaseProbe : public BaseObject {

   // Methods
  public:
   virtual ~BaseProbe();

   virtual Response::Status
   communicateInitInfo(std::shared_ptr<CommunicateInitInfoMessage const> message) override = 0;

   virtual Response::Status registerData(Checkpointer *checkpointer) override;

   int getNumValues() { return numValues; }

   virtual Response::Status outputStateWrapper(double timef, double dt);

   virtual Response::Status outputState(double timef) = 0;
   virtual int writeTimer(PrintStream &stream) { return PV_SUCCESS; }

   const char *getTargetName() { return targetName; }

   char const *getEnergyProbe() { return energyProbe; }

   double getCoefficient() { return coefficient; }

   double getLastUpdateTime() { return lastUpdateTime; }

   void getValues(double timevalue, double *valuesVector);
   void getValues(double timevalue, std::vector<double> *valuesVector);
   double getValue(double timevalue, int index);

  protected:
   BaseProbe();
   int initialize(const char *name, HyPerCol *hc);

   virtual void setObjectType() override;

   virtual int ioParamsFillGroup(enum ParamsIOFlag ioFlag) override;

   virtual void ioParam_targetName(enum ParamsIOFlag ioFlag);

   virtual void ioParam_message(enum ParamsIOFlag ioFlag);

   virtual void ioParam_textOutputFlag(enum ParamsIOFlag ioFlag);

   virtual void ioParam_probeOutputFile(enum ParamsIOFlag ioFlag);

   virtual void ioParam_triggerFlag(enum ParamsIOFlag ioFlag);

   virtual void ioParam_triggerLayerName(enum ParamsIOFlag ioFlag);

   virtual void ioParam_triggerOffset(enum ParamsIOFlag ioFlag);

   virtual void ioParam_energyProbe(enum ParamsIOFlag ioFlag);

   virtual void ioParam_coefficient(enum ParamsIOFlag ioFlag);
   virtual void initOutputStreams(const char *filename, Checkpointer *checkpointer);

   virtual bool needRecalc(double timevalue) = 0;

   virtual double referenceUpdateTime() const = 0;

   virtual void calcValues(double timevalue) = 0;

   void getValues(double timevalue);

   const char *getMessage() { return msgstring; }

   virtual int initMessage(const char *msg);

   PrintStream &output(int b) { return *mOutputStreams.at(b); }

   virtual void initNumValues();

   void setNumValues(int n);

   char const *getProbeOutputFilename() { return probeOutputFilename; }

   double *getValuesBuffer() { return probeValues; }

   inline bool getTextOutputFlag() const { return textOutputFlag; }

   inline bool isWritingToFile() const { return probeOutputFilename != nullptr; }

   virtual bool needUpdate(double time, double dt);

  private:
   int initialize_base();

   // Member variables
  protected:
   // A vector of PrintStreams, one for each batch element.
   std::vector<PrintStream *> mOutputStreams;

   bool triggerFlag;
   char *triggerLayerName;
   HyPerLayer *triggerLayer;
   double triggerOffset;
   char *targetName;
   char *energyProbe; // the name of the ColumnEnergyProbe to attach to, if any.
   double coefficient;

  private:
   char *msgparams; // the message parameter in the params
   char *msgstring; // the string that gets printed by outputState ("" if message
   // is empty or null;
   // message + ":" if nonempty
   char *probeOutputFilename;
   int numValues;
   double *probeValues;
   double lastUpdateTime; // The time of the last time calcValues was called.
   bool textOutputFlag;
   bool mInitInfoCommunicatedFlag    = false;
   bool mDataStructuresAllocatedFlag = false;
};
}

#endif /* BASEPROBE_HPP_ */