KB.cpp

Go to the documentation of this file.

// KB.cpp: implementation of the KB class.
//
 
#include "KB.h"
#include <boost/serialization/export.hpp>
#include "../Global/SimulationContext.h"
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(KB)
using namespace std;
 
// Construction/Destruction
 
KB::KB() {
 
}
 
KB::~KB() {
  this->clearKB();
}
void KB::clearKB() {
  system_decomposition.clear();
  hard_wired_diagnosis.clear();
  indicator_bias_factors.clear();
  system_decomposition_map.clear();
  system_function_map.clear();
}
 
void KB::initiationForSimulation(int _operator, InfoChunk &_perceived_info) {
  this->readSystemDecompositionKB(_operator);
  this->readHardWiredDiagnosis(_operator, _perceived_info);
  this->readIndicatorBiasFactors(_operator);
  //this->m_Concept_Base.ReadKBConceptInfoFromInputFile(_operator); //Y.L.
  //this->m_MP.ReadMentalRepresentationtInfoFromFile(_operator); //Y.L.
  //
}
void KB::readHardWiredDiagnosis(int _operator, InfoChunk &_perceived_info) {
  string file_name;
  string str;
  int n_diagnosis;
  bool got_operator = true;
  ExpectedMentalBelief *mental_belief_ptr;
  decltype(hard_wired_diagnosis)::iterator mental_belief_itr;
//
  int i;
  if (_operator == sim::Operator::ODM) {
    file_name = g_sim.SScheduler.getODMDirectory();
    file_name += "KB_ODM_HardWired_Diagnosis.txt";
  } else if (_operator == sim::Operator::OCT) {
    file_name = g_sim.SScheduler.getOCTDirectory();
    file_name += "KB_OCT_HardWired_Diagnosis.txt";
  } else if (_operator == sim::Operator::OAT) {
    file_name = g_sim.SScheduler.getOATDirectory();
    file_name += "KB_OAT_HardWired_Diagnosis.txt";
  } else {
    ofstream fout("err messages.txt", ios::app);
    cout << "KB::readHardWiredDiagnosis: " << _operator << " is not one of the three operators." << endl;
    fout << r5pars_.timesno << "  KB::readHardWiredDiagnosis: " << _operator << " is not one of the three operators.\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("KB::readHardWiredDiagnosis err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    got_operator = false;
  }
  if (got_operator) {//read in information
    i = 0;
    ifstream fin(file_name.c_str(), ios::in);
    if (!fin.is_open()) {
      cout << "File: " << file_name << " cound not be found" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  File: " << file_name << " cound not be found\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("KB::readHardWiredDiagnosis err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    } else {
      fin >> str >> n_diagnosis;
      for (i = 0; i < n_diagnosis; i++) {
        auto hwu_pt = make_unique<KBHardWiredUnit>();
        hwu_pt->readInfoFromFile(fin);
        hard_wired_diagnosis.push_back(std::move(hwu_pt));
      }
      fin.close();
      // initialize mental belief confidence (i.e., for state = sim::None)
      for (mental_belief_itr = hard_wired_diagnosis.begin(); mental_belief_itr != hard_wired_diagnosis.end();
           mental_belief_itr++) {
        // add mental beliefs to memory and initialize state of activation to sim::None
        auto mental_belief_sp = make_shared<ExpectedMentalBelief>();
        mental_belief_sp->setInfoName(mental_belief_itr->get()->getInfoName());
        mental_belief_sp->setStateOfActivation(sim::None);
        _perceived_info.mental_belief.push_back(mental_belief_sp);
        //
        // update hard wired diagnosis confidence level for mental beliefs
        this->KBcheckHardWiredMatchForMentalBelief(mental_belief_itr->get()->getInfoName(), sim::None);
      }
    }
  }
}
 
void KB::readIndicatorBiasFactors(int _operator) {
  string str, file_name;
  int n_bias_factors;
  bool got_operator = true;
  //
  if (_operator == sim::Operator::ODM) {
    file_name = g_sim.SScheduler.getODMDirectory();
    file_name += "KB_ODM_Bias_Factors.txt";
  } else if (_operator == sim::Operator::OCT) {
    file_name = g_sim.SScheduler.getOCTDirectory();
    file_name += "KB_OCT_Bias_Factors.txt";
  } else if (_operator == sim::Operator::OAT) {
    file_name = g_sim.SScheduler.getOATDirectory();
    file_name += "KB_OAT_Bias_Factors.txt";
  } else {
    ofstream fout("err messages.txt", ios::app);
    cout << "KB::readIndicatorBiasFactors: " << _operator << " is not one of the three operators." << endl;
    fout << r5pars_.timesno << "  KB::readIndicatorBiasFactors: " << _operator
         << " is not one of the three operators.\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("KB::readIndicatorBiasFactors err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    got_operator = false;
  }
  if (got_operator) {
    ifstream fin(file_name.c_str(), ios::in);
    if (!fin.is_open()) {
      cout << "File: " << file_name << " cound not be found" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  File: " << file_name << " cound not be found\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("KB::readIndicatorBiasFactors err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    } else {
      fin >> str >> n_bias_factors;
      for (int i = 0; i < n_bias_factors; i++) {
        auto bf_pt = make_unique<KBBiasFactorUnit>();
        bf_pt->readKBBiasFactorUnit(fin);
        this->indicator_bias_factors.push_back(std::move(bf_pt));
      }
      fin.close();
    }
  }
}
 
void KB::readSystemDecompositionKB(int _operator) {
  string file_name;
  string str;
  char ch;
  int number_of_functions, function_id;
  bool instruction_finished = false;
  bool got_operator = true;
  KBSystemDecompositionUnit *sdu_pt;
  decltype(system_decomposition)::iterator sdu_itr;
 
//  map<string, KBSystemDecompositionUnit *>::iterator system_decomposition_map;
 
  int i;
  if (_operator == sim::Operator::ODM) {
    file_name = g_sim.SScheduler.getODMDirectory();
    file_name += "KB_ODM_System_Decomposition.txt";
  } else if (_operator == sim::Operator::OCT) {
    file_name = g_sim.SScheduler.getOCTDirectory();
    file_name += "KB_OCT_System_Decomposition.txt";
  } else if (_operator == sim::Operator::OAT) {
    file_name = g_sim.SScheduler.getOATDirectory();
    file_name += "KB_OAT_System_Decomposition.txt";
  } else {
    ofstream fout("err messages.txt", ios::app);
    cout << "KB::readSystemDecompositionKB: " << _operator << " is not one of the three operators." << endl;
    fout << r5pars_.timesno << "  KB::readSystemDecompositionKB: " << _operator
         << " is not one of the three operators.\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("KB::readSystemDecompositionKB err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    got_operator = false;
  }
  if (got_operator) {//read in information and construct Map
    i = 0;
    ifstream fin(file_name.c_str(), ios::in);
    if (!fin.is_open()) {
      cout << "File: " << file_name << " cound not be found" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  File: " << file_name << " cound not be found\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("KB::readSystemDecompositionKB err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    } else {
      while (!instruction_finished) {//read instruction inside the quotation marks
        fin.get(ch);
        if (ch == '"') {
          i++;
          if (i >= 2) instruction_finished = true;
        }
      }
      fin >> str >> number_of_functions;
      for (int i = 0; i < number_of_functions; i++) {
        fin >> str >> function_id;
        system_function_map.insert(sfm_type::value_type(function_id, str));
      }
      fin >> str;
      fin >> str;
      while (!fin.eof()) {
        auto sdu_upt = make_unique<KBSystemDecompositionUnit>();
        sdu_upt->setInfoName(str);
        sdu_upt->readInfoFromFileIntegrated(fin);
        system_decomposition.push_back(std::move(sdu_upt));
        fin >> str;
      }
      fin.close();
    }
    //Construct map
    for (sdu_itr = system_decomposition.begin(); sdu_itr != system_decomposition.end(); sdu_itr++) {
      sdu_pt = sdu_itr->get();
      system_decomposition_map.insert(sdu_type::value_type(sdu_pt->getInfoName(), sdu_pt));
    }
  }
}
void KB::KBcheckHardWiredMatchForControl(string _name, double _value) {
  for (auto& hw_ptr : hard_wired_diagnosis) {
    hw_ptr->checkForControl(_name, _value);
  }
}
void KB::KBcheckHardWiredMatchForMentalBelief(string _name, int _state) {
  for (auto& hw_ptr : hard_wired_diagnosis) {
    hw_ptr->checkForMentalBelief(_name, _state);
  }
}
void KB::KBcheckHardWiredMatchForProcedureActivity(string _name, int _state) {
  for (auto& hw_ptr : hard_wired_diagnosis) {
    hw_ptr->checkForProcedureActivity(_name, _state);
  }
}
void KB::KBcheckHardWiredMatchForAlarmState(string _alarm_name, int _alarm_state) {
  for (auto& hw_ptr : hard_wired_diagnosis) {
    hw_ptr->checkForAlarmState(_alarm_name, _alarm_state);
  }
}
void KB::KBcheckHardWiredMatchForComponentState(string _comp_name, int _comp_state) {
  for (auto& hw_ptr : hard_wired_diagnosis) {
    hw_ptr->checkForComponentState(_comp_name, _comp_state);
  }
}
void KB::KBcheckHardWiredMatchForSupportSystemState(string _ss_name, int _ss_state) {
  for (auto& hw_ptr : hard_wired_diagnosis) {
    hw_ptr->checkForSupportSystemState(_ss_name, _ss_state);
  }
}
void KB::KBcheckHardWiredMatchForParameterValue(string _par_name, double _par_value, int _operator) {
  for (auto& hw_ptr : hard_wired_diagnosis) {
    hw_ptr->checkForParameterValue(_par_name, _par_value, _operator);
  }
}
void KB::KBcheckHardWiredMatchForParameterTrend(string _par_name, int _par_trend) {
  for (auto& hw_ptr : hard_wired_diagnosis) {
    hw_ptr->checkForParameterTrend(_par_name, _par_trend);
  }
}
void KB::copyKBForRestart(KB &_kb) {
  for (auto& src : _kb.hard_wired_diagnosis) {
    auto hwd_pt = make_unique<KBHardWiredUnit>();
    hwd_pt->copyKBHardWiredUnit(*src);
    this->hard_wired_diagnosis.push_back(std::move(hwd_pt));
  }
  for (auto& src : _kb.indicator_bias_factors) {
    auto bf_pt = make_unique<KBBiasFactorUnit>();
    bf_pt->copyKBBiasFactorUnit(*src);
    this->indicator_bias_factors.push_back(std::move(bf_pt));
  }
  for (auto& src : _kb.system_decomposition) {
    auto sd_pt = make_unique<KBSystemDecompositionUnit>();
    sd_pt->copyKBSystemDecompositionUnit(*src);
    auto* raw = sd_pt.get();
    this->system_decomposition.push_back(std::move(sd_pt));
    system_decomposition_map.insert(sdu_type::value_type(raw->getInfoName(), raw));
  }
  for (auto& sfm : _kb.system_function_map) {
    this->system_function_map.insert(sfm_type::value_type(sfm.first, sfm.second));
  }
}
void KB::copyKB(KB &_kb) {
  for (auto& src : _kb.hard_wired_diagnosis) {
    auto hwd_pt = make_unique<KBHardWiredUnit>();
    hwd_pt->copyKBHardWiredUnit(*src);
    this->hard_wired_diagnosis.push_back(std::move(hwd_pt));
  }
  for (auto& src : _kb.indicator_bias_factors) {
    auto bf_pt = make_unique<KBBiasFactorUnit>();
    bf_pt->copyKBBiasFactorUnit(*src);
    this->indicator_bias_factors.push_back(std::move(bf_pt));
  }
  for (auto& src : _kb.system_decomposition) {
    auto sd_pt = make_unique<KBSystemDecompositionUnit>();
    sd_pt->copyKBSystemDecompositionUnit(*src);
    auto* raw = sd_pt.get();
    this->system_decomposition.push_back(std::move(sd_pt));
    system_decomposition_map.insert(sdu_type::value_type(raw->getInfoName(), raw));
  }
  for (auto& sfm : _kb.system_function_map) {
    this->system_function_map.insert(sfm_type::value_type(sfm.first, sfm.second));
  }
}
void KB::clearKBForRestart() {
  system_decomposition.clear();
  hard_wired_diagnosis.clear();
  indicator_bias_factors.clear();
  system_decomposition_map.clear();
  system_function_map.clear();
}
void KB::outputHardWiredDiagnosisLabelToFile(string _operator, ofstream &fout) {
  string str;
  for (auto& hwu : hard_wired_diagnosis) {
    str = _operator;
    str += hwu->getInfoName();
    fout << '\t' << str;
  }
}
void KB::outputHardWiredDiagnosisUnitToFile(ofstream &fout) {
  for (auto& hwu : hard_wired_diagnosis) {
    fout << "\tConfidence_%";
  }
}
void KB::KBcalculateHardWiredConfidence() {
  for (auto& hwd : hard_wired_diagnosis) {
    hwd->calculateConfidenceLevel();
  }
}
string KB::getProcedureNameOfHWDiagnosis(string _diagnosis) {
  bool found = false;
  string procedure_name = "NONE";
  auto hwd_itr = hard_wired_diagnosis.begin();
  while (hwd_itr != hard_wired_diagnosis.end() && !found) {
    if ((*hwd_itr)->getInfoName() == _diagnosis) {
      found = true;
      procedure_name = (*hwd_itr)->getProcedureName();
    }
    hwd_itr++;
  }
  if (!found) {
    ofstream fout("err messages.txt", ios::app);
    cout << "KB::getProcedureNameOfHWDiagnosis: could not find Diagnosis: " << _diagnosis
         << " from Hard Wired Diagnosis list" << endl;
    fout << r5pars_.timesno << "  KB::getProcedureNameOfHWDiagnosis: could not find Diagnosis: " << _diagnosis
         << " from Hard Wired Diagnosis list\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("KB::getProcedureNameOfHWDiagnosis err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
  return procedure_name;
}
string KB::getStepNameOfHWDiagnosis(string _diagnosis) {
  bool found = false;
  string step_name = "NONE";
  auto hwd_itr = hard_wired_diagnosis.begin();
  while (hwd_itr != hard_wired_diagnosis.end() && !found) {
    if ((*hwd_itr)->getInfoName() == _diagnosis) {
      found = true;
      step_name = (*hwd_itr)->getStepName();
    }
    hwd_itr++;
  }
  if (!found) {
    ofstream fout("err messages.txt", ios::app);
    cout << "KB::getProcedureNameOfHWDiagnosis: could not find Diagnosis: " << _diagnosis
         << " from Hard Wired Diagnosis list" << endl;
    fout << r5pars_.timesno << "  KB::getProcedureNameOfHWDiagnosis: could not find Diagnosis: " << _diagnosis
         << " from Hard Wired Diagnosis list\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("KB::getStepNameOfHWDiagnosis err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
  return step_name;
}
 
string KB::getAssociatedFunctionalDecompositionName(int _function_id) {
  map<int, string>::iterator sfm_itr;
  string function = "NONE";
  sfm_itr = system_function_map.find(_function_id);
  if (sfm_itr != system_function_map.end()) {
    function = sfm_itr->second;
  } else {
    ofstream fout("err messages.txt", ios::app);
    cout << "KB::getAssociatedFunctionalDecompositionName: could not find function: " << _function_id
         << " in System Decomposition" << endl;
    fout << r5pars_.timesno << "  KB::getAssociatedFunctionalDecompositionName: could not find function: "
         << _function_id << " in System Decomposition\n";
    fout.close();
  }
  return function;
}
 
KBHardWiredUnit *KB::getPtrToHardWiredDiagnosis(string _diagnosis) {
  KBHardWiredUnit *diagnosis_ptr = nullptr;
  bool found = false;
  auto hwd_itr = hard_wired_diagnosis.begin();
  while (hwd_itr != hard_wired_diagnosis.end() && !found) {
    if ((*hwd_itr)->getInfoName() == _diagnosis) {
      found = true;
      diagnosis_ptr = hwd_itr->get();
    }
    hwd_itr++;
  }
  if (!found) {
    ofstream fout("err messages.txt", ios::app);
    cout << r5pars_.timesno << "  KB::getPtrToHardWiredDiagnosis: could not find Diagnosis: " << _diagnosis
         << " from Hard Wired Diagnosis list" << endl;
    fout << r5pars_.timesno << "  KB::getPtrToHardWiredDiagnosis: could not find Diagnosis: " << _diagnosis
         << " from Hard Wired Diagnosis list\n";
    fout.close();
  }
  return diagnosis_ptr;
}
 
double KB::getConfidenceLevelOfHWDiagnosis(string _diagnosis) {
  bool found = false;
  double confidence = 0.0;
  auto hwd_itr = hard_wired_diagnosis.begin();
  while (hwd_itr != hard_wired_diagnosis.end() && !found) {
    if ((*hwd_itr)->getInfoName() == _diagnosis) {
      found = true;
      confidence = (*hwd_itr)->getConfidenceLevel();
    }
    hwd_itr++;
  }
  if (!found) {
    ofstream fout("err messages.txt", ios::app);
    cout << "KB::getConfidenceLevelOfHWDiagnosis: could not find Diagnosis: " << _diagnosis
         << " from Hard Wired Diagnosis list" << endl;
    fout << r5pars_.timesno << "  KB::getConfidenceLevelOfHWDiagnosis: could not find Diagnosis: " << _diagnosis
         << " from Hard Wired Diagnosis list\n";
    fout.close();
  }
  return confidence;
}
 
void KB::saveKBToFile(ofstream &fout) {
  map<int, string>::iterator sfm_itr;
  int i, num;
  num = hard_wired_diagnosis.size();
  fout << "KB\n" << num << '\n';
  for (i = 0; i < num; i++) {
    hard_wired_diagnosis.at(i)->saveKBHardWiredUnitToFile(fout);
  }
  num = this->indicator_bias_factors.size();
  fout << "IndicatorBiasFactors " << num << '\n';
  for (i = 0; i < num; i++) {
    this->indicator_bias_factors.at(i)->saveKBBiasFactorUnitToFile(fout);
  }
  num = system_decomposition.size();
  fout << "SystemDecomposition " << num << '\n';
  for (i = 0; i < num; i++) {
    system_decomposition.at(i)->saveKBSystemDecompositionUnitToFile(fout);
  }
  fout << "SystemFunctionMap " << system_function_map.size() << '\n';
  for (sfm_itr = system_function_map.begin(); sfm_itr != system_function_map.end(); sfm_itr++) {
    fout << sfm_itr->first << ' ' << sfm_itr->second << '\n';
  }
}
void KB::retrieveKBFromFile(ifstream &fin) {
  int i, num, function_id;
  string str, function;
  fin >> str >> num;
  if (str != "KB") {
    ofstream fout("err messages.txt", ios::app);
    cout << "KB::retrieveKBFromFile File retrieval error in previous function" << endl;
    fout << r5pars_.timesno << "  KB::retrieveKBFromFile File retrieval error in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("KB::retrieveKBFromFile Prior error");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
  for (i = 0; i < num; i++) {
    auto hwd_pt = make_unique<KBHardWiredUnit>();
    hwd_pt->retrieveKBHardWiredUnitFromFile(fin);
    hard_wired_diagnosis.push_back(std::move(hwd_pt));
  }
  fin >> str >> num;
  if (str != "IndicatorBiasFactors") {
    ofstream fout("err messages.txt", ios::app);
    cout << "KB::retrieveKBFromFile File retrieval error in KBHardWiredUnit" << endl;
    fout << r5pars_.timesno << "  KB::retrieveKBFromFile File retrieval error in KBHardWiredUnit\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("KB::retrieveKBFromFile in KBHardWiredUnit.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
  for (i = 0; i < num; i++) {
    auto bf_pt = make_unique<KBBiasFactorUnit>();
    bf_pt->retrieveKBBiasFactorUnitFromFile(fin);
    this->indicator_bias_factors.push_back(std::move(bf_pt));
  }
  fin >> str >> num;
  if (str != "SystemDecomposition") {
    ofstream fout("err messages.txt", ios::app);
    cout << "KB::retrieveKBFromFile File retrieval errir in KBHardWiredUnit" << endl;
    fout << r5pars_.timesno << "  KB::retrieveKBFromFile File retrieval errir in KBHardWiredUnit\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("KB::retrieveKBFromFile in KBHardWiredUnit.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
  for (i = 0; i < num; i++) {
    auto sd_pt = make_unique<KBSystemDecompositionUnit>();
    sd_pt->retrieveKBSystemDecompositionUnitFromFile(fin);
    system_decomposition.push_back(std::move(sd_pt));
  }
  //Construct map
  for (auto& sdu : system_decomposition) {
    system_decomposition_map.insert(sdu_type::value_type(sdu->getInfoName(), sdu.get()));
  }
  fin >> str >> num;
  for (i = 0; i < num; i++) {
    fin >> function_id >> function;
    system_function_map.insert(sfm_type::value_type(function_id, function));
  }
}
 
 
 
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <stdexcept>
 
void KB::state_save(boost::archive::binary_oarchive& ar) const {
    const uint32_t n_hw = static_cast<uint32_t>(hard_wired_diagnosis.size());
    const uint32_t n_bias = static_cast<uint32_t>(indicator_bias_factors.size());
    ar << n_hw << n_bias;
    for (const auto& hw : hard_wired_diagnosis) hw->state_save(ar);
    for (const auto& bf : indicator_bias_factors) bf->timer_state_save(ar);
    // system_decomposition is pure definition — fully covered by the seed.
}
void KB::state_load(boost::archive::binary_iarchive& ar) {
    uint32_t n_hw = 0, n_bias = 0;
    ar >> n_hw >> n_bias;
    if (n_hw != hard_wired_diagnosis.size() || n_bias != indicator_bias_factors.size())
        throw std::runtime_error("KB state overlay: unit counts mismatch against the seeded KB");
    for (auto& hw : hard_wired_diagnosis) hw->state_load(ar);
    for (auto& bf : indicator_bias_factors) bf->timer_state_load(ar);
}