KBHardWiredUnit.cpp

Go to the documentation of this file.

// KBHardWiredUnit.cpp: implementation of the KBHardWiredUnit class.
//
 
#include "KBHardWiredUnit.h"
#include <boost/serialization/export.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include "../Global/SimulationContext.h"
BOOST_CLASS_EXPORT_IMPLEMENT(KBHardWiredUnit)
using namespace std;
 
 
// Construction/Destruction
 
KBHardWiredUnit::KBHardWiredUnit() {
  confidence_level = 0.0;
  mental_procedure_priority = 0;
  total_number_of_expectation = 0;
  number_of_fulfilled_alarm_state = 0;
  number_of_fulfilled_component_state = 0;
  number_of_fulfilled_support_system_state = 0;
  number_of_fulfilled_parameter_value = 0;
  number_of_fulfilled_parameter_trend = 0;
  number_of_fulfilled_control = 0;
  number_of_fulfilled_mental_belief = 0;
  number_of_fulfilled_procedure_activity = 0;
}
 
KBHardWiredUnit::~KBHardWiredUnit() {
  expected_alarm_state.clear();
  expected_component_state.clear();
  expected_support_system_state.clear();
  expected_parameter_value.clear();
  expected_parameter_trend.clear();
  expected_control.clear();
  expected_mental_belief.clear();
  expected_procedure_activity.clear();
}
void KBHardWiredUnit::readInfoFromFile(ifstream &fin) {
  string str;
  int i, n, n_seq;
  double trigger_probability, event_probability;
  double act_t_minimum, act_alpha_parameter, act_beta_parameter;
  double react_t_minimum, react_alpha_parameter, react_beta_parameter;
//  KBExpectedParameterTrendUnit * expected_parameter_trend_pt;
  fin >> n_seq;
  KBElement::readInfoFromFile(fin);
  fin >> str >> trigger_probability
      >> str >> event_probability
      >> str >> act_t_minimum >> act_alpha_parameter >> act_beta_parameter
      >> str >> react_t_minimum >> react_alpha_parameter >> react_beta_parameter
      >> str >> n;
  this->activation_probability.setProbability(trigger_probability);
  this->branch_probability.setProbability(event_probability);
  this->activation_delay.setT_Minimum(act_t_minimum);
  this->activation_delay.setAlpha_Weibull(act_alpha_parameter);
  this->activation_delay.setBeta_Weibull(act_beta_parameter);
  this->dormancy_time.setT_Minimum(react_t_minimum);
  this->dormancy_time.setAlpha_Weibull(react_alpha_parameter);
  this->dormancy_time.setBeta_Weibull(react_beta_parameter);
  for (i = 0; i < n; i++) {
    auto expected_alarm_state_pt = make_unique<KBExpectedAlarmStateUnit>();
    expected_alarm_state_pt->readInfoFromFile(fin);
    expected_alarm_state.push_back(std::move(expected_alarm_state_pt));
    total_number_of_expectation++;
  }
  fin >> str >> n;
  for (i = 0; i < n; i++) {
    auto expected_component_state_pt = make_unique<KBExpectedComponentStateUnit>();
    expected_component_state_pt->readInfoFromFile(fin);
    expected_component_state.push_back(std::move(expected_component_state_pt));
    total_number_of_expectation++;
  }
  /*fin >> str >> n;
  for (i = 0; i < n; i++) {
    expected_support_system_state_pt = new KBExpectedSupportSystemStateUnit();
    expected_support_system_state_pt->readInfoFromFile(fin);
    expected_support_system_state.push_back(expected_support_system_state_pt);
    total_number_of_expectation++;
  }*/
  fin >> str >> n;
  for (i = 0; i < n; i++) {
    auto expected_parameter_value_pt = make_unique<KBExpectedParameterValueUnit>();
    expected_parameter_value_pt->readInfoFromFile(fin);
    expected_parameter_value.push_back(std::move(expected_parameter_value_pt));
    total_number_of_expectation++;
  }
  fin >> str >> n;
  for (i = 0; i < n; i++) {
    auto control_pt = make_unique<HardWiredControlActivity>();
    control_pt->readInfoFromFile(fin);
    expected_control.push_back(std::move(control_pt));
    total_number_of_expectation++;
  }
  fin >> str >> n;
  for (i = 0; i < n; i++) {
    auto mental_belief_pt = make_unique<HardWiredMentalBelief>();
    mental_belief_pt->readInfoFromFile(fin);
    expected_mental_belief.push_back(std::move(mental_belief_pt));
    total_number_of_expectation++;
  }
/*  fin >> str >> n;
    for(i = 0; i < n; i ++){
        expected_parameter_trend_pt = new KBExpectedParameterTrendUnit();
        expected_parameter_trend_pt->readInfoFromFile(fin);
        expected_parameter_trend.push_back(expected_parameter_trend_pt);
        total_number_of_expectation++;
    }*/
  fin >> str >> n;
  for (i = 0; i < n; i++) {
    auto expected_procedure_activity_pt = make_unique<HardWiredProcedureActivity>();
    expected_procedure_activity_pt->readInfoFromFile(fin);
    expected_procedure_activity.push_back(std::move(expected_procedure_activity_pt));
    total_number_of_expectation++;
  }
  //
  fin >> str >> n;
  this->setMentalProcedurePriority(n);
  //
  ProcedureStepInfo::readInfoFromFile(fin);
}
 
void KBHardWiredUnit::recalculateConfidenceLevel() {
  int n_fulfilled = 0;
  int n_return;
 
  number_of_fulfilled_alarm_state = 0;
  number_of_fulfilled_component_state = 0;
  number_of_fulfilled_support_system_state = 0;
  number_of_fulfilled_parameter_value = 0;
  number_of_fulfilled_parameter_trend = 0;
  number_of_fulfilled_control = 0;
  number_of_fulfilled_mental_belief = 0;
  number_of_fulfilled_procedure_activity = 0;
 
  if (total_number_of_expectation == 0) this->calculateTotalNumberOfExpectation();
  for (auto& elem : expected_alarm_state) {
    n_return = elem->getStateOfExpectation();
    if (n_return == sim::State::Succeed) { number_of_fulfilled_alarm_state++; n_fulfilled++; }
  }
  for (auto& elem : expected_component_state) {
    n_return = elem->getStateOfExpectation();
    if (n_return == sim::State::Succeed) { number_of_fulfilled_component_state++; n_fulfilled++; }
  }
  for (auto& elem : expected_support_system_state) {
    n_return = elem->getStateOfExpectation();
    if (n_return == sim::State::Succeed) { number_of_fulfilled_support_system_state++; n_fulfilled++; }
  }
  for (auto& elem : expected_parameter_value) {
    n_return = elem->getStateOfExpectation();
    if (n_return == sim::State::Succeed) { number_of_fulfilled_parameter_value++; n_fulfilled++; }
  }
  for (auto& elem : expected_parameter_trend) {
    n_return = elem->getStateOfExpectation();
    if (n_return == sim::State::Succeed) { number_of_fulfilled_parameter_trend++; n_fulfilled++; }
  }
  for (auto& elem : expected_control) {
    n_return = elem->getStateOfExpectation();
    if (n_return == sim::State::Succeed) { number_of_fulfilled_control++; n_fulfilled++; }
  }
  for (auto& elem : expected_mental_belief) {
    n_return = elem->getStateOfExpectation();
    if (n_return == sim::State::Succeed) { number_of_fulfilled_mental_belief++; n_fulfilled++; }
  }
  for (auto& elem : expected_procedure_activity) {
    n_return = elem->getStateOfExpectation();
    if (n_return == sim::State::Succeed) { number_of_fulfilled_procedure_activity++; n_fulfilled++; }
  }
  confidence_level = (double) n_fulfilled / ((double) total_number_of_expectation + 0.00001);
  if (confidence_level < 0.0) confidence_level = 0.0;
};
 
double KBHardWiredUnit::getConfidenceLevel() { return confidence_level; }
void KBHardWiredUnit::calculateTotalNumberOfExpectation() {
  total_number_of_expectation = expected_alarm_state.size()
      + expected_component_state.size()
      + expected_parameter_value.size()
      + expected_parameter_trend.size()
      + expected_mental_belief.size()
      + expected_control.size()
      + expected_procedure_activity.size();
}
double KBHardWiredUnit::calculateConfidenceLevel() {
  int n_fulfilled;
  if (total_number_of_expectation == 0) this->calculateTotalNumberOfExpectation();
 
  n_fulfilled = number_of_fulfilled_alarm_state
      + number_of_fulfilled_component_state
      + number_of_fulfilled_support_system_state
      + number_of_fulfilled_parameter_value
      + number_of_fulfilled_parameter_trend
      + number_of_fulfilled_control
      + number_of_fulfilled_mental_belief
      + number_of_fulfilled_procedure_activity;
//
//  the small offset on total_number_of_expectation prevents a divide by zero when no expectations are specified
  confidence_level = (double) n_fulfilled / ((double) total_number_of_expectation + 0.00001);
//
  if (confidence_level < 0.0) confidence_level = 0.0;
  return confidence_level;
}
void KBHardWiredUnit::checkForAlarmState(string _alarm_name, int _alarm_state) {
  int n_return;
  for (auto& elem : expected_alarm_state) {
    n_return = elem->checkForMatch(_alarm_name, _alarm_state);
    // n_return can take values from -2 to +2 depending on the value of the ExpectationElement state_of_expectation
    // in order to correctly evalute the number of fulfilled parameters, need to ensure that n_return
    // is confined to the range of -1 to +1.
    if (n_return > 1) { n_return = 1; }
    if (n_return < -1) { n_return = -1; }
    number_of_fulfilled_alarm_state += n_return;
  }
}
void KBHardWiredUnit::checkForComponentState(string _comp_name, int _comp_state) {
  int n_return;
  for (auto& elem : expected_component_state) {
    n_return = elem->checkForMatch(_comp_name, _comp_state);
    if (n_return > 1) { n_return = 1; }
    if (n_return < -1) { n_return = -1; }
    number_of_fulfilled_component_state += n_return;
  }
}
void KBHardWiredUnit::checkForSupportSystemState(string _ss_name, int _ss_state) {
  int n_return;
  for (auto& elem : expected_support_system_state) {
    n_return = elem->checkForMatch(_ss_name, _ss_state);
    if (n_return > 1) { n_return = 1; }
    if (n_return < -1) { n_return = -1; }
    number_of_fulfilled_support_system_state += n_return;
  }
}
void KBHardWiredUnit::checkForParameterValue(string _par_name, double _par_value, int _operator) {
  int n_return;
  for (auto& elem : expected_parameter_value) {
    n_return = elem->checkForMatch(_par_name, _par_value, _operator);
    if (n_return > 1) { n_return = 1; }
    if (n_return < -1) { n_return = -1; }
    number_of_fulfilled_parameter_value += n_return;
  }
}
void KBHardWiredUnit::checkForParameterTrend(string _par_name, int _par_trend) {
  int n_return;
  for (auto& elem : expected_parameter_trend) {
    n_return = elem->checkForMatch(_par_name, _par_trend);
    if (n_return > 1) { n_return = 1; }
    if (n_return < -1) { n_return = -1; }
    number_of_fulfilled_parameter_trend += n_return;
  }
}
void KBHardWiredUnit::checkForControl(string _ctrl_name, double _ctrl_value) {
  int n_return;
  for (auto& elem : expected_control) {
    n_return = elem->checkForMatch(_ctrl_name, _ctrl_value);
    if (n_return > 1) { n_return = 1; }
    if (n_return < -1) { n_return = -1; }
    number_of_fulfilled_control += n_return;
  }
}
void KBHardWiredUnit::checkForMentalBelief(string _name, int _state) {
  int n_return;
  for (auto& elem : expected_mental_belief) {
    n_return = elem->checkForMatch(_name, _state);
    if (n_return > 1) { n_return = 1; }
    if (n_return < -1) { n_return = -1; }
    number_of_fulfilled_mental_belief += n_return;
  }
}
void KBHardWiredUnit::checkForProcedureActivity(string _name, int _state) {
  int n_return;
  for (auto& elem : expected_procedure_activity) {
    n_return = elem->checkForMatch(_name, _state);
    if (n_return > 1) { n_return = 1; }
    if (n_return < -1) { n_return = -1; }
    number_of_fulfilled_mental_belief += n_return;
  }
}
void KBHardWiredUnit::copyKBHardWiredUnit(KBHardWiredUnit &_hwp) {
  this->copyKBElement(_hwp);
  this->copyStateOfActivation(_hwp);
  this->copyProcedureStepInfo(_hwp);
  this->activation_delay.copyTimer(_hwp.activation_delay);
  this->dormancy_time.copyTimer(_hwp.dormancy_time);
  this->branch_probability.copyProbability(_hwp.branch_probability);
  this->activation_probability.copyProbability(_hwp.activation_probability);
  number_of_fulfilled_alarm_state = _hwp.getNumberOfFulfilledAlarmState();
  number_of_fulfilled_component_state = _hwp.getNumberOfFulfilledComponentState();
  number_of_fulfilled_support_system_state = _hwp.getNumberOfFulfilledSupportSystemState();
  number_of_fulfilled_parameter_value = _hwp.getNumberOfFulfilledParameterValue();
  number_of_fulfilled_parameter_trend = _hwp.getNumberOfFulfilledParameterTrend();
  number_of_fulfilled_control = _hwp.getNumberOfFulfilledControl();
  number_of_fulfilled_mental_belief = _hwp.getNumberOfFulfilledMentalBelief();
  number_of_fulfilled_procedure_activity = _hwp.getNumberOfFulfilledProcedureActivity();
  total_number_of_expectation = _hwp.getTotalNumberOfExpectation();
  mental_procedure_priority = _hwp.getMentalProcedurePriority();
  confidence_level = _hwp.getConfidenceLevel();
  for (auto& src : _hwp.expected_alarm_state) {
    auto pt = make_unique<KBExpectedAlarmStateUnit>();
    pt->copyKBExpectedAlarmStateUnit(*src);
    expected_alarm_state.push_back(std::move(pt));
  }
  for (auto& src : _hwp.expected_component_state) {
    auto pt = make_unique<KBExpectedComponentStateUnit>();
    pt->copyKBExpectedComponentStateUnit(*src);
    expected_component_state.push_back(std::move(pt));
  }
  for (auto& src : _hwp.expected_support_system_state) {
    auto pt = make_unique<KBExpectedSupportSystemStateUnit>();
    pt->copyKBExpectedSupportSystemStateUnit(*src);
    expected_support_system_state.push_back(std::move(pt));
  }
  for (auto& src : _hwp.expected_parameter_value) {
    auto pt = make_unique<KBExpectedParameterValueUnit>();
    pt->copyKBExpectedParameterValueUnit(*src);
    expected_parameter_value.push_back(std::move(pt));
  }
  for (auto& src : _hwp.expected_parameter_trend) {
    auto pt = make_unique<KBExpectedParameterTrendUnit>();
    pt->copyKBExpectedParameterTrendUnit(*src);
    expected_parameter_trend.push_back(std::move(pt));
  }
  for (auto& src : _hwp.expected_control) {
    auto pt = make_unique<HardWiredControlActivity>();
    pt->copyHardWiredControlActivity(*src);
    expected_control.push_back(std::move(pt));
  }
  for (auto& src : _hwp.expected_mental_belief) {
    auto pt = make_unique<HardWiredMentalBelief>();
    pt->copyHardWiredMentalBelief(*src);
    expected_mental_belief.push_back(std::move(pt));
  }
  for (auto& src : _hwp.expected_procedure_activity) {
    auto pt = make_unique<HardWiredProcedureActivity>();
    pt->copyHardWiredProcedureActivity(*src);
    expected_procedure_activity.push_back(std::move(pt));
  }
}
void KBHardWiredUnit::setTotalNumberOfExpectation(int n) { total_number_of_expectation = n; }
void KBHardWiredUnit::setNumberOfFulfilledAlarmState(int n) { number_of_fulfilled_alarm_state = n; }
void KBHardWiredUnit::setNumberOfFulfilledComponentState(int n) { number_of_fulfilled_component_state = n; }
void KBHardWiredUnit::setNumberOfFulfilledSupportSystemState(int n) { number_of_fulfilled_support_system_state = n; }
void KBHardWiredUnit::setNumberOfFulfilledParameterValue(int n) { number_of_fulfilled_parameter_value = n; }
void KBHardWiredUnit::setNumberOfFulfilledParameterTrend(int n) { number_of_fulfilled_parameter_trend = n; }
int KBHardWiredUnit::getTotalNumberOfExpectation() { return total_number_of_expectation; }
int KBHardWiredUnit::getNumberOfFulfilledAlarmState() { return number_of_fulfilled_alarm_state; }
int KBHardWiredUnit::getNumberOfFulfilledComponentState() { return number_of_fulfilled_component_state; }
int KBHardWiredUnit::getNumberOfFulfilledSupportSystemState() { return number_of_fulfilled_support_system_state; }
int KBHardWiredUnit::getNumberOfFulfilledParameterValue() { return number_of_fulfilled_parameter_value; }
int KBHardWiredUnit::getNumberOfFulfilledParameterTrend() { return number_of_fulfilled_parameter_trend; }
void KBHardWiredUnit::setNumberOfFulfilledControl(int n) { number_of_fulfilled_control = n; }
void KBHardWiredUnit::setNumberOfFulfilledMentalBelief(int n) { number_of_fulfilled_mental_belief = n; }
int KBHardWiredUnit::getNumberOfFulfilledControl() { return number_of_fulfilled_control; }
int KBHardWiredUnit::getNumberOfFulfilledMentalBelief() { return number_of_fulfilled_mental_belief; }
int KBHardWiredUnit::getNumberOfFulfilledProcedureActivity() { return number_of_fulfilled_procedure_activity; }
void KBHardWiredUnit::setNumberOfFulfilledProcedureActivity(int n) { number_of_fulfilled_procedure_activity = n; }
void KBHardWiredUnit::setMentalProcedurePriority(int n) { mental_procedure_priority = n; }
int KBHardWiredUnit::getMentalProcedurePriority() { return mental_procedure_priority; }
void KBHardWiredUnit::saveKBHardWiredUnitToFile(ofstream &fout) {
  int i, num;
  fout << "KBHardWiredUnit ";
  this->saveKBElementToFile(fout);
  fout << confidence_level << ' '
       << total_number_of_expectation << ' '
       << number_of_fulfilled_alarm_state << ' '
       << number_of_fulfilled_component_state << ' '
       << number_of_fulfilled_support_system_state << ' '
       << number_of_fulfilled_parameter_value << ' '
       << number_of_fulfilled_parameter_trend << ' '
       << number_of_fulfilled_control << ' '
       << number_of_fulfilled_mental_belief << ' '
       << number_of_fulfilled_procedure_activity << ' '
       << mental_procedure_priority << '\n';
  num = this->expected_alarm_state.size();
  fout << num << '\n';
  for (i = 0; i < num; i++) {
    this->expected_alarm_state.at(i)->saveKBExpectedAlarmStateUnitToFile(fout);
  }
  num = this->expected_component_state.size();
  fout << num << '\n';
  for (i = 0; i < num; i++) {
    this->expected_component_state.at(i)->saveKBExpectedComponentStateUnitToFile(fout);
  }
  num = this->expected_support_system_state.size();
  fout << num << '\n';
  for (i = 0; i < num; i++) {
    this->expected_support_system_state.at(i)->saveKBExpectedSupportSystemStateUnitToFile(fout);
  }
  num = this->expected_parameter_value.size();
  fout << num << '\n';
  for (i = 0; i < num; i++) {
    this->expected_parameter_value.at(i)->saveKBExpectedParameterValueUnitToFile(fout);
  }
  num = this->expected_parameter_trend.size();
  fout << num << '\n';
  for (i = 0; i < num; i++) {
    this->expected_parameter_trend.at(i)->saveKBExpectedParameterTrendUnitToFile(fout);
  }
  num = this->expected_control.size();
  fout << num << '\n';
  for (i = 0; i < num; i++) {
    this->expected_control.at(i)->saveHardWiredControlActivityToFile(fout);
  }
  num = this->expected_mental_belief.size();
  fout << num << '\n';
  for (i = 0; i < num; i++) {
    this->expected_mental_belief.at(i)->saveHardWiredMentalBeliefToFile(fout);
  }
  num = this->expected_procedure_activity.size();
  fout << num << '\n';
  for (i = 0; i < num; i++) {
    this->expected_procedure_activity.at(i)->saveHardWiredProcedureActivityToFile(fout);
  }
  this->saveStateOfActivationToFile(fout);
  this->saveProcedureStepInfoToFile(fout);
//  this->saveTimerToFile(fout);
  this->activation_delay.saveTimerToFile(fout);
  this->dormancy_time.saveTimerToFile(fout);
  this->activation_probability.saveProbabilityToFile(fout);
  this->branch_probability.saveProbabilityToFile(fout);  // now included in ProcedureProcedureStepUnit
  fout << '\n';
}
void KBHardWiredUnit::retrieveKBHardWiredUnitFromFile(ifstream &fin) {
  int i, num;
  string str;
  fin >> str;
  if (str != "KBHardWiredUnit") {
    ofstream fout("err messages.txt", ios::app);
    cout << "KBHardWiredUnit::retrieveKBHardWiredUnitFromFile error in previous function" << endl;
    fout << r5pars_.timesno
         << "  KBHardWiredUnit::retrieveKBHardWiredUnitFromFile retrieval error in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("KBHardWiredUnit::retrieveKBHardWiredUnitFromFile err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
  this->retrieveKBElementFromFile(fin);
  fin >> confidence_level
      >> total_number_of_expectation
      >> number_of_fulfilled_alarm_state
      >> number_of_fulfilled_component_state
      >> number_of_fulfilled_support_system_state
      >> number_of_fulfilled_parameter_value
      >> number_of_fulfilled_parameter_trend
      >> number_of_fulfilled_control
      >> number_of_fulfilled_mental_belief
      >> number_of_fulfilled_procedure_activity
      >> mental_procedure_priority;
  fin >> num;
  for (i = 0; i < num; i++) {
    auto expected_alarm_state_pt = make_unique<KBExpectedAlarmStateUnit>();
    expected_alarm_state_pt->retrieveKBExpectedAlarmStateUnitFromFile(fin);
    if (r5pars_.sim_err) {
      ofstream fout("err messages.txt", ios::app);
      cout << "Err: KBHardWiredUnit::retrieveKBHardWiredUnitFromFile->KBExpectedAlarmStateUnit loop " << i << endl;
      fout << r5pars_.timesno
           << "  Err: KBHardWiredUnit::retrieveKBHardWiredUnitFromFile->KBExpectedAlarmStateUnit loop " << i << '\n';
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("KBHardWiredUnit::retrieveKBHardWiredUnitFromFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
      return;
    }
    expected_alarm_state.push_back(std::move(expected_alarm_state_pt));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto expected_component_state_pt = make_unique<KBExpectedComponentStateUnit>();
    expected_component_state_pt->retrieveKBExpectedComponentStateUnitFromFile(fin);
    if (r5pars_.sim_err) {
      ofstream fout("err messages.txt", ios::app);
      cout << "Err: KBHardWiredUnit::retrieveKBHardWiredUnitFromFile->KBExpectedComponentStateUnit loop " << i << endl;
      fout << r5pars_.timesno
           << "  Err: KBHardWiredUnit::retrieveKBHardWiredUnitFromFile->KBExpectedComponentStateUnit loop " << i
           << '\n';
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("KBHardWiredUnit::retrieveKBHardWiredUnitFromFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
      return;
    }
    expected_component_state.push_back(std::move(expected_component_state_pt));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto expected_support_system_state_pt = make_unique<KBExpectedSupportSystemStateUnit>();
    expected_support_system_state_pt->retrieveKBExpectedSupportSystemStateUnitFromFile(fin);
    if (r5pars_.sim_err) {
      ofstream fout("err messages.txt", ios::app);
      cout << "Err: KBHardWiredUnit::retrieveKBHardWiredUnitFromFile->KBExpectedSupportSystemStateUnit loop " << i << endl;
      fout << r5pars_.timesno
           << "  Err: KBHardWiredUnit::retrieveKBHardWiredUnitFromFile->KBExpectedSupportSystemStateUnit loop " << i
           << '\n';
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("KBHardWiredUnit::retrieveKBHardWiredUnitFromFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
      return;
    }
    expected_support_system_state.push_back(std::move(expected_support_system_state_pt));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto expected_parameter_value_pt = make_unique<KBExpectedParameterValueUnit>();
    expected_parameter_value_pt->retrieveKBExpectedParameterValueUnitFromFile(fin);
    if (r5pars_.sim_err) {
      ofstream fout("err messages.txt", ios::app);
      cout << "Err: KBHardWiredUnit::retrieveKBHardWiredUnitFromFile->KBExpectedParameterValueUnit loop " << i << endl;
      fout << r5pars_.timesno
           << "  Err: KBHardWiredUnit::retrieveKBHardWiredUnitFromFile->KBExpectedParameterValueUnit loop " << i
           << '\n';
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("KBHardWiredUnit::retrieveKBHardWiredUnitFromFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
      return;
    }
    expected_parameter_value.push_back(std::move(expected_parameter_value_pt));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto expected_parameter_trend_pt = make_unique<KBExpectedParameterTrendUnit>();
    expected_parameter_trend_pt->retrieveKBExpectedParameterTrendUnitFromFile(fin);
    if (r5pars_.sim_err) {
      ofstream fout("err messages.txt", ios::app);
      cout << "Err: KBHardWiredUnit::retrieveKBHardWiredUnitFromFile->KBExpectedParameterTrendUnit loop " << i << endl;
      fout << r5pars_.timesno
           << "  Err: KBHardWiredUnit::retrieveKBHardWiredUnitFromFile->KBExpectedParameterTrendUnit loop " << i
           << '\n';
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("KBHardWiredUnit::retrieveKBHardWiredUnitFromFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
      return;
    }
    expected_parameter_trend.push_back(std::move(expected_parameter_trend_pt));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto expected_control_pt = make_unique<HardWiredControlActivity>();
    expected_control_pt->retrieveHardWiredControlActivityFromFile(fin);
    if (r5pars_.sim_err) {
      ofstream fout("err messages.txt", ios::app);
      cout << "Err: KBHardWiredUnit::retrieveKBHardWiredUnitFromFile->HardWiredControlActivity loop " << i << endl;
      fout << r5pars_.timesno
           << "  Err: KBHardWiredUnit::retrieveKBHardWiredUnitFromFile->HardWiredControlActivity loop " << i << '\n';
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("KBHardWiredUnit::retrieveKBHardWiredUnitFromFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
      return;
    }
    expected_control.push_back(std::move(expected_control_pt));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto expected_mental_belief_pt = make_unique<HardWiredMentalBelief>();
    expected_mental_belief_pt->retrieveHardWiredMentalBeliefFromFile(fin);
    if (r5pars_.sim_err) {
      ofstream fout("err messages.txt", ios::app);
      cout << "Err: KBHardWiredUnit::retrieveKBHardWiredUnitFromFile->HardWiredMentalBelief loop " << i << endl;
      fout << r5pars_.timesno << "  Err: KBHardWiredUnit::retrieveKBHardWiredUnitFromFile->HardWiredMentalBelief loop "
           << i << '\n';
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("KBHardWiredUnit::retrieveKBHardWiredUnitFromFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
      return;
    }
    expected_mental_belief.push_back(std::move(expected_mental_belief_pt));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto expected_procedure_activity_pt = make_unique<HardWiredProcedureActivity>();
    expected_procedure_activity_pt->retrieveHardWiredProcedureActivityFromFile(fin);
    if (r5pars_.sim_err) {
      ofstream fout("err messages.txt", ios::app);
      cout << "Err: KBHardWiredUnit::retrieveKBHardWiredUnitFromFile->HardWiredProcedureActivity loop " << i << endl;
      fout << r5pars_.timesno
           << "  Err: KBHardWiredUnit::retrieveKBHardWiredUnitFromFile->HardWiredProcedureActivity loop " << i << '\n';
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("KBHardWiredUnit::retrieveKBHardWiredUnitFromFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
      return;
    }
    expected_procedure_activity.push_back(std::move(expected_procedure_activity_pt));
  }
  this->retrieveStateOfActivationFromFile(fin);
  this->retrieveProcedureStepInfoFromFile(fin);
//  this->retrieveTimerFromFile(fin);
  this->activation_delay.retrieveTimerFromFile(fin);
  this->dormancy_time.retrieveTimerFromFile(fin);
  this->activation_probability.retrieveProbabilityFromFile(fin);
  this->branch_probability.retrieveProbabilityFromFile(fin);
}
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <stdexcept>
 
namespace {
template <class V>
void hw_vec_state_save(boost::archive::binary_oarchive& ar, const V& v) {
    const uint32_t n = static_cast<uint32_t>(v.size());
    ar << n;
    for (const auto& e : v) e->state_save(ar);
}
template <class V>
void hw_vec_state_load(boost::archive::binary_iarchive& ar, V& v) {
    uint32_t n = 0;
    ar >> n;
    if (n != v.size())
        throw std::runtime_error("KB state overlay: expectation count mismatch against the seeded KB");
    for (auto& e : v) e->state_load(ar);
}
}
 
void KBHardWiredUnit::state_save(boost::archive::binary_oarchive& ar) const {
    const int soa = const_cast<KBHardWiredUnit*>(this)->getStateOfActivation();
    ar << soa << confidence_level
       << number_of_fulfilled_alarm_state << number_of_fulfilled_component_state
       << number_of_fulfilled_support_system_state << number_of_fulfilled_parameter_value
       << number_of_fulfilled_parameter_trend << number_of_fulfilled_control
       << number_of_fulfilled_mental_belief << number_of_fulfilled_procedure_activity;
    hw_vec_state_save(ar, expected_alarm_state);
    hw_vec_state_save(ar, expected_component_state);
    hw_vec_state_save(ar, expected_support_system_state);
    hw_vec_state_save(ar, expected_parameter_value);
    hw_vec_state_save(ar, expected_parameter_trend);
    hw_vec_state_save(ar, expected_control);
    hw_vec_state_save(ar, expected_mental_belief);
    hw_vec_state_save(ar, expected_procedure_activity);
    // Dormancy/activation timers carry live countdown state: dormancy_time's
    // total_time_required is set at diagnosis activation and gates re-firing
    // (Operator::checkAndActivateHWKB) — losing it re-triggers the diagnosis.
    activation_delay.timer_state_save(ar);
    dormancy_time.timer_state_save(ar);
}
void KBHardWiredUnit::state_load(boost::archive::binary_iarchive& ar) {
    int soa = 0;
    ar >> soa >> confidence_level
       >> number_of_fulfilled_alarm_state >> number_of_fulfilled_component_state
       >> number_of_fulfilled_support_system_state >> number_of_fulfilled_parameter_value
       >> number_of_fulfilled_parameter_trend >> number_of_fulfilled_control
       >> number_of_fulfilled_mental_belief >> number_of_fulfilled_procedure_activity;
    setStateOfActivation(soa);
    hw_vec_state_load(ar, expected_alarm_state);
    hw_vec_state_load(ar, expected_component_state);
    hw_vec_state_load(ar, expected_support_system_state);
    hw_vec_state_load(ar, expected_parameter_value);
    hw_vec_state_load(ar, expected_parameter_trend);
    hw_vec_state_load(ar, expected_control);
    hw_vec_state_load(ar, expected_mental_belief);
    hw_vec_state_load(ar, expected_procedure_activity);
    activation_delay.timer_state_load(ar);
    dormancy_time.timer_state_load(ar);
}