KB.h

Go to the documentation of this file.

 
 
#include <iostream>
#include <typeinfo>
#pragma once
 
#include <map>
#include <boost/serialization/export.hpp>
 
#include "KBSystemDecompositionUnit.h"
#include "KBHardWiredUnit.h"
#include "KBBiasFactorUnit.h"
#include "InfoChunk.h"
#include "../ReasonMachine/KBConcept.h" // Added by ClassView
#include "../ReasonMachine/MentalRepresentation.h"  // Added by ClassView
#include "../ReasonMachine/SentenceUnit.h"
#include "../ReasonMachine/KnowledgeUnit.h"
 
#include <memory>
#include <vector>
#include <map>
#include <string>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/unique_ptr.hpp>
#include <boost/serialization/assume_abstract.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
 
typedef std::map<std::string, KBSystemDecompositionUnit *> sdu_type;
typedef std::map<int, std::string> sfm_type;
 
namespace boost { namespace archive {
class binary_oarchive;
class binary_iarchive;
} }
 
class KB {
 public:
  // State hooks: the operator's load seeds this KB from the per-role master,
  // then applies runtime state (hard-wired match-state + bias timers).
  // serialize() carries every member, for uses outside the state overlay.
  void state_save(boost::archive::binary_oarchive& ar) const;
  void state_load(boost::archive::binary_iarchive& ar);
 
 
  KB();
  virtual ~KB();
  void initiationForSimulation(int, InfoChunk &);
  void readSystemDecompositionKB(int);
  void readHardWiredDiagnosis(int, InfoChunk &);
  void readIndicatorBiasFactors(int);
  void readActionPack(int);
  void KBcheckHardWiredMatchForAlarmState(std::string, int);
  void KBcheckHardWiredMatchForComponentState(std::string, int);
  void KBcheckHardWiredMatchForSupportSystemState(std::string, int);
  void KBcheckHardWiredMatchForParameterValue(std::string, double, int);
  void KBcheckHardWiredMatchForParameterTrend(std::string, int);
  void KBcheckHardWiredMatchForControl(std::string, double);
  void KBcheckHardWiredMatchForMentalBelief(std::string, int);
  void KBcheckHardWiredMatchForProcedureActivity(std::string, int);
  void KBcalculateHardWiredConfidence();
  void copyKBForRestart(KB &);
  void clearKBForRestart();
  void copyKB(KB &);
  void outputHardWiredDiagnosisLabelToFile(std::string, std::ofstream &);
  void outputHardWiredDiagnosisUnitToFile(std::ofstream &);
  void clearKB();
  std::string getProcedureNameOfHWDiagnosis(std::string);
  std::string getStepNameOfHWDiagnosis(std::string);
  std::string getAssociatedFunctionalDecompositionName(int);
  double getConfidenceLevelOfHWDiagnosis(std::string);
  void saveKBToFile(std::ofstream &);
  void retrieveKBFromFile(std::ifstream &);
  KBHardWiredUnit *getPtrToHardWiredDiagnosis(std::string);
  std::vector<std::unique_ptr<KBHardWiredUnit>> hard_wired_diagnosis;
  std::vector<std::unique_ptr<KBSystemDecompositionUnit>> system_decomposition;
  std::vector<std::unique_ptr<KBBiasFactorUnit>> indicator_bias_factors;
  std::map<std::string, KBSystemDecompositionUnit *> system_decomposition_map;
  std::map<int, std::string> system_function_map;
 private:
    // Serialization function
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version) {
//     std::cout << "Serializing class: " << typeid(*this).name() << std::endl;
        ar & hard_wired_diagnosis;
        ar & system_decomposition;
        ar & indicator_bias_factors;
        ar & system_decomposition_map;
        ar & system_function_map;
    }
};