ProcedureStepUnit.cpp

Go to the documentation of this file.

// ProcedureStepUnit.cpp: implementation of the ProcedureStepUnit class.
//
 
#include "ProcedureStepUnit.h"
#include <sstream>
#include <boost/serialization/export.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(ProcedureStepUnit)
#include "ProcedureExpectedAlarmStateUnit.h"
#include "ProcedureExpectedComponentStateUnit.h"
#include "ProcedureExpectedParameterValueUnit.h"
#include "ProcedureExpectedParameterDifferenceUnit.h"
#include "../ControlPanel/ControlPanel.h"
#include "../Crew/OperatorDM.h"
#include "../Crew/OperatorAT.h"
#include "Procedures.h"
#include "ProcedureExpectedSupportSystemStateUnit.h"
#include "../Global/SimulationContext.h"
using namespace std;
 
 
// Construction/Destruction
 
ProcedureStepUnit::ProcedureStepUnit() {
  type_of_action = sim::State::Unknown;
  type_of_non_response_action = sim::State::Unknown;
  state_of_action = sim::None;
  state_of_non_response_action = sim::None;
  state_of_expectation = sim::None;
}
ProcedureStepUnit::~ProcedureStepUnit() {
}
 
double ProcedureStepUnit::calculateDynamicHEPMultiplier(int _operator,
                                                        string _action_name,
                                                        AnalysisProcedureDataContainerUnit &_apdcu) {
  double multiplier = 1.0;
  double time_load_PIF, time_factor;
  double action_relevance, relevance_factor;
  double dynamic_multiplier = 1.0;
  //
  // get operator specific dynamic factors
  switch (_operator) {
    case sim::Operator::ODM: time_load_PIF = g_sim.Decision_Maker.time_constrained_load.getTimeConstrainedPIFValue();
      action_relevance = g_sim.Decision_Maker.checkItemRelevanceToCurrentDiagnosis(_action_name);
      break;
    case sim::Operator::OAT: time_load_PIF = g_sim.Action_Taker.time_constrained_load.getTimeConstrainedPIFValue();
      action_relevance = g_sim.Action_Taker.checkItemRelevanceToCurrentDiagnosis(_action_name);
      break;
    default: break;
  }
  //
  // calculate relevance factor
  if (action_relevance > 0.0) {
    relevance_factor = 10.0 * pow(10.0, -2.0 * action_relevance);
    relevance_factor = fmin(relevance_factor, 10.0);
    relevance_factor = fmax(relevance_factor, 0.1);
  } else {
    relevance_factor = 10.0;
  }
  //
  // calculate time constrained load factor
  if (time_load_PIF > 1.0) {
    time_factor = time_load_PIF;
    time_factor = fmin(time_factor, 10.0);
    time_factor = fmax(time_factor, 1.0);
  } else {
    time_factor = pow(10.0, time_load_PIF - 1.0);
    time_factor = fmin(time_factor, 1.0);
    time_factor = fmax(time_factor, 0.1);
  }
 
  dynamic_multiplier = relevance_factor * time_factor;
  dynamic_multiplier = fmin(dynamic_multiplier, 100.0);
  dynamic_multiplier = fmax(dynamic_multiplier, 0.01);
  //
  _apdcu.setActionRelevance(relevance_factor);
  _apdcu.setTimePIF(time_factor);
  _apdcu.setDynamicMultiplier(dynamic_multiplier);
  //
  return dynamic_multiplier;
}
 
double ProcedureStepUnit::calculateAdjustedSkipProbability(double _skip, double _psf) {
  double adjusted_skip_prob;
  _psf = fmax(_psf, 0.01);   // limit minimum _psf value
  _psf = fmin(_psf, 500.0);  // limit maximum _psf value
  if (_psf > 1.0) {          // calculate adjusted skip probability - Based on SPAR-H method in NUREG/CR-6883
    adjusted_skip_prob = _skip * _psf / (_skip * (_psf - 1.0) + 1.0);
  } else {
    adjusted_skip_prob = _skip * _psf;
  }
  return adjusted_skip_prob;
}
 
int ProcedureStepUnit::checkForTypeOfExpectation(string _object_name) {
  int n_return;
  DisplayType n_temp;
  string sub_str;
  SystemDisplay *sd_pt;
  map<string, SystemAlarm *>::iterator alarm_map_itr;
  map<string, SystemDisplay *>::iterator display_map_itr;
  map<string, SystemControl *>::iterator control_map_itr;
  n_return = sim::State::Unknown;
  alarm_map_itr = g_sim.Indicator.alarms.alarm_map.find(_object_name);
  if (alarm_map_itr != g_sim.Indicator.alarms.alarm_map.end()) {//check whether is an alarm
    n_return = sim::Comm::AlarmState;
    return n_return;
  }
  display_map_itr = g_sim.Indicator.indicators.display_map.find(_object_name);
  if (display_map_itr
      != g_sim.Indicator.indicators.display_map.end()) {//check wether is a control panel component stat eor parameter value
    sd_pt = display_map_itr->second;
    n_temp = sd_pt->getTypeOfDisplay();
    if (n_temp == DisplayType::ComponentState) {
      n_return = sim::Comm::ComponentState;
    } else if (n_temp == DisplayType::SupportSystemState) {
      n_return = sim::Comm::SupportSystemState;
    } else if (n_temp == DisplayType::ParameterValue || n_temp == DisplayType::HeatStructure
        || n_temp == DisplayType::ParameterTrend) {
      n_return = sim::Comm::ParameterValue;
    }
      //
    else {
      ofstream fout("err messages.txt", ios::app);
      cout << "ProcedureStepUnit::checkForTypeOfExpectation obj: " << _object_name << " Type of display:" << static_cast<int>(n_temp)
           << " cannot be recognized" << endl;
      fout << r5pars_.timesno << "  ProcedureStepUnit::checkForTypeOfExpectation obj: " << _object_name
           << " Type of display:" << static_cast<int>(n_temp) << " cannot be recognized\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("ProcedureStepUnit::checkForTypeOfExpectation err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
    }
    return n_return;
  }
  if (_object_name == "Mental_Belief") {
    n_return = sim::Branch::MentalBelief;
  } else if (_object_name == "Parameter_Difference") {
    n_return = sim::Comm::ParameterDifference;
  } else {
    ofstream fout("err messages.txt", ios::app);
    cout << "ProcedureStepUnit::checkForTypeOfExpectation: Obj_name: " << _object_name << " cannot be recognized"
         << endl;
    fout << r5pars_.timesno << "  ProcedureStepUnit::checkForTypeOfExpectation: Obj_name: " << _object_name
         << " cannot be recognized\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("ProcedureStepUnit::checkForTypeOfExpectation err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
  return n_return;
}
void ProcedureStepUnit::setTypeOfAction(int n) { type_of_action = n; }
void ProcedureStepUnit::setTypeOfNonResponseAction(int n) { type_of_non_response_action = n; }
int ProcedureStepUnit::getTypeOfAction() { return type_of_action; }
int ProcedureStepUnit::getTypeOfNonResponseAction() { return type_of_non_response_action; }
void ProcedureStepUnit::setActionPtr(ProcedureActionUnit *pt) { action.reset(pt); }
ProcedureActionUnit *ProcedureStepUnit::getActionPtr() { return action.get(); }
ProcedureStepInfo *ProcedureStepUnit::getMentalProcedurePtr() { return mental_procedure.get(); }
ProcedureScannedParameterUnit *ProcedureStepUnit::getScannedParameterUnitPtr() { return scanned_parameter.get(); }
bool ProcedureStepUnit::hasNonResponseAction() const {
  return non_response_action_unit || non_response_procedure || non_response_scan;
}
bool ProcedureStepUnit::checkIfIsChangeSystemAction(string _object_name) {
  bool b_return;
  map<string, SystemControl *>::iterator control_map_itr;
  control_map_itr = g_sim.Indicator.controls.control_map.find(_object_name);
  if (control_map_itr != g_sim.Indicator.controls.control_map.end()) {
    b_return = true;
  } else {
    b_return = false;
  }
  return b_return;
}
void ProcedureStepUnit::setStateOfNonResponseAction(int n) { state_of_non_response_action = n; }
int ProcedureStepUnit::getStateOfNonResponseAction() { return state_of_non_response_action; }
bool ProcedureStepUnit::readInfofromFile(ifstream &fin) {
  int n_expectation;
  n_expectation = this->readInfofromFileAction(fin);
  if (this->getTypeOfAction() != sim::Branch::ProcedureTransfer) {
    this->readInfofromFileExpectation(fin, n_expectation);
    if (this->readInfoFromFileNonResponseExit(fin) == false) { return false; }
  }
  return true;
}
int ProcedureStepUnit::readInfofromFileAction(ifstream &fin) {
  string str_obj;
  int n_expectation, obj_type;
  double minimum_time, alpha_weibull, beta_weibull, act_value;
  double a_beta, b_beta;
  bool is_a_maneuver_action = false;
  string sub_action_name, control_parameter_name;
  n_expectation = 0;
  //action body
  fin >> str_obj;
  if (str_obj == "0") {//procedure transfer
    action = make_unique<ProcedureActionUnit>();
    action->setInfoName("PROCEDURE_TRANSFER");
    type_of_action = sim::Branch::ProcedureTransfer;
    return n_expectation;
  } else if (str_obj == "Do_And_Return") {//need to verify
    mental_procedure = make_unique<ProcedureStepInfo>();
    mental_procedure->readInfoFromFile(fin);
    type_of_action = sim::Branch::MentalBelief;
  } else if (str_obj == "SCAN") { //add parameter to scan queue
    scanned_parameter = make_unique<ProcedureScannedParameterUnit>();
    n_expectation = scanned_parameter->readInfoFromFile(fin);
    type_of_action = sim::ControlAction::ParameterScan;
    return n_expectation;
  } else {
    action = make_unique<ProcedureActionUnit>();
    fin >> obj_type;
    if (obj_type == sim::ControlAction::ParameterControl) {
      fin >> minimum_time >> alpha_weibull >> beta_weibull
          >> control_parameter_name
          >> a_beta >> b_beta >> n_expectation;
      action->setParameterName(control_parameter_name);
      type_of_action = sim::ControlAction::ParameterControl;
    } else {
      // obj_type is of type sim::ControlAction::Additive, sim::Action::Action, or sim::Branch::Verify
      fin >> minimum_time >> alpha_weibull >> beta_weibull
          >> act_value
          >> a_beta >> b_beta >> n_expectation;
      if (str_obj.size() > 9) {
        sub_action_name = str_obj.substr(0, 9);
        if (sub_action_name == "MANEUVER_") {
          is_a_maneuver_action = true;
        }
      }
      if (checkIfIsChangeSystemAction(str_obj) && obj_type != sim::Branch::Verify) {
        action->setControlValue(act_value);
        if (obj_type == sim::ControlAction::Additive) {
          type_of_action = sim::ControlAction::Additive;
        } else {
          type_of_action = sim::Action::Action;
        }
      } else if (is_a_maneuver_action) {
        action->setControlValue(act_value);
        type_of_action = sim::State::Control;
      }
        //else if (obj_type == sim::ControlAction::ParameterScan) {
        //  action->setControlValue(act_value); //control value is priority for scanned parameter
        //  type_of_action = sim::ControlAction::ParameterScan;
        //}
      else {
        //
        type_of_action = sim::State::Waiting;
      }
    }
    //
    // set control name
 
    action->setInfoName(str_obj);
    //
    // set timing parameters (three parameter Weibull Distribution)
    action->setT_Minimum(minimum_time);
    action->setAlpha_Weibull(alpha_weibull);
    action->setBeta_Weibull(beta_weibull);
    //
    // set Beta Distribution parameters for skipped steps
    action->setAlpha_Parameter(a_beta);
    action->setBeta_Parameter(b_beta);
    //
  }
  return n_expectation;
}
void ProcedureStepUnit::readInfofromFileExpectation(ifstream &fin, int n_expectation) {
  string str_obj;
  int obj_type, i_temp;
  ProcedureExpectedAlarmStateUnit *alarm_pt;
  ProcedureExpectedComponentStateUnit *comp_pt;
  ProcedureExpectedSupportSystemStateUnit *ss_pt;
  ProcedureExpectedParameterValueUnit *par_val_pt;
  ProcedureExpectedParameterDifferenceUnit *par_dif_pt;
  ExpectationORUnit *exp_or_pt;
  ExpectedMentalBelief *mp_pt;
  ProcedureExpectORLink *or_pt;
  ExpectationElement *exp_pt;
 
//
  for (i_temp = 0; i_temp < n_expectation; i_temp++) {
    auto exp_or_uptr = make_unique<ExpectationORUnit>();
    exp_or_pt = exp_or_uptr.get();
    expectation.push_back(std::move(exp_or_uptr));
    do {
      fin >> str_obj;
      obj_type = this->checkForTypeOfExpectation(str_obj);
      if (obj_type == sim::Comm::AlarmState) {
        alarm_pt = new ProcedureExpectedAlarmStateUnit();
        alarm_pt->readInfoFromFileWithoutInfoName(fin);
        alarm_pt->setInfoName(str_obj);
        alarm_pt->setTypeOfExpectation(obj_type);
        exp_pt = (ExpectationElement *) alarm_pt;
        or_pt = (ProcedureExpectORLink *) alarm_pt;
        exp_or_pt->add(exp_pt);
      } else if (obj_type == sim::Comm::ComponentState) {
        comp_pt = new ProcedureExpectedComponentStateUnit();
        comp_pt->readInfoFromFileWithoutInfoName(fin);
        comp_pt->setInfoName(str_obj);
        comp_pt->setTypeOfExpectation(obj_type);
        exp_pt = (ExpectationElement *) comp_pt;
        or_pt = (ProcedureExpectORLink *) comp_pt;
        exp_or_pt->add(exp_pt);
      } else if (obj_type == sim::Comm::SupportSystemState) {
        ss_pt = new ProcedureExpectedSupportSystemStateUnit();
        ss_pt->readInfoFromFileWithoutInfoName(fin);
        ss_pt->setInfoName(str_obj);
        ss_pt->setTypeOfExpectation(obj_type);
        exp_pt = (ExpectationElement *) ss_pt;
        or_pt = (ProcedureExpectORLink *) ss_pt;
        exp_or_pt->add(exp_pt);
      } else if (obj_type == sim::Comm::ParameterValue || obj_type == sim::Comm::ParameterTrend) {
        par_val_pt = new ProcedureExpectedParameterValueUnit();
        par_val_pt->readInfoFromFileWithoutInfoName(fin);
        par_val_pt->setInfoName(str_obj);
        par_val_pt->setTypeOfExpectation(obj_type);
        exp_pt = (ExpectationElement *) par_val_pt;
        or_pt = (ProcedureExpectORLink *) par_val_pt;
        exp_or_pt->add(exp_pt);
      } else if (obj_type == sim::Branch::MentalBelief) {
        mp_pt = new ExpectedMentalBelief();
        mp_pt->readInfoFromFile(fin);
        mp_pt->setTypeOfExpectation(obj_type);
        exp_pt = (ExpectationElement *) mp_pt;
        or_pt = (ProcedureExpectORLink *) mp_pt;
        exp_or_pt->add(exp_pt);
      } else if (obj_type == sim::Comm::ParameterDifference) {
        par_dif_pt = new ProcedureExpectedParameterDifferenceUnit();
        par_dif_pt->readInfoFromFile(fin);
        par_dif_pt->setTypeOfExpectation(obj_type);
        exp_pt = (ExpectationElement *) par_dif_pt;
        or_pt = (ProcedureExpectORLink *) par_dif_pt;
        exp_or_pt->add(exp_pt);
      } else {//parmeter trend and parameter state are not provided currently
        ofstream fout("err messages.txt", ios::app);
        cout << "ProcedureStepUnit::readInfofromFile: expectation body obj_type:" << obj_type << " cannot be recognized"
             << endl;
        fout << r5pars_.timesno << "  ProcedureStepUnit::readInfofromFile: expectation body obj_type:" << obj_type
             << " cannot be recognized\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("ProcedureStepUnit::readInfofromFile err.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
      }
    } while (or_pt->getORLink() == sim::Bool::Yes);
  }
}
bool ProcedureStepUnit::readInfoFromFileNonResponseExit(ifstream &fin) {
  string str_obj, str1, str2, control_parameter_name;
  double minimum_time, alpha_weibull, beta_weibull, act_value;
  double a_beta, b_beta;
  int obj_type, n;
  ProcedureStepInfo *procedure_pt;
  ProcedureActionUnit *act_pt;
  ProcedureScannedParameterUnit *scan_par_pt;
  fin >> obj_type;
  type_of_non_response_action = obj_type;
  if (obj_type == sim::Branch::Procedure) {
    procedure_pt = new ProcedureStepInfo();
    fin >> str1 >> str2 >> a_beta >> b_beta;
    procedure_pt->setProcedureName(str1);
    procedure_pt->setStepName(str2);
    //
    // set Beta Distribution parameters for skipped steps
    procedure_pt->setAlpha_Parameter(a_beta);
    procedure_pt->setBeta_Parameter(b_beta);
    //
    non_response_procedure.reset(procedure_pt);
  } else if (obj_type == sim::Action::Action || obj_type == sim::ControlAction::Additive) {
    act_pt = new ProcedureActionUnit();
    fin >> str_obj >> n >> minimum_time >> alpha_weibull >> beta_weibull
        >> act_value >> a_beta >> b_beta;
    act_pt->setInfoName(str_obj);
    //act_pt->setBothTotalTimeRequiredAndRemainingTime(remaining_time);
    //
    // set timing parameters (three parameter Weibull Distribution)
    act_pt->setT_Minimum(minimum_time);
    act_pt->setAlpha_Weibull(alpha_weibull);
    act_pt->setBeta_Weibull(beta_weibull);
    //
    // set Beta Distribution parameters for skipped steps
    act_pt->setAlpha_Parameter(a_beta);
    act_pt->setBeta_Parameter(b_beta);
    //
    act_pt->setControlValue(act_value);
    non_response_action_unit.reset(act_pt);
  } else if (obj_type == sim::ControlAction::ParameterControl) {
    act_pt = new ProcedureActionUnit();
    fin >> str_obj
        >> minimum_time >> alpha_weibull >> beta_weibull
        >> control_parameter_name
        >> a_beta >> b_beta;
    act_pt->setInfoName(str_obj);
    //
    // set timing parameters (three parameter Weibull Distribution)
    act_pt->setT_Minimum(minimum_time);
    act_pt->setAlpha_Weibull(alpha_weibull);
    act_pt->setBeta_Weibull(beta_weibull);
    //
    // set Beta Distribution parameters for skipped steps
    act_pt->setAlpha_Parameter(a_beta);
    act_pt->setBeta_Parameter(b_beta);
    //
    act_pt->setParameterName(control_parameter_name);
    non_response_action_unit.reset(act_pt);
  } else if (obj_type == sim::ControlAction::ParameterScan) {
    int parameter_type, priority;
    scan_par_pt = new ProcedureScannedParameterUnit();
    fin >> str_obj
        >> parameter_type
        >> priority
        >> minimum_time >> alpha_weibull >> beta_weibull
        >> a_beta >> b_beta;
    scan_par_pt->setInfoName(str_obj);
    scan_par_pt->setTypeOfScannedParameter(parameter_type);
    scan_par_pt->setScanPriority(priority);
    //set timing parameters
    scan_par_pt->setT_Minimum(minimum_time);
    scan_par_pt->setAlpha_Weibull(alpha_weibull);
    scan_par_pt->setBeta_Weibull(beta_weibull);
    //set beta distribution parameters
    scan_par_pt->setAlpha_Parameter(a_beta);
    scan_par_pt->setBeta_Parameter(b_beta);
    //
    non_response_scan.reset(scan_par_pt);
  } else if (obj_type == sim::ControlAction::Stop) {   //stop current scenario
  } else if (obj_type == sim::Strategy::Advise) { //ask for advice
  } else if (obj_type == sim::None) {   //no non-response exit
  } else {
    ofstream fout("err messages.txt", ios::app);
    cout << "ProcedureStepUnit::readinfoFromFileNonResponseExit obj_type:" << obj_type << " cannot be recognized"
         << endl;
    fout << r5pars_.timesno << "  ProcedureStepUnit::readinfoFromFileNonResponseExit exit obj_type:" << obj_type
         << " cannot be recognized\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("ProcedureStepUnit::readInfofromFile err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return false;
  }
  return true;
}
void ProcedureStepUnit::copyProcedureStepUnit(ProcedureStepUnit &_psu) {
  ProcedureStepInfo *procedure_pt, *procedure_pt1;
  ProcedureActionUnit *act_pt, *act_pt1;
  ProcedureScannedParameterUnit *scan_pt, *scan_pt1;
  this->copyStateOfActivation(_psu);
  type_of_action = _psu.getTypeOfAction();
  type_of_non_response_action = _psu.getTypeOfNonResponseAction();
  state_of_action = _psu.getStateOfAction();
  state_of_non_response_action = _psu.getStateOfNonResponseAction();
  state_of_expectation = _psu.getStateOfExpectation();
  if (_psu.getActionPtr() != 0) {
    action = make_unique<ProcedureActionUnit>();
    action->copyProcedureActionUnit(*_psu.action);
  }
  if (_psu.getMentalProcedurePtr() != 0) {
    mental_procedure = make_unique<ProcedureStepInfo>();
    mental_procedure->copyProcedureStepInfo(*_psu.mental_procedure);
  }
  if (_psu.getScannedParameterUnitPtr() != 0) {
    scanned_parameter = make_unique<ProcedureScannedParameterUnit>();
    scanned_parameter->copyProcedureScannedParameterUnit(*_psu.scanned_parameter);
  }
  if (_psu.hasNonResponseAction()) {
    if (type_of_non_response_action == sim::Branch::Procedure) {
      procedure_pt = new ProcedureStepInfo();
      procedure_pt1 = _psu.non_response_procedure.get();
      procedure_pt->copyProcedureStepInfo(*procedure_pt1);
      non_response_procedure.reset(procedure_pt);
    } else if (type_of_non_response_action == sim::Action::Action || type_of_non_response_action == sim::ControlAction::Additive
        || type_of_non_response_action == sim::ControlAction::ParameterControl) {
      act_pt = new ProcedureActionUnit();
      act_pt1 = _psu.non_response_action_unit.get();
      act_pt->copyProcedureActionUnit(*act_pt1);
      non_response_action_unit.reset(act_pt);
    } else if (type_of_non_response_action == sim::ControlAction::ParameterScan) {
      scan_pt = new ProcedureScannedParameterUnit();
      scan_pt1 = _psu.non_response_scan.get();
      scan_pt->copyProcedureScannedParameterUnit(*scan_pt1);
      non_response_scan.reset(scan_pt);
    } else {}
  }
  for (auto& src : _psu.expectation) {
    auto ptr = make_unique<ExpectationORUnit>();
    ptr->copyExpectationORUnit(*src);
    expectation.push_back(std::move(ptr));
  }
  serialized_expectation_count = _psu.serialized_expectation_count;
};
 
void ProcedureStepUnit::setStateOfAction(int n) { state_of_action = n; }
int ProcedureStepUnit::getStateOfAction() { return state_of_action; }
 
bool ProcedureStepUnit::executeAction(Operator &_operator,
                                      ShortTermMemory &_stm,
                                      int _entry,
                                      string message,
                                      string _procedure_name,
                                      string _step_name,
                                      double _skip_threshold,
                                      double _static_HEP_factor) {
  bool branch_generated = false;
  bool is_a_mental_procedure = false;
  bool next_is_a_mental_procedure = false;
  bool next_is_a_functional_recovery_guideline = false;
  bool generate_control_branches = false;
  int i, j, num_of_time_branches, num_of_control_branches;
  AnalysisProcedureDataContainerUnit procedure_step_info;
  string str, sub_str, str_prob;
  double control_value, skip_probability, control_probability;
  double delta_cdf, cdf_lower, cdf_upper;
  double time = 0.0;
  double HEP_multiplier = 1.0;
  //double actual_time_for_action;
  BranchProcedureStep *b_procedure_pt = 0;
  BranchProcedureActionTimeUnit *tu_pt = 0;
  BranchProcedureControlValueUnit *cvu_pt = 0;
  SystemControl *sc_ptr = 0;
  ControlValue *control_value_ptr = 0;
  MentalParameterValue *mpv_pt = 0;
  int receiver = sim::Operator::OAT;
  if (_operator.getTypeOfOperator() == sim::Operator::OAT) receiver = sim::Source::Plant;
  BranchAction *b_action_pt;
  BranchScannedParameter *b_scan_pt;
  state_of_action = sim::State::Succeed;
  str = _procedure_name;
  if (str.size() > 5) {
    sub_str = str.substr(0, 5);
    if (sub_str == "MPBG_") {
      is_a_mental_procedure = true;
    }
  }
  if (type_of_action == sim::Action::Action || type_of_action == sim::State::Control ||
      type_of_action == sim::ControlAction::Additive || type_of_action == sim::ControlAction::ParameterControl) {
    // calculate probability of skipping step
    skip_probability = action->calculateProbability();  // calculate probability of skipping a step
    //
    HEP_multiplier *= this->calculateDynamicHEPMultiplier(_operator.getTypeOfOperator(), action->getInfoName(), procedure_step_info);
    HEP_multiplier *= _static_HEP_factor;
    skip_probability = this->calculateAdjustedSkipProbability(skip_probability, HEP_multiplier);
    // Use the Dynamic BBN
    skip_probability = _operator.hfe_bbn.getProcedureStepFailureProbability();
    procedure_step_info.setTime(r5pars_.timesno);
    procedure_step_info.setOperatorID(_operator.getTypeOfOperator());
    procedure_step_info.setActionName(action->getInfoName());
    procedure_step_info.setProcedureName(_procedure_name);
    procedure_step_info.setProcedureStep(_step_name);
    procedure_step_info.setStaticMultiplier(_static_HEP_factor);
    procedure_step_info.setSkipProbability(skip_probability);
    g_sim.Aux_info.addProcedureData(procedure_step_info);
    //
//    if (skip_probability < _skip_threshold)           // reset probability to 1.0 if step is not skipped
//    {
//      skip_probability = 0.0;
//    }
    // determine if multiple time branches will be generated
    tu_pt = g_sim.Branch_center.source_of_procedure_time_branches.checkToGenerateActionTimeBranches(_procedure_name,
                                                                                              _step_name,
                                                                                              action->getInfoName());
    if (tu_pt != 0) {
      num_of_time_branches = tu_pt->getNumOfBranches();
    } else {
      num_of_time_branches = 1;
    }
    //
    // determine if muliple control value branches will be generated
    cvu_pt = g_sim.Branch_center.control_value_branches.checkToGenerateControlValueBranches(_procedure_name,
                                                                                      _step_name,
                                                                                      action->getInfoName());
    if (cvu_pt != 0) {
      num_of_control_branches = cvu_pt->getNumberOfBranches();
      generate_control_branches = true;
    } else {
      num_of_control_branches = 1;
    }
    //
    for (j = 0; j < num_of_control_branches; j++) {
      if (generate_control_branches) {
        control_probability = cvu_pt->probabilities.at(j);
      } else {
        control_probability = 1.0;
      }
      // set control value
      if (type_of_action == sim::ControlAction::ParameterControl)   // set control equal to perceived parameter value
      {
        mpv_pt = _stm.perceived_info.checkExistanceOfPerceivedParameterValue(action->getParameterName());
        sc_ptr = g_sim.Indicator.controls.getControlFromMap(action->getInfoName());
        if (sc_ptr != 0) {
          control_value_ptr = (ControlValue *) sc_ptr;
          if (mpv_pt != 0 && sc_ptr->getTypeOfControl() == DisplayType::ControlValue) {
            if (generate_control_branches) {
              control_value = cvu_pt->control_values.at(j);
            } else {
              control_value = mpv_pt->getObservedParameterValue();
            }
            control_value = fmin(control_value, control_value_ptr->getValueForOnOrFullyOpen());
            control_value = fmax(control_value, control_value_ptr->getValueForOffOrFullyClose());
          } else   // control parameter has not been perceived, do not change control value
          {
            control_value = control_value_ptr->getControlValue();
            //
            ofstream fout("err messages.txt", ios::app);
            cout << "ProcedureStepUnit::executeAction - Parameter: " << action->getParameterName()
                 << " can not be recognized" << endl;
            fout << r5pars_.timesno << "  ProcedureStepUnit::executeAction - Parameter: " << action->getParameterName()
                 << " can not be recognized\n";
            fout.close();
          }
        } else {
          ofstream fout("err messages.txt", ios::app);
          cout << "ProcedureStepUnit::executeAction - Control: " << action->getInfoName() << " can not be recognized"
               << endl;
          fout << r5pars_.timesno << "  ProcedureStepUnit::executeAction - Control: " << action->getInfoName()
               << " can not be recognized\n";
          fout.close();
          r5pars_.sim_err = true;
          g_sim.Branch_center.setTempESMessage("DiagnosisActionModule::onceThroughProcessForReasoningStrategy error");
          g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
        }
      } else {
        if (generate_control_branches) {
          control_value = cvu_pt->control_values.at(j);
        } else {
          control_value = action->getControlValue();
        }
        sc_ptr = g_sim.Indicator.controls.getControlFromMap(action->getInfoName());
        if (sc_ptr->getTypeOfControl() == DisplayType::ControlValue && type_of_action == sim::ControlAction::Additive) {
          control_value_ptr = (ControlValue *) sc_ptr;
          // Displayed control value may differ from actual control value due to perception filtering
          // control_value = control_value_ptr->getDisplayedControlValue();
          control_value += control_value_ptr->getControlValue();
          //control_value += action->getControlValue();
          // verify that control value does not exceeed component control range
          control_value = fmin(control_value, control_value_ptr->getValueForOnOrFullyOpen());
          control_value = fmax(control_value, control_value_ptr->getValueForOffOrFullyClose());
        }
      }
      //
      //
      delta_cdf = 1.0 / (double) num_of_time_branches;
      for (i = 0; i < num_of_time_branches; i++) {
        b_action_pt = new BranchAction();
        b_action_pt->setActionName(action->getInfoName());
        b_action_pt->setControlValue(control_value);
        if (type_of_action == sim::State::Control && is_a_mental_procedure) {//maneuver control initiated from a mental procedure
          b_action_pt->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
        } else {//maneuver control initiated by a paper procedure or regular actions
          b_action_pt->setSenderAndReceiver(_operator.getTypeOfOperator(), receiver);
        }
        //
        // calculate time required to perform action
        cdf_lower = delta_cdf * ((double) i);
        cdf_upper = delta_cdf * ((double) (i + 1));
        time = action->calculateMeanRequiredTime(cdf_lower, cdf_upper);
        b_action_pt->setActionTime(time);
        if (_operator.getTypeOfOperator() == sim::Operator::ODM && b_action_pt->getIntendedReceiver() == sim::Operator::OAT) {
          // set current time to sim::Operator::ODM communication time
          // the action_time will be used by the BranchProbability module to set plant interaction time
          time = g_sim.Decision_Maker.getNominalCommunicationTime();
        }
        b_action_pt->setTimerAndProbability(time,
                                            control_probability * (1.0 - skip_probability)
                                                / static_cast<double> (num_of_time_branches));
        b_action_pt->setMessage(message);
        b_action_pt->setTypeOfPauseActivity(_entry);
        g_sim.Branch_center.addAction(_operator.getTypeOfOperator(), b_action_pt);
        //
        //
        branch_generated = true;
      }    // end time branch "for loop"
    }  // end control value branch "for loop"
    // skip procedure step
    // check to verify probability for skipping is above threshold to minimize branch generation
    if (skip_probability > _skip_threshold) {
      b_action_pt = new BranchAction();
      b_action_pt->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
      //
      // set time delay for skipped step to 1.0 second
      b_action_pt->setTimerAndProbability(1.0, skip_probability);
      str = "WAITING:_Skipped_Step_" + action->getInfoName();
      b_action_pt->setActionName(str);
      std::ostringstream streamObj;
      streamObj << skip_probability;
      message += "_(skip probability_=" + streamObj.str() + "):_";
      b_action_pt->setMessage(message);
      b_action_pt->setStateOfActivation(sim::State::Skip);
      b_action_pt->setTypeOfPauseActivity(_entry);
      g_sim.Branch_center.addAction(_operator.getTypeOfOperator(), b_action_pt);
      branch_generated = true;
    }
  } else if (type_of_action == sim::Branch::MentalBelief) { // sub-module has not been verified
    //
    if (_entry == sim::Strategy::FollowInstruction) {
      _entry = sim::Strategy::InstinctiveResponse;
    }
    // determine if next procedure is a mental procedure
    if (mental_procedure->getProcedureName().size() > 5) {
      sub_str = mental_procedure->getProcedureName().substr(0, 5);
      if (sub_str == "MPBG_") {
        next_is_a_mental_procedure = true;
      }
    }
    //
    // determine if next procedure step is a functional recovery guideline
    if (mental_procedure->getProcedureName().size() > 4) {
      sub_str = mental_procedure->getProcedureName().substr(0, 4);
      if (sub_str == "FRG_") {
        next_is_a_functional_recovery_guideline = true;
      }
    }
    //
    if ((_operator.getTypeOfOperator() == sim::Operator::ODM && _entry == sim::Strategy::FollowProcedure && !next_is_a_mental_procedure) ||
        (_operator.getTypeOfOperator() == sim::Operator::ODM && _entry == sim::Strategy::InstinctiveResponse && !next_is_a_mental_procedure) ||
        (_entry == sim::Strategy::InstinctiveResponse && next_is_a_mental_procedure)) {
      b_procedure_pt = new BranchProcedureStep();
      b_procedure_pt->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
      // set time delay for procedure transfer
      if (mental_procedure->getProcedureName() == _procedure_name) {
        time = g_sim.All_procedure.getStepTransferTime();  // transfer within same procedure
      } else {
        time = g_sim.All_procedure.getProcedureTransferTime(); // transfer to a new procedure
      }
      b_procedure_pt->setTimerAndProbability(time, 1.0 - _operator.hfe_bbn.getProcedureTransferFailureProbability());
      b_procedure_pt->setProcedureName(mental_procedure->getProcedureName());
      b_procedure_pt->setStepName(mental_procedure->getStepName());
      b_procedure_pt->setLastProcedureName(_procedure_name);
      b_procedure_pt->setLastStepName(_step_name);
      // b_procedure_step_pt->setTypeOfPauseActivity(_entry);
      if (_operator.getTypeOfOperator() == sim::Operator::ODM && _entry == sim::Strategy::FollowProcedure && !next_is_a_mental_procedure) {
        b_procedure_pt->setTypeOfPauseActivity(_entry);
        g_sim.Branch_center.addProcedureStep(_operator.getTypeOfOperator(), b_procedure_pt);
        branch_generated = true;
      } else if (_operator.getTypeOfOperator() == sim::Operator::ODM && _entry == sim::Strategy::InstinctiveResponse && !next_is_a_mental_procedure) {
        b_procedure_pt->setTypeOfPauseActivity(sim::Strategy::FollowProcedure);
        g_sim.Branch_center.addProcedureStep(_operator.getTypeOfOperator(), b_procedure_pt);
        g_sim.Decision_Maker.setPauseActivity(true);
      } else if (_entry == sim::Strategy::InstinctiveResponse && next_is_a_mental_procedure) {
        b_procedure_pt->setTypeOfPauseActivity(_entry);
        g_sim.Branch_center.addInstinctiveResponseProcedure(_operator.getTypeOfOperator(), b_procedure_pt);
        branch_generated = true;
      }
    } else {
      //illegal procedure transfer
      ofstream fout("err messages.txt", ios::app);
      cout << "      " << r5pars_.timesno
           << "  ProcedureStepUnit::executeAction: Illegal procedure transfer operation in " << _procedure_name << ' '
           << _step_name << endl;
      fout << r5pars_.timesno << "  ProcedureStepUnit::executeAction: Illegal procedure transfer operation in "
           << _procedure_name << ' ' << _step_name << "\n";
      fout.close();
    }
    //
    return branch_generated;
  } else if (type_of_action == sim::ControlAction::ParameterScan) {
    skip_probability = scanned_parameter->calculateProbability();  // calculate probability of skipping a step
    //
    HEP_multiplier *=
        this->calculateDynamicHEPMultiplier(_operator.getTypeOfOperator(), scanned_parameter->getInfoName(), procedure_step_info);
    HEP_multiplier *= _static_HEP_factor;
    skip_probability = this->calculateAdjustedSkipProbability(skip_probability, HEP_multiplier);
    // Use Dynamic BBN
    skip_probability = _operator.hfe_bbn.getProcedureStepFailureProbability();
    procedure_step_info.setTime(r5pars_.timesno);
    procedure_step_info.setOperatorID(_operator.getTypeOfOperator());
    procedure_step_info.setActionName(scanned_parameter->getInfoName());
    procedure_step_info.setProcedureName(_procedure_name);
    procedure_step_info.setProcedureStep(_step_name);
    procedure_step_info.setStaticMultiplier(_static_HEP_factor);
    procedure_step_info.setSkipProbability(skip_probability);
    g_sim.Aux_info.addProcedureData(procedure_step_info);
    //
//    if (skip_probability < _skip_threshold)           // reset probability to 1.0 if step is not skipped
//    {
//      skip_probability = 0.0;
//    }
    //
    tu_pt = g_sim.Branch_center.source_of_procedure_time_branches.checkToGenerateActionTimeBranches(_procedure_name,
                                                                                              _step_name,
                                                                                              scanned_parameter->getInfoName());
    if (tu_pt != 0) {
      num_of_time_branches = tu_pt->getNumOfBranches();
    } else {
      num_of_time_branches = 1;
    }
    //
    delta_cdf = 1.0 / (double) num_of_time_branches;
    for (i = 0; i < num_of_time_branches; i++) {
      b_scan_pt = new BranchScannedParameter();
      b_scan_pt->setInfoName(scanned_parameter->getInfoName());
      b_scan_pt->setTypeOfScannedParameter(scanned_parameter->getTypeOfScannedParameter());
      b_scan_pt->setScanPriority(scanned_parameter->getScanPriority());
      b_scan_pt->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
      b_scan_pt->setT_Minimum(scanned_parameter->getT_Minimum());
      b_scan_pt->setAlpha_Weibull(scanned_parameter->getAlpha_Weibull());
      b_scan_pt->setBeta_Weibull(scanned_parameter->getBeta_Weibull());
      //
      // calculate time required to perform action
      cdf_lower = delta_cdf * ((double) i);
      cdf_upper = delta_cdf * ((double) (i + 1));
      time = b_scan_pt->calculateMeanRequiredTime(cdf_lower, cdf_upper);
      //
      b_scan_pt->setTimerAndProbability(time, (1.0 - skip_probability) / static_cast<double> (num_of_time_branches));
      b_scan_pt->setTypeOfPauseActivity(_entry);
      g_sim.Branch_center.addScannedParameter(_operator.getTypeOfOperator(), b_scan_pt);
      //
      branch_generated = true;
    }
    // skip
    // check to verify probability for skipping is above threshold to minimize branch generation
    if (skip_probability > _skip_threshold) {
      b_scan_pt = new BranchScannedParameter();
      b_scan_pt->setInfoName(scanned_parameter->getInfoName());
      b_scan_pt->setTypeOfScannedParameter(scanned_parameter->getTypeOfScannedParameter());
      b_scan_pt->setScanPriority(scanned_parameter->getScanPriority());
      b_scan_pt->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
      b_scan_pt->setT_Minimum(scanned_parameter->getT_Minimum());
      b_scan_pt->setAlpha_Weibull(scanned_parameter->getAlpha_Weibull());
      b_scan_pt->setBeta_Weibull(scanned_parameter->getBeta_Weibull());
      b_scan_pt->setStateOfActivation(sim::State::Skip);
      //
      b_scan_pt->setTimerAndProbability(1.0, skip_probability);
      b_scan_pt->setTypeOfPauseActivity(_entry);
      g_sim.Branch_center.addScannedParameter(_operator.getTypeOfOperator(), b_scan_pt);
      //
      branch_generated = true;
    }
  } else if (type_of_action
      == sim::State::Waiting) {//all non-interact with system actions have been chnaged to waiting type of action in readInfoFromFile
    //
    str = "WAITING:_Verify_" + action->getInfoName();
    //
    skip_probability = action->calculateProbability();  // calculate probability of skipping a step
    //
    HEP_multiplier *= this->calculateDynamicHEPMultiplier(_operator.getTypeOfOperator(), action->getInfoName(), procedure_step_info);
    HEP_multiplier *= _static_HEP_factor;
    skip_probability = this->calculateAdjustedSkipProbability(skip_probability, HEP_multiplier);
    // Use Dynamic BBN
    skip_probability = _operator.hfe_bbn.getProcedureStepFailureProbability();
    procedure_step_info.setTime(r5pars_.timesno);
    procedure_step_info.setOperatorID(_operator.getTypeOfOperator());
    procedure_step_info.setActionName(str);
    procedure_step_info.setProcedureName(_procedure_name);
    procedure_step_info.setProcedureStep(_step_name);
    procedure_step_info.setStaticMultiplier(_static_HEP_factor);
    procedure_step_info.setSkipProbability(skip_probability);
    g_sim.Aux_info.addProcedureData(procedure_step_info);
    //
//    if (skip_probability < _skip_threshold)           // reset probability to 1.0 if step is not skipped
//    {
//      skip_probability = 0.0;
//    }
    //
    tu_pt = g_sim.Branch_center.source_of_procedure_time_branches.checkToGenerateActionTimeBranches(_procedure_name,
                                                                                              _step_name,
                                                                                              action->getInfoName());
    if (tu_pt != 0) {
      num_of_time_branches = tu_pt->getNumOfBranches();
    } else {
      num_of_time_branches = 1;
    }
    //
    delta_cdf = 1.0 / (double) num_of_time_branches;
    for (i = 0; i < num_of_time_branches; i++) {
      //perform procedure step unit action
      b_action_pt = new BranchAction();
//          b_action_pt->setActionName(action->getInfoName());
      b_action_pt->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
      b_action_pt->setT_Minimum(action->getT_Minimum());
      b_action_pt->setAlpha_Weibull(action->getAlpha_Weibull());
      b_action_pt->setBeta_Weibull(action->getBeta_Weibull());
      //
      // calculate time required to perform action
      cdf_lower = delta_cdf * ((double) i);
      cdf_upper = delta_cdf * ((double) (i + 1));
      time = b_action_pt->calculateMeanRequiredTime(cdf_lower, cdf_upper);
      //
      b_action_pt->setTimerAndProbability(time, (1.0 - skip_probability) / static_cast<double> (num_of_time_branches));
      //
      b_action_pt->setActionName(str);
      b_action_pt->setMessage(message);
      b_action_pt->setTypeOfPauseActivity(_entry);
      g_sim.Branch_center.addAction(_operator.getTypeOfOperator(), b_action_pt);
      //
      branch_generated = true;
    }
    // skip procedure step unit action
    // check to verify probability for skipping is above threshold to minimize branch generation
    if (skip_probability > _skip_threshold) {
      b_action_pt = new BranchAction();
//          b_action_pt->setActionName(action->getInfoName());
      b_action_pt->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
      // set time delay for skipped step of 1.0 second
      b_action_pt->setTimerAndProbability(1.0, skip_probability);
      str = "WAITING:_Skipped_Verification_Step_" + action->getInfoName();
      b_action_pt->setActionName(str);
      std::ostringstream streamObj;
      streamObj << skip_probability;
      message += "_(skipped_step_probability_=_" + streamObj.str() + ")";
      b_action_pt->setMessage(message);
      b_action_pt->setStateOfActivation(sim::State::Skip);
      b_action_pt->setTypeOfPauseActivity(_entry);
      g_sim.Branch_center.addAction(_operator.getTypeOfOperator(), b_action_pt);
      //
      branch_generated = true;
    }
  } else {//type_of_action == sim::State::Unknown  or sim::Branch::ProcedureTransfer which is handler in ProcedureStep
    ofstream fout("err messages.txt", ios::app);
    cout << "ProcedureStepUnit::executAction: neither ACTIVE nor sim::None procedure step unit is found." << endl;
    fout << r5pars_.timesno
         << "  ProcedureStepUnit::executAction: neither ACTIVE nor sim::None procedure step unit is found.\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("ProcedureStepUnit::executeAction err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
  return branch_generated;
};
bool ProcedureStepUnit::executeExpectation(Operator &_operator, ShortTermMemory &_stm, int _entry) {
  bool found_expectation = false;
  bool branch_generated = false;
  int state_of_activation, n_count;
  decltype(expectation)::iterator expectationOR_itr;
  expectationOR_itr = expectation.begin();
  n_count = 1;
  while (expectationOR_itr != expectation.end() && !found_expectation) {
    state_of_activation = (*expectationOR_itr)->getStateOfActivation();
    if (state_of_activation == sim::None) {
      found_expectation = true;
      (*expectationOR_itr)->setStateOfActivation(sim::State::Active);
      branch_generated = (*expectationOR_itr)->assessExpectation(_operator, _stm, _entry);
    } else if (state_of_activation == sim::State::Active) {
      found_expectation = true;
      branch_generated = (*expectationOR_itr)->assessExpectation(_operator, _stm, _entry);
    } else if (state_of_activation == sim::State::Failed) {
      found_expectation = true;
      this->setStateOfExpectation(sim::State::Failed);
    } else if (state_of_activation == sim::State::Succeed) {
    } else {}
    expectationOR_itr++;
    n_count++;
  }
  if (!found_expectation) {
    this->setStateOfExpectation(sim::State::Succeed);
  }
  return branch_generated;
}
 
bool ProcedureStepUnit::executeNonResponseAction(Operator & _operator,
                                                 ShortTermMemory &_stm,
                                                 int _entry,
                                                 string _current_procedure,
                                                 string _current_step,
                                                 double _skip_threshold,
                                                 double _static_HEP_factor) {
  bool branch_generated = false;
  bool next_is_a_mental_procedure = false;
  bool next_is_a_functional_recovery_guideline = false;
  bool illegal_procedure_transfer = false;
  bool generate_control_branches = false;
  double skip_probability, control_probability, control_value;
  double time, delta_cdf, cdf_lower, cdf_upper;
  double HEP_multiplier = 1.0;
  AnalysisProcedureDataContainerUnit procedure_step_info;
  this->setStateOfNonResponseAction(sim::State::Succeed);
  int i, j, num_of_time_branches, num_of_control_branches;
  int type = this->type_of_non_response_action;
  BranchAction *b_action_pt;
  BranchProcedureStep *b_procedure_step_pt;
  BranchScannedParameter *b_scan_pt;
  BranchProcedureActionTimeUnit *tu_pt = 0;
  BranchProcedureControlValueUnit *cvu_pt = 0;
  BranchEndState *es_pt;
  MentalParameterValue *mpv_pt;
  string str, sub_str, str_prob;
  InfoChunkMental *wm;
  ProcedureActionUnit *act_pt;
  SystemControl *sc_ptr;
  ControlValue *control_value_ptr;
  ProcedureStepInfo *procedure_pt;
  ProcedureScannedParameterUnit *scanned_parameter;
  wm = _stm.getWorkingMemory();
  int receiver = sim::Operator::OAT;
  if (_operator.getTypeOfOperator() == sim::Operator::OAT) receiver = sim::Source::Plant;
  if (hasNonResponseAction()) {
    if (type == sim::Action::Action || type == sim::ControlAction::Additive || type == sim::ControlAction::ParameterControl) {
      act_pt = non_response_action_unit.get();
      // calculate probability of skipping step
      skip_probability = act_pt->calculateProbability();  // calculate probability of skipping a step
      //
      HEP_multiplier *= this->calculateDynamicHEPMultiplier(_operator.getTypeOfOperator(), act_pt->getInfoName(), procedure_step_info);
      HEP_multiplier *= _static_HEP_factor;
      skip_probability = this->calculateAdjustedSkipProbability(skip_probability, HEP_multiplier);
      // Use Dynamic BBN
      skip_probability = _operator.hfe_bbn.getProcedureStepFailureProbability();
      procedure_step_info.setTime(r5pars_.timesno);
      procedure_step_info.setOperatorID(_operator.getTypeOfOperator());
      procedure_step_info.setActionName(act_pt->getInfoName());
      procedure_step_info.setProcedureName(_current_procedure);
      procedure_step_info.setProcedureStep(_current_step);
      procedure_step_info.setStaticMultiplier(_static_HEP_factor);
      procedure_step_info.setSkipProbability(skip_probability);
      g_sim.Aux_info.addProcedureData(procedure_step_info);
      //
//      if (skip_probability < _skip_threshold) {
//        skip_probability = 0.0;
//      }
      //
      tu_pt = g_sim.Branch_center.source_of_procedure_time_branches.checkToGenerateActionTimeBranches(_current_procedure,
                                                                                                _current_step,
                                                                                                act_pt->getInfoName());
      if (tu_pt != 0) {
        num_of_time_branches = tu_pt->getNumOfBranches();
      } else {
        num_of_time_branches = 1;
      }
      //
      cvu_pt = g_sim.Branch_center.control_value_branches.checkToGenerateControlValueBranches(_current_procedure,
                                                                                        _current_step,
                                                                                        act_pt->getInfoName());
      if (cvu_pt != 0) {
        num_of_control_branches = cvu_pt->getNumberOfBranches();
        generate_control_branches = true;
      } else {
        num_of_control_branches = 1;
      }
      //
      for (j = 0; j < num_of_control_branches; j++) {
        if (generate_control_branches) {
          control_probability = cvu_pt->probabilities.at(j);
        } else {
          control_probability = 1.0;
        }
        // set control value
        if (type == sim::ControlAction::ParameterControl)   // set control equal to perceived parameter value
        {
          mpv_pt = _stm.perceived_info.checkExistanceOfPerceivedParameterValue(act_pt->getParameterName());
          sc_ptr = g_sim.Indicator.controls.getControlFromMap(act_pt->getInfoName());
          control_value_ptr = (ControlValue *) sc_ptr;
          if (mpv_pt != 0 && sc_ptr->getTypeOfControl() == DisplayType::ControlValue) {
            if (generate_control_branches) {
              control_value = cvu_pt->control_values.at(j);
            } else {
              control_value = mpv_pt->getObservedParameterValue();
            }
            control_value = fmin(control_value, control_value_ptr->getValueForOnOrFullyOpen());
            control_value = fmax(control_value, control_value_ptr->getValueForOffOrFullyClose());
          } else   // control parameter has not been perceived, do not change control value
          {
            control_value = control_value_ptr->getControlValue();
          }
        } else if (type == sim::Action::Action || type == sim::ControlAction::Additive) {
          if (generate_control_branches) {
            control_value = cvu_pt->control_values.at(j);
          } else {
            control_value = act_pt->getControlValue();
          }
          if (type == sim::ControlAction::Additive) {
            sc_ptr = g_sim.Indicator.controls.getControlFromMap(act_pt->getInfoName());
            control_value_ptr = (ControlValue *) sc_ptr;
            // Displayed control value may differ from actual control value due to perception filtering
            // control_value = control_value_ptr->getDisplayedControlValue();
            control_value += control_value_ptr->getControlValue();
            // verify that control value does not exceeed component control range
            control_value = fmin(control_value, control_value_ptr->getValueForOnOrFullyOpen());
            control_value = fmax(control_value, control_value_ptr->getValueForOffOrFullyClose());
          }
        }
        //
        delta_cdf = 1.0 / (double) num_of_time_branches;
        for (i = 0; i < num_of_time_branches; i++) {
          // nonresponse action is performed
          b_action_pt = new BranchAction();
          b_action_pt->setActionName(act_pt->getInfoName());
          b_action_pt->setControlValue(control_value);
          b_action_pt->setSenderAndReceiver(_operator.getTypeOfOperator(), receiver);
          //
          // calculate time to perform action
          cdf_lower = delta_cdf * ((double) i);
          cdf_upper = delta_cdf * ((double) (i + 1));
          time = action->calculateMeanRequiredTime(cdf_lower, cdf_upper);
          //
          b_action_pt->setActionTime(time);
          if (_operator.getTypeOfOperator() == sim::Operator::ODM && receiver == sim::Operator::OAT) {
            // set branch time to ODM communication time
            time = g_sim.Decision_Maker.getNominalCommunicationTime();
          }
          b_action_pt->setTimerAndProbability(time,
                                              control_probability * (1.0 - skip_probability)
                                                  / static_cast<double> (num_of_time_branches));
          b_action_pt->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addAction(_operator.getTypeOfOperator(), b_action_pt);
          //
          branch_generated = true;
        }  // end time branch "for loop"
      } // end control value branch "for loop"
      // non response action is skipped
      //  check to verify probability for skipping is above threshold to minimize branch generation
      if (skip_probability > _skip_threshold) {
        b_action_pt = new BranchAction();
        b_action_pt->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
        // use time delay of 1.0 second for a skipped step
        b_action_pt->setTimerAndProbability(1.0, skip_probability);
        str = "WAITING:_Skip_Non_Response_Action_" + act_pt->getInfoName();
        str += "_(skip_probability_=_";
        std::ostringstream streamObj;
        streamObj << skip_probability;
        str += streamObj.str() + ")";
        b_action_pt->setActionName(str);
        b_action_pt->setStateOfActivation(sim::State::Skip);
        b_action_pt->setTypeOfPauseActivity(_entry);
        g_sim.Branch_center.addAction(_operator.getTypeOfOperator(), b_action_pt);
        branch_generated = true;
      }
    } else if (type == sim::Branch::Procedure) {
      if (_entry == sim::Strategy::FollowInstruction) {
        _entry = sim::Strategy::InstinctiveResponse;
      }
      procedure_pt = non_response_procedure.get();
      // calculate probability of skipping step
      skip_probability = procedure_pt->calculateProbability();
      //
      HEP_multiplier *= this->calculateDynamicHEPMultiplier(_operator.getTypeOfOperator(), "Procedure", procedure_step_info);
      HEP_multiplier *= _static_HEP_factor;
      skip_probability = this->calculateAdjustedSkipProbability(skip_probability, HEP_multiplier);
      // Use Dynamic BBN
      skip_probability = _operator.hfe_bbn.getProcedureTransferFailureProbability();
      procedure_step_info.setTime(r5pars_.timesno);
      procedure_step_info.setOperatorID(_operator.getTypeOfOperator());
      procedure_step_info.setActionName("Procedure_Transfer");
      procedure_step_info.setProcedureName(_current_procedure);
      procedure_step_info.setProcedureStep(_current_step);
      procedure_step_info.setStaticMultiplier(_static_HEP_factor);
      procedure_step_info.setSkipProbability(skip_probability);
      g_sim.Aux_info.addProcedureData(procedure_step_info);
      //
//      if (skip_probability < _skip_threshold) {
//        skip_probability = 0.0;
//      }
      //
      // nonresponse action is performed
      //
      // determine if next procedure is a mental procedure
      if (procedure_pt->getProcedureName().size() > 5) {
        sub_str = procedure_pt->getProcedureName().substr(0, 5);
        if (sub_str == "MPBG_") {
          next_is_a_mental_procedure = true;
        }
      }
      //
      // determine if next procedure step is a functional recovery guideline
      if (procedure_pt->getProcedureName().size() > 4) {
        sub_str = procedure_pt->getProcedureName().substr(0, 4);
        if (sub_str == "FRG_") {
          next_is_a_functional_recovery_guideline = true;
        }
      }
      //
      if ((_operator.getTypeOfOperator() == sim::Operator::ODM && _entry == sim::Strategy::FollowProcedure && !next_is_a_mental_procedure) ||
          /*(_operator.getTypeOfOperator() == sim::Operator::ODM && _entry == sim::Strategy::InstinctiveResponse && !next_is_a_mental_procedure) || */
          (_entry == sim::Strategy::InstinctiveResponse && next_is_a_mental_procedure)) {
        b_procedure_step_pt = new BranchProcedureStep();
        b_procedure_step_pt->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
        // set time delay for procedure transfer
        if (procedure_pt->getProcedureName() == _current_procedure) {
          time = g_sim.All_procedure.getStepTransferTime();  // transfer within same procedure
        } else {
          time = g_sim.All_procedure.getProcedureTransferTime(); // transfer to a new procedure
        }
        b_procedure_step_pt->setTimerAndProbability(time, 1.0 - skip_probability);
        b_procedure_step_pt->setProcedureName(procedure_pt->getProcedureName());
        b_procedure_step_pt->setStepName(procedure_pt->getStepName());
        b_procedure_step_pt->setLastProcedureName(_current_procedure);
        b_procedure_step_pt->setLastStepName(_current_step);
        // b_procedure_step_pt->setTypeOfPauseActivity(_entry);
        if (_operator.getTypeOfOperator() == sim::Operator::ODM && _entry == sim::Strategy::FollowProcedure && !next_is_a_mental_procedure) {
          b_procedure_step_pt->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addProcedureStep(_operator.getTypeOfOperator(), b_procedure_step_pt);
          branch_generated = true;
        }
          /*else if (_operator.getTypeOfOperator() == sim::Operator::ODM && _entry == sim::Strategy::InstinctiveResponse && !next_is_a_mental_procedure)
          {
 
              b_procedure_step_pt->setTypeOfPauseActivity(sim::Branch::ProcedureXfr);
              g_sim.Branch_center.addProcedureStep(_operator.getTypeOfOperator(), b_procedure_step_pt);
              g_sim.Decision_Maker.setPauseActivity(true);
          }*/
        else if (_entry == sim::Strategy::InstinctiveResponse && next_is_a_mental_procedure) {
          b_procedure_step_pt->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addInstinctiveResponseProcedure(_operator.getTypeOfOperator(), b_procedure_step_pt);
          branch_generated = true;
        }
      } else {
        //illegal procedure transfer
        illegal_procedure_transfer = true;
        ofstream fout("err messages.txt", ios::app);
        cout << "      " << r5pars_.timesno
             << "  ProcedureStep::executeNonResponseAction: Illegal procedure transfer operation in "
             << _current_procedure << ' ' << _current_step << endl;
        fout << r5pars_.timesno << "  ProcedureStep::executeNonResponseAction: Illegal procedure transfer operation in "
             << _current_procedure << ' ' << _current_step << "\n";
        fout.close();
        skip_probability = 1.0;
      }
      //
      // skip procedure transfer non response action
      // check to verify probability for skipping is above threshold to minimize branch generation
      // or treat illegal procedure transfer as skipped step
      if (skip_probability > _skip_threshold || illegal_procedure_transfer) {
        b_procedure_step_pt = new BranchProcedureStep();
        b_procedure_step_pt->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
        b_procedure_step_pt->setTimerAndProbability(1.0, skip_probability);
        b_procedure_step_pt->setProcedureName(_current_procedure);
        b_procedure_step_pt->setStepName(_current_step);
        b_procedure_step_pt->setLastProcedureName(_current_procedure);
        b_procedure_step_pt->setLastStepName(_current_step);
        b_procedure_step_pt->setStateOfActivation(sim::State::Skip);
        b_procedure_step_pt->setTypeOfPauseActivity(_entry);
        if (_entry == sim::Strategy::FollowProcedure) {
          g_sim.Branch_center.addProcedureStep(_operator.getTypeOfOperator(), b_procedure_step_pt);
        } else {
          g_sim.Branch_center.addInstinctiveResponseProcedure(_operator.getTypeOfOperator(), b_procedure_step_pt);
        }
        branch_generated = true;
      }
    } else if (type == sim::ControlAction::ParameterScan) {
      scanned_parameter = non_response_scan.get();
      skip_probability = scanned_parameter->calculateProbability();  // calculate probability of skipping a step
      //
      HEP_multiplier *=
          this->calculateDynamicHEPMultiplier(_operator.getTypeOfOperator(), scanned_parameter->getInfoName(), procedure_step_info);
      HEP_multiplier *= _static_HEP_factor;
      skip_probability = this->calculateAdjustedSkipProbability(skip_probability, HEP_multiplier);
      // Use Dynamic BBN
      skip_probability = _operator.hfe_bbn.getProcedureStepFailureProbability();
      procedure_step_info.setTime(r5pars_.timesno);
      procedure_step_info.setOperatorID(_operator.getTypeOfOperator());
      procedure_step_info.setActionName(scanned_parameter->getInfoName());
      procedure_step_info.setProcedureName(_current_procedure);
      procedure_step_info.setProcedureStep(_current_step);
      procedure_step_info.setStaticMultiplier(_static_HEP_factor);
      procedure_step_info.setSkipProbability(skip_probability);
      g_sim.Aux_info.addProcedureData(procedure_step_info);
      //
//      if (skip_probability < _skip_threshold)           // reset probability to 1.0 if step is not skipped
//      {
//        skip_probability = 0.0;
//      }
      //
      tu_pt = g_sim.Branch_center.source_of_procedure_time_branches.checkToGenerateActionTimeBranches(_current_procedure,
                                                                                                _current_step,
                                                                                                scanned_parameter->getInfoName());
      if (tu_pt != 0) {
        num_of_time_branches = tu_pt->getNumOfBranches();
      } else {
        num_of_time_branches = 1;
      }
      //
      delta_cdf = 1.0 / (double) num_of_time_branches;
      for (i = 0; i < num_of_time_branches; i++) {
        b_scan_pt = new BranchScannedParameter();
        b_scan_pt->setInfoName(scanned_parameter->getInfoName());
        b_scan_pt->setTypeOfScannedParameter(scanned_parameter->getTypeOfScannedParameter());
        b_scan_pt->setScanPriority(scanned_parameter->getScanPriority());
        b_scan_pt->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
        b_scan_pt->setT_Minimum(scanned_parameter->getT_Minimum());
        b_scan_pt->setAlpha_Weibull(scanned_parameter->getAlpha_Weibull());
        b_scan_pt->setBeta_Weibull(scanned_parameter->getBeta_Weibull());
        //
        // calculate time required to perform action
        cdf_lower = delta_cdf * ((double) i);
        cdf_upper = delta_cdf * ((double) (i + 1));
        time = b_scan_pt->calculateMeanRequiredTime(cdf_lower, cdf_upper);
        //
        b_scan_pt->setTimerAndProbability(time, (1.0 - skip_probability) / static_cast<double> (num_of_time_branches));
        b_scan_pt->setTypeOfPauseActivity(_entry);
        g_sim.Branch_center.addScannedParameter(_operator.getTypeOfOperator(), b_scan_pt);
        //
        branch_generated = true;
      }
      // skip
      // check to verify probability for skipping is above threshold to minimize branch generation
      if (_operator.hfe_bbn.getProcedureStepFailureProbability() > _skip_threshold) {
        b_scan_pt = new BranchScannedParameter();
        b_scan_pt->setInfoName(scanned_parameter->getInfoName());
        b_scan_pt->setTypeOfScannedParameter(scanned_parameter->getTypeOfScannedParameter());
        b_scan_pt->setScanPriority(scanned_parameter->getScanPriority());
        b_scan_pt->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
        b_scan_pt->setT_Minimum(scanned_parameter->getT_Minimum());
        b_scan_pt->setAlpha_Weibull(scanned_parameter->getAlpha_Weibull());
        b_scan_pt->setBeta_Weibull(scanned_parameter->getBeta_Weibull());
        b_scan_pt->setStateOfActivation(sim::State::Skip);
        //
        b_scan_pt->setTimerAndProbability(1.0, skip_probability);
        b_scan_pt->setTypeOfPauseActivity(_entry);
        g_sim.Branch_center.addScannedParameter(_operator.getTypeOfOperator(), b_scan_pt);
        //
        branch_generated = true;
      }
    } else if (type == sim::ControlAction::Stop) {
      //
      // branch termination handled in ProcedureStep::oneThroughProcess
    } else {}
  }
  return branch_generated;
}
void ProcedureStepUnit::setStateOfExpectation(int n) { state_of_expectation = n; }
int ProcedureStepUnit::getStateOfExpectation() { return state_of_expectation; }
 
int ProcedureStepUnit::getNumberOfANDExpectation() {
  if (!expectation.empty()) return expectation.size();
  if (serialized_expectation_count >= 0) return serialized_expectation_count;
  return 0;
}
void ProcedureStepUnit::saveProcedureStepUnitToFile(ofstream &fout) {
  fout << type_of_action << ' '
       << type_of_non_response_action << ' '
       << state_of_action << ' '
       << state_of_non_response_action << ' '
       << state_of_expectation << '\n';
  //
  if (type_of_action == sim::Action::Action || type_of_action == sim::ControlAction::Additive || type_of_action == sim::ControlAction::ParameterControl
      || type_of_action == sim::Branch::Verify || type_of_action == sim::State::Waiting) {
    this->saveProcedureStepUnitActionToFile(fout);
  } else if (type_of_action == sim::ControlAction::ParameterScan) {
    this->saveProcedureStepUnitScannedParameterToFile(fout);
  } else if (type_of_action == sim::Branch::ProcedureTransfer) {
    // procedure transfer
  } else if (type_of_action == sim::Branch::MentalBelief) {
    // mental procedure
  }
  //
  //
  //this->saveProcedureStepUnitActionToFile(fout);
  //
  this->saveProcedureStepUnitNonResponseActionToFile(fout);
  this->saveProcedureStepUnitExpectationToFile(fout);
}
void ProcedureStepUnit::retrieveProcedureStepUnitFromFile(ifstream &fin) {
  fin >> type_of_action
      >> type_of_non_response_action
      >> state_of_action
      >> state_of_non_response_action
      >> state_of_expectation;
  //
  if (type_of_action == sim::Action::Action || type_of_action == sim::ControlAction::Additive || type_of_action == sim::ControlAction::ParameterControl
      || type_of_action == sim::Branch::Verify || type_of_action == sim::State::Waiting) {
    this->retrieveProcedureStepUnitActionFromFile(fin);
  } else if (type_of_action == sim::ControlAction::ParameterScan) {
    this->retrieveProcedureStepUnitScannedParameterFromFile(fin);
  } else if (type_of_action == sim::Branch::ProcedureTransfer) {
    // procedure transfer
  } else if (type_of_action == sim::Branch::MentalBelief) {
    // mental procedure
  }
  //this->retrieveProcedureStepUnitActionFromFile(fin);
  this->retrieveProcedureStepUnitNonResponseActionFromFile(fin);
  this->retrieveProcedureStepUnitExpectationFromFile(fin);
}
void ProcedureStepUnit::saveProcedureStepUnitActionToFile(ofstream &fout) {
  if (action != 0) {
    fout << "1 " << '\n';
    action->saveProcedureActionUnitToFile(fout);
  } else {
    fout << "0 " << '\n';
  }
}
void ProcedureStepUnit::retrieveProcedureStepUnitActionFromFile(ifstream &fin) {
  int i_exist;
  fin >> i_exist;
  if (i_exist == 1) {
    action = make_unique<ProcedureActionUnit>();
    action->retrieveProcedureActionUnitFromFile(fin);
  } else if (i_exist == 0) {
    //do nothing here
  } else {
    ofstream fout("err messages.txt", ios::app);
    cout << "ProcedureStepUnit::retrieveProcedureStepUnitActionFromFile: data mismatch in retrieving info from file."
         << endl;
    fout << r5pars_.timesno
         << "  ProcedureStepUnit::retrieveProcedureStepUnitActionFromFile: data mismatch in retrieving info from file\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("ProcedureStepUnit::retrieveProcedureStepUnitActionFromFile err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
}
 
void ProcedureStepUnit::saveProcedureStepUnitMentalProcedureToFile(ofstream &fout) {
  if (mental_procedure != 0) {
    fout << "1 ";
    mental_procedure->saveProcedureStepInfoToFile(fout);
  } else {
    fout << "0" << '\n';
  }
}
 
void ProcedureStepUnit::retrieveProcedureStepUnitMentalProcedureFromFile(ifstream &fin) {
  int i_exist;
  fin >> i_exist;
  if (i_exist == 1) {
    mental_procedure = make_unique<ProcedureStepInfo>();
    mental_procedure->retrieveProcedureStepInfoFromFile(fin);
  } else if (i_exist == 0) {
    //do nothing here
  } else {
    ofstream fout("err messages.txt", ios::app);
    cout
        << "ProcedureStepUnit::retrieveProcedureStepUnitMentalProcedureFromFile: data mismatch in retrieving info from file."
        << endl;
    fout << r5pars_.timesno
         << "  ProcedureStepUnit::retrieveProcedureStepUnitMentalProcedureFromFile: data mismatch in retrieving info from file\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("ProcedureStepUnit::retrieveProcedureStepUnitMentalProcedureFromFile err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
}
 
void ProcedureStepUnit::saveProcedureStepUnitScannedParameterToFile(ofstream &fout) {
  if (scanned_parameter != 0) {
    fout << "1 ";
    scanned_parameter->saveProcedureScannedParameterUnitToFile(fout);
  } else {
    fout << "0" << '\n';
  }
}
 
void ProcedureStepUnit::retrieveProcedureStepUnitScannedParameterFromFile(ifstream &fin) {
  int i_exist;
  fin >> i_exist;
  if (i_exist == 1) {
    scanned_parameter = make_unique<ProcedureScannedParameterUnit>();;
    scanned_parameter->retrieveProcedureScannedParameterUnitFromFile(fin);
  } else if (i_exist == 0) {
    //do nothing here
  } else {
    ofstream fout("err messages.txt", ios::app);
    cout
        << "ProcedureStepUnit::retrieveProcedureStepUnitScannedParameterUnitFromFile: data mismatch in retrieving info from file."
        << endl;
    fout << r5pars_.timesno
         << "  ProcedureStepUnit::retrieveProcedureStepUnitScannedParameterUnitFromFile: data mismatch in retrieving info from file\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("ProcedureStepUnit::retrieveProcedureStepUnitScannedParameterUnitFromFile err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
}
 
void ProcedureStepUnit::saveProcedureStepUnitNonResponseActionToFile(ofstream &fout) {
  ProcedureActionUnit *act_pt;
  ProcedureStepInfo *procedure_pt;
  ProcedureScannedParameterUnit *scan_pt;
 
  if (hasNonResponseAction()) {
    fout << "1 ";
    if (type_of_non_response_action == sim::Action::Action || type_of_non_response_action == sim::ControlAction::Additive
        || type_of_non_response_action == sim::ControlAction::ParameterControl) {
      act_pt = non_response_action_unit.get();
      act_pt->saveProcedureActionUnitToFile(fout);
    } else if (type_of_non_response_action == sim::Branch::Procedure) {
      procedure_pt = non_response_procedure.get();
      procedure_pt->saveProcedureStepInfoToFile(fout);
    } else if (type_of_non_response_action == sim::ControlAction::ParameterScan) {
      scan_pt = non_response_scan.get();
      scan_pt->saveProcedureScannedParameterUnitToFile(fout);
    } else if (type_of_non_response_action == sim::ControlAction::Stop) {
      //do nothing here
    } else {
      ofstream fout("err messages.txt", ios::app);
      cout << "ProcedureStepUnit::saveProcedureStepUnitNonResponseActionToFile: type_of_non_response_action "
           << type_of_non_response_action << " cannot be recognized" << endl;
      fout << r5pars_.timesno
           << "  ProcedureStepUnit::saveProcedureStepUnitNonResponseActionToFile: type_of_non_response_action "
           << type_of_non_response_action << " cannot be recognized\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("ProcedureStepUnit::saveProcedureStepUnitNonResponseActionToFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
    }
  } else {
    fout << "0" << '\n';
  }
}
 
void ProcedureStepUnit::retrieveProcedureStepUnitNonResponseActionFromFile(ifstream &fin) {
  int i_exist;
  ProcedureActionUnit *act_pt;
  ProcedureStepInfo *procedure_pt;
  ProcedureScannedParameterUnit *scan_pt;
  fin >> i_exist;
  if (i_exist == 1) {
    if (type_of_non_response_action == sim::Branch::Procedure) {
      procedure_pt = new ProcedureStepInfo();
      procedure_pt->retrieveProcedureStepInfoFromFile(fin);
      non_response_procedure.reset(procedure_pt);
    } else if (type_of_non_response_action == sim::Action::Action || type_of_non_response_action == sim::ControlAction::Additive
        || type_of_non_response_action == sim::ControlAction::ParameterControl) {
      act_pt = new ProcedureActionUnit();
      act_pt->retrieveProcedureActionUnitFromFile(fin);
      non_response_action_unit.reset(act_pt);
    } else if (type_of_non_response_action == sim::ControlAction::ParameterScan) {
      scan_pt = new ProcedureScannedParameterUnit();
      scan_pt->retrieveProcedureScannedParameterUnitFromFile(fin);
      non_response_scan.reset(scan_pt);
    } else if (type_of_non_response_action == sim::ControlAction::Stop) {//stop current scenario
      //do nothing here
    } else if (type_of_non_response_action == sim::Strategy::Advise) {//ask for advice
    } else if (type_of_non_response_action == sim::None) {//no non-response exit
    } else {
      ofstream fout("err messages.txt", ios::app);
      cout << "ProcedureStepUnit::retrieveProcedureStepUnitNonResponseActionFromFile( obj_type:"
           << type_of_non_response_action << " cannot be recognized" << endl;
      fout << r5pars_.timesno << "  ProcedureStepUnit::retrieveProcedureStepUnitNonResponseActionFromFile( obj_type:"
           << type_of_non_response_action << " cannot be recognized\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("ProcedureStepUnit::readInfofromFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    }
  } else if (i_exist == 0) {
    //do nothing
  } else {
    //error message
  }
}
 
void ProcedureStepUnit::saveProcedureStepUnitExpectationToFile(ofstream &fout) {
  fout << expectation.size() << '\n';
  for (auto& e : expectation) {
    e->saveExpectationORUnitToFile(fout);
  }
}
 
void ProcedureStepUnit::retrieveProcedureStepUnitExpectationFromFile(ifstream &fin) {
  int i, num;
  fin >> num;
  for (i = 0; i < num; i++) {
    auto expOr_pt = make_unique<ExpectationORUnit>();
    expOr_pt->retrieveExpectationORUnitFromFile(fin);
    this->expectation.push_back(std::move(expOr_pt));
  }
}