OperatorAT.cpp

Go to the documentation of this file.

// OperatorAT.cpp: implementation of the OperatorAT class.
//
 
#include "OperatorAT.h"
#include "OperatorDM.h"
#include "../Procedure/Procedures.h"
#include <boost/serialization/export.hpp>
#include "../Global/SimulationContext.h"
using namespace std;
 
 
// Construction/Destruction
 
OperatorAT::OperatorAT() {
  this->setTypeOfOperator(sim::Operator::OAT);
}
 
OperatorAT::~OperatorAT() {
}
void OperatorAT::oneThroughProcessForBlockD() {
  bool branch_generated;
  bool block_VSIR = false;
  bool block_decision_process = false;
  bool mental_procedure_in_progress = false;
  string ODM_IR_procedure_name, ODM_IR_step_name;
  InfoChunkMental *_wm;
  //
  // block instinctive response procedure if Decision Maker is waiting for information
  if (this->existOrderedActivity() || this->getPauseActivity() || this->getNewBranchGenerated()) {
    block_VSIR = true;
  }
  //
  if (!this->getPauseMentalProcedure() && !block_VSIR) {
    ODM_IR_procedure_name = g_sim.Decision_Maker.memory.perceived_info.getCurrentInstinctiveResponseProcedureName();
    ODM_IR_step_name = g_sim.Decision_Maker.memory.perceived_info.getCurrentInstinctiveResponseProceduralStepName();
    bool isThere = this->memory.perceived_info.isThereMentalProcedureWaitingForExecution(ODM_IR_procedure_name,
                                                                              ODM_IR_step_name);
    if (isThere) {
      mental_procedure_in_progress = true;
      branch_generated = this->performAMentalProcedure(sim::Operator::OAT, ODM_IR_procedure_name, ODM_IR_step_name);
      if (branch_generated) {
        this->setPauseMentalProcedure(true);
        return;
      }
    }
  }
  //
  if (this->getPauseActivity() || this->getPauseMentalProcedure() || mental_procedure_in_progress) {
    block_decision_process = true;
  }
  if ((this->getAbnormalSignalPerceived() || this->existOrderedActivity()) && !block_decision_process)
    //
  {
    branch_generated = selectGoal();
    if (branch_generated) {
      this->setPauseActivity(true);
      return;
    }
    branch_generated = selectStrategy();
    if (branch_generated) {
      this->setPauseActivity(true);
      return;
    }
    //
    _wm = this->memory.getWorkingMemory();
    //
    if (_wm->getCurrentStrategy() == sim::Strategy::FollowInstruction && this->existOrderedActivity()) {
      branch_generated = performFollowInstructionStrategy();
      if (branch_generated) {
        this->setPauseActivity(true);
        return;
      }
    }
  }
}
 
bool OperatorAT::selectGoal() {
  // action_taker goal is set to be consistent with decision_maker
  InfoChunkMental *wm;
  BranchGoal *goal_pt;
  int ODM_goal;
  wm = this->memory.getWorkingMemory();
  bool branch_generated = false;
  int who = sim::Operator::OAT;
  ODM_goal = g_sim.Decision_Maker.memory.getCurrentGoal();
  //
  // set OAT goal equal to ODM goal
  if (wm->getCurrentGoal() != ODM_goal) {
    goal_pt = new BranchGoal();
    goal_pt->setSenderAndReceiver(who, who);//(sender, receiver)
    goal_pt->setTimerAndProbability(1.0, 1.0 - this->hfe_bbn.getGoalCommunicationFailureProbability());//(remaining time, probability)
    goal_pt->setDecision(ODM_goal);
    goal_pt->setTypeOfPauseActivity(sim::Decision::Goal);
    g_sim.Branch_center.addGoal(who, goal_pt);
    branch_generated = true;
  }
  return branch_generated;
}
 
bool OperatorAT::selectStrategy() {
  InfoChunkMental *wm, *d_wm;
  BranchStrategy *strategy_pt;
  wm = this->memory.getWorkingMemory();
  bool branch_generated = false;
  int who = sim::Operator::OAT;
  d_wm = g_sim.Decision_Maker.memory.getWorkingMemory();
  if ((d_wm->getCurrentStrategy() == sim::Strategy::FollowProcedure || this->existOrderedActivity()) && wm->getCurrentStrategy() != sim::Strategy::FollowInstruction) {
    strategy_pt = new BranchStrategy();
    strategy_pt->setSenderAndReceiver(who, who);   //(sender, receiver)
    strategy_pt->setTimerAndProbability(1.0, 1.0 - this->hfe_bbn.getStrategyCommunicationFailureProbability()); //(remaining time, probability)
    strategy_pt->setDecision(sim::Strategy::FollowInstruction);
    strategy_pt->setTypeOfPauseActivity(sim::Decision::Strategy);
    g_sim.Branch_center.addStrategy(who, strategy_pt);
    branch_generated = true;
  } else if ((wm->getCurrentGoal() == sim::Goal::MaintainGlobalSafetyMargin || wm->getCurrentGoal() == sim::Goal::TroubleShoot) && wm->getCurrentStrategy() != sim::Strategy::FollowInstruction) {
    strategy_pt = new BranchStrategy();
    strategy_pt->setSenderAndReceiver(who, who);   //(sender, receiver)
    strategy_pt->setTimerAndProbability(1.0, 1.0 - this->hfe_bbn.getStrategyCommunicationFailureProbability()); //(remaining time, probability)
    strategy_pt->setDecision(sim::Strategy::FollowInstruction);
    strategy_pt->setTypeOfPauseActivity(sim::Decision::Strategy);
    g_sim.Branch_center.addStrategy(who, strategy_pt);
    branch_generated = true;
  } else {}
  return branch_generated;
}
void OperatorAT::identifyRelevantInformation() {
  int intended_receiver;
  int sender;
  //
  for (auto &goal_elem : g_sim.Communication_place.goal) {
    intended_receiver = goal_elem->getIntendedReceiver();
    sender = goal_elem->getSender();
    if (intended_receiver == sim::Operator::OAT) {
      if (goal_elem->getStateOfActivation() != sim::Source::Bypass) {
        memory.new_info.goal.push_back(goal_elem);
      } else if (goal_elem->getDecision() == sim::Goal::TroubleShoot) {  // bypass troubleshooting goal
        this->setBlockTroubleshooting(true);
      }
      //
      if (goal_elem->getTypeOfPauseActivity() == sim::Decision::Goal) {
        this->setPauseActivity(false);
      }
    }
  }
  for (auto &strategy_elem : g_sim.Communication_place.strategy) {
    intended_receiver = strategy_elem->getIntendedReceiver();
    sender = strategy_elem->getSender();
    if (intended_receiver == sim::Operator::OAT) {
      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();
    sender = subgoal_elem->getSender();
    if (intended_receiver == sim::Operator::OAT) {
      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);
      }
    }
    if (sender == sim::Operator::OAT && intended_receiver == sim::Operator::ODM && subgoal_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure) {
      this->setPauseActivity(false);
    }
  }
  for (auto &diagnosis_elem : g_sim.Communication_place.diagnosis) {
    intended_receiver = diagnosis_elem->getIntendedReceiver();
    sender = diagnosis_elem->getSender();
    if (intended_receiver == sim::Operator::OAT) {
      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);
      }
    }
    if (sender == sim::Operator::OAT && intended_receiver == sim::Operator::ODM && diagnosis_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure) {
      this->setPauseActivity(false);
    }
  }
  for (auto &action_objective_elem : g_sim.Communication_place.action_objective) {
    intended_receiver = action_objective_elem->getIntendedReceiver();
    sender = action_objective_elem->getSender();
    if (intended_receiver == sim::Operator::OAT) {
      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);
      }
    }
    if (sender == sim::Operator::OAT && intended_receiver == sim::Operator::ODM && action_objective_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure) {
      this->setPauseActivity(false);
    }
  }
  for (auto &action_pack_elem : g_sim.Communication_place.action_pack) {
    intended_receiver = action_pack_elem->getIntendedReceiver();
    sender = action_pack_elem->getSender();
    if (intended_receiver == sim::Operator::OAT) {
      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);
      }
    }
    if (sender == sim::Operator::OAT && intended_receiver == sim::Operator::ODM && action_pack_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure) {
      this->setPauseActivity(false);
    }
  }
  for (auto &action_elem : g_sim.Communication_place.action) {
    intended_receiver = action_elem->getIntendedReceiver();
    sender = action_elem->getSender();
    if (intended_receiver == sim::Operator::OAT) {
      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
          || action_elem->getTypeOfPauseActivity() == sim::Strategy::FollowInstruction) {
        if (sender != sim::Operator::ODM) {
          // action is ordered by ODM - do not reset pause activity flag
          this->setPauseActivity(false);
        }
        if (action_elem->getStateOfActivation() == sim::State::Skip) {
          this->setSkipProcedureStep(true);
        }
      } else if (action_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse) {
        this->setPauseMentalProcedure(false);
        if (action_elem->getStateOfActivation() == sim::State::Skip) {
          this->setSkipInstinctiveResponseStep(true);
        }
      }
    }
    //
    if (sender == sim::Operator::OAT && intended_receiver == sim::Operator::ODM && action_elem->getTypeOfPauseActivity() != sim::Strategy::InstinctiveResponse) {
      this->setPauseActivity(false);
    }
  }
  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::OAT) {
      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) {
        if (sender != sim::Operator::ODM) {
          // action is ordered by ODM - do not reset pause activity flag
          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);
        }
      }
    }
    if (sender == sim::Operator::OAT && intended_receiver == sim::Operator::ODM && procedure_step_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure) {
      this->setPauseActivity(false);
    }
  }
  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::OAT) {
      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) {
        this->setPauseMentalProcedure(false);
        if (procedure_step_elem->getStateOfActivation() == sim::State::Skip) {
          this->setSkipInstinctiveResponseStep(true);
        }
      }
    }
    if (sender == sim::Operator::OAT && intended_receiver == sim::Operator::ODM && procedure_step_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure) {
      this->setPauseActivity(false);
    }
  }
  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::OAT) {
      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);
      }
    }
    if (sender == sim::Operator::OAT && intended_receiver == sim::Operator::ODM && info_gather_mode_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure) {
      this->setPauseActivity(false);
    }
  }
  for (auto &mental_belief_elem : g_sim.Communication_place.mental_belief) {
    int state_of_activation;
    intended_receiver = mental_belief_elem->getIntendedReceiver();
    sender = mental_belief_elem->getSender();
    if (mental_belief_elem->getIntendedReceiver() == sim::Operator::OAT) {
      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);
      } else if (mental_belief_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse) {
        this->setPauseMentalProcedure(false);
      }
    }
    if (sender == sim::Operator::OAT && intended_receiver == sim::Operator::ODM && mental_belief_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure) {
      this->setPauseActivity(false);
    }
  }
 
  for (auto &scanned_parameter_elem : g_sim.Communication_place.scanned_parameter) {
    int state_of_activation;
    intended_receiver = scanned_parameter_elem->getIntendedReceiver();
    sender = scanned_parameter_elem->getSender();
    if (scanned_parameter_elem->getIntendedReceiver() == sim::Operator::OAT) {
      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::Strategy::FollowInstruction
          || 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) {
        this->setPauseMentalProcedure(false);
        if (scanned_parameter_elem->getStateOfActivation() == sim::State::Skip) {
          this->setSkipInstinctiveResponseStep(true);
        }
      }
    }
    if (sender == sim::Operator::OAT && intended_receiver == sim::Operator::ODM && scanned_parameter_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure) {
      this->setPauseActivity(false);
    }
  }
 
  for (auto &alarm_state_elem : g_sim.Communication_place.alarm_state) {
    intended_receiver = alarm_state_elem->getIntendedReceiver();
    sender = alarm_state_elem->getSender();
    if (intended_receiver == sim::Operator::OAT || intended_receiver == sim::Operator::OatScan) {
      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::OAT) {
        if (alarm_state_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure
            || alarm_state_elem->getTypeOfPauseActivity() == sim::Strategy::InductiveDeductive
            || alarm_state_elem->getTypeOfPauseActivity() == sim::Strategy::FollowInstruction) {
          if (sender != sim::Operator::ODM) {
            // action is ordered by ODM - do not reset pause activity flag
            this->setPauseActivity(false);
          }
        } else if (alarm_state_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse) {
          this->setPauseMentalProcedure(false);
        }
      }
    }
    //
    if (sender == sim::Operator::OAT && intended_receiver == sim::Operator::ODM && alarm_state_elem->getTypeOfPauseActivity() != sim::Strategy::InstinctiveResponse) {
      this->setPauseActivity(false);
    }
  }
  for (auto &component_state_elem : g_sim.Communication_place.component_state) {
    intended_receiver = component_state_elem->getIntendedReceiver();
    sender = component_state_elem->getSender();
    if (intended_receiver == sim::Operator::OAT || intended_receiver == sim::Operator::OatScan) {
      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::OAT) {
        if (component_state_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure
            || component_state_elem->getTypeOfPauseActivity() == sim::Strategy::InductiveDeductive
            || component_state_elem->getTypeOfPauseActivity() == sim::Strategy::FollowInstruction) {
          if (sender != sim::Operator::ODM) {
            // action is ordered by ODM - do not reset pause activity flag
            this->setPauseActivity(false);
          }
        } else if (component_state_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse) {
          this->setPauseMentalProcedure(false);
        }
      }
    }
    //
    if (sender == sim::Operator::OAT && intended_receiver == sim::Operator::ODM && component_state_elem->getTypeOfPauseActivity() != sim::Strategy::InstinctiveResponse) {
      this->setPauseActivity(false);
    }
  }
  for (auto &support_system_state_elem : g_sim.Communication_place.support_system_state) {
    intended_receiver = support_system_state_elem->getIntendedReceiver();
    sender = support_system_state_elem->getSender();
    if (intended_receiver == sim::Operator::OAT || intended_receiver == sim::Operator::OatScan) {
      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::OAT) {
        if (support_system_state_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure
            || support_system_state_elem->getTypeOfPauseActivity() == sim::Strategy::InductiveDeductive
            || support_system_state_elem->getTypeOfPauseActivity() == sim::Strategy::FollowInstruction) {
          if (sender != sim::Operator::ODM) {
            // action is ordered by ODM - do not reset pause activity flag
            this->setPauseActivity(false);
          }
        } else if (support_system_state_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse) {
          this->setPauseMentalProcedure(false);
        }
      }
    }
    //
    if (sender == sim::Operator::OAT && intended_receiver == sim::Operator::ODM && support_system_state_elem->getTypeOfPauseActivity() != sim::Strategy::InstinctiveResponse) {
      this->setPauseActivity(false);
    }
  }
  for (auto &parameter_trend_elem : g_sim.Communication_place.parameter_trend) {
    intended_receiver = parameter_trend_elem->getIntendedReceiver();
    sender = parameter_trend_elem->getSender();
    if (intended_receiver == sim::Operator::OAT || intended_receiver == sim::Operator::OatScan) {
      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::OAT) {
        if (parameter_trend_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure
            || parameter_trend_elem->getTypeOfPauseActivity() == sim::Strategy::InductiveDeductive
            || parameter_trend_elem->getTypeOfPauseActivity() == sim::Strategy::FollowInstruction) {
          if (sender != sim::Operator::ODM) {
            // action is ordered by ODM - do not reset pause activity flag
            this->setPauseActivity(false);
          }
        } else if (parameter_trend_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse) {
          this->setPauseMentalProcedure(false);
        }
      }
    }
    //
    if (sender == sim::Operator::OAT && intended_receiver == sim::Operator::ODM && parameter_trend_elem->getTypeOfPauseActivity() != sim::Strategy::InstinctiveResponse) {
      this->setPauseActivity(false);
    }
  }
  for (auto &parameter_value_elem : g_sim.Communication_place.parameter_value) {
    intended_receiver = parameter_value_elem->getIntendedReceiver();
    sender = parameter_value_elem->getSender();
    if (intended_receiver == sim::Operator::OAT || intended_receiver == sim::Operator::OatScan) {
      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::OAT) {
        if (parameter_value_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure
            || parameter_value_elem->getTypeOfPauseActivity() == sim::Strategy::InductiveDeductive
            || parameter_value_elem->getTypeOfPauseActivity() == sim::Strategy::FollowInstruction) {
          if (sender != sim::Operator::ODM) {
            // action is ordered by ODM - do not reset pause activity flag
            this->setPauseActivity(false);
          }
        } else if (parameter_value_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse) {
          this->setPauseMentalProcedure(false);
        }
 
      }
    }
    //
    if (sender == sim::Operator::OAT && intended_receiver == sim::Operator::ODM && parameter_value_elem->getTypeOfPauseActivity() != sim::Strategy::InstinctiveResponse) {
      this->setPauseActivity(false);
    }
  }
  for (auto &parameter_difference_elem : g_sim.Communication_place.parameter_difference) {
    intended_receiver = parameter_difference_elem->getIntendedReceiver();
    sender = parameter_difference_elem->getSender();
    if (intended_receiver == sim::Operator::OAT || intended_receiver == sim::Operator::OatScan) {
      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::OAT) {
        if (parameter_difference_elem->getTypeOfPauseActivity() == sim::Strategy::FollowProcedure
            || parameter_difference_elem->getTypeOfPauseActivity() == sim::Strategy::InductiveDeductive
            || parameter_difference_elem->getTypeOfPauseActivity() == sim::Strategy::FollowInstruction) {
          if (sender != sim::Operator::ODM) {
            // action is ordered by ODM - do not reset pause activity flag
            this->setPauseActivity(false);
          }
        } else if (parameter_difference_elem->getTypeOfPauseActivity() == sim::Strategy::InstinctiveResponse) {
          this->setPauseMentalProcedure(false);
        }
 
      }
    }
    //
    if (sender == sim::Operator::OAT && intended_receiver == sim::Operator::ODM && parameter_difference_elem->getTypeOfPauseActivity() != sim::Strategy::InstinctiveResponse) {
      this->setPauseActivity(false);
    }
  }
  for (auto &new_alarm_elem : g_sim.Communication_place.new_alarm) {
    intended_receiver = new_alarm_elem->getIntendedReceiver();
    sender = new_alarm_elem->getSender();
    if (intended_receiver == sim::Operator::OAT || intended_receiver == sim::None) {
      memory.new_info.new_alarm.push_back(new_alarm_elem);
    }
 
  }
 
}
void OperatorAT::scanControlPanel() {
//
//  perform control panel instrument scan every scan_periodicity
//  panel scan is currently set up to handle only parameter values and trends
  //
  if ((r5pars_.timesno - scanned_indicators.getLastPanelScanTime()) >= scanned_indicators.getScanPeriodicity()) {
    this->quantificationFilter();
    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::OatScan);
      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::OatScan);
      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::OatScan);
      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::OatScan);
      g_sim.Communication_place.alarm_state.push_back(elem);
    }
    g_sim.Aux_info.addScanQueueData(r5pars_.timesno, this->getTypeOfOperator(), this->scanned_indicators);
  }
}
 
void OperatorAT::oneThroughProcessForBlockI() {
  int num_branch, goal;
  int total_new_items;
  bool branch_generated;
  bool reactor_tripped = false;
  BranchScannedParameter *b_scan_pt;
  string limiting_tcl_parameter;
  ExpectedMentalBelief *emb_pt;
  this->setNewBranchGenerated(false);
  this->receiveNewInformation();
  //
  goal = this->memory.getCurrentGoal();
  this->checkAndExecuteManeuverAction();
  //
  total_new_items = this->infoChunking();
  //
  // calculate information load
  this->information_load.addInformationLoadData(r5pars_.timesno, total_new_items);
  this->information_load.calculateAverageInformationLoadPIFValue();
  //
  this->knowledge_base.KBcalculateHardWiredConfidence();
  //
  if (this->getPauseMentalProcedure() == false && this->getPauseActivity() == false
      && this->existOrderedActivity() == 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() > 1) {
    // if tcl is high, verify that main driver for time constrained load is in the scan queue
    if (!this->getPauseActivity() && !this->getPauseMentalProcedure() && !this->existOrderedActivity()) {
      // generate branch to add limiting 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::OAT, sim::Operator::OAT);
        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::OAT, b_scan_pt);
        this->setPauseActivity(true);
      }
    }
  }
  //
  //set abnormal signal perceived flag based on abnormal event confidence
  if (!this->getPauseMentalProcedure() && !this->getAbnormalSignalPerceived()) {
    emb_pt = this->memory.perceived_info.checkExistanceOfMentalBelief("Reactor_Tripped");
    if (emb_pt != 0) {
      if (emb_pt->getStateOfActivation() == sim::State::Succeed) {
        reactor_tripped = true;
      }
    }
    if ((this->diagnosis_matrix.getAbnormalConfidence() > this->getAbnormalSignalThreshold()) || reactor_tripped) {
      this->setAbnormalSignalPerceived(true);
      //
      // set all currently active low priority instinctive response procedures to sim::State::Interrupted
      this->interruptLowPriorityMentalProcedures();
    }
  }
  //
  //
  if (this->getAbnormalSignalPerceived() && !this->getPauseMentalProcedure() && !this->getPauseActivity()) {
    num_branch = generateInfoGatherModeBranch();
    if (num_branch > 0) { this->setNewBranchGenerated(true); }
  }
}
 
void OperatorAT::receiveNewInformation() {
  //info identification and screening
  this->memory.clearNewInfo();
  identifyRelevantInformation();
  Operator::biasFilter();      // NEED MORE WORK
  //Operator::quantificationFilter(); // NEED MORE WORK
//info relating and grouping
}
 
int OperatorAT::getNumberOfOrderedAction() {
  int n_return;
  n_return = ordered_action.size() +
      ordered_alarm_state.size() +
      ordered_component_state.size() +
      ordered_support_system_state.size() +
      ordered_parameter_trend.size() +
      ordered_parameter_value.size() +
      ordered_parameter_difference.size();
  return n_return;
}
int OperatorAT::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;
//
  BranchAction *b_action_pt;
  BranchExpectedAlarmState *b_alarm_state_pt;
  BranchExpectedComponentState *b_component_state_pt;
  BranchExpectedSupportSystemState *b_support_system_state_pt;
  BranchExpectedParameterValue *b_parameter_value_pt;
  BranchExpectedParameterDifference *b_parameter_difference_pt;
//
  DecisionProcedureStep *procedure_step_pt;
  DecisionAction *action_pt1;
  MentalAlarm *perceived_alarms_pt1;
  MentalComponentState *perceived_component_state_pt1;
  MentalSupportSystemState *perceived_support_system_state_pt1;
  MentalParameterValue *perceived_parameter_value_pt1;
  ExpectedMentalBelief *mental_belief_pt1;
  map<string, ProcedureStep *>::iterator procedure_map_itr;
  ProcedureStep *pps_pt = 0;
  //
  InfoChunkMental *wm = memory.getWorkingMemory();
  int sender, intended_received;
  int total_chunked_items = 0;
  string _procedure_name, _step_name, mental_belief_name;
  bool found_info;
//
  for (auto &goal_elem : memory.new_info.goal) {
    auto goal_sp = 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 = 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 = 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 = make_shared<DecisionDiagnosis>();
    diagnosis_sp->copyDecisionDiagnosis(*diagnosis_elem);
    diagnosis_sp->setStateOfActivation(sim::State::Active);
    memory.perceived_info.diagnosis.push_back(diagnosis_sp);
    memory.addNewInfoChunkMentalForTheDiagnosis(diagnosis_sp.get());
    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 = make_shared<DecisionActionObjective>();
    action_objective_sp->copyDecisionActionObjective((DecisionActionObjective &) (*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 = 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) {
    sender = action_elem->getSender();
    total_chunked_items += 1;
    if (sender == sim::Operator::ODM) {
      //for the response which to follow
      {
        auto p = make_unique<BranchAction>();
        p->copyBranchAction(*action_elem);
        p->setSender(sim::Operator::OAT);
        p->setIntendedReceiver(sim::Source::Plant);
        this->ordered_action.push_back(std::move(p));
      }
    } else if (sender == sim::Source::Plant) {
      found_info = this->checkExistanceOfOrderedAction(action_elem->getActionName());
      action_pt1 = this->memory.perceived_info.checkExistanceOfAction(action_elem->getActionName());
      if (action_pt1 == 0) {//info has not been perceived before
        auto action_sp = make_shared<DecisionAction>();
        action_sp->copyDecisionAction(*action_elem);
        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_pt1->copyDecisionAction(*action_elem);
        action_pt1->setStateOfActivation(sim::State::Succeed);
        wm->pointToTheNewAction(action_pt1);
        this->knowledge_base.KBcheckHardWiredMatchForControl(action_pt1->getActionName(),
                                                             action_pt1->getControlValue());
      }
      if (found_info) {//Action is requested by the Decision Maker
        b_action_pt = new BranchAction();
        b_action_pt->copyBranchAction(*action_elem);
        b_action_pt->setTimerAndProbability(0.0, 1.0 - this->hfe_bbn.getManeuverActionFailureProbability());
        b_action_pt->setSender(sim::Operator::OAT);
        b_action_pt->setIntendedReceiver(sim::Operator::ODM);
        g_sim.Branch_center.addAction(sim::Operator::OAT, b_action_pt);
        this->setPauseActivity(true);
        this->removeOrderedActionMemoryAndPointer(action_elem->getActionName());
      }
    } else {//do nothing
    }
  }
 
  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) {
    auto procedure_step_sp = 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);
    if (procedure_step_sp->getProcedureName() != procedure_step_sp->getLastProcedureName()) {
      this->knowledge_base.KBcheckHardWiredMatchForProcedureActivity(procedure_step_sp->getProcedureName(),
                                                                     procedure_step_sp->getStateOfActivation());
      this->knowledge_base.KBcheckHardWiredMatchForProcedureActivity(procedure_step_sp->getLastProcedureName(), sim::State::Done);
    }
    wm->pointToTheNewProcedureStep(procedure_step_sp.get());
    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();
    procedure_step_pt =
        this->memory.perceived_info.checkExistanceOfAnInstinctiveResponseProcedure(_procedure_name, _step_name);
    if (procedure_step_pt == 0) {
      auto irp_sp = make_shared<DecisionProcedureStep>();
      irp_sp->copyDecisionProcedureStep(*procedure_step_elem);
      irp_sp->setStateOfActivation(sim::State::Active);
      memory.perceived_info.instinctive_response_procedure.push_back(irp_sp);
      procedure_step_pt = irp_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 OperatorAT::infoChunking: mental procedure_step " << _procedure_name
           << " is not within the Procedures.txt" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  Warning OperatorAT::infoChunking: mental procedure_step " << _procedure_name
           << " is not witin the Procedures.txt\n";
      fout.close();
    }
    total_chunked_items += 1;
  }
  for (auto &alarm_state_elem : memory.new_info.alarm_state) {
    sender = alarm_state_elem->getSender();
    total_chunked_items += 1;
    if (sender == sim::Operator::ODM) {//order from ODM is received; need to check plant state and reply back to ODM
      //for the response which to follow
      {
        auto p = make_unique<BranchExpectedAlarmState>();
        p->copyBranchExpectedAlarmState(*alarm_state_elem);
        p->setBothTotalTimeRequiredAndRemainingTime(1.0);
        p->setSender(sim::Operator::OAT);
        p->setIntendedReceiver(sim::Source::Plant);
        this->ordered_alarm_state.push_back(std::move(p));
      }
    } else if (sender == sim::Source::Plant) {
      found_info = this->checkExistanceOfOrderedAlarmState(alarm_state_elem->getAlarmName());
      perceived_alarms_pt1 =
          this->memory.perceived_info.checkExistanceOfPerceivedAlarms(alarm_state_elem->getAlarmName());
      if (perceived_alarms_pt1 == 0) {//Info has not been perceived before
        //memorize the info
        auto alarm_sp = make_shared<MentalAlarm>();
        alarm_sp->copyMentalAlarm(*alarm_state_elem);
        memory.perceived_info.perceived_alarms.push_back(alarm_sp);
        memory.checkAndGenerateInfoChunkMentalForRelatedAlarm(alarm_sp.get(), this->knowledge_base);
        this->knowledge_base.KBcheckHardWiredMatchForAlarmState(alarm_sp->getAlarmName(),
                                                                alarm_sp->getObservedAlarmState());//KB Hardwired Update
      } else {
        perceived_alarms_pt1->copyMentalAlarm(*alarm_state_elem);
        this->knowledge_base.KBcheckHardWiredMatchForAlarmState(perceived_alarms_pt1->getAlarmName(),
                                                                perceived_alarms_pt1->getObservedAlarmState());//KB Hardwired Update
      }
      if (found_info
          && alarm_state_elem->getIntendedReceiver() != sim::Operator::OatScan) {//alarm is requested by the Decision Maker
        //reply to ODM
        b_alarm_state_pt = new BranchExpectedAlarmState();
        b_alarm_state_pt->copyBranchExpectedAlarmState(*alarm_state_elem);
        b_alarm_state_pt->setTimerAndProbability(0.0, 1.0 - this->hfe_bbn.getPerceiveStateInfoFailureProbability());
        b_alarm_state_pt->setSender(sim::Operator::OAT);
        b_alarm_state_pt->setIntendedReceiver(sim::Operator::ODM);
        g_sim.Branch_center.addAlarmState(sim::Operator::OAT, b_alarm_state_pt);
        this->setPauseActivity(true);
        this->removeOrderedAlarmStateMemoryAndPointer(alarm_state_elem->getAlarmName());
      }
    } else {//do nothing
    }
  }
  for (auto &mental_belief_elem : memory.new_info.mental_belief) {
    // need to revise to check if mental belief had been previously noted...
    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 belief_sp = make_shared<ExpectedMentalBelief>();
      belief_sp->copyExpectedMentalBelief(*mental_belief_elem);
      memory.perceived_info.mental_belief.push_back(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 &new_alarm_elem : memory.new_info.new_alarm) {
    perceived_alarms_pt1 =
        this->memory.perceived_info.checkExistanceOfPerceivedAlarms(new_alarm_elem->getAlarmName());
    if (perceived_alarms_pt1 == 0) {
      auto new_alarm_sp = make_shared<MentalAlarm>();
      new_alarm_sp->copyAlarmElement(*new_alarm_elem);
      new_alarm_sp->setObservedAlarmState(new_alarm_elem->getDisplayedAlarmState());
      memory.perceived_info.perceived_alarms.push_back(new_alarm_sp);
      memory.checkAndGenerateInfoChunkMentalForRelatedAlarm(new_alarm_sp.get(), this->knowledge_base);
      this->knowledge_base.KBcheckHardWiredMatchForAlarmState(new_alarm_sp->getAlarmName(),
                                                              new_alarm_sp->getObservedAlarmState());//KB Hardwired Update
    } else {
      perceived_alarms_pt1->setObservedAlarmState(new_alarm_elem->getDisplayedAlarmState());
      perceived_alarms_pt1->setTimeAtWhichThisInfoIsPerceived(new_alarm_elem->getTimeAtWhichThisAlarmIsActivated());
      perceived_alarms_pt1->setTimeAtWhichThisAlarmIsActivated(new_alarm_elem->getTimeAtWhichThisAlarmIsActivated());
      this->knowledge_base.KBcheckHardWiredMatchForAlarmState(perceived_alarms_pt1->getAlarmName(),
                                                              perceived_alarms_pt1->getObservedAlarmState());
    }
    total_chunked_items += 1;
  }
  for (auto &component_state_elem : memory.new_info.component_state) {
    sender = component_state_elem->getSender();
    total_chunked_items += 1;
    if (sender == sim::Operator::ODM) {//order from ODM is received; need to check plant state and reply back to ODM
      //response to Decision Maker's request
      {
        auto p = make_unique<BranchExpectedComponentState>();
        p->copyBranchExpectedComponentState(*component_state_elem);
        p->setBothTotalTimeRequiredAndRemainingTime(1.0);
        p->setSender(sim::Operator::OAT);
        p->setIntendedReceiver(sim::Source::Plant);
        this->ordered_component_state.push_back(std::move(p));
      }
    } else if (sender == sim::Source::Plant) {
      found_info = this->checkExistenceOfOrderedComponentState(component_state_elem->getDisplayName());
      perceived_component_state_pt1 =
          memory.perceived_info.checkExistanceOfPerceivedComponentState(component_state_elem->getDisplayName());
      if (perceived_component_state_pt1 == 0) {//info has not been perceived before
        //memorize the info
        auto comp_sp = make_shared<MentalComponentState>();
        comp_sp->copyMentalComponentState(*component_state_elem);
        memory.perceived_info.perceived_component_state.push_back(comp_sp);
        memory.checkAndGenerateInfoChunkMentalForRelatedComponentState(comp_sp.get(),
                                                                       this->knowledge_base);
        this->knowledge_base.KBcheckHardWiredMatchForComponentState(comp_sp->getDisplayName(),
                                                                    comp_sp->getObservedComponentState());//KB Hardwired Update
      } else {
        perceived_component_state_pt1->copyMentalComponentState(*component_state_elem);
        this->knowledge_base.KBcheckHardWiredMatchForComponentState(perceived_component_state_pt1->getDisplayName(),
                                                                    perceived_component_state_pt1->getObservedComponentState());//KB Hardwired Update
      }
      if (found_info && component_state_elem->getIntendedReceiver() != sim::Operator::OatScan) {//info asked by Decision Maker
        //reply to ODM
        b_component_state_pt = new BranchExpectedComponentState();
        b_component_state_pt->copyBranchExpectedComponentState(*component_state_elem);
        b_component_state_pt->setTimerAndProbability(0.0, 1.0 - this->hfe_bbn.getPerceiveStateInfoFailureProbability());
        b_component_state_pt->setSender(sim::Operator::OAT);
        b_component_state_pt->setIntendedReceiver(sim::Operator::ODM);
        g_sim.Branch_center.addComponentState(sim::Operator::OAT, b_component_state_pt);
        this->setPauseActivity(true);
        this->removeOrderedComponentStateMemoryAndPointer(component_state_elem->getDisplayName());
      }
    } else {//do nothing
    }
  }
  for (auto &support_system_state_elem : memory.new_info.support_system_state) {
    sender = support_system_state_elem->getSender();
    total_chunked_items += 1;
    if (sender == sim::Operator::ODM) {//order from ODM is received; need to check support system state and reply back to ODM
      //response to Decision Maker's request
      {
        auto p = make_unique<BranchExpectedSupportSystemState>();
        p->copyBranchExpectedSupportSystemState(*support_system_state_elem);
        p->setBothTotalTimeRequiredAndRemainingTime(1.0);
        p->setSender(sim::Operator::OAT);
        p->setIntendedReceiver(sim::Source::Plant);
        this->ordered_support_system_state.push_back(std::move(p));
      }
    } else if (sender == sim::Source::Plant) {
      found_info = this->checkExistenceOfOrderedSupportSystemState(support_system_state_elem->getDisplayName());
      perceived_support_system_state_pt1 =
          memory.perceived_info.checkExistanceOfPerceivedSupportSystemState(support_system_state_elem->getDisplayName());
      if (perceived_support_system_state_pt1 == 0) {//info has not been perceived before
        //memorize the info
        auto ss_sp = make_shared<MentalSupportSystemState>();
        ss_sp->copyMentalSupportSystemState(*support_system_state_elem);
        memory.perceived_info.perceived_support_system_state.push_back(ss_sp);
        memory.checkAndGenerateInfoChunkMentalForRelatedSupportSystemState(ss_sp.get(),
                                                                           this->knowledge_base);
        this->knowledge_base.KBcheckHardWiredMatchForSupportSystemState(ss_sp->getDisplayName(),
                                                                        ss_sp->getObservedSupportSystemState());//KB Hardwired Update
      } else {
        perceived_support_system_state_pt1->copyMentalSupportSystemState(*support_system_state_elem);
        this->knowledge_base.KBcheckHardWiredMatchForSupportSystemState(perceived_support_system_state_pt1->getDisplayName(),
                                                                        perceived_support_system_state_pt1->getObservedSupportSystemState());//KB Hardwired Update
      }
      if (found_info && support_system_state_elem->getIntendedReceiver() != sim::Operator::OatScan) {//info asked by Decision Maker
        //reply to ODM
        b_support_system_state_pt = new BranchExpectedSupportSystemState();
        b_support_system_state_pt->copyBranchExpectedSupportSystemState(*support_system_state_elem);
        b_support_system_state_pt->setTimerAndProbability(0.0, 1.0 - this->hfe_bbn.getPerceiveStateInfoFailureProbability());
        b_support_system_state_pt->setSender(sim::Operator::OAT);
        b_support_system_state_pt->setIntendedReceiver(sim::Operator::ODM);
        g_sim.Branch_center.addSupportSystemState(sim::Operator::OAT, b_support_system_state_pt);
        this->setPauseActivity(true);
        this->removeOrderedSupportSystemStateMemoryAndPointer(support_system_state_elem->getDisplayName());
      }
    } else {//do nothing
    }
  }
  for (auto &parameter_value_elem : memory.new_info.parameter_value) {
    sender = parameter_value_elem->getSender();
    intended_received = parameter_value_elem->getIntendedReceiver();
    total_chunked_items += 1;
    if (sender == sim::Operator::ODM) {//order from ODM is received; need to check plant state and reply back to ODM
      //for the response which to follow
      {
        auto p = make_unique<BranchExpectedParameterValue>();
        p->copyBranchExpectedParameterValue(*parameter_value_elem);
        p->setBothTotalTimeRequiredAndRemainingTime(1.0);
        p->setSender(sim::Operator::OAT);
        p->setIntendedReceiver(sim::Source::Plant);
        this->ordered_parameter_value.push_back(std::move(p));
      }
    } else if (sender == sim::Source::Plant) {
      found_info = this->checkExistanceOfOrderedParameterValue(parameter_value_elem->getDisplayName());
      perceived_parameter_value_pt1 =
          memory.perceived_info.checkExistanceOfPerceivedParameterValue(parameter_value_elem->getDisplayName());
      if (perceived_parameter_value_pt1 == 0) {//OAT self act
        //memorize the info
        auto pv_sp = make_shared<MentalParameterValue>();
        pv_sp->copyMentalParameterValue(*parameter_value_elem);
        memory.perceived_info.perceived_parameter_value.push_back(pv_sp);
        memory.checkAndGenerateInfoChunkMentalForRelatedParameterValue(pv_sp.get(),
                                                                       this->knowledge_base);
        this->knowledge_base.KBcheckHardWiredMatchForParameterValue(pv_sp->getDisplayName(),
                                                                    pv_sp->getObservedParameterValue(),
                                                                    sim::Operator::OAT);//KB Hardwired Update
      } else {
        perceived_parameter_value_pt1->copyMentalParameterValue(*parameter_value_elem);
        this->knowledge_base.KBcheckHardWiredMatchForParameterValue(perceived_parameter_value_pt1->getDisplayName(),
                                                                    perceived_parameter_value_pt1->getObservedParameterValue(),
                                                                    sim::Operator::OAT);//KB Hardwired Update
      }
      if (found_info && parameter_value_elem->getIntendedReceiver() != sim::Operator::OatScan) {//info requested by Decision Maker
        b_parameter_value_pt = new BranchExpectedParameterValue();
        b_parameter_value_pt->copyBranchExpectedParameterValue(*parameter_value_elem);
        b_parameter_value_pt->setTimerAndProbability(0.0, 1.0 - this->hfe_bbn.getPerceiveStateInfoFailureProbability());
        b_parameter_value_pt->setSender(sim::Operator::OAT);
        b_parameter_value_pt->setIntendedReceiver(sim::Operator::ODM);
        g_sim.Branch_center.addParameterValue(sim::Operator::OAT, b_parameter_value_pt);
        this->setPauseActivity(true);
        this->removeOrderedParameterValueMemoryAndPointer(parameter_value_elem->getDisplayName());
      }
    } else {//do nothing
    }
  }
 
  for (auto &parameter_difference_elem : memory.new_info.parameter_difference) {
    sender = parameter_difference_elem->getSender();
    intended_received = parameter_difference_elem->getIntendedReceiver();
    total_chunked_items += 1;
    if (sender == sim::Operator::ODM) {//order from ODM is received; need to check plant state and reply back to ODM
      //for the response which to follow
      {
        auto p = make_unique<BranchExpectedParameterDifference>();
        p->copyBranchExpectedParameterDifference(*parameter_difference_elem);
        p->setBothTotalTimeRequiredAndRemainingTime(1.0);
        p->setSender(sim::Operator::OAT);
        p->setIntendedReceiver(sim::Source::Plant);
        this->ordered_parameter_difference.push_back(std::move(p));
      }
    } else if (sender == sim::Source::Plant) {
      found_info =
          this->checkExistanceOfOrderedParameterDifference(parameter_difference_elem->first_mental_parameter.getDisplayName(),
                                                           parameter_difference_elem->second_mental_parameter.getDisplayName());
      // check if first parameter has been previously memorized and check for KB Hard Wired match
      perceived_parameter_value_pt1 =
          memory.perceived_info.checkExistanceOfPerceivedParameterValue(parameter_difference_elem->first_mental_parameter.getDisplayName());
      if (perceived_parameter_value_pt1 == 0) {
        //memorize the first differene parameter
        auto pv1_sp = make_shared<MentalParameterValue>();
        pv1_sp->copyMentalParameterValue(parameter_difference_elem->first_mental_parameter);
        memory.perceived_info.perceived_parameter_value.push_back(pv1_sp);
        memory.checkAndGenerateInfoChunkMentalForRelatedParameterValue(pv1_sp.get(),
                                                                       this->knowledge_base);
        this->knowledge_base.KBcheckHardWiredMatchForParameterValue(pv1_sp->getDisplayName(),
                                                                    pv1_sp->getObservedParameterValue(),
                                                                    sim::Operator::OAT);//KB Hardwired Update
      } else {
        perceived_parameter_value_pt1->copyMentalParameterValue(parameter_difference_elem->first_mental_parameter);
        this->knowledge_base.KBcheckHardWiredMatchForParameterValue(perceived_parameter_value_pt1->getDisplayName(),
                                                                    perceived_parameter_value_pt1->getObservedParameterValue(),
                                                                    sim::Operator::OAT);//KB Hardwired Update
      }
      // check if second parameter has been previously memorized and check for KB Hard Wired match
      perceived_parameter_value_pt1 =
          memory.perceived_info.checkExistanceOfPerceivedParameterValue(parameter_difference_elem->second_mental_parameter.getDisplayName());
      if (perceived_parameter_value_pt1 == 0) {
        //memorize the second difference parameter
        auto pv2_sp = make_shared<MentalParameterValue>();
        pv2_sp->copyMentalParameterValue(parameter_difference_elem->second_mental_parameter);
        memory.perceived_info.perceived_parameter_value.push_back(pv2_sp);
        memory.checkAndGenerateInfoChunkMentalForRelatedParameterValue(pv2_sp.get(),
                                                                       this->knowledge_base);
        this->knowledge_base.KBcheckHardWiredMatchForParameterValue(pv2_sp->getDisplayName(),
                                                                    pv2_sp->getObservedParameterValue(),
                                                                    sim::Operator::OAT);//KB Hardwired Update
      } else {
        perceived_parameter_value_pt1->copyMentalParameterValue(parameter_difference_elem->second_mental_parameter);
        this->knowledge_base.KBcheckHardWiredMatchForParameterValue(perceived_parameter_value_pt1->getDisplayName(),
                                                                    perceived_parameter_value_pt1->getObservedParameterValue(),
                                                                    sim::Operator::OAT);//KB Hardwired Update
      }
      // check for KB Hard Wired Match for Parameter Difference
      // future implementation...
      //
      if (found_info
          && parameter_difference_elem->getIntendedReceiver() != sim::Operator::OatScan) {//info requested by Decision Maker
        b_parameter_difference_pt = new BranchExpectedParameterDifference();
        b_parameter_difference_pt->copyBranchExpectedParameterDifference(*parameter_difference_elem);
        b_parameter_difference_pt->setTimerAndProbability(0.0, 1.0 - this->hfe_bbn.getPerceiveStateInfoFailureProbability());
        b_parameter_difference_pt->setSender(sim::Operator::OAT);
        b_parameter_difference_pt->setIntendedReceiver(sim::Operator::ODM);
        g_sim.Branch_center.addParameterDifference(sim::Operator::OAT, b_parameter_difference_pt);
        this->setPauseActivity(true);
        this->removeOrderedParameterDifferenceMemoryAndPointer(parameter_difference_elem->first_mental_parameter.getDisplayName(),
                                                               parameter_difference_elem->second_mental_parameter.getDisplayName());
      }
    } else {//do nothing
    }
  }
  return total_chunked_items;
}
bool OperatorAT::performFollowInstructionStrategy() {
  bool branch_generated = false;
  decltype(ordered_action)::iterator ordered_action_itr;
  decltype(ordered_alarm_state)::iterator ordered_alarm_state_itr;
  decltype(ordered_component_state)::iterator ordered_component_state_itr;
  decltype(ordered_support_system_state)::iterator ordered_support_system_state_itr;
  decltype(ordered_parameter_trend)::iterator ordered_parameter_trend_itr;
  decltype(ordered_parameter_value)::iterator ordered_parameter_value_itr;
  decltype(ordered_parameter_difference)::iterator ordered_parameter_difference_itr;
  BranchAction *b_act_pt;
  BranchExpectedAlarmState *b_alarm_pt;
  BranchExpectedComponentState *b_comp_pt;
  BranchExpectedSupportSystemState *b_ss_pt;
  BranchExpectedParameterTrend *b_trend_pt;
  BranchExpectedParameterValue *b_par_pt;
  BranchExpectedParameterDifference *b_diff_pt;
 
  if (ordered_action.size() > 0) {
    ordered_action_itr = ordered_action.begin();
    b_act_pt = new BranchAction();
    (*ordered_action_itr)->setProbability(1.0 - this->hfe_bbn.getStrategyCommunicationFailureProbability());
    b_act_pt->copyBranchAction(**ordered_action_itr);
    g_sim.Branch_center.addAction(sim::Operator::OAT, b_act_pt);
    branch_generated = true;
    return branch_generated;
  }
  if (ordered_alarm_state.size() > 0) {
    ordered_alarm_state_itr = ordered_alarm_state.begin();
    b_alarm_pt = new BranchExpectedAlarmState();
    (*ordered_alarm_state_itr)->setProbability(1.0 - this->hfe_bbn.getStrategyCommunicationFailureProbability());
    b_alarm_pt->copyBranchExpectedAlarmState(**ordered_alarm_state_itr);
    g_sim.Branch_center.addAlarmState(sim::Operator::OAT, b_alarm_pt);
    branch_generated = true;
    return branch_generated;
  }
  if (ordered_component_state.size() > 0) {
    ordered_component_state_itr = ordered_component_state.begin();
    b_comp_pt = new BranchExpectedComponentState();
    (*ordered_component_state_itr)->setProbability(1.0 - this->hfe_bbn.getStrategyCommunicationFailureProbability());
    b_comp_pt->copyBranchExpectedComponentState(**ordered_component_state_itr);
    g_sim.Branch_center.addComponentState(sim::Operator::OAT, b_comp_pt);
    branch_generated = true;
    return branch_generated;
  }
  if (ordered_support_system_state.size() > 0) {
    ordered_support_system_state_itr = ordered_support_system_state.begin();
    b_ss_pt = new BranchExpectedSupportSystemState();
    (*ordered_support_system_state_itr)->setProbability(1.0 - this->hfe_bbn.getStrategyCommunicationFailureProbability());
    b_ss_pt->copyBranchExpectedSupportSystemState(**ordered_support_system_state_itr);
    g_sim.Branch_center.addSupportSystemState(sim::Operator::OAT, b_ss_pt);
    branch_generated = true;
    return branch_generated;
  }
  if (ordered_parameter_value.size() > 0) {
    ordered_parameter_value_itr = ordered_parameter_value.begin();
    b_par_pt = new BranchExpectedParameterValue();
    (*ordered_parameter_value_itr)->setProbability(1.0 - this->hfe_bbn.getStrategyCommunicationFailureProbability());
    b_par_pt->copyBranchExpectedParameterValue(**ordered_parameter_value_itr);
    g_sim.Branch_center.addParameterValue(sim::Operator::OAT, b_par_pt);
    branch_generated = true;
    return branch_generated;
  }
  if (ordered_parameter_difference.size() > 0) {
    ordered_parameter_difference_itr = ordered_parameter_difference.begin();
    b_diff_pt = new BranchExpectedParameterDifference();
    (*ordered_parameter_difference_itr)->setProbability(1.0 - this->hfe_bbn.getStrategyCommunicationFailureProbability());
    b_diff_pt->copyBranchExpectedParameterDifference(**ordered_parameter_difference_itr);
    g_sim.Branch_center.addParameterDifference(sim::Operator::OAT, b_diff_pt);
    branch_generated = true;
    return branch_generated;
  }
  if (ordered_parameter_trend.size() > 0) {
    ordered_parameter_trend_itr = ordered_parameter_trend.begin();
    b_trend_pt = new BranchExpectedParameterTrend();
    (*ordered_parameter_trend_itr)->setProbability(1.0 - this->hfe_bbn.getStrategyCommunicationFailureProbability());
    b_trend_pt->copyBranchExpectedParameterTrend(**ordered_parameter_trend_itr);
    g_sim.Branch_center.addParameterTrend(sim::Operator::OAT, b_trend_pt);
//      ordered_parameter_trend.erase(ordered_parameter_trend_itr);
    branch_generated = true;
    return branch_generated;
  }
  return branch_generated;
}
void OperatorAT::copyOperatorATToRestartInfo(OperatorAT &_operator) {
  this->copyOperatorToRestartInfo(_operator);
  this->copyOrderedInfo(_operator);
 
}
void OperatorAT::copyOperatorATFromRestartInfo(OperatorAT &_operator) {
  Operator::copyOperatorFromRestartInfo(_operator);
  this->copyOrderedInfo(_operator);
}
void OperatorAT::copyOperatorATFromRestartInfoMultiProcessor(OperatorAT &_operator) {
  Operator::copyOperatorFromRestartInfoMultiProcessor(_operator);
  this->copyOrderedInfo(_operator);
}
 
void OperatorAT::clearOperatorATForRestart() {
  Operator::clearOperatorForRestart();
  this->clearOrderedItems();
}
void OperatorAT::clearOperatorATFromRestartInfo() {
  Operator::clearOperatorFromRestartInfo();
  this->clearOrderedItems();
};
void OperatorAT::clearOperatorATFinal() {
  Operator::clearOperatorFinal();
  this->clearOrderedItems();
};
void OperatorAT::clearOperatorATFromRestartNodeInfoMultiProcessors() {
  Operator::clearOperatorFromRestartNodeInfoMultiProcessors();
  this->clearOrderedItems();
}
void OperatorAT::copyOrderedInfo(OperatorAT &_operator) {
  for (const auto &src : _operator.ordered_action) {
    auto dst = make_unique<BranchAction>();
    dst->copyBranchAction(*src);
    this->ordered_action.push_back(std::move(dst));
  }
  for (const auto &src : _operator.ordered_alarm_state) {
    auto dst = make_unique<BranchExpectedAlarmState>();
    dst->copyBranchExpectedAlarmState(*src);
    this->ordered_alarm_state.push_back(std::move(dst));
  }
  for (const auto &src : _operator.ordered_component_state) {
    auto dst = make_unique<BranchExpectedComponentState>();
    dst->copyBranchExpectedComponentState(*src);
    this->ordered_component_state.push_back(std::move(dst));
  }
  for (const auto &src : _operator.ordered_support_system_state) {
    auto dst = make_unique<BranchExpectedSupportSystemState>();
    dst->copyBranchExpectedSupportSystemState(*src);
    this->ordered_support_system_state.push_back(std::move(dst));
  }
  for (const auto &src : _operator.ordered_parameter_trend) {
    auto dst = make_unique<BranchExpectedParameterTrend>();
    dst->copyBranchExpectedParameterTrend(*src);
    this->ordered_parameter_trend.push_back(std::move(dst));
  }
  for (const auto &src : _operator.ordered_parameter_value) {
    auto dst = make_unique<BranchExpectedParameterValue>();
    dst->copyBranchExpectedParameterValue(*src);
    this->ordered_parameter_value.push_back(std::move(dst));
  }
  for (const auto &src : _operator.ordered_parameter_difference) {
    auto dst = make_unique<BranchExpectedParameterDifference>();
    dst->copyBranchExpectedParameterDifference(*src);
    this->ordered_parameter_difference.push_back(std::move(dst));
  }
}
void OperatorAT::clearOrderedItems() {
  ordered_action.clear();
  ordered_alarm_state.clear();
  ordered_component_state.clear();
  ordered_support_system_state.clear();
  ordered_parameter_trend.clear();
  ordered_parameter_value.clear();
  ordered_parameter_difference.clear();
}
void OperatorAT::saveOperatorATToFile(ofstream &fout) {
  fout << "OperatorAT\n" << ordered_action.size() << '\n';
  for (const auto &p : ordered_action) {
    p->saveBranchActionToFile(fout);
  }
  fout << "OperatorAT_ordered_alarm " << ordered_alarm_state.size() << '\n';
  for (const auto &p : ordered_alarm_state) {
    p->saveBranchExpectedAlarmStateToFile(fout);
  }
  fout << "OperatorAT_ordered_component " << ordered_component_state.size() << '\n';
  for (const auto &p : ordered_component_state) {
    p->saveBranchExpectedComponentStateToFile(fout);
  }
  fout << "OperatorAT_ordered_support_system " << ordered_support_system_state.size() << '\n';
  for (const auto &p : ordered_support_system_state) {
    p->saveBranchExpectedSupportSystemStateToFile(fout);
  }
  fout << "OperatorAT_ordered_parameter_trend " << ordered_parameter_trend.size() << '\n';
  for (const auto &p : ordered_parameter_trend) {
    p->saveBranchExpectedParameterTrendToFile(fout);
  }
  fout << "OperatorAT_ordered_parameter_value " << ordered_parameter_value.size() << '\n';
  for (const auto &p : ordered_parameter_value) {
    p->saveBranchExpectedParameterValueToFile(fout);
  }
  fout << "OperatorAT_ordered_parameter_difference " << ordered_parameter_difference.size() << '\n';
  for (const auto &p : ordered_parameter_difference) {
    p->saveBranchExpectedParameterDifferenceToFile(fout);
  }
  this->saveOperatorToFile(fout);
}
void OperatorAT::retrieveOperatorATFromFile(ifstream &fin) {
  int i, num;
  string str;
  // all push_backs below use make_unique directly
//
  fin >> str >> num;
  if (str != "OperatorAT_ordered_alarm") {
    ofstream fout("err messages.txt", ios::app);
    cout << "OperatorAT::retrieveOperatorDMFromFile peratorAT_ordered_alarm File retrieval error in previous function"
         << endl;
    fout << r5pars_.timesno
         << "  OperatorAT::retrieveOperatorDMFromFile OperatorAT_ordered_alarm File retrieval error in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("OperatorAT::retrieveOperatorDMFromFile Prior error");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
  for (i = 0; i < num; i++) {
    auto p = make_unique<BranchExpectedAlarmState>();
    p->retrieveBranchExpectedAlarmStateFromFile(fin);
    this->ordered_alarm_state.push_back(std::move(p));
  }
  //ordered_component
  fin >> str >> num;
  if (str != "OperatorAT_ordered_component") {
    ofstream fout("err messages.txt", ios::app);
    cout
        << "OperatorAT::retrieveOperatorDMFromFile OperatorAT_ordered_component File retrieval error in previous function"
        << endl;
    fout << r5pars_.timesno
         << "  OperatorAT::retrieveOperatorDMFromFile OperatorAT_ordered_component File retrieval error in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("OperatorAT::retrieveOperatorDMFromFile Prior err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
  for (i = 0; i < num; i++) {
    auto p = make_unique<BranchExpectedComponentState>();
    p->retrieveBranchExpectedComponentStateFromFile(fin);
    this->ordered_component_state.push_back(std::move(p));
  }
  //ordered_support_system
  fin >> str >> num;
  if (str != "OperatorAT_ordered_support_system") {
    ofstream fout("err messages.txt", ios::app);
    cout
        << "OperatorAT::retrieveOperatorDMFromFile OperatorAT_ordered_support_system File retrieval error in previous function"
        << endl;
    fout << r5pars_.timesno
         << "  OperatorAT::retrieveOperatorDMFromFile OperatorAT_ordered_support_system File retrieval error in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("OperatorAT::retrieveOperatorDMFromFile Prior err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
  for (i = 0; i < num; i++) {
    auto p = make_unique<BranchExpectedSupportSystemState>();
    p->retrieveBranchExpectedSupportSystemStateFromFile(fin);
    this->ordered_support_system_state.push_back(std::move(p));
  }
  //ordered_parameter_trend
  fin >> str >> num;
  if (str != "OperatorAT_ordered_parameter_trend") {
    ofstream fout("err messages.txt", ios::app);
    cout
        << "OperatorAT::retrieveOperatorDMFromFile OperatorAT_ordered_parameter_trend File retrieval error in previous function"
        << endl;
    fout << r5pars_.timesno
         << "  OperatorAT::retrieveOperatorDMFromFile OperatorAT_ordered_parameter_trend File retrieval error in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("OperatorAT::retrieveOperatorDMFromFile Prior error");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
  for (i = 0; i < num; i++) {
    auto p = make_unique<BranchExpectedParameterTrend>();
    p->retrieveBranchExpectedParameterTrendFromFile(fin);
    this->ordered_parameter_trend.push_back(std::move(p));
  }
  //ordered_parameter_value
  fin >> str >> num;
  if (str != "OperatorAT_ordered_parameter_value") {
    ofstream fout("err messages.txt", ios::app);
    cout
        << "OperatorAT::retrieveOperatorDMFromFile OperatorAT_ordered_parameter_value File retrieval error in previous function"
        << endl;
    fout << r5pars_.timesno
         << "  OperatorAT::retrieveOperatorDMFromFile OperatorAT_ordered_parameter_value File retrieval error in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("OperatorAT::retrieveOperatorDMFromFile Prior error");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
  for (i = 0; i < num; i++) {
    auto p = make_unique<BranchExpectedParameterValue>();
    p->retrieveBranchExpectedParameterValueFromFile(fin);
    this->ordered_parameter_value.push_back(std::move(p));
  }
  //ordered_parameter_difference
  fin >> str >> num;
  if (str != "OperatorAT_ordered_parameter_difference") {
    ofstream fout("err messages.txt", ios::app);
    cout
        << "OperatorAT::retrieveOperatorDMFromFile OperatorAT_ordered_parameter_difference File retrieval error in previous function"
        << endl;
    fout << r5pars_.timesno
         << "  OperatorAT::retrieveOperatorDMFromFile OperatorAT_ordered_parameter_difference File retrieval error in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("OperatorAT::retrieveOperatorDMFromFile Prior err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
  for (i = 0; i < num; i++) {
    auto p = make_unique<BranchExpectedParameterDifference>();
    p->retrieveBranchExpectedParameterDifferenceFromFile(fin);
    this->ordered_parameter_difference.push_back(std::move(p));
  }
  this->retrieveOperatorFromFile(fin);
}
bool OperatorAT::existOrderedActivity() {
  bool order_exist = false;
  if (ordered_action.size() > 0 ||
      ordered_alarm_state.size() > 0 ||
      ordered_component_state.size() > 0 ||
      ordered_parameter_value.size() > 0 ||
      ordered_parameter_trend.size() > 0 ||
      ordered_parameter_difference.size() > 0) {
    order_exist = true;
  }
  return order_exist;
}
 
bool OperatorAT::checkExistanceOfOrderedAction(string _name) {
  bool found = false;
  decltype(ordered_action)::iterator ordered_action_itr, ordered_action_itr_end;
  ordered_action_itr = this->ordered_action.begin();
  ordered_action_itr_end = this->ordered_action.end();
  while (ordered_action_itr != ordered_action_itr_end && !found) {
    if ((*ordered_action_itr)->getActionName() == _name) {
      found = true;
    } else {
      ordered_action_itr++;
    }
  }
  return found;
}
void OperatorAT::removeOrderedActionMemoryAndPointer(string _name) {
  bool found = false;
  decltype(ordered_action)::iterator ordered_action_itr, ordered_action_itr_end;
  ordered_action_itr = this->ordered_action.begin();
  ordered_action_itr_end = this->ordered_action.end();
  while (ordered_action_itr != ordered_action_itr_end && !found) {
    if ((*ordered_action_itr)->getActionName() == _name) {
      found = true;
      this->ordered_action.erase(ordered_action_itr);
    } else {
      ordered_action_itr++;
    }
  }
}
 
bool OperatorAT::checkExistanceOfOrderedAlarmState(string _name) {
  bool found = false;
  decltype(ordered_alarm_state)::iterator ordered_alarm_state_itr, ordered_alarm_state_itr_end;
  ordered_alarm_state_itr = this->ordered_alarm_state.begin();
  ordered_alarm_state_itr_end = this->ordered_alarm_state.end();
  while (ordered_alarm_state_itr != ordered_alarm_state_itr_end && !found) {
    if ((*ordered_alarm_state_itr)->getAlarmName() == _name) {
      found = true;
    } else {
      ordered_alarm_state_itr++;
    }
  }
  return found;
}
void OperatorAT::removeOrderedAlarmStateMemoryAndPointer(string _name) {
  bool found = false;
  decltype(ordered_alarm_state)::iterator ordered_alarm_state_itr, ordered_alarm_state_itr_end;
  ordered_alarm_state_itr = this->ordered_alarm_state.begin();
  ordered_alarm_state_itr_end = this->ordered_alarm_state.end();
  while (ordered_alarm_state_itr != ordered_alarm_state_itr_end && !found) {
    if ((*ordered_alarm_state_itr)->getAlarmName() == _name) {
      found = true;
      this->ordered_alarm_state.erase(ordered_alarm_state_itr);
    } else {
      ordered_alarm_state_itr++;
    }
  }
}
 
bool OperatorAT::checkExistenceOfOrderedComponentState(string _name) {
  bool found = false;
  decltype(ordered_component_state)::iterator ordered_component_state_itr, ordered_component_state_itr_end;
  ordered_component_state_itr = this->ordered_component_state.begin();
  ordered_component_state_itr_end = this->ordered_component_state.end();
  while (ordered_component_state_itr != ordered_component_state_itr_end && !found) {
    if ((*ordered_component_state_itr)->getDisplayName() == _name) {
      found = true;
    } else {
      ordered_component_state_itr++;
    }
  }
  return found;
}
bool OperatorAT::checkExistenceOfOrderedSupportSystemState(string _name) {
  bool found = false;
  decltype(ordered_support_system_state)::iterator ordered_support_system_state_itr,
      ordered_support_system_state_itr_end;
  ordered_support_system_state_itr = this->ordered_support_system_state.begin();
  ordered_support_system_state_itr_end = this->ordered_support_system_state.end();
  while (ordered_support_system_state_itr != ordered_support_system_state_itr_end && !found) {
    if ((*ordered_support_system_state_itr)->getDisplayName() == _name) {
      found = true;
    } else {
      ordered_support_system_state_itr++;
    }
  }
  return found;
}
void OperatorAT::removeOrderedComponentStateMemoryAndPointer(string _name) {
  bool found = false;
  decltype(ordered_component_state)::iterator ordered_component_state_itr, ordered_component_state_itr_end;
  ordered_component_state_itr = this->ordered_component_state.begin();
  ordered_component_state_itr_end = this->ordered_component_state.end();
  while (ordered_component_state_itr != ordered_component_state_itr_end && !found) {
    if ((*ordered_component_state_itr)->getDisplayName() == _name) {
      found = true;
      this->ordered_component_state.erase(ordered_component_state_itr);
    } else {
      ordered_component_state_itr++;
    }
  }
}
void OperatorAT::removeOrderedSupportSystemStateMemoryAndPointer(string _name) {
  bool found = false;
  decltype(ordered_support_system_state)::iterator ordered_support_system_state_itr,
      ordered_support_system_state_itr_end;
  ordered_support_system_state_itr = this->ordered_support_system_state.begin();
  ordered_support_system_state_itr_end = this->ordered_support_system_state.end();
  while (ordered_support_system_state_itr != ordered_support_system_state_itr_end && !found) {
    if ((*ordered_support_system_state_itr)->getDisplayName() == _name) {
      found = true;
      this->ordered_support_system_state.erase(ordered_support_system_state_itr);
    } else {
      ordered_support_system_state_itr++;
    }
  }
}
 
bool OperatorAT::checkExistanceOfOrderedParameterTrend(string _name) {
  bool found = false;
  decltype(ordered_parameter_trend)::iterator ordered_parameter_trend_itr, ordered_parameter_trend_itr_end;
  ordered_parameter_trend_itr = this->ordered_parameter_trend.begin();
  ordered_parameter_trend_itr_end = this->ordered_parameter_trend.end();
  while (ordered_parameter_trend_itr != ordered_parameter_trend_itr_end && !found) {
    if ((*ordered_parameter_trend_itr)->getDisplayName() == _name) {
      found = true;
    } else {
      ordered_parameter_trend_itr++;
    }
  }
  return found;
}
void OperatorAT::removeOrderedParameterTrendMemoryAndPointer(string _name) {
  bool found = false;
  decltype(ordered_parameter_trend)::iterator ordered_parameter_trend_itr, ordered_parameter_trend_itr_end;
  ordered_parameter_trend_itr = this->ordered_parameter_trend.begin();
  ordered_parameter_trend_itr_end = this->ordered_parameter_trend.end();
  while (ordered_parameter_trend_itr != ordered_parameter_trend_itr_end && !found) {
    if ((*ordered_parameter_trend_itr)->getDisplayName() == _name) {
      found = true;
      this->ordered_parameter_trend.erase(ordered_parameter_trend_itr);
    } else {
      ordered_parameter_trend_itr++;
    }
  }
}
 
bool OperatorAT::checkExistanceOfOrderedParameterValue(string _name) {
  bool found = false;
  decltype(ordered_parameter_value)::iterator ordered_parameter_value_itr, ordered_parameter_value_itr_end;
  ordered_parameter_value_itr = this->ordered_parameter_value.begin();
  ordered_parameter_value_itr_end = this->ordered_parameter_value.end();
  while (ordered_parameter_value_itr != ordered_parameter_value_itr_end && !found) {
    if ((*ordered_parameter_value_itr)->getDisplayName() == _name) {
      found = true;
    } else {
      ordered_parameter_value_itr++;
    }
  }
  return found;
}
 
void OperatorAT::removeOrderedParameterValueMemoryAndPointer(string _name) {
  bool found = false;
  decltype(ordered_parameter_value)::iterator ordered_parameter_value_itr, ordered_parameter_value_itr_end;
  ordered_parameter_value_itr = this->ordered_parameter_value.begin();
  ordered_parameter_value_itr_end = this->ordered_parameter_value.end();
  while (ordered_parameter_value_itr != ordered_parameter_value_itr_end && !found) {
    if ((*ordered_parameter_value_itr)->getDisplayName() == _name) {
      found = true;
      this->ordered_parameter_value.erase(ordered_parameter_value_itr);
    } else {
      ordered_parameter_value_itr++;
    }
  }
}
 
bool OperatorAT::checkExistanceOfOrderedParameterDifference(string _name1, string _name2) {
  bool found = false;
  decltype(ordered_parameter_difference)::iterator ordered_parameter_difference_itr,
      ordered_parameter_difference_itr_end;
  ordered_parameter_difference_itr = this->ordered_parameter_difference.begin();
  ordered_parameter_difference_itr_end = this->ordered_parameter_difference.end();
  while (ordered_parameter_difference_itr != ordered_parameter_difference_itr_end && !found) {
    if ((*ordered_parameter_difference_itr)->first_mental_parameter.getDisplayName() == _name1 &&
        (*ordered_parameter_difference_itr)->second_mental_parameter.getDisplayName() == _name2) {
      found = true;
    } else {
      ordered_parameter_difference_itr++;
    }
  }
  return found;
}
 
void OperatorAT::removeOrderedParameterDifferenceMemoryAndPointer(string _name1, string _name2) {
  bool found = false;
  decltype(ordered_parameter_difference)::iterator ordered_parameter_difference_itr,
      ordered_parameter_difference_itr_end;
  ordered_parameter_difference_itr = this->ordered_parameter_difference.begin();
  ordered_parameter_difference_itr_end = this->ordered_parameter_difference.end();
  while (ordered_parameter_difference_itr != ordered_parameter_difference_itr_end && !found) {
    if ((*ordered_parameter_difference_itr)->first_mental_parameter.getDisplayName() == _name1 &&
        (*ordered_parameter_difference_itr)->second_mental_parameter.getDisplayName() == _name2) {
      found = true;
      this->ordered_parameter_difference.erase(ordered_parameter_difference_itr);
    } else {
      ordered_parameter_difference_itr++;
    }
  }
}
 
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(OperatorAT)