OperatorDM.cpp

Go to the documentation of this file.

// OperatorDM.cpp: implementation of the OperatorDM class.
//
 
#include "OperatorDM.h"
#include <memory>
#include <sstream>
#include "../Procedure/Procedures.h"
#include "../ControlPanel/ControlPanel.h"
#include <boost/serialization/export.hpp>
#include "../Global/SimulationContext.h"
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(OperatorDM)
using namespace std;
 
 
// Construction/Destruction
 
OperatorDM::OperatorDM() {
  this->setTypeOfOperator(sim::Operator::ODM);
}
 
OperatorDM::~OperatorDM() {
 
}
void OperatorDM::oneThroughProcessForBlockD() {
  bool branch_generated;
  bool block_ordered_action = false;
  bool block_decision_process = false;
  bool mental_procedure_in_progress = false;
  int current_strategy = sim::None;
  string OAT_IR_procedure_name, OAT_IR_step_name;
  InfoChunkMental *_wm;
  _wm = this->memory.getWorkingMemory();
  //
  //if(!this->getPauseMentalProcedure() && !this->getPauseActivity() && !Action_Taker.getPauseMentalProcedure())
  if (!this->getPauseMentalProcedure() && !g_sim.Action_Taker.getPauseMentalProcedure() && !this->getNewBranchGenerated()) {
    OAT_IR_procedure_name = g_sim.Action_Taker.memory.perceived_info.getCurrentInstinctiveResponseProcedureName();
    OAT_IR_step_name = g_sim.Action_Taker.memory.perceived_info.getCurrentInstinctiveResponseProceduralStepName();
    if (this->memory.perceived_info.isThereMentalProcedureWaitingForExecution(OAT_IR_procedure_name,
                                                                              OAT_IR_step_name)) {
      //mental_procedure_in_progress = true; Y.L.
      if (OAT_IR_step_name != "NO_STEP") {
        mental_procedure_in_progress = true;
        branch_generated = this->performAMentalProcedure(sim::Operator::ODM, OAT_IR_procedure_name, OAT_IR_step_name);
        if (branch_generated) {
          this->setPauseMentalProcedure(true);
          return;
        }
      }
    }
  }
  if (this->getPauseActivity() || this->getPauseMentalProcedure() || mental_procedure_in_progress) {
    block_decision_process = true;
  }
  //
  if (!block_decision_process) {
    // select goal
    branch_generated = selectGoal();
    if (branch_generated) {
      this->setPauseActivity(true);
      return;
    }
    // select strategy
    branch_generated = selectStrategy();
    if (branch_generated) {
      this->setPauseActivity(true);
      return;
    }
    //
    // check if Action Taker is busy - if so, block ODM from issuing odered actions
    if (g_sim.Action_Taker.memory.perceived_info.isThereMentalProcedureWaitingForExecution("NONE", "NONE")
        || g_sim.Action_Taker.getPauseMentalProcedure() || g_sim.Action_Taker.getPauseActivity()) {
      block_ordered_action = true;
      //
      if (g_sim.Branch_center.num_of_OAT_branch == 0 && g_sim.Branch_center.num_of_ODM_branch == 0
          && _wm->getCurrentStrategy() == sim::Strategy::FollowProcedure) { block_ordered_action = false; }
    }
    //
    if (!block_ordered_action) {
      current_strategy = _wm->getCurrentStrategy();
      switch (current_strategy) {
        // perform follow procedure strategy
        case (sim::Strategy::FollowProcedure): branch_generated = performFollowProcedureStrategy();
          break;
          // perform inductive/deductive reasoning strategy
        case (sim::Strategy::InductiveDeductive): branch_generated = this->performReasoningStrategy();
          break;
        default: break;
      }
      if (branch_generated) {
        this->setPauseActivity(true);
        return;
      }
    }
  }
 
}
bool OperatorDM::selectGoal() {
  InfoChunkMental *wm = 0;
  KBHardWiredUnit *kb_hwd_ptr = 0;
  BranchGoal *goal_pt = 0;
  wm = this->memory.getWorkingMemory();
  bool branch_generated = false;
  bool normal_operation = false;
  int who = sim::Operator::ODM;
  int current_goal;
  double dead_time = 60.0;
  //
  //
  // do not select a goal until simulation has approached steady state conditions
  // allow simulation to stabilize during dead_time before selecting a goal
  if (r5pars_.timesno > dead_time) {
    current_goal = wm->getCurrentGoal();
    //
    kb_hwd_ptr = this->knowledge_base.getPtrToHardWiredDiagnosis("Normal_Operation");
    if (kb_hwd_ptr != 0) {
      if (kb_hwd_ptr->getConfidenceLevel() >= kb_hwd_ptr->activation_probability.getProbability()) {
        normal_operation = true;
      }
    }
 
    //the reasoning module, when present, overrides the normal operation assessment
    if (this->m_RM && this->m_RM->m_event_schema_base->WhetherItIsNormalOperating() == false) {
      normal_operation = false;
      if (current_goal != sim::Goal::MaintainGlobalSafetyMargin) {
        // generate maintain global safety margin branch & enable procedure use
        goal_pt = new BranchGoal();
        goal_pt->setSenderAndReceiver(who, who);   //(sender, receiver)
        goal_pt->setTimerAndProbability(1.0, 1.0 - this->hfe_bbn.getGoalSelectionFailureProbability()); //(remaining time, probability)
        goal_pt->setDecision(sim::Goal::MaintainGlobalSafetyMargin);
        goal_pt->setTypeOfPauseActivity(sim::Decision::Goal);
        g_sim.Branch_center.addGoal(who, goal_pt);
        branch_generated = true;
        //
        if (this->getProcedureUseProbability()
            < 0.9999) {// bypass maintain global safety margin branch & block long term procedure use
          goal_pt = new BranchGoal();
          goal_pt->setSenderAndReceiver(who, who);   //(sender, receiver)
          goal_pt->setTimerAndProbability(1.0, 1.0 - this->getProcedureUseProbability()); //(remaining time, probability)
          goal_pt->setDecision(sim::Goal::MaintainGlobalSafetyMargin);
          goal_pt->setTypeOfPauseActivity(sim::Decision::Goal);
          goal_pt->setStateOfActivation(sim::Source::Bypass);
          g_sim.Branch_center.addGoal(who, goal_pt);
          branch_generated = true;
        }
      }
      return branch_generated;
    }
    if (normal_operation && !this->getAbnormalSignalPerceived() && current_goal != sim::Goal::NormalOp) {
      goal_pt = new BranchGoal();
      goal_pt->setSenderAndReceiver(who, who);//(sender, receiver)
      goal_pt->setTimerAndProbability(1.0, 1.0 - this->hfe_bbn.getGoalSelectionFailureProbability());//(remaining time, probability)
      goal_pt->setDecision(sim::Goal::NormalOp);
      goal_pt->setTypeOfPauseActivity(sim::Decision::Goal);
      g_sim.Branch_center.addGoal(who, goal_pt);
      branch_generated = true;
    }
    if (!normal_operation) {
      if (!this->getBlockTroubleshooting() && current_goal != sim::Goal::TroubleShoot && !this->getAbnormalSignalPerceived()) {
        // generate troubleshooting goal
        // two branches can be generated depending on the value of "troubleshooting_probability"
        if (this->getTroubleshootingProbability() > 0.9999) {
          goal_pt = new BranchGoal();
          goal_pt->setSenderAndReceiver(who, who);//(sender, receiver)
          goal_pt->setTimerAndProbability(1.0, 1.0 - this->hfe_bbn.getGoalSelectionFailureProbability());//(remaining time, probability)
          goal_pt->setDecision(sim::Goal::TroubleShoot);
          goal_pt->setTypeOfPauseActivity(sim::Decision::Goal);
          g_sim.Branch_center.addGoal(who, goal_pt);
          branch_generated = true;
        } else if (this->getTroubleshootingProbability() < 0.0001) {
          // generate bypass troubleshooting branch
          goal_pt = new BranchGoal();
          goal_pt->setSenderAndReceiver(who, who);   //(sender, receiver)
          goal_pt->setTimerAndProbability(1.0, 1.0 - this->hfe_bbn.getGoalSelectionFailureProbability()); //(remaining time, probability)
          goal_pt->setDecision(sim::Goal::TroubleShoot);
          goal_pt->setTypeOfPauseActivity(sim::Decision::Goal);
          goal_pt->setStateOfActivation(sim::Source::Bypass);
          g_sim.Branch_center.addGoal(who, goal_pt);
          //
          branch_generated = true;
        } else {
          // generate troubleshooting branch
          goal_pt = new BranchGoal();
          goal_pt->setSenderAndReceiver(who, who);   //(sender, receiver)
          goal_pt->setTimerAndProbability(1.0, this->getTroubleshootingProbability()); //(remaining time, probability)
          goal_pt->setDecision(sim::Goal::TroubleShoot);
          goal_pt->setTypeOfPauseActivity(sim::Decision::Goal);
          g_sim.Branch_center.addGoal(who, goal_pt);
          //
          // generate bypass troubleshooting branch
          goal_pt = new BranchGoal();
          goal_pt->setSenderAndReceiver(who, who);   //(sender, receiver)
          goal_pt->setTimerAndProbability(1.0, 1.0 - this->getTroubleshootingProbability()); //(remaining time, probability)
          goal_pt->setDecision(sim::Goal::TroubleShoot);
          goal_pt->setTypeOfPauseActivity(sim::Decision::Goal);
          goal_pt->setStateOfActivation(sim::Source::Bypass);
          g_sim.Branch_center.addGoal(who, goal_pt);
          //
          branch_generated = true;
        }
      } else if (this->getBlockTroubleshooting() && !this->getAbnormalSignalPerceived() && current_goal != sim::Goal::MonitorAbnormal) {
        // set goal to monitoring situation
        goal_pt = new BranchGoal();
        goal_pt->setSenderAndReceiver(who, who);   //(sender, receiver)
        goal_pt->setTimerAndProbability(1.0, 1.0 - this->hfe_bbn.getGoalSelectionFailureProbability()); //(remaining time, probability)
        goal_pt->setDecision(sim::Goal::MonitorAbnormal);
        goal_pt->setTypeOfPauseActivity(sim::Decision::Goal);
        g_sim.Branch_center.addGoal(who, goal_pt);
        branch_generated = true;
      }
        //
      else if (this->getAbnormalSignalPerceived() && current_goal == sim::Goal::MonitorAbnormal) {
        // set goal to maintain global safety margin
        goal_pt = new BranchGoal();
        goal_pt->setSenderAndReceiver(who, who);   //(sender, receiver)
        goal_pt->setTimerAndProbability(1.0, 1.0 - this->hfe_bbn.getGoalSelectionFailureProbability()); //(remaining time, probability)
        goal_pt->setDecision(sim::Goal::MaintainGlobalSafetyMargin);
        goal_pt->setTypeOfPauseActivity(sim::Decision::Goal);
        g_sim.Branch_center.addGoal(who, goal_pt);
        branch_generated = true;
      } else if (!this->getBlockProcedureUse() && current_goal == sim::Goal::TroubleShoot && this->getAbnormalSignalPerceived()) {
        if (this->getProcedureUseProbability() > 0.9999) {
          // generate a maintain global safety margin branch
          goal_pt = new BranchGoal();
          goal_pt->setSenderAndReceiver(who, who);   //(sender, receiver)
          goal_pt->setTimerAndProbability(1.0, 1.0 - this->hfe_bbn.getGoalSelectionFailureProbability()); //(remaining time, probability)
          goal_pt->setDecision(sim::Goal::MaintainGlobalSafetyMargin);
          goal_pt->setTypeOfPauseActivity(sim::Decision::Goal);
          g_sim.Branch_center.addGoal(who, goal_pt);
          branch_generated = true;
        } else if (this->getProcedureUseProbability() < 0.0001) {
          // bypass maintain global safety margin branch and block long term procedure use
          goal_pt = new BranchGoal();
          goal_pt->setSenderAndReceiver(who, who);   //(sender, receiver)
          goal_pt->setTimerAndProbability(1.0, 1.0 - this->hfe_bbn.getGoalSelectionFailureProbability()); //(remaining time, probability)
          goal_pt->setDecision(sim::Goal::MaintainGlobalSafetyMargin);
          goal_pt->setTypeOfPauseActivity(sim::Decision::Goal);
          goal_pt->setStateOfActivation(sim::Source::Bypass);
          g_sim.Branch_center.addGoal(who, goal_pt);
          //
          branch_generated = true;
        } else {
          // generate maintain global safety margin branch & enable procedure use
          goal_pt = new BranchGoal();
          goal_pt->setSenderAndReceiver(who, who);   //(sender, receiver)
          goal_pt->setTimerAndProbability(1.0, this->getProcedureUseProbability()); //(remaining time, probability)
          goal_pt->setDecision(sim::Goal::MaintainGlobalSafetyMargin);
          goal_pt->setTypeOfPauseActivity(sim::Decision::Goal);
          g_sim.Branch_center.addGoal(who, goal_pt);
          //
          // bypass maintain global safety margin branch & block long term procedure use
          goal_pt = new BranchGoal();
          goal_pt->setSenderAndReceiver(who, who);   //(sender, receiver)
          goal_pt->setTimerAndProbability(1.0, 1.0 - this->getProcedureUseProbability()); //(remaining time, probability)
          goal_pt->setDecision(sim::Goal::MaintainGlobalSafetyMargin);
          goal_pt->setTypeOfPauseActivity(sim::Decision::Goal);
          goal_pt->setStateOfActivation(sim::Source::Bypass);
          g_sim.Branch_center.addGoal(who, goal_pt);
          //
          branch_generated = true;
        }
      }
    }
 
  }
  //
  return branch_generated;
}
 
bool OperatorDM::selectStrategy() {
  InfoChunkMental *wm;
  BranchStrategy *strategy_pt = NULL;
  wm = this->memory.getWorkingMemory();
  bool branch_generated = false;
  int who = sim::Operator::ODM;
 
  if (wm->getCurrentGoal() == sim::Goal::TroubleShoot && wm->getCurrentStrategy() != sim::Strategy::InductiveDeductive) {
    // activate knowledge based reasoning strategy
    strategy_pt = new BranchStrategy();
    strategy_pt->setSenderAndReceiver(who, who);    //(sender, receiver)
    strategy_pt->setTimerAndProbability(1.0, 1.0 - this->hfe_bbn.getStrategySelectionFailureProbability());  //(remaining time, probability)
    strategy_pt->setDecision(sim::Strategy::InductiveDeductive);
    strategy_pt->setTypeOfPauseActivity(sim::Decision::Strategy);
  } else if ((wm->getCurrentGoal() == sim::Goal::MaintainGlobalSafetyMargin || this->memory.perceived_info.getCurrentProcedureName() != "NO_PROCEDURE")
      && wm->getCurrentStrategy() != sim::Strategy::FollowProcedure) {
    // activate follow procedure strategy
    strategy_pt = new BranchStrategy();
    strategy_pt->setSenderAndReceiver(who, who);    //(sender, receiver)
    strategy_pt->setTimerAndProbability(1.0, 1.0 - this->hfe_bbn.getStrategySelectionFailureProbability());  //(remaining time, probability)
    strategy_pt->setDecision(sim::Strategy::FollowProcedure);
    strategy_pt->setTypeOfPauseActivity(sim::Decision::Strategy);
  } else if ((wm->getCurrentGoal() == sim::Goal::NormalOp || wm->getCurrentGoal() == sim::Goal::MonitorAbnormal) && wm->getCurrentStrategy() != sim::Strategy::WaitMonitor) {
    // activate wait and monitor strategy
    strategy_pt = new BranchStrategy();
    strategy_pt->setSenderAndReceiver(who, who);    //(sender, receiver)
    strategy_pt->setTimerAndProbability(1.0, 1.0 - this->hfe_bbn.getStrategySelectionFailureProbability());  //(remaining time, probability)
    strategy_pt->setDecision(sim::Strategy::WaitMonitor);
    strategy_pt->setTypeOfPauseActivity(sim::Decision::Strategy);
  }
 
  //after 60 s, a current procedure and step in working memory select the FollowProcedure strategy
  if (wm->getCurrentStrategy() != sim::Strategy::FollowProcedure && r5pars_.timesno > 60) {
    if ((wm->getCurrentProcedureName() != "NONE")
        && (wm->getCurrentProcedureName() != "NO_PROCEDURE")
        && (wm->getCurrentProceduralStepName() != "NO_STEP")
        && (wm->getCurrentProceduralStepName() != "NONE")) {
      strategy_pt = new BranchStrategy();
      strategy_pt->setSenderAndReceiver(who, who);    //(sender, receiver)
      strategy_pt->setTimerAndProbability(1.0, 1.0 - this->hfe_bbn.getStrategySelectionFailureProbability());  //(remaining time, probability)
      strategy_pt->setDecision(sim::Strategy::FollowProcedure);
      strategy_pt->setTypeOfPauseActivity(sim::Decision::Strategy);
    }
  }
 
  if (strategy_pt != NULL) {
    g_sim.Branch_center.addStrategy(who, strategy_pt);
    branch_generated = true;
  }
 
  return branch_generated;
}
bool OperatorDM::performFollowProcedureStrategy() {
//  InfoChunkMental *wm;
  string _procedure_name, _step_name;
  DecisionProcedureStep *procedure_pt;
  BranchProcedureStep *b_procedure_pt;
  int who = sim::Operator::ODM;
  ProcedureStep *_procedure_step_pt;
  map<string, ProcedureStep *>::iterator procedure_map_itr;
  BranchEndState *es_pt;
  string str;
  bool branch_generated = false;
  //
  procedure_pt = this->memory.perceived_info.getCurrentProcedureStepPtr(sim::Operator::ODM);
  if (procedure_pt == 0) { // i.e. no sim::State::Active or sim::State::Pause procedure steps in memory
    _procedure_name = g_sim.All_procedure.getEntryProcedureName();
    if (_procedure_name != "NO_PROCEDURE") {
      _step_name = g_sim.All_procedure.getEntryStepName();
      // determine if entry procedure has already been executed
      if (this->memory.perceived_info.getStateOfAProcedureStep(_procedure_name, _step_name) == sim::None) {
        b_procedure_pt = new BranchProcedureStep();
        b_procedure_pt->setSenderAndReceiver(who, who);   //(sender, receiver)
        b_procedure_pt->setTimerAndProbability(5.0, 1.0 - this->hfe_bbn.getProcedureStepFailureProbability()); //(remaining time, probability)
        b_procedure_pt->setProcedureName(_procedure_name);
        b_procedure_pt->setStepName(_step_name);
        b_procedure_pt->setTypeOfPauseActivity(sim::Strategy::FollowProcedure);
        g_sim.Branch_center.addProcedureStep(who, b_procedure_pt);
        branch_generated = true;
      } else {
        // do nothing - entry procedure has already been attempted
 
      }
    } else {
      ofstream fout("err messages.txt", ios::app);
      cout << r5pars_.timesno << "OperatorDM::performFollowProcedure: No entry procedure is found." << endl;
      fout << r5pars_.timesno << "  OperatorDM::performFollowProcedure: No entry procedure is found.\n";
      fout.close();
      r5pars_.sim_err = true;
    }
  } else if (procedure_pt->getStateOfActivation() == sim::State::Pause) {
    procedure_pt->setStateOfActivation(sim::State::Active);
    b_procedure_pt = new BranchProcedureStep();
    b_procedure_pt->setSenderAndReceiver(who, who);   //(sender, receiver)
    b_procedure_pt->setTimerAndProbability(5.0, 1.0 - this->hfe_bbn.getProcedureStepFailureProbability()); //(remaining time, probability)
    b_procedure_pt->setProcedureName(procedure_pt->getProcedureName());
    b_procedure_pt->setStepName(procedure_pt->getStepName());
    b_procedure_pt->setTypeOfPauseActivity(sim::Strategy::FollowProcedure);
    g_sim.Branch_center.addProcedureStep(who, 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->oneThroughProcessForProcedureStep(*this,
                                                                               this->getSkipActionThreshold(),
                                                                               this->getSkipNonResponseThreshold(),
                                                                               this->getSkipProcedureStep(),
                                                                               this->memory);
      this->setSkipProcedureStep(false);
    } else {//current procedure does not exist; find previously unfinished procedure
      procedure_pt->setStateOfActivation(sim::State::Failed);
      procedure_pt = this->memory.perceived_info.getCurrentProcedureStepPtr(sim::Operator::ODM);
      //
      if (procedure_pt != 0) {
        _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);
          procedure_pt->setStateOfActivation(sim::State::Active);
          branch_generated = _procedure_step_pt->oneThroughProcessForProcedureStep(*this,
                                                                                   this->getSkipActionThreshold(),
                                                                                   this->getSkipNonResponseThreshold(),
                                                                                   this->getSkipProcedureStep(),
                                                                                   this->memory);
          this->setSkipProcedureStep(false);
        } else {
          procedure_pt->setStateOfActivation(sim::State::Failed);
          es_pt = new BranchEndState();
          str = "Undefined procedure step at ";
          str += procedure_pt->getProcedureName();
          str += ' ';
          str += procedure_pt->getStepName();
          es_pt->setTypeOfConsequence(Consequence::NoKB);
          es_pt->setConsequenceDescription(str);
          g_sim.Branch_center.addAnEndState(es_pt);
          this->setPauseActivity(true);
        }
      } else {
 
        // no other procedure is currently avialable
      }
    }
  }
  return branch_generated;
}
 
void OperatorDM::identifyRelevantInformation() {
  int intended_receiver;
  int sender;
  //
  for (auto &goal_elem : g_sim.Communication_place.goal) {
    intended_receiver = goal_elem->getIntendedReceiver();
    if (intended_receiver == sim::Operator::ODM) {
      if (goal_elem->getStateOfActivation() != sim::Source::Bypass) {
        memory.new_info.goal.push_back(goal_elem);
      } else {
        switch (goal_elem->getDecision()) {
          case sim::Goal::TroubleShoot: this->setBlockTroubleshooting(true);
            break;
          case sim::Goal::MaintainGlobalSafetyMargin: this->setBlockProcedureUse(true);
            break;
          default: break;
        }
      }
      //
      if (goal_elem->getTypeOfPauseActivity() == sim::Decision::Goal) {
        this->setPauseActivity(false);
      }
    }
  }
  for (auto &strategy_elem : g_sim.Communication_place.strategy) {
    intended_receiver = strategy_elem->getIntendedReceiver();
    if (intended_receiver == sim::Operator::ODM) {
      if (strategy_elem->getStateOfActivation() != sim::Source::Bypass) {
        memory.new_info.strategy.push_back(strategy_elem);
      }
      //
      if (strategy_elem->getTypeOfPauseActivity() == sim::Decision::Strategy) {
        this->setPauseActivity(false);
      }
    }
  }
  for (auto &subgoal_elem : g_sim.Communication_place.subgoal) {
    intended_receiver = subgoal_elem->getIntendedReceiver();
    if (intended_receiver == sim::Operator::ODM) {
      if (subgoal_elem->getStateOfActivation() != sim::Source::Bypass) {
        memory.new_info.subgoal.push_back(subgoal_elem);
      }
      if (subgoal_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure) {
        this->setPauseActivity(false);
      } else if (subgoal_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse) {
        this->setPauseMentalProcedure(false);
      }
    }
  }
  for (auto &diagnosis_elem : g_sim.Communication_place.diagnosis) {
    intended_receiver = diagnosis_elem->getIntendedReceiver();
    if (intended_receiver == sim::Operator::ODM) {
      if (diagnosis_elem->getStateOfActivation() != sim::Source::Bypass) {
        memory.new_info.diagnosis.push_back(diagnosis_elem);
      }
      if (diagnosis_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure) {
        this->setPauseActivity(false);
      } else if (diagnosis_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse) {
        this->setPauseMentalProcedure(false);
      }
    }
  }
  for (auto &action_objective_elem : g_sim.Communication_place.action_objective) {
    intended_receiver = action_objective_elem->getIntendedReceiver();
    if (intended_receiver == sim::Operator::ODM) {
      if (action_objective_elem->getStateOfActivation() != sim::Source::Bypass) {
        memory.new_info.action_objective.push_back(action_objective_elem);
      }
      if (action_objective_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure) {
        this->setPauseActivity(false);
      } else if (action_objective_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse) {
        this->setPauseMentalProcedure(false);
      }
    }
  }
  for (auto &action_pack_elem : g_sim.Communication_place.action_pack) {
    intended_receiver = action_pack_elem->getIntendedReceiver();
    if (intended_receiver == sim::Operator::ODM) {
      if (action_pack_elem->getStateOfActivation() != sim::Source::Bypass) {
        memory.new_info.action_pack.push_back(action_pack_elem);
      }
      if (action_pack_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure) {
        this->setPauseActivity(false);
      } else if (action_pack_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse) {
        this->setPauseMentalProcedure(false);
      }
    }
  }
  for (auto &action_elem : g_sim.Communication_place.action) {
    intended_receiver = action_elem->getIntendedReceiver();
    sender = action_elem->getSender();
    if (intended_receiver == sim::Operator::ODM) {
      if (action_elem->getStateOfActivation() != sim::Source::Bypass) {
        memory.new_info.action.push_back(action_elem);
      }
      if (action_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure || action_elem->getTypeOfPauseActivity() == sim::Strategy::InductiveDeductive) {
        this->setPauseActivity(false);
        if (action_elem->getStateOfActivation() == sim::State::Skip) {
          this->setSkipProcedureStep(true);
        }
      } else if (action_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse || action_elem->getTypeOfPauseActivity() == sim::Strategy::FollowInstruction) {
        this->setPauseMentalProcedure(false);
        if (action_elem->getStateOfActivation() == sim::State::Skip) {
          this->setSkipInstinctiveResponseStep(true);
        }
      }
    }
  }
  for (auto &procedure_step_elem : g_sim.Communication_place.procedure_step) {
    intended_receiver = procedure_step_elem->getIntendedReceiver();
    sender = procedure_step_elem->getSender();
    if (intended_receiver == sim::Operator::ODM) {
      if (procedure_step_elem->getStateOfActivation() != sim::Source::Bypass) {
        memory.new_info.procedure_step.push_back(procedure_step_elem);
        if (procedure_step_elem->getStateOfActivation() != sim::State::Skip) {
          this->checkAndResetProcedureStep(procedure_step_elem.get());
        }
      }
      if (procedure_step_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure
          || procedure_step_elem->getTypeOfPauseActivity() == sim::Branch::ProcedureXfr) {
        this->setPauseActivity(false);
        if (procedure_step_elem->getStateOfActivation() == sim::State::Skip) {
          this->setSkipProcedureStep(true);
        }
      } else if (procedure_step_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse) {
        this->setPauseMentalProcedure(false);
        if (procedure_step_elem->getStateOfActivation() == sim::State::Skip) {
          this->setSkipInstinctiveResponseStep(true);
        }
      }
    }
  }
  for (auto &procedure_step_elem : g_sim.Communication_place.instinctive_response_procedure) {
    intended_receiver = procedure_step_elem->getIntendedReceiver();
    sender = procedure_step_elem->getSender();
    if (intended_receiver == sim::Operator::ODM) {
      if (procedure_step_elem->getStateOfActivation() != sim::Source::Bypass) {
        memory.new_info.instinctive_response_procedure.push_back(procedure_step_elem);
        if (procedure_step_elem->getStateOfActivation() != sim::State::Skip) {
          this->checkAndResetProcedureStep(procedure_step_elem.get());
        }
      }
      if (procedure_step_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure) {
        this->setPauseActivity(false);
        if (procedure_step_elem->getStateOfActivation() == sim::State::Skip) {
          this->setSkipProcedureStep(true);
        }
      } else if (procedure_step_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse
          || procedure_step_elem->getTypeOfPauseActivity() == sim::Strategy::FollowInstruction) {
        this->setPauseMentalProcedure(false);
        if (procedure_step_elem->getStateOfActivation() == sim::State::Skip) {
          this->setSkipInstinctiveResponseStep(true);
        }
      }
    }
  }
  for (auto &info_gather_mode_elem : g_sim.Communication_place.info_gather_mode) {
    intended_receiver = info_gather_mode_elem->getIntendedReceiver();
    sender = info_gather_mode_elem->getSender();
    if (intended_receiver == sim::Operator::ODM) {
      this->memory.setInfoGatherMode(info_gather_mode_elem->getInfoGatherMode());
      if (info_gather_mode_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure
          || info_gather_mode_elem->getTypeOfPauseActivity() == sim::Branch::InfoGatherMode) {
        this->setPauseActivity(false);
      } else if (info_gather_mode_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse) {
        this->setPauseMentalProcedure(false);
      }
    }
  }
  for (auto &mental_belief_elem : g_sim.Communication_place.mental_belief) {
    int state_of_activation;
    intended_receiver = mental_belief_elem->getIntendedReceiver();
    if (mental_belief_elem->getIntendedReceiver() == sim::Operator::ODM) {
      state_of_activation = mental_belief_elem->getStateOfActivation();
      if (state_of_activation != sim::State::OldInfo && state_of_activation != sim::Source::Bypass) {
        this->memory.new_info.mental_belief.push_back(mental_belief_elem);
      }
      if (mental_belief_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure
          || mental_belief_elem->getTypeOfPauseActivity() == sim::Strategy::InductiveDeductive) {
        this->setPauseActivity(false);
        if (mental_belief_elem->getStateOfActivation() == sim::State::Skip) {
          this->setSkipProcedureStep(true);
        }
      } else if (mental_belief_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse) {
        this->setPauseMentalProcedure(false);
        if (mental_belief_elem->getStateOfActivation() == sim::State::Skip) {
          this->setSkipInstinctiveResponseStep(true);
        }
      }
    }
  }
 
  for (auto &scanned_parameter_elem : g_sim.Communication_place.scanned_parameter) {
    int state_of_activation;
    intended_receiver = scanned_parameter_elem->getIntendedReceiver();
    if (scanned_parameter_elem->getIntendedReceiver() == sim::Operator::ODM) {
      state_of_activation = scanned_parameter_elem->getStateOfActivation();
      if (state_of_activation != sim::State::OldInfo && state_of_activation != sim::Source::Bypass) {
        this->memory.new_info.scanned_parameter.push_back(scanned_parameter_elem);
      }
      if (scanned_parameter_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure
          || scanned_parameter_elem->getTypeOfPauseActivity() == sim::ControlAction::ParameterScan) {
        this->setPauseActivity(false);
        if (scanned_parameter_elem->getStateOfActivation() == sim::State::Skip) {
          this->setSkipProcedureStep(true);
        }
      } else if (scanned_parameter_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse
          || scanned_parameter_elem->getTypeOfPauseActivity() == sim::Strategy::FollowInstruction) {
        this->setPauseMentalProcedure(false);
        if (scanned_parameter_elem->getStateOfActivation() == sim::State::Skip) {
          this->setSkipInstinctiveResponseStep(true);
        }
      }
    }
  }
 
  for (auto &alarm_state_elem : g_sim.Communication_place.alarm_state) {
    intended_receiver = alarm_state_elem->getIntendedReceiver();
    if (intended_receiver == sim::Operator::ODM || intended_receiver == sim::Operator::OdmScan) {
      if (alarm_state_elem->getStateOfActivation() != sim::Source::Bypass
          && alarm_state_elem->getStateOfActivation() != sim::State::OldInfo) {
        memory.new_info.alarm_state.push_back(alarm_state_elem);
      }
      if (intended_receiver == sim::Operator::ODM) {
        if (alarm_state_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure
            || alarm_state_elem->getTypeOfPauseActivity() == sim::Strategy::InductiveDeductive) {
          this->setPauseActivity(false);
        } else if (alarm_state_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse
            || alarm_state_elem->getTypeOfPauseActivity() == sim::Strategy::FollowInstruction) {
          this->setPauseMentalProcedure(false);
        }
      }
    }
  }
  for (auto &component_state_elem : g_sim.Communication_place.component_state) {
    intended_receiver = component_state_elem->getIntendedReceiver();
    if (intended_receiver == sim::Operator::ODM || intended_receiver == sim::Operator::OdmScan) {
      if (component_state_elem->getStateOfActivation() != sim::Source::Bypass
          && component_state_elem->getStateOfActivation() != sim::State::OldInfo) {
        memory.new_info.component_state.push_back(component_state_elem);
      }
      if (intended_receiver == sim::Operator::ODM) {
        if (component_state_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure
            || component_state_elem->getTypeOfPauseActivity() == sim::Strategy::InductiveDeductive) {
          this->setPauseActivity(false);
        } else if (component_state_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse
            || component_state_elem->getTypeOfPauseActivity() == sim::Strategy::FollowInstruction) {
          this->setPauseMentalProcedure(false);
        }
      }
    }
  }
  for (auto &support_system_state_elem : g_sim.Communication_place.support_system_state) {
    intended_receiver = support_system_state_elem->getIntendedReceiver();
    if (intended_receiver == sim::Operator::ODM || intended_receiver == sim::Operator::OdmScan) {
      if (support_system_state_elem->getStateOfActivation() != sim::Source::Bypass
          && support_system_state_elem->getStateOfActivation() != sim::State::OldInfo) {
        memory.new_info.support_system_state.push_back(support_system_state_elem);
      }
      if (intended_receiver == sim::Operator::ODM) {
        if (support_system_state_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure
            || support_system_state_elem->getTypeOfPauseActivity() == sim::Strategy::InductiveDeductive) {
          this->setPauseActivity(false);
        } else if (support_system_state_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse
            || support_system_state_elem->getTypeOfPauseActivity() == sim::Strategy::FollowInstruction) {
          this->setPauseMentalProcedure(false);
        }
      }
    }
  }
  for (auto &parameter_trend_elem : g_sim.Communication_place.parameter_trend) {
    intended_receiver = parameter_trend_elem->getIntendedReceiver();
    if (intended_receiver == sim::Operator::ODM || intended_receiver == sim::Operator::OdmScan) {
      if (parameter_trend_elem->getStateOfActivation() != sim::Source::Bypass
          && parameter_trend_elem->getStateOfActivation() != sim::State::OldInfo) {
        memory.new_info.parameter_trend.push_back(parameter_trend_elem);
      }
      if (intended_receiver == sim::Operator::ODM) {
        if (parameter_trend_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure
            || parameter_trend_elem->getTypeOfPauseActivity() == sim::Strategy::InductiveDeductive) {
          this->setPauseActivity(false);
        } else if (parameter_trend_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse
            || parameter_trend_elem->getTypeOfPauseActivity() == sim::Strategy::FollowInstruction) {
          this->setPauseMentalProcedure(false);
        }
      }
    }
  }
  for (auto &parameter_value_elem : g_sim.Communication_place.parameter_value) {
    intended_receiver = parameter_value_elem->getIntendedReceiver();
    if (intended_receiver == sim::Operator::ODM || intended_receiver == sim::Operator::OdmScan) {
      if (parameter_value_elem->getStateOfActivation() != sim::Source::Bypass
          && parameter_value_elem->getStateOfActivation() != sim::State::OldInfo) {
        memory.new_info.parameter_value.push_back(parameter_value_elem);
      }
      if (intended_receiver == sim::Operator::ODM) {
        if (parameter_value_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure
            || parameter_value_elem->getTypeOfPauseActivity() == sim::Strategy::InductiveDeductive) {
          this->setPauseActivity(false);
        } else if (parameter_value_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse
            || parameter_value_elem->getTypeOfPauseActivity() == sim::Strategy::FollowInstruction) {
          this->setPauseMentalProcedure(false);
        }
      }
    }
  }
  for (auto &parameter_difference_elem : g_sim.Communication_place.parameter_difference) {
    intended_receiver = parameter_difference_elem->getIntendedReceiver();
    if (intended_receiver == sim::Operator::ODM || intended_receiver == sim::Operator::OdmScan) {
      if (parameter_difference_elem->getStateOfActivation() != sim::Source::Bypass
          && parameter_difference_elem->getStateOfActivation() != sim::State::OldInfo) {
        memory.new_info.parameter_difference.push_back(parameter_difference_elem);
      }
      if (intended_receiver == sim::Operator::ODM) {
        if (parameter_difference_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure
            || parameter_difference_elem->getTypeOfPauseActivity() == sim::Strategy::InductiveDeductive) {
          this->setPauseActivity(false);
        } else if (parameter_difference_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse
            || parameter_difference_elem->getTypeOfPauseActivity() == sim::Strategy::FollowInstruction) {
          this->setPauseMentalProcedure(false);
        }
      }
    }
  }
  for (auto &new_alarm_elem : g_sim.Communication_place.new_alarm) {
    intended_receiver = new_alarm_elem->getIntendedReceiver();
    if (intended_receiver == sim::Operator::ODM || intended_receiver == sim::None) {
      memory.new_info.new_alarm.push_back(new_alarm_elem);
    }
  }
 
}
void OperatorDM::scanControlPanel() {
//
//  perform control panel instrument scan every scan_periodicity
  //
  if ((r5pars_.timesno - scanned_indicators.getLastPanelScanTime()) >= scanned_indicators.getScanPeriodicity()) {
    this->quantificationFilter(); // Item priority is reduced based on the age of the item in the queue and its relevance to the diagnosis, even be removed from the queue
    this->scanned_indicators.setLastPanelScanTime(r5pars_.timesno);
    for (auto& elem : this->scanned_indicators.parameter_scan_list) {
      //
      elem->setTimeAtWhichThisInfoIsPerceived(r5pars_.timesno);
      elem->setTimeOfCommunication(r5pars_.timesno);
      elem->setIntendedReceiver(sim::Source::Plant);
      elem->setSender(sim::Operator::OdmScan);
      g_sim.Communication_place.parameter_value.push_back(elem);
    }
    for (auto& elem : this->scanned_indicators.component_scan_list) {
      elem->setTimeAtWhichThisInfoIsPerceived(r5pars_.timesno);
      elem->setTimeOfCommunication(r5pars_.timesno);
      elem->setIntendedReceiver(sim::Source::Plant);
      elem->setSender(sim::Operator::OdmScan);
      g_sim.Communication_place.component_state.push_back(elem);
    }
    for (auto& elem : this->scanned_indicators.support_system_scan_list) {
      elem->setTimeAtWhichThisInfoIsPerceived(r5pars_.timesno);
      elem->setTimeOfCommunication(r5pars_.timesno);
      elem->setIntendedReceiver(sim::Source::Plant);
      elem->setSender(sim::Operator::OdmScan);
      g_sim.Communication_place.support_system_state.push_back(elem);
    }
    for (auto& elem : this->scanned_indicators.alarm_scan_list) {
      elem->setTimeAtWhichThisInfoIsPerceived(r5pars_.timesno);
      elem->setTimeOfCommunication(r5pars_.timesno);
      elem->setIntendedReceiver(sim::Source::Plant);
      elem->setSender(sim::Operator::OdmScan);
      g_sim.Communication_place.alarm_state.push_back(elem);
    }
    g_sim.Aux_info.addScanQueueData(r5pars_.timesno, this->getTypeOfOperator(), this->scanned_indicators);
  }
}
 
void OperatorDM::oneThroughProcessForBlockI() {
  bool branch_generated;
  bool reactor_tripped = false;
  int num_branch, goal;
  int total_new_items;
  string limiting_tcl_parameter;
  BranchScannedParameter *b_scan_pt;
  ExpectedMentalBelief *emb_pt;
  InfoChunkMental *wm;
  this->setNewBranchGenerated(false);
  wm = this->memory.getWorkingMemory();
  this->receiveNewInformation();
  goal = this->memory.getCurrentGoal();
  this->checkAndExecuteManeuverAction();
  //
  //chunking info and update the confidence level on Hardwired KB based on the newly perceived information
  total_new_items = this->infoChunking();
  //
  this->information_load.addInformationLoadData(r5pars_.timesno, total_new_items);
  this->information_load.calculateAverageInformationLoadPIFValue();
  //
  this->knowledge_base.KBcalculateHardWiredConfidence();
  if (this->getPauseMentalProcedure() == false && this->getPauseActivity() == false) {
    branch_generated = this->checkAndActivateHWKB();
    if (branch_generated) this->setPauseMentalProcedure(true);
    this->memory.calculatePriorityAndSetStateOfActivation();
  }
  //
  this->diagnosis_matrix.updateBothRationalConfidence(this->knowledge_base);
  this->safety_parameters.updateAllSPDSValueAndRate(&this->memory.perceived_info);
  this->time_constrained_load.operatorUpdateTimeConstrainedValuesWithGoal(&this->memory.perceived_info);
  if (this->time_constrained_load.getTimeConstrainedPIFValue() > 5) {
    // if tcl is high, verify that main driver for time constrained load is in the scan queue
    if (!this->getPauseActivity() && !this->getPauseMentalProcedure()) {
      // generate branch to add prime time constrained load to scan queue
      limiting_tcl_parameter = this->time_constrained_load.determineLimitingTimeConstrainedParameter();
      if (!this->scanned_indicators.checkIfParameterInQueue(limiting_tcl_parameter)) {
        // add parameter to scan queue
        b_scan_pt = new BranchScannedParameter();
        b_scan_pt->setInfoName(limiting_tcl_parameter);
        b_scan_pt->setTypeOfScannedParameter(sim::Comm::ParameterValue);
        b_scan_pt->setScanPriority(1);
        b_scan_pt->setSenderAndReceiver(sim::Operator::ODM, sim::Operator::ODM);
        b_scan_pt->setTimerAndProbability(0.0, 1.0 - this->hfe_bbn.getGatherNewInfoFailureProbability());
        b_scan_pt->setTypeOfPauseActivity(sim::ControlAction::ParameterScan);
        g_sim.Branch_center.addScannedParameter(sim::Operator::ODM, b_scan_pt);
        this->setPauseActivity(true);
      }
    }
  }
  //
  if (!this->getAbnormalSignalPerceived() && !this->getPauseMentalProcedure()) {
    emb_pt = this->memory.perceived_info.checkExistanceOfMentalBelief("Reactor_Tripped");
    if (emb_pt != 0) {
      if (emb_pt->getStateOfActivation() == sim::State::Succeed) {
        reactor_tripped = true;
      }
    }
    switch (goal) {
      case sim::Goal::MonitorAbnormal:
        if ((this->diagnosis_matrix.getAbnormalConfidence() > this->getAbnormalSignalThreshold()) || reactor_tripped) {
          this->setAbnormalSignalPerceived(true);
          this->interruptLowPriorityMentalProcedures();
        }
        break;
      case sim::Goal::TroubleShoot:
        if (reactor_tripped) {
          this->setAbnormalSignalPerceived(true);
          this->interruptLowPriorityMentalProcedures();
        }
        break;
      case sim::Goal::MaintainGlobalSafetyMargin: this->setAbnormalSignalPerceived(true);
        break;
      case sim::Goal::NormalOp:
        // do nothing
        break;
      case sim::None:
        // do nothing
        break;
      default: ofstream fout("err messages.txt", ios::app);
        cout << r5pars_.timesno << " OperatorDM::oneThroughProcessForBlockI: "
             << g_sim.Translator.getString(wm->getCurrentGoal()) << " can not be recognized" << endl;
        fout << r5pars_.timesno << " OperatorDM::oneThroughProcessForBlockI: "
             << g_sim.Translator.getString(wm->getCurrentGoal()) << " can not be recognized\n";
        fout.close();
        this->setAbnormalSignalPerceived(true);
        //
        break;
    }
  }
 
  //
  if (this->getAbnormalSignalPerceived() && !this->getPauseMentalProcedure() && !this->getPauseActivity()) {
    num_branch = generateInfoGatherModeBranch();
    if (num_branch > 0) { this->setNewBranchGenerated(true); }
  }
}
void OperatorDM::receiveNewInformation() {
  //info identification and screening
  this->memory.clearNewInfo();
  identifyRelevantInformation();
  Operator::biasFilter();      //NEED MORE WORK
  //Operator::quantificationFilter(); //NEED MORE WORK
}
int OperatorDM::infoChunking() {
/*
A. register perceived information
  Go piece by piece of perceived new information (relevant_new_info) to
  1. Add the piece of new information to perceived informatin list (perceived_info)
  2. Check whether new InfoChunkMental should be added to the ShhortTermMemory based on teh sub-system; add InfoChunkMental if needed
  3. Add pointer in InfoChunkMental to the information in the piece of info in the perceived_info.
B. Update confidence level of KB::Hardwired diagnosis
*/
//  vector<BranchExpectedParameterTrend *>::iterator parameter_trend_elem;
//
  ProcedureStep *pps_pt = 0;
  DecisionAction *action_pt = 0;
  DecisionProcedureStep *procedure_step_pt = 0;
  MentalAlarm *perceived_alarms_pt = 0;
  MentalComponentState *perceived_component_state_pt = 0;
  MentalSupportSystemState *perceived_support_system_state_pt = 0;
  MentalParameterValue *perceived_parameter_value_pt = 0;
  ExpectedMentalBelief *mental_belief_pt1;
  //
  InfoChunkMental *wm = memory.getWorkingMemory();
  int sender;
  int total_chunked_items = 0;
  string _procedure_name, _step_name, mental_belief_name;
  map<string, ProcedureStep *>::iterator procedure_map_itr;
  BranchEndState *es_pt;
  string str;
//
  for (auto &goal_elem : memory.new_info.goal) {
    auto goal_sp = std::make_shared<DecisionGoal>();
    goal_sp->copyDecisionGoal(*goal_elem);
    goal_sp->setStateOfActivation(sim::State::Active);
    memory.perceived_info.goal.push_back(goal_sp);
    wm->pointToTheNewGoal(goal_sp.get());
    total_chunked_items += 1;
  }
  for (auto &strategy_elem : memory.new_info.strategy) {
    auto strategy_sp = std::make_shared<DecisionStrategy>();
    strategy_sp->copyDecisionStrategy(*strategy_elem);
    strategy_sp->setStateOfActivation(sim::State::Active);
    memory.perceived_info.strategy.push_back(strategy_sp);
    wm->pointToTheNewStrategy(strategy_sp.get());
    total_chunked_items += 1;
  }
  for (auto &subgoal_elem : memory.new_info.subgoal) {
    auto subgoal_sp = std::make_shared<DecisionSubGoal>();
    subgoal_sp->copyDecisionSubGoal(*subgoal_elem);
    subgoal_sp->setStateOfActivation(sim::State::Active);
    memory.perceived_info.subgoal.push_back(subgoal_sp);
    wm->pointToTheNewSubGoal(subgoal_sp.get());
    total_chunked_items += 1;
  }
  for (auto &diagnosis_elem : memory.new_info.diagnosis) {
    auto diagnosis_sp = std::make_shared<DecisionDiagnosis>();
    diagnosis_sp->copyDecisionDiagnosis(*diagnosis_elem);
    diagnosis_sp->setStateOfActivation(sim::State::Active);
    sender = diagnosis_elem->getSender();
    if (sender == sim::Operator::ODM) {
      diagnosis_sp->setStateOfActivation(sim::State::Active);
      this->memory.addNewInfoChunkMentalForTheDiagnosis(diagnosis_sp.get());
    } else if (sender == sim::Operator::OCT) {
      diagnosis_sp->setStateOfActivation(sim::None);
    } else {}
    memory.perceived_info.diagnosis.push_back(diagnosis_sp);
    this->knowledge_base.KBcheckHardWiredMatchForMentalBelief(diagnosis_elem->getDiagnosis(), sim::State::Succeed);
    total_chunked_items += 1;
  }
  for (auto &action_objective_elem : memory.new_info.action_objective) {
    auto action_objective_sp = std::make_shared<DecisionActionObjective>();
    action_objective_sp->copyDecisionActionObjective(*action_objective_elem);
    action_objective_sp->setStateOfActivation(sim::State::Active);
    memory.perceived_info.action_objective.push_back(action_objective_sp);
    wm->pointToTheNewActionObjective(action_objective_sp.get());
    total_chunked_items += 1;
  }
  for (auto &action_pack_elem : memory.new_info.action_pack) {
    auto action_pack_sp = std::make_shared<DecisionActionPack>();
    action_pack_sp->copyDecisionActionPack(*action_pack_elem);
    action_pack_sp->setStateOfActivation(sim::State::Active);
    memory.perceived_info.action_pack.push_back(action_pack_sp);
    wm->pointToTheNewActionPack(action_pack_sp.get());
    total_chunked_items += 1;
  }
  for (auto &action_elem : memory.new_info.action) {
    action_pt = this->memory.perceived_info.checkExistanceOfAction(action_elem->getActionName());
    if (action_pt == 0) {//info has not been perceived before
      auto action_sp = std::make_shared<DecisionAction>();
      action_sp->copyDecisionAction(*action_elem);
      if (action_elem->getStateOfActivation() == sim::State::Skip) {
        action_sp->setStateOfActivation(sim::State::Skip);
      } else {
        action_sp->setStateOfActivation(sim::State::Succeed);
      }
      memory.perceived_info.action.push_back(action_sp);
      wm->pointToTheNewAction(action_sp.get());
      this->knowledge_base.KBcheckHardWiredMatchForControl(action_sp->getActionName(), action_sp->getControlValue());
    } else {
      action_pt->copyDecisionAction(*action_elem);
      if (action_elem->getStateOfActivation() == sim::State::Skip) {
        action_pt->setStateOfActivation(sim::State::Skip);
      } else {
        action_pt->setStateOfActivation(sim::State::Succeed);
      }
      wm->pointToTheNewAction(action_pt);
      this->knowledge_base.KBcheckHardWiredMatchForControl(action_pt->getActionName(), action_pt->getControlValue());
    }
    total_chunked_items += 1;
  }
 
  for (auto &scanned_parameter_elem : memory.new_info.scanned_parameter) {
    string name;
    int scan_priority;
    if (scanned_parameter_elem->getStateOfActivation() != sim::State::Skip) {
      name = scanned_parameter_elem->getInfoName();
      scan_priority = scanned_parameter_elem->getScanPriority();
      switch (scanned_parameter_elem->getTypeOfScannedParameter()) {
 
        case sim::Comm::ParameterValue: this->scanned_indicators.addScannedParameter(name, scan_priority);
          break;
 
        case sim::Comm::ComponentState: this->scanned_indicators.addScannedComponent(name, scan_priority);
          break;
 
        case sim::Comm::SupportSystemState: this->scanned_indicators.addScannedSupportSystem(name, scan_priority);
          break;
 
        case sim::Comm::AlarmState: this->scanned_indicators.addScannedAlarm(name, scan_priority);
          break;
 
        default:
          // not a valid scan parameter
 
          break;
      }
      total_chunked_items += 1;
    }
 
  }
 
  for (auto &procedure_step_elem : memory.new_info.procedure_step) {
    _procedure_name = procedure_step_elem->getProcedureName();
    _step_name = procedure_step_elem->getStepName();
    procedure_step_pt = this->memory.perceived_info.checkExistanceOfAProcedure(_procedure_name, _step_name);
    if (procedure_step_pt == 0) {
      auto procedure_step_sp = std::make_shared<DecisionProcedureStep>();
      procedure_step_sp->copyDecisionProcedureStep(*procedure_step_elem);
      procedure_step_sp->setStateOfActivation(sim::State::Active);
      memory.perceived_info.procedure_step.push_back(procedure_step_sp);
      procedure_step_pt = procedure_step_sp.get();
    } else {
      procedure_step_pt->setStateOfActivation(sim::State::Active);
    }
    // check for hard wired diagnosis match
    if (procedure_step_pt->getProcedureName() != procedure_step_pt->getLastProcedureName()) {
      this->knowledge_base.KBcheckHardWiredMatchForProcedureActivity(procedure_step_pt->getProcedureName(),
                                                                     procedure_step_pt->getStateOfActivation());
      this->knowledge_base.KBcheckHardWiredMatchForProcedureActivity(procedure_step_pt->getLastProcedureName(), sim::State::Done);
    }
    wm->pointToTheNewProcedureStep(procedure_step_pt);
    //update the  activation state of the procedue step
    _procedure_name = procedure_step_pt->getProcedureName();
    _step_name = procedure_step_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()) {
      pps_pt = procedure_map_itr->second;
      pps_pt->setStateOfActivation(sim::State::Active);
    } else {
      es_pt = new BranchEndState();
      str = "Undefined procedure step at ";
      str += procedure_step_pt->getProcedureName();
      str += ' ';
      str += procedure_step_pt->getStepName();
      es_pt->setTypeOfConsequence(Consequence::NoKB);
      es_pt->setConsequenceDescription(str);
      g_sim.Branch_center.addAnEndState(es_pt);
 
      int branch_number = g_sim.Branch_center.getIDOfRecentGeneratedBranch();
      g_sim.Command_handler.displayInformation(str);
      g_sim.Aux_info.addRecord(str, branch_number);
    }
    total_chunked_items += 1;
  }
  for (auto &procedure_step_elem : memory.new_info.instinctive_response_procedure) {
    _procedure_name = procedure_step_elem->getProcedureName();
    _step_name = procedure_step_elem->getStepName();
    // check if instinctive response procedure has already been placed in memory and has not already been completed (sim::State::Done) or interrupted (VINTERRUPT)
    procedure_step_pt =
        this->memory.perceived_info.checkExistanceOfAnInstinctiveResponseProcedure(_procedure_name, _step_name);
    if (procedure_step_pt == 0) {
      auto procedure_step_sp = std::make_shared<DecisionProcedureStep>();
      procedure_step_sp->copyDecisionProcedureStep(*procedure_step_elem);
      procedure_step_sp->setStateOfActivation(sim::State::Active);
      memory.perceived_info.instinctive_response_procedure.push_back(procedure_step_sp);
      procedure_step_pt = procedure_step_sp.get();
    } else {
      procedure_step_pt->setStateOfActivation(sim::State::Active);
    }
    //
    if (procedure_step_pt->getProcedureName() != procedure_step_pt->getLastProcedureName()) {
      this->knowledge_base.KBcheckHardWiredMatchForProcedureActivity(procedure_step_pt->getProcedureName(),
                                                                     procedure_step_pt->getStateOfActivation());
      this->knowledge_base.KBcheckHardWiredMatchForProcedureActivity(procedure_step_pt->getLastProcedureName(), sim::State::Done);
    }
    //
    wm->pointToTheNewInstinctiveResponseProcedureStep(procedure_step_pt);
    //update the mark of activation state of the procedue step
    _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()) {
      pps_pt = procedure_map_itr->second;
      pps_pt->setStateOfActivation(sim::State::Active);
    } else {
      procedure_step_pt->setStateOfActivation(sim::State::Failed);
      wm->setStateOfActivation(sim::State::Done);
      this->memory.failCurrentDiagnosisAndActivateAPausedDiagnosis();
      cout << "Warning OperatorDM::infoChunking: mental procedure_step " << _procedure_name
           << " is not within the Procedures.txt" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  Warning OperatorDM::infoChunking: mental procedure_step " << _procedure_name
           << " is not witin the Procedures.txt\n";
      fout.close();
    }
    total_chunked_items += 1;
  }
  for (auto &mental_belief_elem : memory.new_info.mental_belief) {
    mental_belief_name = mental_belief_elem->getInfoName();
    mental_belief_pt1 = this->memory.perceived_info.checkExistanceOfMentalBelief(mental_belief_name);
    if (mental_belief_pt1 == 0) { // belief has not been perceived
      // memorize the mental belief
      auto mental_belief_sp = std::make_shared<ExpectedMentalBelief>();
      mental_belief_sp->copyExpectedMentalBelief(*mental_belief_elem);
      memory.perceived_info.mental_belief.push_back(mental_belief_sp);
    } else {
      mental_belief_pt1->copyExpectedMentalBelief(*mental_belief_elem);
    }
    _procedure_name = this->knowledge_base.getProcedureNameOfHWDiagnosis(mental_belief_elem->getInfoName());
    _step_name = this->knowledge_base.getStepNameOfHWDiagnosis(mental_belief_elem->getInfoName());
    if (_procedure_name != "NONE" && _procedure_name != "None") {
      this->memory.perceived_info.addNewInstinctiveResponseProcedure(_procedure_name,
                                                                     _step_name,
                                                                     mental_belief_elem->getMentalPriority(),
                                                                     sim::State::Waiting,
                                                                     mental_belief_elem->getActivationTime());
    }
    this->knowledge_base.KBcheckHardWiredMatchForMentalBelief(mental_belief_elem->getInfoName(),
                                                              mental_belief_elem->getStateOfActivation());
    total_chunked_items += 1;
  }
  for (auto &alarm_state_elem : memory.new_info.alarm_state) {
    perceived_alarms_pt =
        this->memory.perceived_info.checkExistanceOfPerceivedAlarms(alarm_state_elem->getAlarmName());
    if (perceived_alarms_pt == 0) {//the alarm has not been perceived
      auto alarm_sp = std::make_shared<MentalAlarm>();
      alarm_sp->copyMentalAlarm(*alarm_state_elem);
      memory.perceived_info.perceived_alarms.push_back(alarm_sp);
      perceived_alarms_pt = alarm_sp.get();
      memory.checkAndGenerateInfoChunkMentalForRelatedAlarm(perceived_alarms_pt, this->knowledge_base);
    } else {//the operator perceived alarm earlier of the sequence
      //perceived_alarms_pt->setDisplayedAlarmState(alarm_state_elem->getDisplayedAlarmState());
      perceived_alarms_pt->setObservedAlarmState(alarm_state_elem->getObservedAlarmState());
      perceived_alarms_pt->setTimeAtWhichThisInfoIsPerceived(alarm_state_elem->getTimeAtWhichThisInfoIsPerceived());
    }
    if (g_sim.config.rm_cycle_enabled && this->m_RM) this->m_RM->m_tbi_A_list.push_back(perceived_alarms_pt); // only the RM reasoning cycle (disabled by default) consumes these
    //check point
    if (r5pars_.timesno > 119) { total_chunked_items += 0; }
    this->knowledge_base.KBcheckHardWiredMatchForAlarmState(perceived_alarms_pt->getAlarmName(),
                                                            perceived_alarms_pt->getObservedAlarmState());//KB Hardwired Update
    total_chunked_items += 1;
  }
  for (auto &new_alarm_elem : memory.new_info.new_alarm) {
    perceived_alarms_pt = this->memory.perceived_info.checkExistanceOfPerceivedAlarms(new_alarm_elem->getAlarmName());
    if (perceived_alarms_pt == 0) {//the alarm has not been perceived
      auto alarm_sp = std::make_shared<MentalAlarm>();
      alarm_sp->copyAlarmElement(*new_alarm_elem);
      alarm_sp->setObservedAlarmState(new_alarm_elem->getDisplayedAlarmState());
      memory.perceived_info.perceived_alarms.push_back(alarm_sp);
      perceived_alarms_pt = alarm_sp.get();
      memory.checkAndGenerateInfoChunkMentalForRelatedAlarm(perceived_alarms_pt, this->knowledge_base);
    } else {//the operator perceived alarm earlier of the sequence
      //perceived_alarms_pt->setDisplayedAlarmState(new_alarm_elem->getDisplayedAlarmState());
      perceived_alarms_pt->setObservedAlarmState(new_alarm_elem->getDisplayedAlarmState());
      perceived_alarms_pt->setTimeAtWhichThisInfoIsPerceived(new_alarm_elem->getTimeAtWhichThisAlarmIsActivated());
      perceived_alarms_pt->setTimeAtWhichThisAlarmIsActivated(new_alarm_elem->getTimeAtWhichThisAlarmIsActivated());
    }
    if (g_sim.config.rm_cycle_enabled && this->m_RM) this->m_RM->m_tbi_A_list.push_back(perceived_alarms_pt); // only the RM reasoning cycle (disabled by default) consumes these
    //check point
    if (r5pars_.timesno > 119) { total_chunked_items += 0; }
    this->knowledge_base.KBcheckHardWiredMatchForAlarmState(perceived_alarms_pt->getAlarmName(),
                                                            perceived_alarms_pt->getObservedAlarmState());//KB Hardwired Update
    total_chunked_items += 1;
  }
  for (auto &component_state_elem : memory.new_info.component_state) {
    perceived_component_state_pt =
        this->memory.perceived_info.checkExistanceOfPerceivedComponentState(component_state_elem->getDisplayName());
    if (perceived_component_state_pt == 0) {
      auto component_state_sp = std::make_shared<MentalComponentState>();
      component_state_sp->copyMentalComponentState(*component_state_elem);
      memory.perceived_info.perceived_component_state.push_back(component_state_sp);
      perceived_component_state_pt = component_state_sp.get();
      memory.checkAndGenerateInfoChunkMentalForRelatedComponentState(perceived_component_state_pt,
                                                                     this->knowledge_base);
    } else {
      perceived_component_state_pt->setObservedComponentState(component_state_elem->getObservedComponentState());
      perceived_component_state_pt->setTimeAtWhichThisInfoIsPerceived(component_state_elem->getTimeAtWhichThisInfoIsPerceived());
    }
    if (g_sim.config.rm_cycle_enabled && this->m_RM) this->m_RM->m_tbi_C_list.push_back(perceived_component_state_pt);
    this->knowledge_base.KBcheckHardWiredMatchForComponentState(perceived_component_state_pt->getDisplayName(),
                                                                perceived_component_state_pt->getObservedComponentState());//KB Hardwired Update
    total_chunked_items += 1;
  }
  for (auto &support_system_state_elem : memory.new_info.support_system_state) {
    perceived_support_system_state_pt =
        this->memory.perceived_info.checkExistanceOfPerceivedSupportSystemState(support_system_state_elem->getDisplayName());
    if (perceived_support_system_state_pt == 0) {
      auto support_system_state_sp = std::make_shared<MentalSupportSystemState>();
      support_system_state_sp->copyMentalSupportSystemState(*support_system_state_elem);
      memory.perceived_info.perceived_support_system_state.push_back(support_system_state_sp);
      perceived_support_system_state_pt = support_system_state_sp.get();
      memory.checkAndGenerateInfoChunkMentalForRelatedSupportSystemState(perceived_support_system_state_pt,
                                                                         this->knowledge_base);
    } else {
      perceived_support_system_state_pt->setObservedSupportSystemState(support_system_state_elem->getObservedSupportSystemState());
      perceived_support_system_state_pt->setTimeAtWhichThisInfoIsPerceived(support_system_state_elem->getTimeAtWhichThisInfoIsPerceived());
    }
    if (g_sim.config.rm_cycle_enabled && this->m_RM) this->m_RM->m_tbi_SS_list.push_back(perceived_support_system_state_pt);
    this->knowledge_base.KBcheckHardWiredMatchForSupportSystemState(perceived_support_system_state_pt->getDisplayName(),
                                                                    perceived_support_system_state_pt->getObservedSupportSystemState());//KB Hardwired Update
    total_chunked_items += 1;
  }
  for (auto &parameter_value_elem : memory.new_info.parameter_value) {
    perceived_parameter_value_pt =
        this->memory.perceived_info.checkExistanceOfPerceivedParameterValue(parameter_value_elem->getDisplayName());
    if (perceived_parameter_value_pt == 0) {
      auto parameter_value_sp = std::make_shared<MentalParameterValue>();
      parameter_value_sp->copyMentalParameterValue(*parameter_value_elem);
      memory.perceived_info.perceived_parameter_value.push_back(parameter_value_sp);
      perceived_parameter_value_pt = parameter_value_sp.get();
      memory.checkAndGenerateInfoChunkMentalForRelatedParameterValue(perceived_parameter_value_pt,
                                                                     this->knowledge_base);
    } else {
      perceived_parameter_value_pt->setObservedParameterValue(parameter_value_elem->getObservedParameterValue());
      perceived_parameter_value_pt->setTimeAtWhichThisInfoIsPerceived(parameter_value_elem->getTimeAtWhichThisInfoIsPerceived());
    }
    // clear memory created for parameter scan function
    //if (parameter_value_elem->getIntendedReceiver() == sim::Operator::OdmScan) {
    //delete *parameter_value_elem;
    //Communication_place.parameter_value.erase(parameter_value_elem);
    //}
    if (g_sim.config.rm_cycle_enabled && this->m_RM) this->m_RM->m_tbi_P_list.push_back(perceived_parameter_value_pt);
    this->knowledge_base.KBcheckHardWiredMatchForParameterValue(perceived_parameter_value_pt->getDisplayName(),
                                                                perceived_parameter_value_pt->getObservedParameterValue(),
                                                                sim::Operator::ODM);//KB Hardwired Update
    total_chunked_items += 1;
  }
  for (auto &parameter_difference_elem : memory.new_info.parameter_difference) {
    // check if first difference parameter has been previously memorized
    perceived_parameter_value_pt =
        this->memory.perceived_info.checkExistanceOfPerceivedParameterValue(parameter_difference_elem->first_mental_parameter.getDisplayName());
    if (perceived_parameter_value_pt == 0) {
      auto param_value_sp = std::make_shared<MentalParameterValue>();
      param_value_sp->copyMentalParameterValue(parameter_difference_elem->first_mental_parameter);
      memory.perceived_info.perceived_parameter_value.push_back(param_value_sp);
      perceived_parameter_value_pt = param_value_sp.get();
      memory.checkAndGenerateInfoChunkMentalForRelatedParameterValue(perceived_parameter_value_pt,
                                                                     this->knowledge_base);
    } else {
      perceived_parameter_value_pt->setObservedParameterValue(parameter_difference_elem->first_mental_parameter.getObservedParameterValue());
      perceived_parameter_value_pt->setTimeAtWhichThisInfoIsPerceived(parameter_difference_elem->first_mental_parameter.getTimeAtWhichThisInfoIsPerceived());
    }
    this->knowledge_base.KBcheckHardWiredMatchForParameterValue(perceived_parameter_value_pt->getDisplayName(),
                                                                perceived_parameter_value_pt->getObservedParameterValue(),
                                                                sim::Operator::ODM);//KB Hardwired Update
    //check if second difference parameter has been previously memorized
    perceived_parameter_value_pt =
        this->memory.perceived_info.checkExistanceOfPerceivedParameterValue(parameter_difference_elem->second_mental_parameter.getDisplayName());
    if (perceived_parameter_value_pt == 0) {
      auto param_value_sp2 = std::make_shared<MentalParameterValue>();
      param_value_sp2->copyMentalParameterValue(parameter_difference_elem->second_mental_parameter);
      memory.perceived_info.perceived_parameter_value.push_back(param_value_sp2);
      perceived_parameter_value_pt = param_value_sp2.get();
      memory.checkAndGenerateInfoChunkMentalForRelatedParameterValue(perceived_parameter_value_pt,
                                                                     this->knowledge_base);
    } else {
      perceived_parameter_value_pt->setObservedParameterValue(parameter_difference_elem->second_mental_parameter.getObservedParameterValue());
      perceived_parameter_value_pt->setTimeAtWhichThisInfoIsPerceived(parameter_difference_elem->second_mental_parameter.getTimeAtWhichThisInfoIsPerceived());
    }
    this->knowledge_base.KBcheckHardWiredMatchForParameterValue(perceived_parameter_value_pt->getDisplayName(),
                                                                perceived_parameter_value_pt->getObservedParameterValue(),
                                                                sim::Operator::ODM);//KB Hardwired Update
    total_chunked_items += 1;
  }
  return total_chunked_items;
 
}
void OperatorDM::copyOperatorDMToRestartInfo(OperatorDM &_operator) {
  Operator::copyOperatorToRestartInfo(_operator);
}
void OperatorDM::copyOperatorDMFromRestartInfo(OperatorDM &_operator) {
  Operator::copyOperatorFromRestartInfo(_operator);
}
void OperatorDM::copyOperatorDMFromRestartInfoMultiProcessor(OperatorDM &_operator) {
  Operator::copyOperatorFromRestartInfoMultiProcessor(_operator);
}
 
void OperatorDM::clearOperatorDMForRestart() {
  Operator::clearOperatorForRestart();
}
void OperatorDM::clearOperatorDMFromRestartInfo() {
  Operator::clearOperatorFromRestartInfo();
}
void OperatorDM::clearOperatorDMFinal() {
  Operator::clearOperatorFinal();
}
void OperatorDM::clearOperatorDMFromRestartNodeInfoMultiProcessors() {
  Operator::clearOperatorFromRestartNodeInfoMultiProcessors();
}
bool OperatorDM::performRecoveryAction() {
  InfoChunkMental *wm;
  string _procedure_name, _step_name, diagnosis;
  DecisionProcedureStep *procedure_pt;
  BranchProcedureStep *b_procedure_pt;
  int who = sim::Operator::ODM;
  ProcedureStep *_procedure_step_pt;
  map<string, ProcedureStep *>::iterator procedure_map_itr;
  string str;
//
  wm = this->memory.getWorkingMemory();
  bool branch_generated = false;
  procedure_pt = wm->getCurrentInstinctiveResponseProcedurePtr();
  if (procedure_pt == 0) {
    diagnosis = wm->getCurrentDiagnosis();
    if (diagnosis != "NONE") {
      _procedure_name = this->knowledge_base.getProcedureNameOfHWDiagnosis(diagnosis);
      _step_name = this->knowledge_base.getStepNameOfHWDiagnosis(diagnosis);
      b_procedure_pt = new BranchProcedureStep();
      b_procedure_pt->setSenderAndReceiver(who, who);//(sender, receiver)
      b_procedure_pt->setTimerAndProbability(5.0, 1.0 - this->hfe_bbn.getProcedureStepFailureProbability());//(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(who, b_procedure_pt);
      branch_generated = true;
    } else {
      ofstream fout("err messages.txt", ios::app);
      cout << "OperatorDM::performFollowProcedure: No entry procedure is found." << endl;
      fout << r5pars_.timesno << "  OperatorDM::performFollowProcedure: No entry procedure is found.\n";
      fout.close();
      r5pars_.sim_err = true;
    }
  } else {
    diagnosis = wm->getCurrentDiagnosis();
    _procedure_name = this->knowledge_base.getProcedureNameOfHWDiagnosis(diagnosis);
    _step_name = this->knowledge_base.getStepNameOfHWDiagnosis(diagnosis);
    _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);
    } else {
      wm->setStateOfActivation(sim::State::Done);
      this->memory.activatePausedInfoChunck();
    }
  }
  return branch_generated;
}
 
void OperatorDM::saveOperatorDMToFile(ofstream &fout) {
  fout << "OperatorDM\n";
  this->saveOperatorToFile(fout);
}
void OperatorDM::retrieveOperatorDMFromFile(ifstream &fin) {
  string str;
  fin >> str;
  if (str != "OperatorDM") {
    ofstream fout("err messages.txt", ios::app);
    cout << "OperatorDM::retrieveOperatorDMFromFile File retrieval error in previous function" << endl;
    fout << r5pars_.timesno << "  OperatorDM::retrieveOperatorDMFromFile File retrieval error in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("OperatorDM::retrieveOperatorDMFromFile Prior error");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
  this->retrieveOperatorFromFile(fin);
}