Operator.cpp

Go to the documentation of this file.

// Operator.cpp: implementation of the Operator class.
//
 
#include <map>
#include "../Global/SharedConfig.h"
#include <vector>
#include <fstream>
#include <boost/serialization/export.hpp>
 
#include "Operator.h"
#include "../ControlPanel/ControlPanel.h"
#include "../Procedure/Procedures.h"
#include "../Global/SimulationContext.h"
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(Operator)
 
 
using namespace std;
 
// Construction/Destruction
 
Operator::Operator() {
  pause_activity = false;
  skip_procedure_step = false;
  skip_action_threshold = 0.0;
  skip_non_response_threshold = 0.0;
  abnormal_signal_perceived = false;
  abnormal_signal_threshold = 0.0;
  troubleshooting_probability = 0.0;
  procedure_use_probability = 0.0;
  threshold_value_for_HWKB_confidence = 0.8;
  action_time_multiplier = 1.0;
  nominal_communication_time = 0.0;
  info_gather_mode_branch_generated = false;
  block_troubleshooting = false;
  block_procedure_use = false;
  // These are serialized and deep-copied at every branch point, so they get
  // deterministic defaults. Zero/false matches the effective state of the
  // zero-initialized global operators.
  type_of_operator = 0; // sentinel; subclass constructors set the real value
  mental_procedure_priority_threshold = 0;
  scan_queue_limit = 0;
  pause_mental_procedure = false;
  skip_instinctive_response_step = false;
  new_branch_generated = false;
  use_of_old_info_probability = 0.0;
 
  // m_RM default-constructs to nullptr
}
 
Operator::~Operator() {
 
}
void Operator::setTypeOfOperator(int n) { type_of_operator = n; }
int Operator::getTypeOfOperator() { return type_of_operator; }
void Operator::setMentalProcedurePriorityThreshold(int n) { mental_procedure_priority_threshold = n; }
int Operator::getMentalProcedurePriorityThreshold() { return mental_procedure_priority_threshold; }
void Operator::seedKnowledgeBaseFromMaster() {
  // State overlay: rebuild the role's knowledge base from the process-local
  // master before the state stream lands. Null-tolerant for unit tests.
  const KB* master = adsidac::shared_kb(type_of_operator);
  if (master == nullptr || master == &knowledge_base) return;
  knowledge_base.clearKB();
  knowledge_base.copyKBForRestart(const_cast<KB&>(*master));
}
 
void Operator::seedDiagnosisMatrixFromMaster() {
  // State overlay: same contract as the KB seed. The copy appends, so clear first.
  const EventSymptomMatrix* master = adsidac::shared_diagnosis_matrix(type_of_operator);
  if (master == nullptr || master == &diagnosis_matrix) return;
  diagnosis_matrix.clearEventSymptomMatrix();
  diagnosis_matrix.copyEventSymptomMatrix(const_cast<EventSymptomMatrix&>(*master));
}
 
void Operator::initiationForSimulation() {
  // Idempotent: clients/server load operator config at startup so the KB
  // masters exist before the first snapshot arrives; onFirstInit reaches here
  // again on the engine's normal path. Pure file reads (no RNG draws, those
  // happen at construction); reloading would append duplicate KB units.
  if (!knowledge_base.hard_wired_diagnosis.empty()) return;
 
  string str, str1, str_base;
  double alarm_t_min, alarm_alpha, alarm_beta;
  double comp_t_min, comp_alpha, comp_beta;
  double ss_t_min, ss_alpha, ss_beta;
  double param_t_min, param_alpha, param_beta;
  double low_info_load_limit, upper_info_load_limit;
  ifstream fin;
 
  int num;
  if (type_of_operator == sim::Operator::ODM) {
    str = g_sim.SScheduler.getODMDirectory();
    str_base = str;
    str += "DecisionMaker.txt";
    fin.open(str.c_str(), ios::in);
    if (!fin.is_open()) {
      cout << "File: " << str << " cound not be found" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  File: " << str << " cound not be found\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("Operator::initiationForSimulation DecisionMaker.txt err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    } else {
      fin >> str1 >> num
          >> str1 >> action_time_multiplier
          >> str1 >> threshold_value_for_HWKB_confidence
          >> str1 >> use_of_old_info_probability
          >> str1 >> scan_queue_limit
          >> str1 >> low_info_load_limit
          >> str1 >> upper_info_load_limit
          >> str1 >> alarm_t_min >> alarm_alpha >> alarm_beta
          >> str1 >> comp_t_min >> comp_alpha >> comp_beta
          >> str1 >> ss_t_min >> ss_alpha >> ss_beta
          >> str1 >> param_t_min >> param_alpha >> param_beta
          >> str1 >> skip_action_threshold
          >> str1 >> skip_non_response_threshold
          >> str1 >> abnormal_signal_threshold
          >> str1 >> mental_procedure_priority_threshold
          >> str1 >> nominal_communication_time
          >> str1 >> troubleshooting_probability
          >> str1 >> procedure_use_probability;
      fin.close();
      g_sim.SScheduler.setODMActionTimeMultiplier(action_time_multiplier);
      this->information_load.setLowerInfoLoadThreshold(low_info_load_limit);
      this->information_load.setUpperInfoLoadThreshold(upper_info_load_limit);
      this->memory.alarm_update_time.setT_Minimum(alarm_t_min);
      this->memory.alarm_update_time.setAlpha_Weibull(alarm_alpha);
      this->memory.alarm_update_time.setBeta_Weibull(alarm_beta);
      this->memory.component_update_time.setT_Minimum(comp_t_min);
      this->memory.component_update_time.setAlpha_Weibull(comp_alpha);
      this->memory.component_update_time.setBeta_Weibull(comp_beta);
      this->memory.support_system_update_time.setT_Minimum(ss_t_min);
      this->memory.support_system_update_time.setAlpha_Weibull(ss_alpha);
      this->memory.support_system_update_time.setBeta_Weibull(ss_beta);
      this->memory.parameter_update_time.setT_Minimum(param_t_min);
      this->memory.parameter_update_time.setAlpha_Weibull(param_alpha);
      this->memory.parameter_update_time.setBeta_Weibull(param_beta);
    }
    //
    // initialize event diagnosis data
    str = str_base + "KB_ODM_Event_Matrix.txt";
    this->diagnosis_matrix.readInfoFromFile(str);
    //
    // initialize time constrained data
    str = str_base + "KB_ODM_Time_Constrained_Input.txt";
    this->time_constrained_load.initiationForSimulation(str);
    //
    // initialize control panel scanned parameters
    str = str_base + "KB_ODM_Scanned_Parameters.txt";
    this->scanned_indicators.readInfoFromFile(str);
    //
    str = str_base + "KB_ODM_Safety_Parameters.txt";
    this->safety_parameters.initiationForSimulation(str);
    //
    str = str_base + "KB_ODM_Diagnosis_Actions.txt";
    this->event_actions.readDiagnosisActionModuleInfoFromFile(str);
    //
  } else if (type_of_operator == sim::Operator::OAT) {
    str = g_sim.SScheduler.getOATDirectory();
    str_base = str;
    str += "ActionTaker.txt";
    fin.open(str.c_str(), ios::in);
    if (!fin.is_open()) {
      cout << "File: " << str << " cound not be found" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  File: " << str << " cound not be found\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("Operator::initiationForSimulation ActionTaker.txt err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    } else {
      fin >> str1 >> num
          >> str1 >> action_time_multiplier
          >> str1 >> threshold_value_for_HWKB_confidence
          >> str1 >> use_of_old_info_probability
          >> str1 >> scan_queue_limit
          >> str1 >> low_info_load_limit
          >> str1 >> upper_info_load_limit
          >> str1 >> alarm_t_min >> alarm_alpha >> alarm_beta
          >> str1 >> comp_t_min >> comp_alpha >> comp_beta
          >> str1 >> ss_t_min >> ss_alpha >> ss_beta
          >> str1 >> param_t_min >> param_alpha >> param_beta
          >> str1 >> skip_action_threshold
          >> str1 >> skip_non_response_threshold
          >> str1 >> abnormal_signal_threshold
          >> str1 >> mental_procedure_priority_threshold
          >> str1 >> nominal_communication_time
          >> str1 >> troubleshooting_probability
          >> str1 >> procedure_use_probability;
      fin.close();
      g_sim.SScheduler.setOATActionTimeMultiplier(action_time_multiplier);
      this->information_load.setLowerInfoLoadThreshold(low_info_load_limit);
      this->information_load.setUpperInfoLoadThreshold(upper_info_load_limit);
      this->memory.alarm_update_time.setT_Minimum(alarm_t_min);
      this->memory.alarm_update_time.setAlpha_Weibull(alarm_alpha);
      this->memory.alarm_update_time.setBeta_Weibull(alarm_beta);
      this->memory.component_update_time.setT_Minimum(comp_t_min);
      this->memory.component_update_time.setAlpha_Weibull(comp_alpha);
      this->memory.component_update_time.setBeta_Weibull(comp_beta);
      this->memory.support_system_update_time.setT_Minimum(ss_t_min);
      this->memory.support_system_update_time.setAlpha_Weibull(ss_alpha);
      this->memory.support_system_update_time.setBeta_Weibull(ss_beta);
      this->memory.parameter_update_time.setT_Minimum(param_t_min);
      this->memory.parameter_update_time.setAlpha_Weibull(param_alpha);
      this->memory.parameter_update_time.setBeta_Weibull(param_beta);
    }
    //
    //  initialize event diagnosis data
    str = str_base + "KB_OAT_Event_Matrix.txt";
    this->diagnosis_matrix.readInfoFromFile(str);
    //
    //  initialize time constrained loading data
    str = str_base + "KB_OAT_Time_Constrained_Input.txt";
    this->time_constrained_load.initiationForSimulation(str);
    //
    // initialize control panel scanned parameters
    str = str_base + "KB_OAT_Scanned_Parameters.txt";
    this->scanned_indicators.readInfoFromFile(str);
    //
    str = str_base + "KB_OAT_Safety_Parameters.txt";
    this->safety_parameters.initiationForSimulation(str);
    //
    str = str_base + "KB_OAT_Diagnosis_Actions.txt";
    this->event_actions.readDiagnosisActionModuleInfoFromFile(str);
  } else {
    //
    //  Still need to add event diagnosis and time constrianed modules to OCT
    //
    str = g_sim.SScheduler.getOCTDirectory();
    str += "Consultant.txt";
    fin.open(str.c_str(), ios::in);
    if (!fin.is_open()) {
      cout << "File: " << str << " cound not be found" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  File: " << str << " cound not be found\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("Operator::initiationForSimulation Consultant.txt err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    } else {
      fin >> str1 >> num
          >> str1 >> action_time_multiplier
          >> str1 >> threshold_value_for_HWKB_confidence
          >> str1 >> use_of_old_info_probability
          >> str1 >> skip_action_threshold
          >> str1 >> skip_non_response_threshold
          >> str1 >> abnormal_signal_threshold
          >> str1 >> nominal_communication_time;
      fin.close();
      g_sim.SScheduler.setOCTActionTimeMultiplier(action_time_multiplier);
    }
    if (use_of_old_info_probability < 0.000001) {
      info_gather_mode_branch_generated = true;
      this->memory.setInfoGatherMode(sim::State::New);
    } else if (use_of_old_info_probability > 0.999999) {
      info_gather_mode_branch_generated = true;
      this->memory.setInfoGatherMode(sim::State::OldInfo);
    }
  }
  memory.initiationForSimulation();
  knowledge_base.initiationForSimulation(this->type_of_operator, this->memory.perceived_info);
  maneuver_action.readInfoFromFile(this->type_of_operator);
  //
 
  //caution, only decision maker runs the reasoning module
  if (this->type_of_operator == sim::Operator::ODM) {
    this->m_RM = make_unique<ReasonMachine>();
    this->m_RM->m_operator = this->type_of_operator;
    this->m_RM->InitiationOfReasonMachineFromInputFile();
    //Temporary codes
    ofstream fout("RMI.txt", ios::out);
    fout << "Reasoning Module Information" << '\n';
    fout.close();
 
    ofstream fout1("AuxInfo.txt", ios::out);
    fout1 << "Aux Information" << '\n';
    fout1.close();
 
    ofstream fout2("Semantic_Base.txt", ios::out);
    fout2 << "ODM's Semantic Pool" << '\n';
    fout2.close();
  }
}
void Operator::biasFilter() {
  bool found_indicator = false;
  double biased_value;
  for (auto& bf_ptr : this->knowledge_base.indicator_bias_factors) {
    if (bf_ptr->getTotalTimeRequired() < r5pars_.timesno) {
      for (auto &parameter_value_elem : this->memory.new_info.parameter_value) {
        //
        // bias parameter values
        if (bf_ptr->getInfoName() == parameter_value_elem->getInfoName()
            && parameter_value_elem->getSender() == sim::Source::Plant) {
          switch (bf_ptr->getTypeOfBias()) {
            case sim::ControlAction::Additive:
              biased_value = parameter_value_elem->getObservedParameterValue() + bf_ptr->getBiasFactor();
              parameter_value_elem->setObservedParameterValue(biased_value);
              break;
            case sim::ControlAction::Proportional:
              biased_value = parameter_value_elem->getObservedParameterValue() * bf_ptr->getBiasFactor();
              parameter_value_elem->setObservedParameterValue(biased_value);
              break;
            case sim::Compare::EQ: biased_value = bf_ptr->getBiasFactor();
              parameter_value_elem->setObservedParameterValue(biased_value);
              break;
            case sim::Compare::GT: biased_value = bf_ptr->getBiasFactor();
              if (parameter_value_elem->getObservedParameterValue() <= biased_value) {
                parameter_value_elem->setObservedParameterValue(biased_value);
              }
              break;
            case sim::Compare::GE: biased_value = bf_ptr->getBiasFactor();
              if (parameter_value_elem->getObservedParameterValue() <= biased_value) {
                parameter_value_elem->setObservedParameterValue(biased_value);
              }
              break;
            case sim::Compare::LT: biased_value = bf_ptr->getBiasFactor();
              if (parameter_value_elem->getObservedParameterValue() >= biased_value) {
                parameter_value_elem->setObservedParameterValue(biased_value);
              }
              break;
            case sim::Compare::LE: biased_value = bf_ptr->getBiasFactor();
              if (parameter_value_elem->getObservedParameterValue() >= biased_value) {
                parameter_value_elem->setObservedParameterValue(biased_value);
              }
              break;
            default: break;
          }
        }
      }
      //
      // bias parameters used for parameter difference compariosn
      for (auto &parameter_difference_elem : this->memory.new_info.parameter_difference) {
 
        if (bf_ptr->getInfoName() == parameter_difference_elem->first_indicator.getInfoName()
            && parameter_difference_elem->getSender() == sim::Source::Plant) {
          switch (bf_ptr->getTypeOfBias()) {
            case sim::ControlAction::Additive:
              biased_value = parameter_difference_elem->first_mental_parameter.getObservedParameterValue()
                  + bf_ptr->getBiasFactor();
              parameter_difference_elem->first_mental_parameter.setObservedParameterValue(biased_value);
              break;
            case sim::ControlAction::Proportional:
              biased_value = parameter_difference_elem->first_mental_parameter.getObservedParameterValue()
                  * bf_ptr->getBiasFactor();
              parameter_difference_elem->first_mental_parameter.setObservedParameterValue(biased_value);
              break;
            case sim::Compare::EQ: biased_value = bf_ptr->getBiasFactor();
              parameter_difference_elem->first_mental_parameter.setObservedParameterValue(biased_value);
              break;
            case sim::Compare::GT: biased_value = bf_ptr->getBiasFactor();
              if (parameter_difference_elem->first_mental_parameter.getObservedParameterValue() <= biased_value) {
                parameter_difference_elem->first_mental_parameter.setObservedParameterValue(biased_value);
              }
              break;
            case sim::Compare::GE: biased_value = bf_ptr->getBiasFactor();
              if (parameter_difference_elem->first_mental_parameter.getObservedParameterValue() <= biased_value) {
                parameter_difference_elem->first_mental_parameter.setObservedParameterValue(biased_value);
              }
              break;
            case sim::Compare::LT: biased_value = bf_ptr->getBiasFactor();
              if (parameter_difference_elem->first_mental_parameter.getObservedParameterValue() >= biased_value) {
                parameter_difference_elem->first_mental_parameter.setObservedParameterValue(biased_value);
              }
              break;
            case sim::Compare::LE: biased_value = bf_ptr->getBiasFactor();
              if (parameter_difference_elem->first_mental_parameter.getObservedParameterValue() >= biased_value) {
                parameter_difference_elem->first_mental_parameter.setObservedParameterValue(biased_value);
              }
              break;
            default: break;
          }
        }
        if (bf_ptr->getInfoName() == parameter_difference_elem->second_indicator.getInfoName()
            && parameter_difference_elem->getSender() == sim::Source::Plant) {
          switch (bf_ptr->getTypeOfBias()) {
            case sim::ControlAction::Additive:
              biased_value = parameter_difference_elem->second_mental_parameter.getObservedParameterValue()
                  + bf_ptr->getBiasFactor();
              parameter_difference_elem->second_mental_parameter.setObservedParameterValue(biased_value);
              break;
            case sim::ControlAction::Proportional:
              biased_value = parameter_difference_elem->second_mental_parameter.getObservedParameterValue()
                  * bf_ptr->getBiasFactor();
              parameter_difference_elem->second_mental_parameter.setObservedParameterValue(biased_value);
              break;
            case sim::Compare::EQ: biased_value = bf_ptr->getBiasFactor();
              parameter_difference_elem->second_mental_parameter.setObservedParameterValue(biased_value);
              break;
            case sim::Compare::GT: biased_value = bf_ptr->getBiasFactor();
              if (parameter_difference_elem->second_mental_parameter.getObservedParameterValue() <= biased_value) {
                parameter_difference_elem->second_mental_parameter.setObservedParameterValue(biased_value);
              }
              break;
            case sim::Compare::GE: biased_value = bf_ptr->getBiasFactor();
              if (parameter_difference_elem->second_mental_parameter.getObservedParameterValue() <= biased_value) {
                parameter_difference_elem->second_mental_parameter.setObservedParameterValue(biased_value);
              }
              break;
            case sim::Compare::LT: biased_value = bf_ptr->getBiasFactor();
              if (parameter_difference_elem->second_mental_parameter.getObservedParameterValue() >= biased_value) {
                parameter_difference_elem->second_mental_parameter.setObservedParameterValue(biased_value);
              }
              break;
            case sim::Compare::LE: biased_value = bf_ptr->getBiasFactor();
              if (parameter_difference_elem->second_mental_parameter.getObservedParameterValue() >= biased_value) {
                parameter_difference_elem->second_mental_parameter.setObservedParameterValue(biased_value);
              }
              break;
            default: break;
          }
        }
      }
    }
  }
}
void Operator::quantificationFilter()
// the quantification filter limits the amount of information that an operator can
// obtain from a control panel scan to less than the queue size limit
{
  int priority_limit;
  bool found;
  bool reduce_limit;
  decltype(scanned_indicators.parameter_scan_list)::iterator parameter_itr;
  decltype(scanned_indicators.component_scan_list)::iterator component_itr;
  decltype(scanned_indicators.support_system_scan_list)::iterator support_system_itr;
  decltype(scanned_indicators.alarm_scan_list)::iterator alarm_itr;
 
  double dynamic_queue_limit;
  // initially set priority limit to only remove low priority information
  priority_limit = this->scanned_indicators.getPriorityLimit();
  //
  // adjust scanned parameter priority based on time in queue and relevance to current diagnosis
  // Item priority is reduced based on the age of the item in the queue and its relevance to the diagnosis
  // Decayed items are collected and removed after each pass: erasing mid-loop
  // invalidates the vector iterators (UB when the erased item is the first element).
  vector<string> decayed;
  for (auto &item : scanned_indicators.parameter_scan_list) {
    if ((r5pars_.timesno - item->getT_Minimum()) > this->scanned_indicators.getPriorityDecayTime()) {
      if (this->checkItemRelevanceToCurrentDiagnosis(item->getInfoName())
          < this->scanned_indicators.getRelevanceLimit()) {
        item->setDecision(item->getDecision() + 1);
        if (item->getDecision() > priority_limit) {
          decayed.push_back(item->getDisplayName());
        } else {
          item->setT_Minimum(r5pars_.timesno);
        }
      }
    }
  }
  for (const auto &name : decayed) { this->scanned_indicators.removeScannedParameter(name); }
  decayed.clear();
  for (auto &item : scanned_indicators.component_scan_list) {
    if ((r5pars_.timesno - item->getT_Minimum()) > this->scanned_indicators.getPriorityDecayTime()) {
      if (this->checkItemRelevanceToCurrentDiagnosis(item->getInfoName())
          < this->scanned_indicators.getRelevanceLimit()) {
        item->setDecision(item->getDecision() + 1);
        if (item->getDecision() > priority_limit) {
          decayed.push_back(item->getDisplayName());
        } else {
          item->setT_Minimum(r5pars_.timesno);
        }
      }
    }
  }
  for (const auto &name : decayed) { this->scanned_indicators.removeScannedComponent(name); }
  decayed.clear();
  for (auto &item : scanned_indicators.support_system_scan_list) {
    if ((r5pars_.timesno - item->getT_Minimum()) > this->scanned_indicators.getPriorityDecayTime()) {
      if (this->checkItemRelevanceToCurrentDiagnosis(item->getInfoName())
          < this->scanned_indicators.getRelevanceLimit()) {
        item->setDecision(item->getDecision() + 1);
        if (item->getDecision() > priority_limit) {
          decayed.push_back(item->getDisplayName());
        } else {
          item->setT_Minimum(r5pars_.timesno);
        }
      }
    }
  }
  for (const auto &name : decayed) { this->scanned_indicators.removeScannedSupportSystem(name); }
  decayed.clear();
  for (auto &item : scanned_indicators.alarm_scan_list) {
    if ((r5pars_.timesno - item->getT_Minimum()) > this->scanned_indicators.getPriorityDecayTime()) {
      if (this->checkItemRelevanceToCurrentDiagnosis(item->getAlarmName())
          < this->scanned_indicators.getRelevanceLimit()) {
        item->setDecision(item->getDecision() + 1);
        if (item->getDecision() > priority_limit) {
          decayed.push_back(item->getAlarmName());
        } else {
          item->setT_Minimum(r5pars_.timesno);
        }
      }
    }
  }
  for (const auto &name : decayed) { this->scanned_indicators.removeScannedAlarm(name); }
  decayed.clear();
  //
  // if scanned_indicator queue exceeds maximum size, remove items based on their priority
  // determine dynamic scan queue size
  dynamic_queue_limit = scan_queue_limit;
  // adjust for information load
  dynamic_queue_limit *=
      (1.0 - this->scanned_indicators.getInfoLoadSensitivity() * this->information_load.getInfoLoadPIFValue());
  // adjust for perceived criticality of situation
  dynamic_queue_limit *=
      (1.0 - this->scanned_indicators.getSystemCriticalitySensitivity() * this->safety_parameters.getSPDSValue());
  //
  // ensure dynamic_queue_limit remians within appropriate limits
  if (dynamic_queue_limit > scan_queue_limit) { dynamic_queue_limit = scan_queue_limit; }
  if (dynamic_queue_limit < 0) { dynamic_queue_limit = 0; }
  //
  while (this->scanned_indicators.getScanListSize() > dynamic_queue_limit) {
    reduce_limit = true;
    found = false;
    // attempt to remove low priority scanned alarm
    alarm_itr = this->scanned_indicators.alarm_scan_list.begin();
    while (alarm_itr != this->scanned_indicators.alarm_scan_list.end() && !found) {
      if ((*alarm_itr)->getDecision() >= priority_limit) {
        this->scanned_indicators.removeScannedAlarm((*alarm_itr)->getAlarmName());
        found = true;
        reduce_limit = false;
        break; // alarm_itr is invalidated by the erase
      }
      alarm_itr++;
    }
    //
    // attempt to remove low priority scanned component
    component_itr = this->scanned_indicators.component_scan_list.begin();
    while (component_itr != this->scanned_indicators.component_scan_list.end() && !found) {
      if ((*component_itr)->getDecision() >= priority_limit) {
        this->scanned_indicators.removeScannedComponent((*component_itr)->getDisplayName());
        found = true;
        reduce_limit = false;
        break; // component_itr is invalidated by the erase
      }
      component_itr++;
    }
    //
    // attempt to remove low priority scanned support system
    support_system_itr = this->scanned_indicators.support_system_scan_list.begin();
    while (support_system_itr != this->scanned_indicators.support_system_scan_list.end() && !found) {
      if ((*support_system_itr)->getDecision() >= priority_limit) {
        this->scanned_indicators.removeScannedSupportSystem((*support_system_itr)->getDisplayName());
        found = true;
        reduce_limit = false;
        break; // support_system_itr is invalidated by the erase
      }
      support_system_itr++;
    }
    //
    // attempt to remove low priority scanned parameter
    parameter_itr = this->scanned_indicators.parameter_scan_list.begin();
    while (parameter_itr != this->scanned_indicators.parameter_scan_list.end() && !found) {
      if ((*parameter_itr)->getDecision() >= priority_limit) {
        this->scanned_indicators.removeScannedParameter((*parameter_itr)->getDisplayName());
        found = true;
        reduce_limit = false;
        break; // parameter_itr is invalidated by the erase
      }
      parameter_itr++;
    }
    //
    // if no scanned parameter can be eliminated, reduce the priority limit
    if (reduce_limit) {
      priority_limit = priority_limit - 1;
      priority_limit = fmax(1, priority_limit);
    }
 
  }
 
}
void Operator::setPauseActivity(bool bl) {
  pause_activity = bl;
}
bool Operator::getPauseActivity() { return pause_activity; }
void Operator::setNewBranchGenerated(bool bl) { new_branch_generated = bl; }
bool Operator::getNewBranchGenerated() { return new_branch_generated; }
void Operator::setPauseMentalProcedure(bool bl) {
  pause_mental_procedure = bl;
}
bool Operator::getPauseMentalProcedure() { return pause_mental_procedure; }
void Operator::setAbnormalSignalPerceived(bool _log) { abnormal_signal_perceived = _log; }
bool Operator::getAbnormalSignalPerceived() { return abnormal_signal_perceived; }
void Operator::setAbnormalSignalThreshold(double x) { abnormal_signal_threshold = x; }
double Operator::getAbnormalSignalThreshold() { return abnormal_signal_threshold; }
void Operator::setSkipProcedureStep(bool _log) { skip_procedure_step = _log; }
bool Operator::getSkipProcedureStep() { return skip_procedure_step; }
void Operator::setSkipInstinctiveResponseStep(bool _log) { skip_instinctive_response_step = _log; }
bool Operator::getSkipInstinctiveResponseStep() { return skip_instinctive_response_step; }
void Operator::copyOperatorToRestartInfo(Operator &_op) {
  this->knowledge_base.copyKBForRestart(_op.knowledge_base);
  this->memory.copyShortTermMemoryToRestartInfo(_op.memory);
  this->diagnosis_matrix.copyEventSymptomMatrix(_op.diagnosis_matrix);
  //this->Relap_PIFs.copyPIFRelap(_op.Relap_PIFs);
  this->scanned_indicators.copyScannedParameters(_op.scanned_indicators);
  this->maneuver_action.copyManeuverAction(_op.maneuver_action);
  this->safety_parameters.copySPDS(_op.safety_parameters);
  this->time_constrained_load.copyTimeConstrainedData(_op.time_constrained_load);
  this->information_load.copyInformationLoadModule(_op.information_load);
  this->event_actions.copyDiagnosisActionModule(_op.event_actions);
  type_of_operator = _op.getTypeOfOperator();
  mental_procedure_priority_threshold = _op.getMentalProcedurePriorityThreshold();
  pause_activity = _op.getPauseActivity();
  pause_mental_procedure = _op.getPauseMentalProcedure();
  new_branch_generated = _op.getNewBranchGenerated();
  abnormal_signal_perceived = _op.getAbnormalSignalPerceived();
  abnormal_signal_threshold = _op.getAbnormalSignalThreshold();
  skip_procedure_step = _op.getSkipProcedureStep();
  skip_instinctive_response_step = _op.getSkipInstinctiveResponseStep();
  skip_action_threshold = _op.getSkipActionThreshold();
  skip_non_response_threshold = _op.getSkipNonResponseThreshold();
  threshold_value_for_HWKB_confidence = _op.getThresholdValueForHWKBConfidence();
  action_time_multiplier = _op.getActionTimeMultiplier();
  nominal_communication_time = _op.getNominalCommunicationTime();
  troubleshooting_probability = _op.getTroubleshootingProbability();
  procedure_use_probability = _op.getProcedureUseProbability();
  info_gather_mode_branch_generated = _op.getInfoGatherModeBranchGenerated();
  use_of_old_info_probability = _op.getUseOfOldInfoProbabiility();
  block_troubleshooting = _op.getBlockTroubleshooting();
  block_procedure_use = _op.getBlockProcedureUse();
  scan_queue_limit = _op.getScanQueueLimit();
 
  // NOTE: hfe_bbn is deliberately NOT copied into the snapshot, so every
  // restored branch starts its first decision cycle from default (zero) PSF
  // posteriors until updateEvidenceForAllPSFs runs at the end of that tick,
  // while the in-line sibling branch uses live PSFs. This is consistent
  // across serial, MPI and checkpoint runs, but it biases HEP values at
  // branch points. Copying it here is a one-line change that CHANGES RESULTS
  // in all modes, so it requires new gold baselines.
 
  // RM gate: with the reasoning cycle disabled (the default), nothing reads
  // the snapshot's RM, so the clone + Build at every branch point is skipped.
  // A null snapshot RM also keeps the rm_data blob out of every MPI transfer
  // and checkpoint (has_rm=false in Operator::serialize).
  // See docs/developer/internals/reason-machine-status.md before enabling it.
  if (g_sim.config.rm_cycle_enabled && _op.m_RM != nullptr) {
    this->m_RM = make_unique<ReasonMachine>();
    this->m_RM->CopyReasonMachineFromAnotherRM(_op.m_RM.get());
    this->m_RM->BuildTheConnectionsWithinRM();
  }
}
void Operator::copyOperatorFromRestartInfo(Operator &_op) {
  this->knowledge_base.copyKBForRestart(_op.knowledge_base);
  this->memory.copyShortTermMemoryFromRestartInfo(_op.memory);
  this->diagnosis_matrix.copyEventSymptomMatrix(_op.diagnosis_matrix);
  //this->Relap_PIFs.copyPIFRelap(_op.Relap_PIFs);
  this->scanned_indicators.copyScannedParameters(_op.scanned_indicators);
  this->maneuver_action.copyManeuverAction(_op.maneuver_action);
  this->safety_parameters.copySPDS(_op.safety_parameters);
  this->time_constrained_load.copyTimeConstrainedData(_op.time_constrained_load);
  this->information_load.copyInformationLoadModule(_op.information_load);
  this->event_actions.copyDiagnosisActionModule(_op.event_actions);
  type_of_operator = _op.getTypeOfOperator();
  mental_procedure_priority_threshold = _op.getMentalProcedurePriorityThreshold();
  pause_activity = _op.getPauseActivity();
  pause_mental_procedure = _op.getPauseMentalProcedure();
  new_branch_generated = _op.getNewBranchGenerated();
  abnormal_signal_perceived = _op.getAbnormalSignalPerceived();
  abnormal_signal_threshold = _op.getAbnormalSignalThreshold();
  skip_procedure_step = _op.getSkipProcedureStep();
  skip_instinctive_response_step = _op.getSkipInstinctiveResponseStep();
  skip_action_threshold = _op.getSkipActionThreshold();
  skip_non_response_threshold = _op.getSkipNonResponseThreshold();
  threshold_value_for_HWKB_confidence = _op.getThresholdValueForHWKBConfidence();
  action_time_multiplier = _op.getActionTimeMultiplier();
  nominal_communication_time = _op.getNominalCommunicationTime();
  troubleshooting_probability = _op.getTroubleshootingProbability();
  procedure_use_probability = _op.getProcedureUseProbability();
  info_gather_mode_branch_generated = _op.getInfoGatherModeBranchGenerated();
  use_of_old_info_probability = _op.getUseOfOldInfoProbabiility();
  block_troubleshooting = _op.getBlockTroubleshooting();
  block_procedure_use = _op.getBlockProcedureUse();
  scan_queue_limit = _op.getScanQueueLimit();
 
  // RM gate: with the reasoning cycle disabled, the live RM persists across
  // sequences (as in the MPI restore path below, which does not clone). Only
  // the disabled cycle's input queues are reset, which gives the same state
  // as a fresh clone.
  if (g_sim.config.rm_cycle_enabled && _op.m_RM != nullptr) {
    this->m_RM = make_unique<ReasonMachine>();
    this->m_RM->CopyReasonMachineFromAnotherRM(_op.m_RM.get());
    this->m_RM->BuildTheConnectionsWithinRM();
  } else if (this->m_RM != nullptr) {
    this->m_RM->ClearTBIListsForRestart();
  }
  this->hfe_bbn.copyHumanFailureEventsBBN(_op.hfe_bbn);
}
void Operator::copyOperatorFromRestartInfoMultiProcessor(Operator &_op) {
  this->knowledge_base.copyKB(_op.knowledge_base);
  this->memory.copyShortTermMemoryFromRestartInfo(_op.memory);
  this->diagnosis_matrix.copyEventSymptomMatrix(_op.diagnosis_matrix);
  //this->Relap_PIFs.copyPIFRelap(_op.Relap_PIFs);
  this->scanned_indicators.copyScannedParameters(_op.scanned_indicators);
  this->maneuver_action.copyManeuverAction(_op.maneuver_action);
  this->safety_parameters.copySPDS(_op.safety_parameters);
  this->time_constrained_load.copyTimeConstrainedData(_op.time_constrained_load);
  this->information_load.copyInformationLoadModule(_op.information_load);
  this->event_actions.copyDiagnosisActionModule(_op.event_actions);
  type_of_operator = _op.getTypeOfOperator();
  mental_procedure_priority_threshold = _op.getMentalProcedurePriorityThreshold();
  pause_activity = _op.getPauseActivity();
  pause_mental_procedure = _op.getPauseMentalProcedure();
  new_branch_generated = _op.getNewBranchGenerated();
  abnormal_signal_perceived = _op.getAbnormalSignalPerceived();
  abnormal_signal_threshold = _op.getAbnormalSignalThreshold();
  skip_procedure_step = _op.getSkipProcedureStep();
  skip_instinctive_response_step = _op.getSkipInstinctiveResponseStep();
  skip_action_threshold = _op.getSkipActionThreshold();
  skip_non_response_threshold = _op.getSkipNonResponseThreshold();
  threshold_value_for_HWKB_confidence = _op.getThresholdValueForHWKBConfidence();
  action_time_multiplier = _op.getActionTimeMultiplier();
  nominal_communication_time = _op.getNominalCommunicationTime();
  troubleshooting_probability = _op.getTroubleshootingProbability();
  procedure_use_probability = _op.getProcedureUseProbability();
  info_gather_mode_branch_generated = _op.getInfoGatherModeBranchGenerated();
  use_of_old_info_probability = _op.getUseOfOldInfoProbabiility();
  block_troubleshooting = _op.getBlockTroubleshooting();
  block_procedure_use = _op.getBlockProcedureUse();
  scan_queue_limit = _op.getScanQueueLimit();
 
  // RM gate: this MPI restore path does not clone the RM (the live RM
  // persists across sequences here). With the reasoning cycle disabled it
  // also resets the disabled cycle's input queues, same as the serial
  // restore path.
  if (!g_sim.config.rm_cycle_enabled && this->m_RM != nullptr) {
    this->m_RM->ClearTBIListsForRestart();
  }
}
void Operator::clearOperatorForRestart() {
  this->memory.clearShortTermMemoryForRestart();
  this->knowledge_base.clearKBForRestart();
  this->diagnosis_matrix.clearEventSymptomMatrix();
  //this->Relap_PIFs.clearPIFRelap();
  this->scanned_indicators.clearScannedParameters();
  this->maneuver_action.clearManeuverAction();
  this->safety_parameters.clearSPDS();
  this->time_constrained_load.clearTimeConstrainedData();
  this->information_load.clearInformationLoadData();
  this->event_actions.clearDiagnosisActionModule();
}
void Operator::clearOperatorFromRestartInfo() {
  this->memory.clearShortTermMemoryFromRestartInfo();
  this->knowledge_base.clearKBForRestart();
  this->diagnosis_matrix.clearEventSymptomMatrix();
  //this->Relap_PIFs.clearPIFRelap();
  this->scanned_indicators.clearScannedParameters();
  this->maneuver_action.clearManeuverAction();
  this->safety_parameters.clearSPDS();
  this->time_constrained_load.clearTimeConstrainedData();
  this->information_load.clearInformationLoadData();
  this->event_actions.clearDiagnosisActionModule();
}
 
void Operator::clearOperatorFinal() {
  this->memory.clearShortTermMemoryForRestart();
  this->knowledge_base.clearKB();
  this->diagnosis_matrix.clearEventSymptomMatrix();
  //this->Relap_PIFs.clearPIFRelap();
  this->scanned_indicators.clearScannedParameters();
  this->maneuver_action.clearManeuverAction();
  this->safety_parameters.clearSPDS();
  this->time_constrained_load.clearTimeConstrainedData();
  this->information_load.clearInformationLoadData();
  this->event_actions.clearDiagnosisActionModule();
}
void Operator::clearOperatorFromRestartNodeInfoMultiProcessors() {
  this->memory.clearShortTermMemoryFromRestartNodeInfoMultiProcessors();
  this->knowledge_base.clearKB();
  //this->Relap_PIFs.clearPIFRelap();
  this->scanned_indicators.clearScannedParameters();
  this->maneuver_action.clearManeuverAction();
  this->safety_parameters.clearSPDS();
  this->time_constrained_load.clearTimeConstrainedData();
  this->information_load.clearInformationLoadData();
  this->event_actions.clearDiagnosisActionModule();
}
 
void Operator::setThresholdValueForHWKBConfidence(double x) { threshold_value_for_HWKB_confidence = x; }
double Operator::getThresholdValueForHWKBConfidence() { return threshold_value_for_HWKB_confidence; }
void Operator::setSkipActionThreshold(double x) { skip_action_threshold = x; }
double Operator::getSkipActionThreshold() { return skip_action_threshold; }
void Operator::setSkipNonResponseThreshold(double x) { skip_non_response_threshold = x; }
double Operator::getSkipNonResponseThreshold() { return skip_non_response_threshold; }
void Operator::setNominalCommunicationTime(double x) { nominal_communication_time = x; }
double Operator::getNominalCommunicationTime() { return nominal_communication_time; };
void Operator::setTroubleshootingProbability(double x) { troubleshooting_probability = x; }
double Operator::getTroubleshootingProbability() { return troubleshooting_probability; }
void Operator::setProcedureUseProbability(double x) { procedure_use_probability = x; }
double Operator::getProcedureUseProbability() { return procedure_use_probability; }
bool Operator::checkAndActivateHWKB() {
  decltype(knowledge_base.hard_wired_diagnosis)::iterator hwd_itr;
//  BranchDiagnosis *dia_active, *dia_not_active;
  BranchExpectedMentalBelief *mb_active, *mb_not_active;
  BranchMentalProcedureActivationTimeUnit *bmp_atu_pt;
  ExpectedMentalBelief *mb_ptr = 0;
  double active_probability, time_delay, activation_time;
  double cdf_lower, cdf_upper, delta_cdf, activation_branch_probability;
  int i, number_of_branches;
  bool branch_generated = false;
  hwd_itr = this->knowledge_base.hard_wired_diagnosis.begin();
  while (hwd_itr != this->knowledge_base.hard_wired_diagnosis.end() && !branch_generated) {
    //
    // reset activation if timer has expired
    if ((*hwd_itr)->getStateOfActivation() == sim::State::Succeed) {
      //
      // reset state of mental diagnosis based on dormancy time
      if ((*hwd_itr)->dormancy_time.getTotalTimeRequired() < r5pars_.timesno) {
        (*hwd_itr)->setStateOfActivation(sim::None);
        mb_ptr = this->memory.perceived_info.checkExistanceOfMentalBelief((*hwd_itr)->getInfoName());
        if (mb_ptr != 0) {
          //reset set of activation for memorized mental belief
          mb_ptr->setStateOfActivation(sim::None);
          this->knowledge_base.KBcheckHardWiredMatchForMentalBelief(mb_ptr->getInfoName(),
                                                                    mb_ptr->getStateOfActivation());
        }
      }
    }
    //
    //if((*hwd_itr)->getConfidenceLevel() >= threshold_value_for_HWKB_confidence && (*hwd_itr)->getStateOfActivation() == sim::None){
    if ((*hwd_itr)->getConfidenceLevel() >= (*hwd_itr)->activation_probability.getProbability()
        && (*hwd_itr)->getStateOfActivation() == sim::None) {
      (*hwd_itr)->setStateOfActivation(sim::State::Succeed);
      // set dormancy time delay before hard wired diagnosis can be reactived
      time_delay = (*hwd_itr)->dormancy_time.calculateMeanRequiredTime() + r5pars_.timesno;
      (*hwd_itr)->dormancy_time.setBothTotalTimeRequiredAndRemainingTime(time_delay);
      //
      // set activation time for mental procedure (activation time sets time lag between the mental diagnosis and proceedure initiation)
      bmp_atu_pt =
          g_sim.Branch_center.mental_procedure_activation_branches.checkToGenerateActivationTimeBranches((*hwd_itr)->getInfoName(),
                                                                                                   (*hwd_itr)->getProcedureName());
      if (bmp_atu_pt != 0) {
        number_of_branches = bmp_atu_pt->getNumberOfBranches();
      } else {
        number_of_branches = 1;
      }
      activation_branch_probability = 1.0 / ((double) number_of_branches);
      delta_cdf = 1.0 / ((double) number_of_branches);
      for (i = 0; i != number_of_branches; i++) {
        // calculate time required to perform action
        cdf_lower = delta_cdf * ((double) i);
        cdf_upper = delta_cdf * ((double) (i + 1));
        activation_time =
            (*hwd_itr)->activation_delay.calculateMeanRequiredTime(cdf_lower, cdf_upper) + r5pars_.timesno;
        if ((*hwd_itr)->branch_probability.getProbability()
            > 0.999999) {//when the probability is set to close to one, generate only success branches
          mb_active = new BranchExpectedMentalBelief();
          mb_active->setInfoName((*hwd_itr)->getInfoName());
          mb_active->setMentalPriority((*hwd_itr)->getMentalProcedurePriority());
          mb_active->setActivationTime(activation_time);
          mb_active->setBothTotalTimeRequiredAndRemainingTime(-1.0);
          /*
          cout << "-------------------\n";
          cout << type_of_operator << "\n";
          cout << -1.0*this->hfe_bbn.getMentalProcedureFailureProbability();
          cout << "\n-------------------\n";
          */
          mb_active->setProbability(1.0 - activation_branch_probability * this->hfe_bbn.getMentalProcedureFailureProbability());
          mb_active->setStateOfActivation(sim::State::Succeed);
          mb_active->setSenderAndReceiver(type_of_operator, type_of_operator);
          mb_active->setTypeOfPauseActivity(sim::Strategy::InstinctiveResponse);
          g_sim.Branch_center.addMentalBelief(type_of_operator, mb_active);
          branch_generated = true;
        } else if ((*hwd_itr)->branch_probability.getProbability()
            < 0.000001) {//when the probability is set to close to zero, do nothing
        } else {    //otherwise, generate success branch(es) and one failure(bypass) branch
          active_probability = (*hwd_itr)->branch_probability.getProbability();
          mb_active = new BranchExpectedMentalBelief();
          mb_active->setInfoName((*hwd_itr)->getInfoName());
          mb_active->setMentalPriority((*hwd_itr)->getMentalProcedurePriority());
          mb_active->setActivationTime(activation_time);
          mb_active->setBothTotalTimeRequiredAndRemainingTime(-1.0);
          mb_active->setProbability(1.0 - active_probability * activation_branch_probability * this->hfe_bbn.getMentalProcedureFailureProbability());
          mb_active->setStateOfActivation(sim::State::Succeed);
          mb_active->setSenderAndReceiver(type_of_operator, type_of_operator);
          mb_active->setTypeOfPauseActivity(sim::Strategy::InstinctiveResponse);
          g_sim.Branch_center.addMentalBelief(type_of_operator, mb_active);
          //
          if (i == (number_of_branches - 1)) // generate one mental belief failure (bypass) branch
          {
            mb_not_active = new BranchExpectedMentalBelief();
            mb_not_active->setInfoName((*hwd_itr)->getInfoName());
            mb_not_active->setMentalPriority((*hwd_itr)->getMentalProcedurePriority());
            mb_not_active->setStateOfActivation(sim::Source::Bypass);
            mb_not_active->setBothTotalTimeRequiredAndRemainingTime(-1.0);
            //mb_not_active->setProbability((1.0 - active_probability) * activation_branch_probability);
            mb_not_active->setProbability(active_probability * activation_branch_probability * this->hfe_bbn.getMentalProcedureFailureProbability());
            mb_not_active->setSenderAndReceiver(type_of_operator, type_of_operator);
            mb_not_active->setTypeOfPauseActivity(sim::Strategy::InstinctiveResponse);
            g_sim.Branch_center.addMentalBelief(type_of_operator, mb_not_active);
            branch_generated = true;
          }
        }
      }
    } else {
      //  do nothing
    }
    hwd_itr++;
  }
  return branch_generated;
}
void Operator::setActionTimeMultiplier(double x) { action_time_multiplier = x; }
double Operator::getActionTimeMultiplier() { return action_time_multiplier; }
void Operator::setBlockTroubleshooting(bool bl) { block_troubleshooting = bl; }
bool Operator::getBlockTroubleshooting() { return block_troubleshooting; }
void Operator::setBlockProcedureUse(bool bl) { block_procedure_use = bl; }
bool Operator::getBlockProcedureUse() { return block_procedure_use; }
void Operator::setInfoGatherModeBranchGenerated(bool bl) { info_gather_mode_branch_generated = bl; }
bool Operator::getInfoGatherModeBranchGenerated() { return info_gather_mode_branch_generated; }
void Operator::setScanQueueLimit(int n) { scan_queue_limit = n; }
int Operator::getScanQueueLimit() { return scan_queue_limit; }
 
int Operator::generateInfoGatherModeBranch() {
  BranchInfoGatherMode *bigm;
  int num_branch = 0;
  if (!info_gather_mode_branch_generated) {
    info_gather_mode_branch_generated = true;
    if (use_of_old_info_probability < 0.999999
        && use_of_old_info_probability > 0.000001) {//two branches for used of old info and checking for new info
      this->setPauseActivity(true);
      bigm = new BranchInfoGatherMode();
      bigm->setInfoGatherMode(sim::State::OldInfo);
      bigm->setTimerAndProbability(-1.0, use_of_old_info_probability);
      bigm->setSenderAndReceiver(type_of_operator, type_of_operator);
      bigm->setTypeOfPauseActivity(sim::Branch::InfoGatherMode);
      g_sim.Branch_center.addInfoGatherMode(type_of_operator, bigm);
      //
      bigm = new BranchInfoGatherMode();
      bigm->setInfoGatherMode(sim::State::New);
      bigm->setTimerAndProbability(-1.0, 1.0 - use_of_old_info_probability);
      bigm->setSenderAndReceiver(type_of_operator, type_of_operator);
      bigm->setTypeOfPauseActivity(sim::Branch::InfoGatherMode);
      g_sim.Branch_center.addInfoGatherMode(type_of_operator, bigm);
      num_branch = 2;
    } else if (use_of_old_info_probability > 0.999999) {//use the old (memorized) information only
      this->setPauseActivity(true);
      BranchInfoGatherMode *bigm;
      bigm = new BranchInfoGatherMode();
      bigm->setInfoGatherMode(sim::State::OldInfo);
      bigm->setTimerAndProbability(-1.0, 1.0 - this->hfe_bbn.getGatherInfoModeFailureProbability());
      bigm->setSenderAndReceiver(type_of_operator, type_of_operator);
      bigm->setTypeOfPauseActivity(sim::Branch::InfoGatherMode);
      g_sim.Branch_center.addInfoGatherMode(type_of_operator, bigm);
      num_branch = 1;
    } else {//check for the new information only
      this->setPauseActivity(true);
      bigm = new BranchInfoGatherMode();
      bigm->setInfoGatherMode(sim::State::New);
      bigm->setTimerAndProbability(-1.0, 1.0 - this->hfe_bbn.getGatherInfoModeFailureProbability());
      bigm->setSenderAndReceiver(type_of_operator, type_of_operator);
      bigm->setTypeOfPauseActivity(sim::Branch::InfoGatherMode);
      g_sim.Branch_center.addInfoGatherMode(type_of_operator, bigm);
      num_branch = 1;
    }
  }
  return num_branch;
}
void Operator::setUseOfOldInfoProbability(double x) { use_of_old_info_probability = x; }
double Operator::getUseOfOldInfoProbabiility() { return use_of_old_info_probability; }
void Operator::saveOperatorToFile(ofstream &fout) {
  int i_pause_activity, i_pause_mental_procedure, i_abnormal_signal_perceived;
  int i_skip_procedure_step, i_skip_instinctive_response_step;
  int i_info_gather_mode_branch_generated, i_block_troubleshooting, i_block_procedures;
  int i_new_branch_generated;
  i_pause_activity = 0;
  i_pause_mental_procedure = 0;
  i_new_branch_generated = 0;
  i_abnormal_signal_perceived = 0;
  i_skip_procedure_step = 0;
  i_skip_instinctive_response_step = 0;
  i_info_gather_mode_branch_generated = 0;
  i_block_troubleshooting = 0;
  i_block_procedures = 0;
  if (pause_activity) i_pause_activity = 1;
  if (pause_mental_procedure) i_pause_mental_procedure = 1;
  if (new_branch_generated) i_new_branch_generated = 1;
  if (abnormal_signal_perceived) i_abnormal_signal_perceived = 1;
  if (skip_procedure_step) i_skip_procedure_step = 1;
  if (skip_instinctive_response_step) i_skip_instinctive_response_step = 1;
  if (info_gather_mode_branch_generated) i_info_gather_mode_branch_generated = 1;
  if (block_troubleshooting) i_block_troubleshooting = 1;
  if (block_procedure_use) i_block_procedures = 1;
  fout << "Operator "
       << i_pause_activity << ' '
       << i_pause_mental_procedure << ' '
       << i_new_branch_generated << ' '
       << i_abnormal_signal_perceived << ' '
       << abnormal_signal_threshold << ' '
       << i_skip_procedure_step << ' '
       << i_skip_instinctive_response_step << ' '
       << skip_action_threshold << ' '
       << skip_non_response_threshold << ' '
       << i_info_gather_mode_branch_generated << ' '
       << i_block_troubleshooting << ' '
       << i_block_procedures << ' '
       << type_of_operator << ' '
       << mental_procedure_priority_threshold << ' '
       << threshold_value_for_HWKB_confidence << ' '
       << action_time_multiplier << ' '
       << nominal_communication_time << ' '
       << troubleshooting_probability << ' '
       << procedure_use_probability << ' '
       << scan_queue_limit << ' '
       << use_of_old_info_probability << '\n';
  this->memory.saveShortTermMemoryToFile(fout);
  this->knowledge_base.saveKBToFile(fout);
  this->diagnosis_matrix.saveEventSymptomMatrixToFile(fout);
  //this->Relap_PIFs.savePIFRelapToFile(fout);
  this->scanned_indicators.saveKBSCannedParameterToFile(fout);
  this->maneuver_action.saveManeuverActionToFile(fout);
  this->safety_parameters.saveSPDSToFile(fout);
  this->time_constrained_load.saveTimeConstrainedModuleToFile(fout);
  this->information_load.saveInformationLoadModuleToFile(fout);
  this->event_actions.saveDiagnosisActionModuleToFile(fout);
}
void Operator::retrieveOperatorFromFile(ifstream &fin) {
  int i_pause_activity, i_pause_mental_procedure, i_abnormal_signal_perceived;
  int i_skip_procedure_step, i_skip_instinctive_response_step;
  int i_info_gather_mode_branch_generated, i_block_troubleshooting, i_block_procedures;
  int i_new_branch_generated;
  string str;
  pause_activity = false;
  pause_mental_procedure = false;
  new_branch_generated = false;
  abnormal_signal_perceived = false;
  skip_procedure_step = false;
  skip_instinctive_response_step = false;
  info_gather_mode_branch_generated = false;
  block_troubleshooting = false;
  block_procedure_use = false;
  fin >> str;
  if (str != "Operator") {
    ofstream fout("err messages.txt", ios::app);
    cout << "Operator::retrieveOperatorFromFile File retrieval error in previous function" << endl;
    fout << r5pars_.timesno << "  Operator::retrieveOperatorFromFile File retrieval error in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("Operator::retrieveOperatorFromFile Prior error");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
  fin >> i_pause_activity
      >> i_pause_mental_procedure
      >> i_new_branch_generated
      >> i_abnormal_signal_perceived
      >> abnormal_signal_threshold
      >> i_skip_procedure_step
      >> i_skip_instinctive_response_step
      >> skip_action_threshold
      >> skip_non_response_threshold
      >> i_info_gather_mode_branch_generated
      >> i_block_troubleshooting
      >> i_block_procedures
      >> type_of_operator
      >> mental_procedure_priority_threshold
      >> threshold_value_for_HWKB_confidence
      >> action_time_multiplier
      >> nominal_communication_time
      >> troubleshooting_probability
      >> procedure_use_probability
      >> scan_queue_limit
      >> use_of_old_info_probability;
  if (i_pause_activity == 1) pause_activity = true;
  if (i_pause_mental_procedure == 1) pause_mental_procedure = true;
  if (i_new_branch_generated == 1) new_branch_generated = true;
  if (i_abnormal_signal_perceived == 1) abnormal_signal_perceived = true;
  if (i_skip_procedure_step == 1) skip_procedure_step = true;
  if (i_skip_instinctive_response_step == 1) skip_instinctive_response_step = true;
  if (i_info_gather_mode_branch_generated == 1) info_gather_mode_branch_generated = true;
  if (i_block_troubleshooting == 1) block_troubleshooting = true;
  if (i_block_procedures == 1) block_procedure_use = true;
  this->memory.retrieveShortTermMemoryFromFile(fin);
  this->knowledge_base.retrieveKBFromFile(fin);
  this->diagnosis_matrix.retrieveEventSymptomMatrixFromFile(fin);
  //this->Relap_PIFs.retrievePIFRelapFromFile(fin);
  this->scanned_indicators.retrieveKBSCannedParameterFromFile(fin);
  this->maneuver_action.retrieveManeuverActionFromFile(fin);
  this->safety_parameters.retrieveSPDSFromFile(fin);
  this->time_constrained_load.retrieveTimeConstrainedModuleFromFile(fin);
  this->information_load.retreiveInformationLoadModuleFromFile(fin);
  this->event_actions.retreiveDiagnosisActionModuleFromFile(fin);
}
void Operator::checkCompletenessOfSystemDecomposition(int _operator) {
  vector<unique_ptr<AlarmParameter>>::iterator ap_itr;
  vector<unique_ptr<AlarmComponent>>::iterator ac_itr;
  vector<unique_ptr<AlarmTwoParameterDifference>>::iterator atpd_itr;
  vector<unique_ptr<ControlState>>::iterator cs_itr;
  vector<unique_ptr<ControlValue>>::iterator cv_itr;
  vector<unique_ptr<DisplayComponentState>>::iterator dcs_itr;
  vector<unique_ptr<DisplaySupportSystemState>>::iterator dsss_itr;
  vector<unique_ptr<DisplayParameterValue>>::iterator dpv_itr;
  vector<unique_ptr<DisplayHeatStructure>>::iterator dhs_itr; //meash points are the objects stored
  vector<unique_ptr<DisplayParameterValueRate>>::iterator dpvr_itr;
  vector<StringContainer *> not_found_item;
  string name_list = "";
  bool found_mismatch = false;
  map<string, KBSystemDecompositionUnit *>::const_iterator map_itr;
 
  for (ap_itr = g_sim.Indicator.alarms.alarm_parameter_value_array.begin();
       ap_itr != g_sim.Indicator.alarms.alarm_parameter_value_array.end(); ap_itr++) {
    map_itr = this->knowledge_base.system_decomposition_map.find((*ap_itr)->getAlarmName());
    if (map_itr == this->knowledge_base.system_decomposition_map.end()) {
      found_mismatch = true;
      name_list += (*ap_itr)->getAlarmName();
      name_list += ",\n";
    }
  }
  for (ac_itr = g_sim.Indicator.alarms.alarm_component_state_array.begin();
       ac_itr != g_sim.Indicator.alarms.alarm_component_state_array.end(); ac_itr++) {
    map_itr = this->knowledge_base.system_decomposition_map.find((*ac_itr)->getAlarmName());
    if (map_itr == this->knowledge_base.system_decomposition_map.end()) {
      found_mismatch = true;
      name_list += (*ac_itr)->getAlarmName();
      name_list += ",\n";
    }
  }
  for (atpd_itr = g_sim.Indicator.alarms.alarm_value_difference_array.begin();
       atpd_itr != g_sim.Indicator.alarms.alarm_value_difference_array.end(); atpd_itr++) {
    map_itr = this->knowledge_base.system_decomposition_map.find((*atpd_itr)->getAlarmName());
    if (map_itr == this->knowledge_base.system_decomposition_map.end()) {
      found_mismatch = true;
      name_list += (*atpd_itr)->getAlarmName();
      name_list += ",\n";
    }
  }
  for (cs_itr = g_sim.Indicator.controls.control_state_array.begin(); cs_itr != g_sim.Indicator.controls.control_state_array.end();
       cs_itr++) {
    map_itr = this->knowledge_base.system_decomposition_map.find((*cs_itr)->getDisplayName());
    if (map_itr == this->knowledge_base.system_decomposition_map.end()) {
      found_mismatch = true;
      name_list += (*cs_itr)->getDisplayName();
      name_list += ",\n";
    }
  }
  for (cv_itr = g_sim.Indicator.controls.control_value_array.begin(); cv_itr != g_sim.Indicator.controls.control_value_array.end();
       cv_itr++) {
    map_itr = this->knowledge_base.system_decomposition_map.find((*cv_itr)->getDisplayName());
    if (map_itr == this->knowledge_base.system_decomposition_map.end()) {
      found_mismatch = true;
      name_list += (*cv_itr)->getDisplayName();
      name_list += ",\n";
    }
  }
  for (dcs_itr = g_sim.Indicator.indicators.component_state_array.begin();
       dcs_itr != g_sim.Indicator.indicators.component_state_array.end(); dcs_itr++) {
    map_itr = this->knowledge_base.system_decomposition_map.find((*dcs_itr)->getDisplayName());
    if (map_itr == this->knowledge_base.system_decomposition_map.end()) {
      found_mismatch = true;
      name_list += (*dcs_itr)->getDisplayName();
      name_list += ",\n";
    }
  }
  for (dsss_itr = g_sim.Indicator.indicators.support_systems_state_array.begin();
       dsss_itr != g_sim.Indicator.indicators.support_systems_state_array.end(); dsss_itr++) {
    map_itr = this->knowledge_base.system_decomposition_map.find((*dsss_itr)->getDisplayName());
    if (map_itr == this->knowledge_base.system_decomposition_map.end()) {
      found_mismatch = true;
      name_list += (*dsss_itr)->getDisplayName();
      name_list += ",\n";
    }
  }
  for (dpv_itr = g_sim.Indicator.indicators.parameter_value_array.begin();
       dpv_itr != g_sim.Indicator.indicators.parameter_value_array.end(); dpv_itr++) {
    map_itr = this->knowledge_base.system_decomposition_map.find((*dpv_itr)->getDisplayName());
    if (map_itr == this->knowledge_base.system_decomposition_map.end()) {
      found_mismatch = true;
      name_list += (*dpv_itr)->getDisplayName();
      name_list += ",\n";
    }
  }
  for (dhs_itr = g_sim.Indicator.indicators.heat_structure_array.begin();
       dhs_itr != g_sim.Indicator.indicators.heat_structure_array.end(); dhs_itr++) {
    map_itr = this->knowledge_base.system_decomposition_map.find((*dhs_itr)->getDisplayName());
    if (map_itr == this->knowledge_base.system_decomposition_map.end()) {
      found_mismatch = true;
      name_list += (*dhs_itr)->getDisplayName();
      name_list += ",\n";
    }
  }
  for (dpvr_itr = g_sim.Indicator.indicators.parameter_trend_array.begin();
       dpvr_itr != g_sim.Indicator.indicators.parameter_trend_array.end(); dpvr_itr++) {
    map_itr = this->knowledge_base.system_decomposition_map.find((*dpvr_itr)->getDisplayName());
    if (map_itr == this->knowledge_base.system_decomposition_map.end()) {
      found_mismatch = true;
      name_list += (*dpvr_itr)->getDisplayName();
      name_list += ",\n";
    }
  }
//output not found items
  if (found_mismatch) {
    cout << "Operator " << _operator
         << " The following ControlPanel elements do not exist in teh operators KB_OYY_System_Decomposition.txt file\n"
         << name_list << endl;
    ofstream fout("err messages.txt", ios::app);
    fout << r5pars_.timesno << "  Operator " << _operator
         << " The following ControlPanel elements do not exist in teh operators KB_OYY_System_Decomposition.txt file\n"
         << name_list;
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("Operator::checkCompletenessOfSystemDecomposition err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
  }
}
 
double Operator::checkItemRelevanceToCurrentDiagnosis(string _str) {
  map<string, KBSystemDecompositionUnit *>::const_iterator map_itr;
  KBSystemDecompositionUnit *sdu_pt;
  int number_of_functions, function_id, i;
  string function_name;
  double relevance = 0.0;
  if (_str == "Procedure") {
    // set relevance factor for procedure transfers to 0.5 (this results in a multiplier of 1.0)
    relevance = 0.5;
  } else {
    map_itr = this->knowledge_base.system_decomposition_map.find(_str);
    if (map_itr != this->knowledge_base.system_decomposition_map.end()) {
      sdu_pt = map_itr->second;
      number_of_functions = sdu_pt->getNumberOfRelatedSubsystem();
      for (i = 0; i < number_of_functions; i++) {
        function_id = sdu_pt->getRelatedSubsystem(i);
        function_name = this->knowledge_base.getAssociatedFunctionalDecompositionName(function_id);
        relevance = fmax(relevance, this->diagnosis_matrix.getEventRationalConfidence(function_name));
      }
    }
  }
  return relevance;
}
 
bool Operator::performAMentalProcedure(int _operator, string _in_use_procedure_name, string _in_use_step_name) {
  string _procedure_name, _step_name, diagnosis, str, str1;
  DecisionProcedureStep *procedure_pt = 0;
  BranchProcedureStep *b_procedure_pt;
  int state_of_activation;
  ProcedureStep *_procedure_step_pt;
  map<string, ProcedureStep *>::iterator procedure_map_itr;
//
  bool branch_generated = false;
  procedure_pt =
      this->memory.perceived_info.identifyTheMentalProcedureToBePerformed(_in_use_procedure_name, _in_use_step_name);
  if (procedure_pt == 0) {
    if (_operator == sim::Operator::ODM) {
      str = "OperatorDM::performAMentalProcedure: No mental procedure is found.";
      str1 = "OperatorDM::performAMentalProcedure err.";
    } else if (_operator == sim::Operator::OAT) {
      str = "OperatorAT::performAMentalProcedure: No mental procedure is found.";
      str1 = "OperatorAT::performAMentalProcedure err.";
    } else {
      str = "OperatorCT::performAMentalProcedure: No mental procedure is found.";
      str1 = "OperatorCT::performAMentalProcedure err.";
    }
    ofstream fout("err messages.txt", ios::app);
    cout << str << endl;
    fout << r5pars_.timesno << "  " << str << '\n';
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage(str1);
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  } else {
    state_of_activation = procedure_pt->getStateOfActivation();
    if (state_of_activation == sim::None) {
      procedure_pt->setStateOfActivation(sim::State::Active);
      _procedure_name = procedure_pt->getProcedureName();
      _step_name = procedure_pt->getStepName();
      b_procedure_pt = new BranchProcedureStep();
      b_procedure_pt->setSenderAndReceiver(_operator, _operator);//(sender, receiver)
      b_procedure_pt->setTimerAndProbability(0.0, 1.0 - this->hfe_bbn.getMentalProcedureFailureProbability());//(remaining time, probability)
      b_procedure_pt->setProcedureName(_procedure_name);
      b_procedure_pt->setStepName(_step_name);
      b_procedure_pt->setTypeOfPauseActivity(sim::Strategy::InstinctiveResponse);
      g_sim.Branch_center.addInstinctiveResponseProcedure(_operator, b_procedure_pt);
      branch_generated = true;
    } else {
      _procedure_name = procedure_pt->getProcedureName();
      _step_name = procedure_pt->getStepName();
      _procedure_name += _step_name;
      procedure_map_itr = g_sim.All_procedure.procedure_map.find(_procedure_name);
      if (procedure_map_itr != g_sim.All_procedure.procedure_map.end()) {
        _procedure_step_pt = procedure_map_itr->second;
        _procedure_step_pt->setStateOfActivation(sim::State::Active);
        branch_generated = _procedure_step_pt->oneThroughProcessForInstinctiveResponseProcedure(*this,
                                                                                                this->getSkipActionThreshold(),
                                                                                                this->getSkipNonResponseThreshold(),
                                                                                                this->getSkipInstinctiveResponseStep(),
                                                                                                this->memory);
        this->setSkipInstinctiveResponseStep(false);
        state_of_activation = _procedure_step_pt->getStateOfActivation();
        if (state_of_activation == sim::None || state_of_activation == sim::State::Done || state_of_activation == sim::State::Succeed) {
          //this->setPauseActivity(false);
          this->setPauseMentalProcedure(false);
          procedure_pt->setStateOfActivation(sim::State::Done);
        }
      } else {
        //the mental belief refers to an non-existing procedure
        procedure_pt->setStateOfActivation(sim::State::Done);
        //this->setPauseActivity(false);
        this->setPauseMentalProcedure(false);
      }
    }
 
  }
  return branch_generated;
}
 
bool Operator::performReasoningStrategy() {
  bool branch_generated = false;
  branch_generated =
      this->event_actions.onceThroughProcessForReasoningStrategy(*this, this->memory, this->diagnosis_matrix);
  return branch_generated;
}
 
void Operator::checkAndExecuteManeuverAction() {
  string action_name, sub_action_name;
  int sender, receiver;
  bool is_a_maneuver_action = false;
  this->maneuver_action.checkAndExecuteManeuverUnit(*this);
  for (auto &action_elem : g_sim.Communication_place.action) {
    action_name = action_elem->getActionName();
    if (action_name.size() > 9) {
      sub_action_name = action_name.substr(0, 9);
      sender = action_elem->getSender();
      receiver = action_elem->getIntendedReceiver();
      if (sub_action_name == "MANEUVER_" && receiver == this->type_of_operator) {
        if (sender == sim::Operator::OAT && receiver == sim::Operator::ODM) {
          // do nothing; OAT replies to ODM the starting of the maneuver control
        } else {
          this->maneuver_action.activateManeuverUnit(action_name);
        }
      }
    }
  }
}
void Operator::checkAndResetProcedureStep(BranchProcedureStep *_bps_pt) {
  // resets previous procedure step when procedure transfer is due to non-response action
  map<string, ProcedureStep *>::iterator procedure_map_itr;
  vector<unique_ptr<ProcedureStepUnit>>::iterator ps_unit_itr;
  string last_procedure_name, last_step_name, combined_name;
  string sub_str;
  int non_response_status, non_response_type;
  ProcedureStep *pps_pt = 0;
  bool found_ps_unit = false;
  bool next_is_a_functional_recovery_guideline = false;
  bool last_is_a_mental_procedure = false;
  bool next_is_a_mental_procedure = false;
  last_procedure_name = _bps_pt->getLastProcedureName();
  last_step_name = _bps_pt->getLastStepName();
  combined_name = last_procedure_name + last_step_name;
  procedure_map_itr = g_sim.All_procedure.procedure_map.find(combined_name);
  if (procedure_map_itr != g_sim.All_procedure.procedure_map.end()) {
    pps_pt = procedure_map_itr->second;
    ps_unit_itr = (*pps_pt).procedure_step_unit.begin();
    while (ps_unit_itr != (*pps_pt).procedure_step_unit.end() && !found_ps_unit) {
      non_response_status = (*ps_unit_itr)->getStateOfExpectation();
      non_response_type = (*ps_unit_itr)->getTypeOfNonResponseAction();
      if (non_response_status == sim::State::Failed && non_response_type == sim::Branch::Procedure) {
        found_ps_unit = true;
        pps_pt->resetStateOfActivation();
        // reset mental procedure status for last procedure step
        this->memory.perceived_info.setStateOfAProcedureStep(last_procedure_name, last_step_name, sim::State::Done);
        //
        // check if paper procedure status needs to be reset
        if (_bps_pt->getProcedureName().size() > 4) {
          sub_str = _bps_pt->getProcedureName().substr(0, 4);
          if (sub_str == "FRG_") {
            next_is_a_functional_recovery_guideline = true;
          }
        }
        if (_bps_pt->getProcedureName().size() > 5) {
          sub_str = _bps_pt->getProcedureName().substr(0, 5);
          if (sub_str == "MPBG_") {
            next_is_a_mental_procedure = true;
          }
        }
        if (last_procedure_name.size() > 5) {
          sub_str = last_procedure_name.substr(0, 5);
          if (sub_str == "MPBG_") {
            last_is_a_mental_procedure = true;
          }
        }
        if (last_is_a_mental_procedure && !next_is_a_mental_procedure && !next_is_a_functional_recovery_guideline) {
          for (auto& dps_elem : this->memory.perceived_info.procedure_step) {
            if (dps_elem->getStateOfActivation() == sim::State::Active || dps_elem->getStateOfActivation() == sim::None) {
              dps_elem->setStateOfActivation(sim::State::Interrupted);
            }
          }
          //this->memory.perceived_info.setStateOfAProcedureStep(_bps_pt->getProcedureName(), _bps_pt->getStepName(), sim::State::Active);
        }
        //
      }
      ps_unit_itr++;
    } // end while
  }
}
 
void Operator::interruptAllMentalProcedures() {
  ProcedureStep *procedure_step_ptr;
  map<string, ProcedureStep *>::iterator procedure_map_itr;
  string procedure_name, step_name;
  for (auto& mp_elem : this->memory.perceived_info.instinctive_response_procedure) {
    if (mp_elem->getStateOfActivation() != sim::State::Done) {
      mp_elem->setStateOfActivation(sim::State::Interrupted);
      // reset mental procedure state of activation
      procedure_name = mp_elem->getProcedureName();
      step_name = mp_elem->getStepName();
      procedure_name += step_name;
      procedure_map_itr = g_sim.All_procedure.procedure_map.find(procedure_name);
      if (procedure_map_itr != g_sim.All_procedure.procedure_map.end()) {
        procedure_step_ptr = procedure_map_itr->second;
        procedure_step_ptr->resetStateOfActivation();
      }
 
    }
  }
  this->setPauseMentalProcedure(false);
  this->setSkipInstinctiveResponseStep(false);
}
 
void Operator::interruptLowPriorityMentalProcedures() {
  ProcedureStep *procedure_step_ptr;
  map<string, ProcedureStep *>::iterator procedure_map_itr;
  string procedure_name, step_name;
  string active_procedure, active_step;
  active_procedure = this->memory.perceived_info.getCurrentInstinctiveResponseProcedureName();
  active_step = this->memory.perceived_info.getCurrentInstinctiveResponseProceduralStepName();
  for (auto& mp_elem : this->memory.perceived_info.instinctive_response_procedure) {
    if (mp_elem->getStateOfActivation() != sim::State::Done
        && mp_elem->getPriority() > this->getMentalProcedurePriorityThreshold()) {
      mp_elem->setStateOfActivation(sim::State::Interrupted);
      // reset mental procedure state of activation
      procedure_name = mp_elem->getProcedureName();
      step_name = mp_elem->getStepName();
      if (procedure_name == active_procedure && step_name == active_step) {
        // reset pause and skip flags if active instinctive response procedure is low priority
        this->setPauseMentalProcedure(false);
        this->setSkipInstinctiveResponseStep(false);
      }
      procedure_name += step_name;
      procedure_map_itr = g_sim.All_procedure.procedure_map.find(procedure_name);
      if (procedure_map_itr != g_sim.All_procedure.procedure_map.end()) {
        procedure_step_ptr = procedure_map_itr->second;
        procedure_step_ptr->resetStateOfActivation();
      }
 
    }
  }
}
 
void Operator::ActiveFetchParameterValueInfo(string _name, int _timer) {
  if (this->m_RM) this->m_RM->AddDeltaToCognitiveLoad(0.12);
  BranchExpectedParameterValue *Expected_Par_pt;
  Expected_Par_pt = new BranchExpectedParameterValue;
  Expected_Par_pt->setInfoName(_name);
  Expected_Par_pt->setDisplayName(_name);
  Expected_Par_pt->setTimeRequiredForCheckingThisDisplay(_timer);
  Expected_Par_pt->setSender(this->type_of_operator);
  Expected_Par_pt->setIntendedReceiver(sim::Source::Plant);
  Expected_Par_pt->setTimerAndProbability(_timer, 1.0 - this->hfe_bbn.getGatherStateInfoFailureProbability());
  //To be continued
  g_sim.Branch_center.addParameterValue(this->type_of_operator, Expected_Par_pt);
 
}
 
void Operator::ActiveFetchComponentStateInfo(string _name, int _timer) {
  if (this->m_RM) this->m_RM->AddDeltaToCognitiveLoad(0.12);
  BranchExpectedComponentState *B_C_pt;
  B_C_pt = new BranchExpectedComponentState;
  B_C_pt->setInfoName(_name);
  B_C_pt->setDisplayName(_name);
  B_C_pt->setTimeRequiredForCheckingThisDisplay(_timer);
  B_C_pt->setSender(this->type_of_operator);
  B_C_pt->setIntendedReceiver(sim::Source::Plant);
  B_C_pt->setTimerAndProbability(_timer, 1.0 - this->hfe_bbn.getGatherStateInfoFailureProbability());
 
  g_sim.Branch_center.addComponentState(this->type_of_operator, B_C_pt);
}
//
void Operator::ActiveFetchSupportSystemStateInfo(string _name, int _timer) {
  if (this->m_RM) this->m_RM->AddDeltaToCognitiveLoad(0.12);
  BranchExpectedSupportSystemState *B_SS_pt;
  B_SS_pt = new BranchExpectedSupportSystemState;
  B_SS_pt->setInfoName(_name);
  B_SS_pt->setDisplayName(_name);
  B_SS_pt->setTimeRequiredForCheckingThisDisplay(_timer);
  B_SS_pt->setSender(this->type_of_operator);
  B_SS_pt->setIntendedReceiver(sim::Source::Plant);
  B_SS_pt->setTimerAndProbability(_timer, 1.0 - this->hfe_bbn.getGatherStateInfoFailureProbability());
 
  g_sim.Branch_center.addSupportSystemState(this->type_of_operator, B_SS_pt);
}
 
void Operator::ActiveFetchAlarmStateInfo(string _name, int _timer) {
  if (this->m_RM) this->m_RM->AddDeltaToCognitiveLoad(0.12);
  BranchExpectedAlarmState *A_C_pt;
  A_C_pt = new BranchExpectedAlarmState;
  A_C_pt->setInfoName(_name);
  A_C_pt->setAlarmName(_name);
  A_C_pt->setTimeRequiredToCheckThisAlarm(_timer);
  A_C_pt->setSender(this->type_of_operator);
  A_C_pt->setIntendedReceiver(sim::Source::Plant);
  A_C_pt->setTimerAndProbability(_timer, 1.0 - this->hfe_bbn.getGatherStateInfoFailureProbability());
  g_sim.Branch_center.addAlarmState(this->type_of_operator, A_C_pt);
 
}
 
void Operator::PrintMessage(string str) {
  cout << "      " << r5pars_.timesno << "  " << str << '\n';
 
  //test
  ofstream fout("RMI.txt", ios::app);
  fout << "Time: " << r5pars_.timesno << "  " << str << '\n';
  fout.close();
}
 
void Operator::updateEvidenceForAllPSFs() {
  // Adjust for perceived system criticality
  double system_criticality = this->scanned_indicators.getSystemCriticalitySensitivity() * this->safety_parameters.getSPDSValue();
  // Normalize system criticality
  this->hfe_bbn.setSystemCriticality(system_criticality/10);
 
  // Adjust for perceived information load
  double information_load = this->scanned_indicators.getInfoLoadSensitivity() * this->information_load.getInfoLoadPIFValue();
  // Normalize information load
  this->hfe_bbn.setInformationLoad(information_load/10);
 
  double time_constraint_load = this->time_constrained_load.getTimeConstrainedPIFValue();
  // Normalize information load
  this->hfe_bbn.setTimeConstraintLoad(time_constraint_load/10);
 
//  if (m_RM != nullptr) {
//    double cognitive_task_load = m_RM->m_cognitive_load;
//    this->hfe_bbn.setCognitiveTaskLoad(cognitive_task_load);
//    double passive_alarm_load = m_RM->m_passive_alarm_load->m_alarm_load_value;
//    this->hfe_bbn.setPassiveAlarmLoad(passive_alarm_load);
//    double task_complexity = m_RM->m_diagnosis_complexity;
//    this->hfe_bbn.setTaskComplexity(task_complexity);
//    double expert_level = m_RM->m_expert_level;
//    this->hfe_bbn.setExpertise(expert_level);
//    double stress = m_RM->m_overall_stress;
//    this->hfe_bbn.setStress(stress);
//    double fatigue = m_RM->m_fatigue_level;
//    this->hfe_bbn.setFatigue(fatigue);
//    int problem_solving_style = m_RM->m_problem_solving_style;
//    switch(problem_solving_style) {
//      case 0 : this->hfe_bbn.setProblemSolvingStyle(0);
//        break;
//      case 1 : this->hfe_bbn.setProblemSolvingStyle(0.1);
//        break;
//      case 2 : this->hfe_bbn.setProblemSolvingStyle(1.0);
//        break;
//      case 3 : this->hfe_bbn.setProblemSolvingStyle(0.5);
//        break;
//      case 4 : this->hfe_bbn.setProblemSolvingStyle(0.25);
//        break;
//    }
//  }
}