KBScannedParameters.cpp

Go to the documentation of this file.

// KBScannedParameters.cpp: implementation of the KBScannedParameters class.
//
 
#include "KBScannedParameters.h"
#include "../Branch/BranchRecord.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(KBScannedParameters)
using namespace std;
 
 
// Construction/Destruction
 
KBScannedParameters::KBScannedParameters() {
  last_panel_scan_time = -1.0e6;
  scan_periodicity = 10.0;
  info_load_sensitivity = 0.0;
  system_criticality_sensitivity = 0.0;
}
 
KBScannedParameters::~KBScannedParameters() {
  clearScannedParameters();
}
void KBScannedParameters::clearScannedParameters() {
  parameter_scan_list.clear();
  component_scan_list.clear();
  support_system_scan_list.clear();
  alarm_scan_list.clear();
}
void KBScannedParameters::copyScannedParameters(KBScannedParameters &_KBSP) {
  last_panel_scan_time = _KBSP.getLastPanelScanTime();
  scan_periodicity = _KBSP.getScanPeriodicity();
  info_load_sensitivity = _KBSP.getInfoLoadSensitivity();
  system_criticality_sensitivity = _KBSP.getSystemCriticalitySensitivity();
  priority_decay_time = _KBSP.getPriorityDecayTime();
  relevance_limit = _KBSP.getRelevanceLimit();
  priority_limit = _KBSP.getPriorityLimit();
  for (auto& src : _KBSP.parameter_scan_list) {
    auto pt = make_shared<BranchExpectedParameterValue>();
    pt->copyBranchExpectedParameterValue(*src);
    parameter_scan_list.push_back(std::move(pt));
  }
  for (auto& src : _KBSP.component_scan_list) {
    auto pt = make_shared<BranchExpectedComponentState>();
    pt->copyBranchExpectedComponentState(*src);
    component_scan_list.push_back(std::move(pt));
  }
  for (auto& src : _KBSP.support_system_scan_list) {
    auto pt = make_shared<BranchExpectedSupportSystemState>();
    pt->copyBranchExpectedSupportSystemState(*src);
    support_system_scan_list.push_back(std::move(pt));
  }
  for (auto& src : _KBSP.alarm_scan_list) {
    auto pt = make_shared<BranchExpectedAlarmState>();
    pt->copyBranchExpectedAlarmState(*src);
    alarm_scan_list.push_back(std::move(pt));
  }
}
void KBScannedParameters::setLastPanelScanTime(double x) { last_panel_scan_time = x; }
void KBScannedParameters::setScanPeriodicity(double x) { scan_periodicity = x; }
void KBScannedParameters::setInfoLoadSensitivity(double x) { info_load_sensitivity = x; }
void KBScannedParameters::setSystemCriticalitySensitivity(double x) { system_criticality_sensitivity = x; }
void KBScannedParameters::setPriorityDecayTime(double x) { priority_decay_time = x; }
void KBScannedParameters::setRelevanceLimit(double x) { relevance_limit = x; }
void KBScannedParameters::setPriorityLimit(double x) { priority_limit = x; }
double KBScannedParameters::getLastPanelScanTime() { return last_panel_scan_time; }
double KBScannedParameters::getScanPeriodicity() { return scan_periodicity; }
double KBScannedParameters::getInfoLoadSensitivity() { return info_load_sensitivity; }
double KBScannedParameters::getSystemCriticalitySensitivity() { return system_criticality_sensitivity; }
double KBScannedParameters::getPriorityDecayTime() { return priority_decay_time; }
double KBScannedParameters::getRelevanceLimit() { return relevance_limit; }
double KBScannedParameters::getPriorityLimit() { return priority_limit; }
int KBScannedParameters::getScanListSize() {
  int n = 0;
  n = alarm_scan_list.size() +
      component_scan_list.size() +
      support_system_scan_list.size() +
      parameter_scan_list.size();
  return n;
}
void KBScannedParameters::readInfoFromFile(string _file_name) {
  string str;
  int i, num, priority;
  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();
  } else {
    fin >> str >> scan_periodicity
        >> str >> info_load_sensitivity
        >> str >> system_criticality_sensitivity
        >> str >> priority_decay_time
        >> str >> priority_limit
        >> str >> relevance_limit;
    // read parameter values for control panel scan
    fin >> str >> num;
    for (i = 0; i != num; i++) {
      fin >> str >> priority;
      this->addScannedParameter(str, priority);
    }
    // read component states for control panel scan
    fin >> str >> num;
    for (i = 0; i != num; i++) {
      fin >> str >> priority;
      this->addScannedComponent(str, priority);
    }
    // read component states for control panel scan
    fin >> str >> num;
    for (i = 0; i != num; i++) {
      fin >> str >> priority;
      this->addScannedSupportSystem(str, priority);
    }
    // read alarms for control panel scan
    fin >> str >> num;
    for (i = 0; i != num; i++) {
      fin >> str >> priority;
      this->addScannedAlarm(str, priority);
    }
    fin.close();
    last_panel_scan_time = r5pars_.timesno - scan_periodicity;
  }
}
void KBScannedParameters::saveKBSCannedParameterToFile(ofstream &fout) {
  fout << "Scanned_Parameters\n"
       << " last_panel_scan_time " << last_panel_scan_time
       << " scan_periodicity " << scan_periodicity
       << " info_load_sensitivity " << info_load_sensitivity
       << " system_criticality " << system_criticality_sensitivity
       << " priority_decay_time " << priority_decay_time
       << " priority_limit " << priority_limit
       << " relevance_limit " << relevance_limit << "\n";
  fout << " number_of_scanned_parameters " << this->parameter_scan_list.size() << "\n";
  for (auto& elem : parameter_scan_list) { elem->saveBranchExpectedParameterValueToFile(fout); }
  fout << " number_of_scanned_components " << this->component_scan_list.size() << "\n";
  for (auto& elem : component_scan_list) { elem->saveBranchExpectedComponentStateToFile(fout); }
  fout << " number_of_scanned_support_systems " << this->support_system_scan_list.size() << "\n";
  for (auto& elem : support_system_scan_list) { elem->saveBranchExpectedSupportSystemStateToFile(fout); }
  fout << " number_of_scanned_alarms " << this->alarm_scan_list.size() << "\n";
  for (auto& elem : alarm_scan_list) { elem->saveBranchExpectedAlarmStateToFile(fout); }
  fout << '\n';
}
void KBScannedParameters::retrieveKBSCannedParameterFromFile(ifstream &fin) {
  string str;
  int i, num_items;
  fin >> str;
  if (str != "Scanned_Parameters") {
    ofstream fout("err messages.txt", ios::app);
    cout << "KBScannedParameters::retrieveInfoFromFile File retrieval error in previous function" << endl;
    fout << r5pars_.timesno
         << "  KBScannedParameters::retrieveInfoFromFile File retrieval error in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("KBScannedParameters::retrieveInfoFromFile Prior error");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
 
  fin >> str >> last_panel_scan_time
      >> str >> scan_periodicity
      >> str >> info_load_sensitivity
      >> str >> system_criticality_sensitivity
      >> str >> priority_decay_time
      >> str >> priority_limit
      >> str >> relevance_limit;
  fin >> str >> num_items;
  for (i = 0; i != num_items; i++) {
    auto pt = make_shared<BranchExpectedParameterValue>();
    pt->retrieveBranchExpectedParameterValueFromFile(fin);
    this->parameter_scan_list.push_back(std::move(pt));
  }
  fin >> str >> num_items;
  for (i = 0; i != num_items; i++) {
    auto pt = make_shared<BranchExpectedComponentState>();
    pt->retrieveBranchExpectedComponentStateFromFile(fin);
    this->component_scan_list.push_back(std::move(pt));
  }
  fin >> str >> num_items;
  for (i = 0; i != num_items; i++) {
    auto pt = make_shared<BranchExpectedSupportSystemState>();
    pt->retrieveBranchExpectedSupportSystemStateFromFile(fin);
    this->support_system_scan_list.push_back(std::move(pt));
  }
  fin >> str >> num_items;
  for (i = 0; i != num_items; i++) {
    auto pt = make_shared<BranchExpectedAlarmState>();
    pt->retrieveBranchExpectedAlarmStateFromFile(fin);
    this->alarm_scan_list.push_back(std::move(pt));
  }
}
 
bool KBScannedParameters::checkIfParameterInQueue(string _parameter_name) {
  auto parameter_itr = parameter_scan_list.begin();
  bool found = false;
  while (parameter_itr != parameter_scan_list.end() && !found) {
    if ((*parameter_itr)->getInfoName() == _parameter_name) {
      found = true;
    } else {
      parameter_itr++;
    }
  }
  return found;
}
 
void KBScannedParameters::addScannedParameter(string _parameter_name, int _priority) {
  bool found = false;
  auto parameter_itr = parameter_scan_list.begin();
  while (parameter_itr != parameter_scan_list.end() && !found) {
    if ((*parameter_itr)->getInfoName() == _parameter_name) {
      found = true;
      (*parameter_itr)->setT_Minimum(r5pars_.timesno);
      (*parameter_itr)->setDecision(_priority);
    }
    parameter_itr++;
  }
  if (!found) {
    auto pt = make_shared<BranchExpectedParameterValue>();
    pt->setDisplayName(_parameter_name);
    pt->setInfoName(_parameter_name);
    pt->setDecision(_priority);
    pt->setT_Minimum(r5pars_.timesno);
    parameter_scan_list.push_back(std::move(pt));
  }
}
 
void KBScannedParameters::addScannedComponent(string _component_name, int _priority) {
  bool found = false;
  auto component_itr = component_scan_list.begin();
  while (component_itr != component_scan_list.end() && !found) {
    if ((*component_itr)->getInfoName() == _component_name) {
      found = true;
      (*component_itr)->setT_Minimum(r5pars_.timesno);
      (*component_itr)->setDecision(_priority);
    }
    component_itr++;
  }
  if (!found) {
    auto pt = make_shared<BranchExpectedComponentState>();
    pt->setDisplayName(_component_name);
    pt->setInfoName(_component_name);
    pt->setDecision(_priority);
    pt->setT_Minimum(r5pars_.timesno);
    component_scan_list.push_back(std::move(pt));
  }
}
 
void KBScannedParameters::addScannedSupportSystem(string _ss_name, int _priority) {
  bool found = false;
  auto ss_itr = support_system_scan_list.begin();
  while (ss_itr != support_system_scan_list.end() && !found) {
    if ((*ss_itr)->getInfoName() == _ss_name) {
      found = true;
      (*ss_itr)->setT_Minimum(r5pars_.timesno);
      (*ss_itr)->setDecision(_priority);
    }
    ss_itr++;
  }
  if (!found) {
    auto pt = make_shared<BranchExpectedSupportSystemState>();
    pt->setDisplayName(_ss_name);
    pt->setInfoName(_ss_name);
    pt->setDecision(_priority);
    pt->setT_Minimum(r5pars_.timesno);
    support_system_scan_list.push_back(std::move(pt));
  }
}
 
void KBScannedParameters::addScannedAlarm(string _alarm_name, int _priority) {
  bool found = false;
  auto alarm_itr = alarm_scan_list.begin();
  while (alarm_itr != alarm_scan_list.end() && !found) {
    if ((*alarm_itr)->getAlarmName() == _alarm_name) {
      found = true;
      (*alarm_itr)->setT_Minimum(r5pars_.timesno);
      (*alarm_itr)->setDecision(_priority);
    }
    alarm_itr++;
  }
  if (!found) {
    auto pt = make_shared<BranchExpectedAlarmState>();
    pt->setInfoName(_alarm_name);
    pt->setAlarmName(_alarm_name);
    pt->setDecision(_priority);
    alarm_scan_list.push_back(std::move(pt));
  }
}
 
void KBScannedParameters::removeScannedParameter(string _parameter_name) {
  bool found = false;
  auto parameter_itr = this->parameter_scan_list.begin();
  while (parameter_itr != this->parameter_scan_list.end() && !found) {
    if ((*parameter_itr)->getDisplayName() == _parameter_name) {
      found = true;
      this->parameter_scan_list.erase(parameter_itr);
    } else {
      parameter_itr++;
    }
  }
}
 
void KBScannedParameters::removeScannedComponent(string _component_name) {
  bool found = false;
  auto comp_itr = this->component_scan_list.begin();
  while (comp_itr != this->component_scan_list.end() && !found) {
    if ((*comp_itr)->getDisplayName() == _component_name) {
      found = true;
      this->component_scan_list.erase(comp_itr);
    } else {
      comp_itr++;
    }
  }
}
 
void KBScannedParameters::removeScannedSupportSystem(string _ss_name) {
  bool found = false;
  auto ss_itr = this->support_system_scan_list.begin();
  while (ss_itr != this->support_system_scan_list.end() && !found) {
    if ((*ss_itr)->getDisplayName() == _ss_name) {
      found = true;
      this->support_system_scan_list.erase(ss_itr);
    } else {
      ss_itr++;
    }
  }
}
 
void KBScannedParameters::removeScannedAlarm(string _alarm_name) {
  bool found = false;
  auto alarm_itr = this->alarm_scan_list.begin();
  while (alarm_itr != this->alarm_scan_list.end() && !found) {
    if ((*alarm_itr)->getAlarmName() == _alarm_name) {
      found = true;
      this->alarm_scan_list.erase(alarm_itr);
    } else {
      alarm_itr++;
    }
  }
}