SEValidationTarget.h

/* Distributed under the Apache License, Version 2.0.
   See accompanying NOTICE file for details.*/
 
#pragma once
 
#include "cdm/CommonDefs.h"
#include "cdm/engine/SEDataRequest.h"
#include "cdm/engine/SEEventManager.h"
 
 
enum class eValidationGrade { Good=0, Fair, Bad };
 
class CDM_DECL SEValidationTarget : public Loggable
{
  friend class PBValidation;//friend the serialization class
protected:
  SEValidationTarget() { Clear(); }
public:
  virtual ~SEValidationTarget() = default;
 
  virtual void Clear();
  virtual bool IsValid();
 
  std::string GetHeader() const { return m_Header; }
  void SetHeader(const std::string& h) { m_Header = h; }
 
  std::string GetReference() const { return m_Reference; }
  void SetReference(const std::string& c) { m_Reference = c; }
 
  std::string GetNotes() const { return m_Notes; }
  void SetNotes(const std::string& n) { m_Notes = n; }
 
  std::string GetTableFormatting() const { return m_TableFormatting; }
  void SetTableFormatting(const std::string& f) { m_TableFormatting = f; }
 
  double GetGoodPercentError() const { return m_GoodPercentError; }
  void SetGoodPercentError(double e) { m_GoodPercentError = e; }
 
  double GetFairPercentError() const { return m_FairPercentError; }
  void SetFairPercentError(double e) { m_FairPercentError = e; }
 
  bool GetComputedBool() const { return m_ComputedBool; }
  void SetComputedBool(bool b) { m_ComputedBool = b; }
 
  std::string GetComputedEnum() const { return m_ComputedEnum; }
  void SetComputedEnum(const std::string& e) { m_ComputedEnum = e; }
 
  double GetComputedValue() const { return m_ComputedValue; }
  void SetComputedValue(double d) { m_ComputedValue = d; }
 
  void   SetGrade(eValidationGrade g) { m_Grade = g; }
  eValidationGrade GetGrade() const { return m_Grade; }
 
 
protected:
  std::string                                m_Header;
  std::string                                m_Reference;
  std::string                                m_Notes;
  std::string                                m_TableFormatting;
  
  double                                     m_GoodPercentError;
  double                                     m_FairPercentError;
 
  // Only 1 of these
  bool                                       m_ComputedBool;
  std::string                                m_ComputedEnum;
  double                                     m_ComputedValue;
 
  eValidationGrade                           m_Grade;
};
 
class CDM_DECL SESegmentValidationTarget : public SEValidationTarget
{
  friend class PBValidation;//friend the serialization class
public:
  struct Evaluation
  {
    eValidationGrade Grade;
    double           Error;
    double           Compare;
  };
  SESegmentValidationTarget();
  virtual ~SESegmentValidationTarget();
 
  static bool SerializeToString(const std::vector<const SESegmentValidationTarget*>& src, std::string& output, eSerializationFormat m, Logger* logger);
  static bool SerializeToFile(const std::vector<const SESegmentValidationTarget*>& src, const std::string& filename, Logger* logger);
  static bool SerializeFromString(const std::string& src, std::vector<SESegmentValidationTarget*>& dst, eSerializationFormat m, Logger* logger);
  static bool SerializeFromFile(const std::string& filename, std::vector<SESegmentValidationTarget*>& dst, Logger* logger);
 
  void Clear() override;
 
  std::string GetComparisonFormula() const { return m_ComparisonFormula; }
  void SetComparisonFormula(const std::string& f) { m_ComparisonFormula = f; }
 
  std::string GetExpressionJoin() const { return m_ExpressionJoin; }
  void SetExpressionJoin(const std::string& e) { m_ExpressionJoin = e; }
 
  // Not evaluating expressions here, so only adding a const getter here.
  const std::map<std::string, Evaluation>& GetExpressions() const { return m_Expressions; }
 
protected:
  std::string m_ComparisonFormula;
  std::string m_ExpressionJoin;
  std::map<std::string, Evaluation> m_Expressions; // Key is a piece of the comparison formula
};
 
class CDM_DECL SETimeSeriesValidationTarget : public SEValidationTarget
{
  friend class PBValidation;//friend the serialization class
public:
  enum class eComparisonType { None=0, TargetEnum, TargetValue, TargetRange };
  enum class eEvaluationType { Mean=0, Minimum, Maximum,
    MeanPerIdealWeight_kg, MaxPerIdealWeight_kg, MinPerIdealWeight_kg, Enumeration };
  SETimeSeriesValidationTarget();
  virtual ~SETimeSeriesValidationTarget() = default;
 
  void Clear() override;
 
  static bool SerializeToString(const std::vector<const SETimeSeriesValidationTarget*>&src, std::string& output, eSerializationFormat m, Logger* logger);
  static bool SerializeToFile(const std::vector<const SETimeSeriesValidationTarget*>& src, const std::string& filename, Logger* logger);
  static bool SerializeFromString(const std::string& src, std::vector<SETimeSeriesValidationTarget*>& dst, eSerializationFormat m, Logger* logger);
  static bool SerializeFromFile(const std::string& filename, std::vector<SETimeSeriesValidationTarget*>& dst, Logger* logger);
 
  eComparisonType GetComparisonType() const { return m_ComparisonType; }
 
  void SetAssessment(const std::string& a) { m_Assessment = a; }
  std::string GetAssessment() const { return m_Assessment; }
 
  void SetPatientSpecific(bool b) { m_PatientSpecific = b; }
  bool GetPatientSpecific() const { return m_PatientSpecific; }
 
  eEvaluationType GetEvaluationType() const { return m_EvaluationType; }
 
  void SetTargetEnum(const std::string& s);
  std::string GetTargetEnum() const { return m_TargetEnum; }
 
  void   SetTargetValue(double d, eEvaluationType t);
  double GetTargetValue() const { return m_TargetValue; }
 
  void   SetTargetRange(double min, double max, eEvaluationType t);
  double GetTargetMaximum() const { return m_TargetMaximum; }
  double GetTargetMinimum() const { return m_TargetMinimum; }
 
  double GetError() const { return m_Error; }
  void SetError(double d) { m_Error = d; }
 
  // Maybe we want a different class to do the comparision
  // For now, I just put it in line here for the CircuitOptimizer
  bool ComputeError();
  std::vector<double>& GetData() { return m_Data; }
 
protected:
  eComparisonType                            m_ComparisonType;
 
  std::string                                m_Assessment;
  bool                                       m_PatientSpecific;
  eEvaluationType                            m_EvaluationType;
 
  std::string                                m_TargetEnum;
  double                                     m_TargetValue;
  double                                     m_TargetMaximum;
  double                                     m_TargetMinimum;
 
  double                                     m_Error;
 
  // Not serializing
  std::vector<double>                        m_Data;
};