boon_metrology.hpp

#pragma ONCE
 
#include "boon_metrology.h"
#include "nanoutil.h"
#include "cring_buffer.h"
#include <cstdint>
#include <vector>
#include <cstddef>
#include <mutex>
#include <random>
 
#define MAX_ERROR_STRING 256
 
class CBoonNano;
 
#ifdef __cplusplus
 
#define MS_NOT_CONFIGURED                0
#define MS_IS_CONFIGURED                 1
#define MS_TRAINING_IN_PROGRESS          2
#define MS_READY_TO_USE                  3
 
#define NUM_USE_CASE 4
#define MAX_USE_CASE_NAME_LENGTH 50
#define MAX_MODEL_STATUS_STRING_LENGTH 2500
#define NUM_DHC_RANDOM_SAMPLE 1000
 
// Turn a C struct into a class
class CMetrologySample : public MetrologySample {
public:
  // init this class from a struct coming from the C code
  CMetrologySample();
  explicit CMetrologySample(const MetrologySample& StructForInit);
  CMetrologySample& operator=(const CMetrologySample& rhs);
};
 
class CMetrologyUseCase {
public:
  CMetrologyUseCase(const char* UseCaseName);
  ~CMetrologyUseCase();
  const char* GetErrorMessage() { return m_ErrorStringBuffer; };
 
protected:
  void SetErrorMessage(const char* fmt, ...);
  bool IsConfigured() { return m_ModelStatus >= MS_IS_CONFIGURED; }
  bool IsReadyToUse() { return m_ModelStatus == MS_READY_TO_USE; }
  bool TrainingInProgress() { return m_ModelStatus == MS_TRAINING_IN_PROGRESS; }
  float GetTrainingProgress();
  virtual const char* GetStatus();
 
  virtual bool Configure(uint64_t NumTrainingSamples);
  virtual bool Serialize(const char* VarPath, const char* ThisVarName, struct archive* ar, bool IsLoading);
  virtual bool PostData(const CMetrologySample& MS);
 
  virtual void Reset();
 
  char m_ErrorStringBuffer[MAX_ERROR_STRING];
  char m_UseCaseName[MAX_USE_CASE_NAME_LENGTH];
  char m_ModelStatusString[MAX_MODEL_STATUS_STRING_LENGTH];
  int m_ModelStatus;               // MS_NOT_CONFIGURED, MS_TRAINING_IN_PROGRESS, MS_READY_TO_USE
  uint64_t m_PostedSampleCount;    // the number of samples that have been posted to this use case
  uint64_t m_NumTrainingSamples;   // the number of samples required for training
};
 
//Power Quality Monitoring Use Case
class CPowerQualityMonitoring : public CMetrologyUseCase {
public:
  CPowerQualityMonitoring();
  ~CPowerQualityMonitoring();
  bool Configure(struct PowerQualitySettings* PQS);
  bool PostData(const CMetrologySample& MS) override;
  bool Serialize(const char* VarPath, const char* ThisVarName, struct archive* ar, bool IsLoading) override;
  const char* GetStatus() override;
  const char* GetDiagnostics(uint16_t ResultsList);
  bool GetPowerQualityScore(float *QualityScore);
 
protected:
  void Reset() override;
 
  CBoonNano *m_Nano;
  int m_MostRecentID;
};
 
//PV Disaggregation Use Case
class CPVDisaggregation : public CMetrologyUseCase {
public:
  CPVDisaggregation();
  ~CPVDisaggregation();
  bool Configure(struct PVDisaggregationSettings* PVDS);
  bool PostData(const CMetrologySample& MS) override;
  bool Serialize(const char* VarPath, const char* ThisVarName, struct archive* ar, bool IsLoading) override;
  const char* GetStatus() override;
  const char* GetDiagnostics(uint16_t ResultsList);
 
  bool ResetEstimate();
  float GetPVEstimate();
  const char *GetDisaggregation();
 
protected:
  void Reset() override;
  void ComputeDerivativeStatistics();
  void InitializeStatistics();
  bool m_isReset;
 
  CRB::CRingBuffer<float> m_Derivatives;
  float m_LastValue;
  float m_Mean, m_StdDev, m_ZValueThresh, m_RunningSum;
  uint64_t m_SamplesSinceReset;
};
 
#define NUM_LOADS 2
 
class CStateChange {
public:
  CStateChange();
  ~CStateChange();
  CStateChange& operator=(const CStateChange& rhs);
 
  // state variables
  bool m_LoadIsOn;
  char m_LastChangeTOD[MAX_TIMESTAMP_LENGTH];
  float m_ActivePower;
 
protected:
  void Reset();
};
 
//PV Disaggregation Use Case
class CLoadDisaggregation : public CMetrologyUseCase {
public:
  CLoadDisaggregation();
  ~CLoadDisaggregation();
  bool Configure(struct LoadDisaggregationSettings* LDS);
  bool PostData(const CMetrologySample& MS, struct LoadChange *LC);
  bool Serialize(const char* VarPath, const char* ThisVarName, struct archive* ar, bool IsLoading) override;
  const char* GetStatus() override;
  const char* GetDiagnostics(uint16_t ResultsList);
  const char *GetDisaggregation();
 
protected:
  void Reset() override;
  void GenerateKernel(uint16_t WindowSize);
  float ConvolveRecentDiffs();
  bool GetCenterRingBufferPattern(std::vector<float> & Pattern);
 
  CBoonNano *m_Nano;
  CRB::CRingBuffer<CMetrologySample> m_RecentMetrologySamples;
  std::vector<float> m_DetectedPattern;
  std::vector<float> m_Kernel;
  bool m_AwaitingThreshCrossing;
  float m_MaxDetectedConvolution;
 
  // state variables
  std::vector<CStateChange> m_StateChange;
  LoadDisaggregationSettings m_LDS;
};
 
struct CapacityData {
  float P;
  float Q;
  float V;
};
 
struct LeastSquares {
  double a;
  double b;
  double c;
};
 
struct DataStatistics {
  double Mean;
  double Min;
  double Max;
};
 
class CDynamicHostingCapacity : public CMetrologyUseCase {
public:
  CDynamicHostingCapacity();
  ~CDynamicHostingCapacity();
 
  bool Configure(struct DynamicHostingCapacitySettings* DHS);
  bool PostData(const CMetrologySample& MS) override;
  bool Serialize(const char* VarPath, const char* ThisVarName, struct archive* ar, bool IsLoading) override;
  const char* GetStatus() override;
  const char* GetDiagnostics(uint16_t ResultsList);
 
  bool GetVoltageEstimatePQ(float DeltaP, float DeltaQ, float *DeltaVEstimate);
  bool GetVoltageEstimateP(float DeltaP, float *DeltaVEstimate);
 
protected:
  bool PushBack(float P, float Q, float V);
  void Reset() override;
  uint16_t GetRandomGeometric();
  bool GenerateDeltaStatsValues(bool isLinear);
 
  // random sample buffer
  CRB::CRingBuffer<CapacityData> m_RandomSampleOne;
  CRB::CRingBuffer<CapacityData> m_RandomSampleTwo;
 
  uint16_t m_geometric_rand_space_one;
  uint16_t m_geometric_rand_space_two;
  uint16_t m_CountOne;
  uint16_t m_CountTwo;
 
  std::mt19937 m_Gen;
  std::uniform_real_distribution<float> m_Distribution;
 
  // results
  LeastSquares m_ModelCoefficients;
  std::vector<DataStatistics> m_Stats;
};
 
// Define a structure to for libarchive callbacks
struct ArchiveBufferStatus {
  uint8_t* Data;
  size_t Size;
};
 
 
class BoonMetrology {
public:
  BoonMetrology(uint16_t SamplesPerSecond);
  ~BoonMetrology();
 
  bool ConfigureLoadDisaggregation(struct LoadDisaggregationSettings* LDS);
  bool ConfigurePVDisaggregation(struct PVDisaggregationSettings* PVDS);
  bool ConfigureDynamicHostingCapacity(struct DynamicHostingCapacitySettings* DHS);
  bool ConfigurePowerQualityMonitoring(struct PowerQualitySettings* PQS);
  void CopyBoonMetrologyConfiguration(struct BoonMetrologyConfiguration* BMC);
 
  bool IncrementalSerialize(const char* DirPath, void* ReadOrWriteCallback, struct IncrementalArchiveFileStatus* AFS,
                            size_t TransferBufferSize, void* UserData, bool IsLoading);
  bool SerializeBuffer(uint8_t **Buffer, size_t *BufferLength, bool IsLoading);
 
  bool PostMetrologySample(const MetrologySample* MS, struct LoadChange* LC);
 
  void ResetPVDisaggregationEstimate();
  bool GetPVDisaggregationEstimate(float *PVEstimate);
 
  const char *GetDisaggregation();
 
  bool GetPowerQualityScore(float *QualityScore);
 
  bool GetVoltageEstimatePQ(float DeltaP, float DeltaQ, float *DeltaVEstimate);
  bool GetVoltageEstimateP(float DeltaP, float *DeltaVEstimate);
 
  const char* GetStatus();
  const char* GetStatusPowerQualityMonitoring();
  const char* GetStatusDynamicHostingCapacity();
  const char* GetStatusPVDisaggregation();
  const char* GetStatusLoadDisaggregation();
 
  const char* GetDiagnostics(uint16_t ResultsList);
 
  float GetVersion();
 
  const char *GetErrorMessage();
 
protected:
  bool Serialize(struct archive* ar, bool IsLoading);
  void Reset();
 
  std::mutex m_Mutex;
 
  void SetErrorMessage(const char* fmt, ...);
  void SetDefaultMetrologyConfiguration();
  struct BoonMetrologyConfiguration m_MetrologyConfiguration;
  char m_ErrorStringBuffer[MAX_ERROR_STRING];
  char m_ModelStatusString[MAX_MODEL_STATUS_STRING_LENGTH * NUM_USE_CASE];
 
  uint16_t m_SamplesPerSecond;
  CRB::CRingBuffer<CMetrologySample> m_RecentMetrologySamples;
  CPVDisaggregation* m_PVDisaggregation;
  CLoadDisaggregation* m_LoadDisaggregation;
  CPowerQualityMonitoring* m_PQM;
  CDynamicHostingCapacity* m_DHC;
};
 
#endif