InfoChunk.cpp

Go to the documentation of this file.

// InfoChunk.cpp: implementation of the InfoChunk class.
//
 
#include "InfoChunk.h"
#include "../Branch/BranchRecord.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(InfoChunk)
using namespace std;
 
// Construction/Destruction
 
InfoChunk::InfoChunk() {
 
}
 
InfoChunk::~InfoChunk() {
}
void InfoChunk::clearInfoChunk() {
  goal.clear();
  strategy.clear();
  subgoal.clear();
  diagnosis.clear();
  action_objective.clear();
  action_pack.clear();
  action.clear();
  procedure_step.clear();
  instinctive_response_procedure.clear();
  perceived_alarms.clear();
  perceived_component_state.clear();
  perceived_support_system_state.clear();
  perceived_parameter_value.clear();
  perceived_parameter_trend.clear();
  mental_belief.clear();
}
void InfoChunk::clearInfoChunkPointers() {
  goal.clear();
  strategy.clear();
  subgoal.clear();
  diagnosis.clear();
  action_objective.clear();
  action_pack.clear();
  action.clear();
  procedure_step.clear();
  instinctive_response_procedure.clear();
  perceived_alarms.clear();
  perceived_component_state.clear();
  perceived_support_system_state.clear();
  perceived_parameter_value.clear();
  perceived_parameter_trend.clear();
  mental_belief.clear();
}
int InfoChunk::getTotalPieceOfInfoPerceived() {
  int n;
  n = perceived_component_state.size() + perceived_parameter_value.size() + perceived_parameter_trend.size()
      + perceived_alarms.size();
  return n;
}
double InfoChunk::getTotalWeightOfAlarmPerceived() {
  double x = 0.0;
  auto alarm_itr = perceived_alarms.begin();
  for (; alarm_itr != perceived_alarms.end(); alarm_itr++) {
    x += (*alarm_itr)->getImportanceOfTheAlarm();
  }
  return x;
}
int InfoChunk::getTotalNumberOfAlarmPerceived() {
  return perceived_alarms.size();
}
int InfoChunk::getTotalNumberOfFailedDiagnosis() {
  int r_n = 0;
  for (auto diagnosis_itr = diagnosis.begin(); diagnosis_itr != diagnosis.end(); diagnosis_itr++) {
    if ((*diagnosis_itr)->getAssessedState() == sim::State::Failed) { r_n++; }
  }
  return r_n;
}
int InfoChunk::getCurrentGoal() {
  bool found_goal = false;
  int current_goal = sim::None;
  auto goal_itr = this->goal.rbegin();
  while (goal_itr != this->goal.rend() && !found_goal) {
    if ((*goal_itr)->getStateOfActivation() == sim::State::Active) {
      current_goal = (*goal_itr)->getDecision();
      found_goal = true;
    } else {
      goal_itr++;
    }
  }
  return current_goal;
}
 
int InfoChunk::getCurrentStrategy() {
  bool found_strategy = false;
  int current_strategy = sim::None;
  auto strategy_itr = strategy.rbegin();
  while (strategy_itr != strategy.rend() && !found_strategy) {
    if ((*strategy_itr)->getStateOfActivation() == sim::State::Active) {
      current_strategy = (*strategy_itr)->getDecision();
      found_strategy = true;
    } else {
      strategy_itr++;
    }
  }
  return current_strategy;
}
int InfoChunk::getCurrentSubGoal() {
  bool found_subgoal = false;
  int current_subgoal = sim::None;
  auto subgoal_itr = subgoal.rbegin();
  while (subgoal_itr != subgoal.rend() && !found_subgoal) {
    if ((*subgoal_itr)->getStateOfActivation() == sim::State::Active) {
      current_subgoal = (*subgoal_itr)->getDecision();
      found_subgoal = true;
    } else {
      subgoal_itr++;
    }
  }
  return current_subgoal;
}
string InfoChunk::getCurrentDiagnosis() {
  bool found_diagnosis = false;
  string current_diagnosis = "NONE";
  int i = 0;
  auto diagnosis_itr = diagnosis.rbegin();
  while (diagnosis_itr != diagnosis.rend() && !found_diagnosis) {
    if ((*diagnosis_itr)->getStateOfActivation() == sim::State::Active) {
      current_diagnosis = (*diagnosis_itr)->getDiagnosis();
      found_diagnosis = true;
    } else {
      diagnosis_itr++;
    }
  }
  return current_diagnosis;
}
string InfoChunk::getCurrentProcedureName() {
  string str = "NO_PROCEDURE";
  bool found = false;
  decltype(procedure_step)::reverse_iterator procedure_step_ritr;
  procedure_step_ritr = procedure_step.rbegin();
  while (procedure_step_ritr != procedure_step.rend() && !found) {
    if ((*procedure_step_ritr)->getStateOfActivation() == sim::State::Active) {
      found = true;
      str = (*procedure_step_ritr)->getProcedureName();
    } else {
      procedure_step_ritr++;
    }
  }
  return str;
}
string InfoChunk::getCurrentProceduralStepName() {
  string str = "NO_STEP";
  bool found = false;
  decltype(procedure_step)::reverse_iterator procedure_step_ritr;
  procedure_step_ritr = procedure_step.rbegin();
  while (procedure_step_ritr != procedure_step.rend() && !found) {
    if ((*procedure_step_ritr)->getStateOfActivation() == sim::State::Active) {
      found = true;
      str = (*procedure_step_ritr)->getStepName();
    } else {
      procedure_step_ritr++;
    }
  }
  return str;
}
string InfoChunk::getCurrentInstinctiveResponseProcedureName() {
  string str = "NO_PROCEDURE";
  bool found = false;
  decltype(procedure_step)::reverse_iterator procedure_step_ritr;
  procedure_step_ritr = instinctive_response_procedure.rbegin();
  while (procedure_step_ritr != instinctive_response_procedure.rend() && !found) {
    if ((*procedure_step_ritr)->getStateOfActivation() == sim::State::Active) {
      found = true;
      str = (*procedure_step_ritr)->getProcedureName();
    } else {
      procedure_step_ritr++;
    }
  }
  return str;
}
string InfoChunk::getCurrentInstinctiveResponseProceduralStepName() {
  string str = "NO_STEP";
  bool found = false;
  decltype(procedure_step)::reverse_iterator procedure_step_ritr;
  procedure_step_ritr = instinctive_response_procedure.rbegin();
  while (procedure_step_ritr != instinctive_response_procedure.rend() && !found) {
    if ((*procedure_step_ritr)->getStateOfActivation() == sim::State::Active) {
      found = true;
      str = (*procedure_step_ritr)->getStepName();
    } else {
      procedure_step_ritr++;
    }
  }
  return str;
}
 
DecisionProcedureStep *InfoChunk::getCurrentProcedureStepPtr(int _operator) {
  DecisionProcedureStep *r_ptr = nullptr;
  bool found = false;
  auto procedure_step_ritr = procedure_step.rbegin();
  while (procedure_step_ritr != procedure_step.rend() && !found) {
    if ((*procedure_step_ritr)->getStateOfActivation() == sim::State::Active) {
      found = true;
      r_ptr = procedure_step_ritr->get();
    } else {
      procedure_step_ritr++;
    }
  }
  if (r_ptr == nullptr) {
    procedure_step_ritr = procedure_step.rbegin();
    while (procedure_step_ritr != procedure_step.rend() && !found) {
      if ((*procedure_step_ritr)->getStateOfActivation() == sim::State::Pause) {
        found = true;
        //(*procedure_step_ritr)->setStateOfActivation(sim::State::Active);
        r_ptr = procedure_step_ritr->get();
      }
      procedure_step_ritr++;
    }
  }
  return r_ptr;
}
DecisionProcedureStep *InfoChunk::getCurrentInstinctiveResponseProcedurePtr() {
  DecisionProcedureStep *r_ptr = nullptr;
  bool found = false;
  auto procedure_step_ritr = instinctive_response_procedure.rbegin();
  while (procedure_step_ritr != instinctive_response_procedure.rend() && !found) {
    if ((*procedure_step_ritr)->getStateOfActivation() == sim::State::Active) {
      found = true;
      r_ptr = procedure_step_ritr->get();
    }
    procedure_step_ritr++;
  }
  return r_ptr;
}
 
void InfoChunk::addANewGoal(int _goal, int _active_state) {
  auto goal_pt = make_shared<DecisionGoal>();
  goal_pt->setDecision(_goal);
  goal_pt->setStateOfActivation(_active_state);
  goal.push_back(goal_pt);
}
void InfoChunk::addANewStrategy(int _strategy, int _active_state) {
  auto strategy_pt = make_shared<DecisionStrategy>();
  strategy_pt->setDecision(_strategy);
  strategy_pt->setStateOfActivation(_active_state);
  strategy.push_back(strategy_pt);
}
 
void InfoChunk::addANewDiagnosis(string _diagnosis, int _active_state) {
  auto diagnosis_pt = make_shared<DecisionDiagnosis>();
  diagnosis_pt->setDiagnosis(_diagnosis);
  diagnosis_pt->setStateOfActivation(_active_state);
  diagnosis.push_back(diagnosis_pt);
}
void InfoChunk::addANewSubGoal(int _subgoal, int _active_state) {
  auto subgoal_pt = make_shared<DecisionSubGoal>();
  subgoal_pt->setDecision(_subgoal);
  subgoal_pt->setStateOfActivation(_active_state);
  subgoal.push_back(subgoal_pt);
}
void InfoChunk::addNewProcedureStep(string _procedure, string _step, int _active_state) {
  auto ps = make_shared<DecisionProcedureStep>();
  ps->setProcedureName(_procedure);
  ps->setStepName(_step);
  ps->setStateOfActivation(_active_state);
  procedure_step.push_back(ps);
}
void InfoChunk::addNewInstinctiveResponseProcedure(string _procedure,
                                                   string _step,
                                                   int _priority,
                                                   int _active_state,
                                                   double _activation_time) {
  DecisionProcedureStep *mental_procedure_pt = nullptr;
  mental_procedure_pt = this->checkExistanceOfAnInstinctiveResponseProcedure(_procedure, _step);
  if (mental_procedure_pt == nullptr) {
    auto ps = make_shared<DecisionProcedureStep>();
    ps->setProcedureName(_procedure);
    ps->setStepName(_step);
    ps->setStateOfActivation(_active_state);
    ps->setActivationTime(_activation_time);
    ps->setPriority(_priority);
    instinctive_response_procedure.push_back(ps);
  }
}
int InfoChunk::doneWithCurrentGoalAndGoForPreviouslyPausedOne() {
  bool found_goal = false;
  int current_goal = sim::State::Unknown;
  int i = 0;
  auto goal_itr = goal.rbegin();
  while (goal_itr != goal.rend() && !found_goal) {
    if ((*goal_itr)->getStateOfActivation() == sim::State::Active) {
      (*goal_itr)->setDecision(sim::State::Done);
      found_goal = true;
    }
    goal_itr++;
  }
  found_goal = false;
  goal_itr = goal.rbegin();
  while (goal_itr != goal.rend() && !found_goal) {
    if ((*goal_itr)->getStateOfActivation() == sim::State::Pause) {
      (*goal_itr)->setDecision(sim::State::Active);
      found_goal = true;
      current_goal = (*goal_itr)->getDecision();
    }
    goal_itr++;
    i++;
  }
  if (i == 0) {//no
    ofstream fout("err messages.txt", ios::app);
    cout << "InfoChunk::doneWithCurrentGoalAndGoForPreviousOne: no goal exist" << endl;
    fout << r5pars_.timesno << "  InfoChunk::doneWithCurrentGoalAndGoForPreviousOne: no goal exist\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("InfoChunk::doneWithCurrentGoalAndGoForPreviouslyPausedOne err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  } else if (goal_itr == goal.rend()) {
    ofstream fout("err messages.txt", ios::app);
    cout << "InfoChunk::doneWithCurrentGoalAndGoForPreviousOne: could not find previousely paused goal" << endl;
    fout << r5pars_.timesno
         << "  InfoChunk::doneWithCurrentGoalAndGoForPreviousOne: could not find previousely paused goal\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("InfoChunk::doneWithCurrentGoalAndGoForPreviouslyPausedOne err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  } else {
  }
  return current_goal;
}
int InfoChunk::doneWithCurrentStrategyAndGoForPreviouslyPausedOne() {
  bool found_strategy = false;
  int current_strategy = sim::State::Unknown;
  int i = 0;
  auto strategy_itr = strategy.rbegin();
  while (strategy_itr != strategy.rend() && !found_strategy) {
    if ((*strategy_itr)->getStateOfActivation() == sim::State::Active) {
      (*strategy_itr)->setDecision(sim::State::Done);
      found_strategy = true;
    }
    strategy_itr++;
  }
  found_strategy = false;
  strategy_itr = strategy.rbegin();
  while (strategy_itr != strategy.rend() && !found_strategy) {
    if ((*strategy_itr)->getStateOfActivation() == sim::State::Pause) {
      (*strategy_itr)->setDecision(sim::State::Active);
      found_strategy = true;
      current_strategy = (*strategy_itr)->getDecision();
    }
    strategy_itr++;
    i++;
  }
  if (i == 0) {//no
    ofstream fout("err messages.txt", ios::app);
    cout << "InfoChunk::doneWithCurrentStrategyAndGoForPreviousOne: no strategy exist" << endl;
    fout << r5pars_.timesno << "  InfoChunk::doneWithCurrentStrategyAndGoForPreviousOne: no strategy exist\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("InfoChunk::doneWithCurrentStrategyAndGoForPreviouslyPausedOne err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  } else if (strategy_itr == strategy.rend()) {
    ofstream fout("err messages.txt", ios::app);
    cout << "InfoChunk::doneWithCurrentStrategyAndGoForPreviousOne: could not find previousely paused strategy" << endl;
    fout << r5pars_.timesno
         << "  InfoChunk::doneWithCurrentStrategyAndGoForPreviousOne: could not find previousely paused strategy\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("InfoChunk::doneWithCurrentStrategyAndGoForPreviouslyPausedOne err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  } else {
  }
  return current_strategy;
}
string InfoChunk::doneWithCurrentDiagnosisAndGoForPreviouslyPausedOne() {
  bool found_diagnosis = false;
  string current_diagnosis = "UNKNOWN";
  int i = 0;
  auto diagnosis_itr = diagnosis.rbegin();
  while (diagnosis_itr != diagnosis.rend() && !found_diagnosis) {
    if ((*diagnosis_itr)->getStateOfActivation() == sim::State::Active) {
      (*diagnosis_itr)->setDecision(sim::State::Done);
      found_diagnosis = true;
    }
    diagnosis_itr++;
  }
  found_diagnosis = false;
  diagnosis_itr = diagnosis.rbegin();
  while (diagnosis_itr != diagnosis.rend() && !found_diagnosis) {
    if ((*diagnosis_itr)->getStateOfActivation() == sim::State::Pause) {
      (*diagnosis_itr)->setDecision(sim::State::Active);
      found_diagnosis = true;
      current_diagnosis = (*diagnosis_itr)->getDiagnosis();
    }
    diagnosis_itr++;
    i++;
  }
  if (i == 0) {//no
    ofstream fout("err messages.txt", ios::app);
    cout << "InfoChunk::doneWithCurrentDiagnosisAndGoForPreviousOne: no diagnosis exist" << endl;
    fout << r5pars_.timesno << "  InfoChunk::doneWithCurrentDiagnosisAndGoForPreviousOne: no diagnosis exist\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("InfoChunk::doneWithCurrentDiagnosisAndGoForPreviouslyPausedOne err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  } else if (diagnosis_itr == diagnosis.rend()) {
    ofstream fout("err messages.txt", ios::app);
    cout << "InfoChunk::doneWithCurrentDiagnosisAndGoForPreviousOne: could not find previousely paused diagnosis"
         << endl;
    fout << r5pars_.timesno
         << "  InfoChunk::doneWithCurrentDiagnosisAndGoForPreviousOne: could not find previousely paused diagnosis\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("InfoChunk::doneWithCurrentDiagnosisAndGoForPreviouslyPausedOne err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  } else {
  }
  return current_diagnosis;
}
int InfoChunk::doneWithCurrentSubGoalAndGoForPreviouslyPausedOne() {
  bool found_subgoal = false;
  int current_subgoal = sim::State::Unknown;
  int i = 0;
  auto subgoal_itr = subgoal.rbegin();
  while (subgoal_itr != subgoal.rend() && !found_subgoal) {
    if ((*subgoal_itr)->getStateOfActivation() == sim::State::Active) {
      (*subgoal_itr)->setDecision(sim::State::Done);
      found_subgoal = true;
    }
    subgoal_itr++;
  }
  found_subgoal = false;
  subgoal_itr = subgoal.rbegin();
  while (subgoal_itr != subgoal.rend() && !found_subgoal) {
    if ((*subgoal_itr)->getStateOfActivation() == sim::State::Pause) {
      (*subgoal_itr)->setDecision(sim::State::Active);
      found_subgoal = true;
      current_subgoal = (*subgoal_itr)->getDecision();
    }
    subgoal_itr++;
    i++;
  }
  if (i == 0) {//no
    ofstream fout("err messages.txt", ios::app);
    cout << "InfoChunk::doneWithCurrentSubgoalAndGoForPreviousOne: no subgoal exist" << endl;
    fout << r5pars_.timesno << "  InfoChunk::doneWithCurrentSubgoalAndGoForPreviousOne: no subgoal exist\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("InfoChunk::doneWithCurrentSubGoalAndGoForPreviouslyPausedOne err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  } else if (subgoal_itr == subgoal.rend()) {
    ofstream fout("err messages.txt", ios::app);
    cout << "InfoChunk::doneWithCurrentSubgoalAndGoForPreviousOne: could not find previousely paused subgoal" << endl;
    fout << r5pars_.timesno
         << "  InfoChunk::doneWithCurrentSubgoalAndGoForPreviousOne: could not find previousely paused subgoal\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("InfoChunk::doneWithCurrentSubGoalAndGoForPreviouslyPausedOne err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  } else {
  }
  return current_subgoal;
}
 
void InfoChunk::pauseCurrenGoalAndAddANewOne(int _goal) {
  bool found_goal = false;
  auto goal_itr = goal.rbegin();
  while (goal_itr != goal.rend() && !found_goal) {
    if ((*goal_itr)->getStateOfActivation() == sim::State::Active) {
      (*goal_itr)->setStateOfActivation(sim::State::Pause);
      found_goal = true;
    }
    goal_itr++;
  }
  InfoChunk::addANewGoal(_goal, sim::State::Active);
}
void InfoChunk::pauseCurrenStrategyAndAddANewOne(int _strategy) {
  bool found_strategy = false;
  auto strategy_itr = strategy.rbegin();
  while (strategy_itr != strategy.rend() && !found_strategy) {
    if ((*strategy_itr)->getStateOfActivation() == sim::State::Active) {
      (*strategy_itr)->setStateOfActivation(sim::State::Pause);
      found_strategy = true;
    }
    strategy_itr++;
  }
  InfoChunk::addANewStrategy(_strategy, sim::State::Active);
}
void InfoChunk::pauseCurrenSubGoalAndAddANewOne(int _subgoal) {
  bool found_subgoal = false;
  auto subgoal_itr = subgoal.rbegin();
  while (subgoal_itr != subgoal.rend() && !found_subgoal) {
    if ((*subgoal_itr)->getStateOfActivation() == sim::State::Active) {
      (*subgoal_itr)->setStateOfActivation(sim::State::Pause);
      found_subgoal = true;
    }
    subgoal_itr++;
  }
  InfoChunk::addANewSubGoal(_subgoal, sim::State::Active);
}
void InfoChunk::pauseCurrenDiagnosisAndAddANewOne(string _diagnosis) {
  bool found_diagnosis = false;
  auto diagnosis_itr = diagnosis.rbegin();
  while (diagnosis_itr != diagnosis.rend() && !found_diagnosis) {
    if ((*diagnosis_itr)->getStateOfActivation() == sim::State::Active) {
      (*diagnosis_itr)->setStateOfActivation(sim::State::Pause);
      found_diagnosis = true;
    }
    diagnosis_itr++;
  }
  InfoChunk::addANewDiagnosis(_diagnosis, sim::State::Active);
}
bool InfoChunk::activateTheDiagnosis(string _diagnosis) {
  bool found_diagnosis = false;
  DecisionDiagnosis *diagnosis_pt = nullptr;
  auto diagnosis_itr = diagnosis.rbegin();
  while (diagnosis_itr != diagnosis.rend() && !found_diagnosis) {
    if ((*diagnosis_itr)->getDiagnosis() == _diagnosis) {
      found_diagnosis = true;
      diagnosis_pt = diagnosis_itr->get();
    }
    diagnosis_itr++;
  }
  if (found_diagnosis) {
    for (diagnosis_itr = diagnosis.rbegin(); diagnosis_itr != diagnosis.rend(); diagnosis_itr++) {
      if ((*diagnosis_itr)->getStateOfActivation() == sim::State::Active) {
        (*diagnosis_itr)->setStateOfActivation(sim::State::Pause);
      }
    }
    diagnosis_pt->setStateOfActivation(sim::State::Active);
  }
  return found_diagnosis;
}
bool InfoChunk::includeActiveDiagnosis() {
  bool found_diagnosis = false;
  auto diagnosis_itr = diagnosis.rbegin();
  while (diagnosis_itr != diagnosis.rend() && !found_diagnosis) {
    if ((*diagnosis_itr)->getStateOfActivation() == sim::State::Active) {
      found_diagnosis = true;
    }
    diagnosis_itr++;
  }
  return found_diagnosis;
}
DecisionProcedureStep *InfoChunk::identifyTheMentalProcedureToBePerformed(string _in_use_procedure_name,
                                                                          string _in_use_step_name) {
  bool found_mental_procedure = false;
  bool procedure_in_use;
  int state_of_activation = sim::State::Done;
  int highest_priority = 999;
  DecisionProcedureStep *dds_pt = nullptr;
  auto instinctive_response_procedure_itr = instinctive_response_procedure.begin();
  while (instinctive_response_procedure_itr != instinctive_response_procedure.end() && !found_mental_procedure) {
    procedure_in_use = false;
    state_of_activation = (*instinctive_response_procedure_itr)->getStateOfActivation();
    if ((*instinctive_response_procedure_itr)->getProcedureName() == _in_use_procedure_name
        && (*instinctive_response_procedure_itr)->getStepName() == _in_use_step_name) {
      procedure_in_use = true;
    }
    if (state_of_activation == sim::State::Active && !procedure_in_use) {
      found_mental_procedure = true;
      dds_pt = instinctive_response_procedure_itr->get();
    } else {
      instinctive_response_procedure_itr++;
    }
  }
  if (!found_mental_procedure) {
    // check for previosuly paused procedures
    instinctive_response_procedure_itr = instinctive_response_procedure.begin();
    while (instinctive_response_procedure_itr != instinctive_response_procedure.end() && !found_mental_procedure) {
      procedure_in_use = false;
      state_of_activation = (*instinctive_response_procedure_itr)->getStateOfActivation();
      if ((*instinctive_response_procedure_itr)->getProcedureName() == _in_use_procedure_name
          && (*instinctive_response_procedure_itr)->getStepName() == _in_use_step_name) {
        procedure_in_use = true;
      }
      if (state_of_activation == sim::State::Pause && !procedure_in_use) {
        found_mental_procedure = true;
        dds_pt = instinctive_response_procedure_itr->get();
      } else {
        instinctive_response_procedure_itr++;
      }
    }
  }
  if (!found_mental_procedure) {
    // find highest priority waiting procedure
    instinctive_response_procedure_itr = instinctive_response_procedure.begin();
    while (instinctive_response_procedure_itr != instinctive_response_procedure.end()) {
      procedure_in_use = false;
      state_of_activation = (*instinctive_response_procedure_itr)->getStateOfActivation();
      if ((*instinctive_response_procedure_itr)->getProcedureName() == _in_use_procedure_name
          && (*instinctive_response_procedure_itr)->getStepName() == _in_use_step_name) {
        procedure_in_use = true;
      }
      if (state_of_activation == sim::None && !procedure_in_use
          && (*instinctive_response_procedure_itr)->getPriority() < highest_priority) {
        highest_priority = (*instinctive_response_procedure_itr)->getPriority();
        found_mental_procedure = true;
        dds_pt = instinctive_response_procedure_itr->get();
      }
      instinctive_response_procedure_itr++;
    }
  }
  return dds_pt;
}
bool InfoChunk::isThereMentalProcedureWaitingForExecution(string _procedure_name, string _step_name) {
  bool found_mental_procedure = false;
  bool procedure_in_use;
  bool procedure_waiting;
  int state_of_activation;
  auto instinctive_response_procedure_itr = instinctive_response_procedure.begin();
  while (instinctive_response_procedure_itr != instinctive_response_procedure.end() && !found_mental_procedure) {
    procedure_in_use = false;
    procedure_waiting = false;
    state_of_activation = (*instinctive_response_procedure_itr)->getStateOfActivation();
    //
    // check if procedure is being used by another operator
    if ((*instinctive_response_procedure_itr)->getProcedureName() == _procedure_name
        && (*instinctive_response_procedure_itr)->getStepName() == _step_name) {
      procedure_in_use = true;
    }
    //
    // check to see if queued procedure can be activated
    if ((*instinctive_response_procedure_itr)->getActivationTime() < r5pars_.timesno
        && state_of_activation == sim::State::Waiting) {
      state_of_activation = sim::None;
      (*instinctive_response_procedure_itr)->setStateOfActivation(state_of_activation);
    }
    //
    if (state_of_activation == sim::State::Active || state_of_activation == sim::None || state_of_activation == sim::State::Pause) {
      procedure_waiting = true;
    }
    if (procedure_waiting && !procedure_in_use) {
      found_mental_procedure = true;
    } else {
      instinctive_response_procedure_itr++;
    }
  }
  return found_mental_procedure;
}
void InfoChunk::pointToAvtiveGoalAndStrategy(InfoChunk &_perceived_info) {
  if (this->getCurrentGoal() == sim::None) {
    // Find the active goal shared_ptr in source and share it
    bool found = false;
    for (auto ritr = _perceived_info.goal.rbegin(); ritr != _perceived_info.goal.rend(); ritr++) {
      if ((*ritr)->getStateOfActivation() == sim::State::Active) {
        this->goal.push_back(*ritr);
        found = true;
        break;
      }
    }
    if (!found) {
      ofstream fout("err messages.txt", ios::app);
      cout << "InfoChunk::pointToAvtiveGoalAndStrategy: No active goal exists." << endl;
      fout << r5pars_.timesno << "  InfoChunk::pointToAvtiveGoalAndStrategy: No active goal exists.\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("InfoChunk::pointToAvtiveGoalAndStrategy err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
    }
  }
  if (this->getCurrentStrategy() == sim::None) {
    bool found = false;
    for (auto ritr = _perceived_info.strategy.rbegin(); ritr != _perceived_info.strategy.rend(); ritr++) {
      if ((*ritr)->getStateOfActivation() == sim::State::Active) {
        this->strategy.push_back(*ritr);
        found = true;
        break;
      }
    }
    if (!found) {
      ofstream fout("err messages.txt", ios::app);
      cout << "InfoChunk::pointToAvtiveGoalAndStrategy: No active strategy exists." << endl;
      fout << r5pars_.timesno << "  InfoChunk::pointToAvtiveGoalAndStrategy: No active strategy exists.\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("InfoChunk::pointToAvtiveGoalAndStrategy err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
    }
  }
}
 
void InfoChunk::pointToTheNewGoal(DecisionGoal *_pt) {
  bool found = false;
  if (_pt->getStateOfActivation() == sim::State::Active) {
    auto ritr = goal.rbegin();
    while (ritr != goal.rend() && !found) {
      if ((*ritr)->getStateOfActivation() == sim::State::Active) {
        found = true;
        (*ritr)->setStateOfActivation(sim::State::Pause);
      }
      ritr++;
    }
  }
  this->goal.push_back(shared_ptr<DecisionGoal>(_pt, [](DecisionGoal*){}));
}
void InfoChunk::pointToTheNewStrategy(DecisionStrategy *_pt) {
  bool found = false;
  if (_pt->getStateOfActivation() == sim::State::Active) {
    auto ritr = strategy.rbegin();
    while (ritr != strategy.rend() && !found) {
      if ((*ritr)->getStateOfActivation() == sim::State::Active) {
        found = true;
        (*ritr)->setStateOfActivation(sim::State::Pause);
      }
      ritr++;
    }
  }
  this->strategy.push_back(shared_ptr<DecisionStrategy>(_pt, [](DecisionStrategy*){}));
}
void InfoChunk::pointToTheNewSubGoal(DecisionSubGoal *_pt) {
  bool found = false;
  if (_pt->getStateOfActivation() == sim::State::Active) {
    auto ritr = subgoal.rbegin();
    while (ritr != subgoal.rend() && !found) {
      if ((*ritr)->getStateOfActivation() == sim::State::Active) {
        found = true;
        (*ritr)->setStateOfActivation(sim::State::Pause);
      }
      ritr++;
    }
  }
  this->subgoal.push_back(shared_ptr<DecisionSubGoal>(_pt, [](DecisionSubGoal*){}));
}
void InfoChunk::pointToTheNewDiagnosis(DecisionDiagnosis *_pt) {
  bool found = false;
  if (_pt->getStateOfActivation() == sim::State::Active) {
    auto ritr = diagnosis.rbegin();
    while (ritr != diagnosis.rend() && !found) {
      if ((*ritr)->getStateOfActivation() == sim::State::Active) {
        found = true;
        (*ritr)->setStateOfActivation(sim::State::Pause);
      }
      ritr++;
    }
  }
  this->diagnosis.push_back(shared_ptr<DecisionDiagnosis>(_pt, [](DecisionDiagnosis*){}));
}
void InfoChunk::pointToTheNewActionObjective(DecisionActionObjective *_pt) {
  bool found = false;
  if (_pt->getStateOfActivation() == sim::State::Active) {
    auto ritr = action_objective.rbegin();
    while (ritr != action_objective.rend() && !found) {
      if ((*ritr)->getStateOfActivation() == sim::State::Active) {
        found = true;
        (*ritr)->setStateOfActivation(sim::State::Pause);
      }
      ritr++;
    }
  }
  this->action_objective.push_back(shared_ptr<DecisionActionObjective>(_pt, [](DecisionActionObjective*){}));
}
void InfoChunk::pointToTheNewActionPack(DecisionActionPack *_pt) {
  bool found = false;
  if (_pt->getStateOfActivation() == sim::State::Active) {
    auto ritr = action_pack.rbegin();
    while (ritr != action_pack.rend() && !found) {
      if ((*ritr)->getStateOfActivation() == sim::State::Active) {
        found = true;
        (*ritr)->setStateOfActivation(sim::State::Pause);
      }
      ritr++;
    }
  }
  this->action_pack.push_back(shared_ptr<DecisionActionPack>(_pt, [](DecisionActionPack*){}));
}
void InfoChunk::pointToTheNewAction(DecisionAction *_pt) {
  bool found = false;
  if (_pt->getStateOfActivation() == sim::State::Active) {
    auto ritr = action.rbegin();
    while (ritr != action.rend() && !found) {
      if ((*ritr)->getStateOfActivation() == sim::State::Active) {
        found = true;
        (*ritr)->setStateOfActivation(sim::State::Pause);
      }
      ritr++;
    }
  }
  this->action.push_back(shared_ptr<DecisionAction>(_pt, [](DecisionAction*){}));
}
void InfoChunk::pointToTheNewProcedureStep(DecisionProcedureStep *_pt) {
  bool found = false;
  string _pt_procedure_name, ritr_procedure_name;
  _pt_procedure_name = _pt->getProcedureName();
  _pt_procedure_name += _pt->getStepName();
  if (_pt->getStateOfActivation() == sim::State::Active) {
    auto ritr = procedure_step.rbegin();
    while (ritr != procedure_step.rend() && !found) {
      ritr_procedure_name = (*ritr)->getProcedureName();
      ritr_procedure_name += (*ritr)->getStepName();
      if (_pt_procedure_name == ritr_procedure_name) {
        // don't reset status if reactivating previous procedure
        found = true;
      } else if ((*ritr)->getStateOfActivation() == sim::State::Active) {
        found = true;
        (*ritr)->setStateOfActivation(sim::State::Pause);
      }
      ritr++;
    }
  }
  if (!found) {
    // add new procedure pointer to working memory stack
    this->procedure_step.push_back(shared_ptr<DecisionProcedureStep>(_pt, [](DecisionProcedureStep*){}));
  }
}
void InfoChunk::pointToTheNewInstinctiveResponseProcedureStep(DecisionProcedureStep *_pt) {
  bool found = false;
  if (_pt->getStateOfActivation() == sim::State::Active) {
    auto ritr = instinctive_response_procedure.rbegin();
    while (ritr != instinctive_response_procedure.rend() && !found) {
      if ((*ritr)->getStateOfActivation() == sim::State::Active) {
        found = true;
        (*ritr)->setStateOfActivation(sim::State::Pause);
      }
      ritr++;
    }
  }
  this->instinctive_response_procedure.push_back(shared_ptr<DecisionProcedureStep>(_pt, [](DecisionProcedureStep*){}));
}
void InfoChunk::updateActionState(string _action_name, int _new_state) {
  bool found = false;
  auto ritr = action.rbegin();
  while (ritr != action.rend() && !found) {
    if (_action_name == (*ritr)->getActionName()) {
      found = true;
      (*ritr)->setStateOfActivation(_new_state);
    }
    ritr++;
  }
}
 
DecisionAction *InfoChunk::checkExistanceOfAction(string str) {
  bool found = false;
  DecisionAction *da_pt = nullptr;
  auto ritr = action.rbegin();
  while (ritr != action.rend() && !found) {
    if ((*ritr)->getActionName() == str) {
      found = true;
      da_pt = ritr->get();
    }
    ritr++;
  }
  return da_pt;
}
MentalAlarm *InfoChunk::checkExistanceOfPerceivedAlarms(string str) {
  bool found = false;
  MentalAlarm *da_pt = nullptr;
  auto ritr = perceived_alarms.rbegin();
  while (ritr != perceived_alarms.rend() && !found) {
    if ((*ritr)->getAlarmName() == str) {
      found = true;
      da_pt = ritr->get();
    }
    ritr++;
  }
  return da_pt;
}
DecisionProcedureStep *InfoChunk::checkExistanceOfAnInstinctiveResponseProcedure(string _procedure_name,
                                                                                 string _step_name) {
  DecisionProcedureStep *pds_pt = nullptr;
  bool found = false;
  auto ritr = this->instinctive_response_procedure.rbegin();
  while (ritr != this->instinctive_response_procedure.rend() && !found) {
    if ((*ritr)->getProcedureName() == _procedure_name && (*ritr)->getStepName() == _step_name &&
        (*ritr)->getStateOfActivation() != sim::State::Done && (*ritr)->getStateOfActivation() != sim::State::Interrupted
        && (*ritr)->getStateOfActivation() != sim::State::Succeed) {
      found = true;
      pds_pt = ritr->get();
    } else {
      ritr++;
    }
  }
  return pds_pt;
}
 
DecisionProcedureStep *InfoChunk::checkExistanceOfAProcedure(string _procedure_name, string _step_name) {
  DecisionProcedureStep *pds_pt = nullptr;
  bool found = false;
  auto ritr = this->procedure_step.rbegin();
  while (ritr != this->procedure_step.rend() && !found) {
    if ((*ritr)->getProcedureName() == _procedure_name && (*ritr)->getStepName() == _step_name &&
        (*ritr)->getStateOfActivation() != sim::State::Done && (*ritr)->getStateOfActivation() != sim::State::Interrupted
        && (*ritr)->getStateOfActivation() != sim::State::Succeed) {
      found = true;
      pds_pt = ritr->get();
    } else {
      ritr++;
    }
  }
  return pds_pt;
}
 
MentalComponentState *InfoChunk::checkExistanceOfPerceivedComponentState(string str) {
  bool found = false;
  MentalComponentState *da_pt = nullptr;
  auto ritr = perceived_component_state.rbegin();
  while (ritr != perceived_component_state.rend() && !found) {
    if ((*ritr)->getDisplayName() == str) {
      found = true;
      da_pt = ritr->get();
    }
    ritr++;
  }
  return da_pt;
}
MentalSupportSystemState *InfoChunk::checkExistanceOfPerceivedSupportSystemState(string str) {
  bool found = false;
  MentalSupportSystemState *da_pt = nullptr;
  auto ritr = perceived_support_system_state.rbegin();
  while (ritr != perceived_support_system_state.rend() && !found) {
    if ((*ritr)->getDisplayName() == str) {
      found = true;
      da_pt = ritr->get();
    }
    ritr++;
  }
  return da_pt;
}
MentalParameterValue *InfoChunk::checkExistanceOfPerceivedParameterValue(string str) {
  bool found = false;
  MentalParameterValue *da_pt = nullptr;
  auto ritr = perceived_parameter_value.rbegin();
  while (ritr != perceived_parameter_value.rend() && !found) {
    if ((*ritr)->getDisplayName() == str) {
      found = true;
      da_pt = ritr->get();
    }
    ritr++;
  }
  return da_pt;
}
ExpectedMentalBelief *InfoChunk::checkExistanceOfMentalBelief(string str) {
  bool found = false;
  ExpectedMentalBelief *mp_pt = nullptr;
  auto mental_belief_ritr = mental_belief.rbegin();
  while (mental_belief_ritr != mental_belief.rend() && !found) {
    if ((*mental_belief_ritr)->getInfoName() == str) {
      found = true;
      mp_pt = mental_belief_ritr->get();
    }
    mental_belief_ritr++;
  }
  return mp_pt;
}
MentalParameterTrend *InfoChunk::checkExistanceOfPerceivedParameterTrend(string str) {
  bool found = false;
  MentalParameterTrend *da_pt = nullptr;
  auto ritr = perceived_parameter_trend.rbegin();
  while (ritr != perceived_parameter_trend.rend() && !found) {
    if ((*ritr)->getDisplayName() == str) {
      found = true;
      da_pt = ritr->get();
    }
    ritr++;
  }
  return da_pt;
}
void InfoChunk::interruptCurrentGoal() {
  bool found = false;
  auto r_itr = goal.rbegin();
  while (r_itr != goal.rend() && !found) {
    if ((*r_itr)->getStateOfActivation() == sim::State::Active) {
      found = true;
      (*r_itr)->setStateOfActivation(sim::State::Pause);
    }
    r_itr++;
  }
}
void InfoChunk::interruptCurrentStrategy() {
  bool found = false;
  auto r_itr = strategy.rbegin();
  while (r_itr != strategy.rend() && !found) {
    if ((*r_itr)->getStateOfActivation() == sim::State::Active) {
      found = true;
      (*r_itr)->setStateOfActivation(sim::State::Pause);
    }
    r_itr++;
  }
}
void InfoChunk::interruptCurrentSubGoal() {
  bool found = false;
  auto r_itr = subgoal.rbegin();
  while (r_itr != subgoal.rend() && !found) {
    if ((*r_itr)->getStateOfActivation() == sim::State::Active) {
      found = true;
      (*r_itr)->setStateOfActivation(sim::State::Pause);
    }
    r_itr++;
  }
}
void InfoChunk::interruptCurrentDiagnosis() {
  bool found = false;
  auto r_itr = diagnosis.rbegin();
  while (r_itr != diagnosis.rend() && !found) {
    if ((*r_itr)->getStateOfActivation() == sim::State::Active) {
      found = true;
      (*r_itr)->setStateOfActivation(sim::State::Pause);
    }
    r_itr++;
  }
}
void InfoChunk::interruptCurrentActionObjective() {
  bool found = false;
  auto r_itr = action_objective.rbegin();
  while (r_itr != action_objective.rend() && !found) {
    if ((*r_itr)->getStateOfActivation() == sim::State::Active) {
      found = true;
      (*r_itr)->setStateOfActivation(sim::State::Pause);
    }
    r_itr++;
  }
}
void InfoChunk::interruptCurrentActionPack() {
  bool found = false;
  auto r_itr = action_pack.rbegin();
  while (r_itr != action_pack.rend() && !found) {
    if ((*r_itr)->getStateOfActivation() == sim::State::Active) {
      found = true;
      (*r_itr)->setStateOfActivation(sim::State::Pause);
    }
    r_itr++;
  }
}
void InfoChunk::interruptCurrentAction() {
  bool found = false;
  auto r_itr = action.rbegin();
  while (r_itr != action.rend() && !found) {
    if ((*r_itr)->getStateOfActivation() == sim::State::Active) {
      found = true;
      (*r_itr)->setStateOfActivation(sim::State::Pause);
    }
    r_itr++;
  }
}
void InfoChunk::interruptCurrentProcedureStep() {
  bool found = false;
  auto r_itr = procedure_step.rbegin();
  while (r_itr != procedure_step.rend() && !found) {
    if ((*r_itr)->getStateOfActivation() == sim::State::Active) {
      found = true;
      (*r_itr)->setStateOfActivation(sim::State::Pause);
      (*r_itr)->setLastProcedureName("NONE");
      (*r_itr)->setLastStepName("NONE");
    }
    r_itr++;
  }
}
 
int InfoChunk::checkWhetherExpectedAlarmMatchObservation(KBExpectedAlarmStateUnit *_exp) {
  bool found = false;
  int r_return = sim::None;
  decltype(perceived_alarms)::reverse_iterator ritr;
  ritr = perceived_alarms.rbegin();
  while (ritr != perceived_alarms.rend() && !found) {
    if ((*ritr)->getAlarmName() == _exp->getInfoName()) {
      found = true;
      if ((*ritr)->getObservedAlarmState() == _exp->getExpectedState()) {
        r_return = sim::State::Succeed;
      } else {
        r_return = sim::State::Failed;
      }
    }
    ritr++;
  }
  return r_return;
}
int InfoChunk::checkWhetherExpectedComponentStateMatchObservation(KBExpectedComponentStateUnit *_exp) {
  bool found = false;
  int r_return = sim::None;
  decltype(perceived_component_state)::reverse_iterator ritr;
  ritr = perceived_component_state.rbegin();
  while (ritr != perceived_component_state.rend() && !found) {
    if ((*ritr)->getDisplayName() == _exp->getInfoName()) {
      found = true;
      if ((*ritr)->getObservedComponentState() == _exp->getExpectedState()) {
        r_return = sim::State::Succeed;
      } else {
        r_return = sim::State::Failed;
      }
    }
    ritr++;
  }
  return r_return;
};
int InfoChunk::checkWhetherExpectedSupportSystemStateMatchObservation(KBExpectedSupportSystemStateUnit *_exp) {
  bool found = false;
  int r_return = sim::None;
  decltype(perceived_support_system_state)::reverse_iterator ritr;
  ritr = perceived_support_system_state.rbegin();
  while (ritr != perceived_support_system_state.rend() && !found) {
    if ((*ritr)->getDisplayName() == _exp->getInfoName()) {
      found = true;
      if ((*ritr)->getObservedSupportSystemState() == _exp->getExpectedState()) {
        r_return = sim::State::Succeed;
      } else {
        r_return = sim::State::Failed;
      }
    }
    ritr++;
  }
  return r_return;
};
int InfoChunk::checkWhetherExpectedParameterValueMatchObservation(KBExpectedParameterValueUnit *_exp) {
  bool found = false;
  int r_return = sim::None;
  double observed_value, par1, par2;
  decltype(perceived_parameter_value)::reverse_iterator ritr;
  ritr = perceived_parameter_value.rbegin();
  while (ritr != perceived_parameter_value.rend() && !found) {
    if ((*ritr)->getDisplayName() == _exp->getInfoName()) {
      found = true;
      r_return = sim::State::Failed;
      observed_value = (*ritr)->getObservedParameterValue();
      par1 = _exp->getExpectedValue1();
      par2 = _exp->getExpectedValue2();
      switch (_exp->getLogicalRelation()) {
        case sim::Compare::GT: if (observed_value > par1) r_return = sim::State::Succeed;
          break;
        case sim::Compare::GE: if (observed_value >= par1) r_return = sim::State::Succeed;
          break;
        case sim::Compare::EQ: if (observed_value == par1) r_return = sim::State::Succeed;
          break;
        case sim::Compare::LE: if (observed_value <= par1) r_return = sim::State::Succeed;
          break;
        case sim::Compare::LT: if (observed_value < par1) r_return = sim::State::Succeed;
          break;
        case sim::Compare::Between: if (observed_value > par1 && observed_value < par2) r_return = sim::State::Succeed;
          break;
        default: ofstream fout("err messages.txt", ios::app);
          cout << "InfoChunk::checkWhetherExpectedParameterValueMatchObservation: KBExpectation: "
               << (*ritr)->getDisplayName()
               << " whose logical relation: " << _exp->getLogicalRelation() << " could not be recognized" << endl;
          fout << r5pars_.timesno << "  InfoChunk::checkWhetherExpectedParameterValueMatchObservation: KBExpectation: "
               << (*ritr)->getDisplayName()
               << " whose logical relation: " << _exp->getLogicalRelation() << " could not be recognized.\n";
          fout.close();
          r5pars_.sim_err = true;
          g_sim.Branch_center.setTempESMessage("InfoChunk::checkWhetherExpectedParameterValueMatchObservation err.");
          g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
          break;
      }
    }
    ritr++;
  }
  return r_return;
}
 
int InfoChunk::checkWhetherExpectedParameterDifferenceMatchObservation(KBExpectedParameterDifferenceUnit *_expd) {
  bool found1 = false;
  bool found2 = false;
  int r_return = sim::None;
  double observed_value1, observed_value2;
  decltype(perceived_parameter_value)::reverse_iterator ritr;
  ritr = perceived_parameter_value.rbegin();
  //find first difference parameter in perceived information
  while (ritr != perceived_parameter_value.rend() && !found1) {
    if ((*ritr)->getDisplayName() == _expd->first_indicator.getInfoName()) {
      found1 = true;
      observed_value1 = (*ritr)->getObservedParameterValue();
    }
    ritr++;
  }
  //find second difference parameter in perceived information
  ritr = perceived_parameter_value.rbegin();
  while (ritr != perceived_parameter_value.rend() && !found2) {
    if ((*ritr)->getDisplayName() == _expd->second_indicator.getInfoName()) {
      found2 = true;
      observed_value2 = (*ritr)->getObservedParameterValue();
    }
    ritr++;
  }
  if (found1 == true && found2 == true) {
    r_return = sim::State::Failed;
    if (observed_value1 - observed_value2 > _expd->getThresholdValueThatActivatesExpectation()) {
      r_return = sim::State::Succeed;
    }
  }
  return r_return;
}
 
int InfoChunk::checkWhetherExpectedParameterTrendMatchObservation(KBExpectedParameterTrendUnit *_exp) {
  int r_return = sim::None;
  r_return = this->checkWhetherExpectedParameterValueMatchObservation((KBExpectedParameterValueUnit *) _exp);
  return r_return;
}
 
void InfoChunk::copyInfoChunk(InfoChunk &_ic) {
  for (auto goal_itr = _ic.goal.begin(); goal_itr != _ic.goal.end(); goal_itr++) {
    auto goal_sp = make_shared<DecisionGoal>();
    goal_sp->copyDecisionGoal(**goal_itr);
    this->goal.push_back(goal_sp);
  }
  for (auto strategy_itr = _ic.strategy.begin(); strategy_itr != _ic.strategy.end(); strategy_itr++) {
    auto strategy_sp = make_shared<DecisionStrategy>();
    strategy_sp->copyDecisionStrategy(**strategy_itr);
    this->strategy.push_back(strategy_sp);
  }
  for (auto subgoal_itr = _ic.subgoal.begin(); subgoal_itr != _ic.subgoal.end(); subgoal_itr++) {
    auto subgoal_sp = make_shared<DecisionSubGoal>();
    subgoal_sp->copyDecisionSubGoal(**subgoal_itr);
    this->subgoal.push_back(subgoal_sp);
  }
  for (auto diagnosis_itr = _ic.diagnosis.begin(); diagnosis_itr != _ic.diagnosis.end(); diagnosis_itr++) {
    auto diagnosis_sp = make_shared<DecisionDiagnosis>();
    diagnosis_sp->copyDecisionDiagnosis(**diagnosis_itr);
    this->diagnosis.push_back(diagnosis_sp);
  }
  for (auto action_objective_itr = _ic.action_objective.begin(); action_objective_itr != _ic.action_objective.end();
       action_objective_itr++) {
    auto action_objective_sp = make_shared<DecisionActionObjective>();
    action_objective_sp->copyDecisionActionObjective(**action_objective_itr);
    this->action_objective.push_back(action_objective_sp);
  }
  for (auto action_pack_itr = _ic.action_pack.begin(); action_pack_itr != _ic.action_pack.end(); action_pack_itr++) {
    auto action_pack_sp = make_shared<DecisionActionPack>();
    action_pack_sp->copyDecisionActionPack(**action_pack_itr);
    this->action_pack.push_back(action_pack_sp);
  }
  for (auto action_itr = _ic.action.begin(); action_itr != _ic.action.end(); action_itr++) {
    auto action_sp = make_shared<DecisionAction>();
    action_sp->copyDecisionAction(**action_itr);
    this->action.push_back(action_sp);
  }
  for (auto procedure_step_itr = _ic.procedure_step.begin(); procedure_step_itr != _ic.procedure_step.end();
       procedure_step_itr++) {
    auto procedure_step_sp = make_shared<DecisionProcedureStep>();
    procedure_step_sp->copyDecisionProcedureStep(**procedure_step_itr);
    this->procedure_step.push_back(procedure_step_sp);
  }
  for (auto procedure_step_itr = _ic.instinctive_response_procedure.begin();
       procedure_step_itr != _ic.instinctive_response_procedure.end(); procedure_step_itr++) {
    auto procedure_step_sp = make_shared<DecisionProcedureStep>();
    procedure_step_sp->copyDecisionProcedureStep(**procedure_step_itr);
    this->instinctive_response_procedure.push_back(procedure_step_sp);
  }
  for (auto perceived_alarms_itr = _ic.perceived_alarms.begin(); perceived_alarms_itr != _ic.perceived_alarms.end();
       perceived_alarms_itr++) {
    auto perceived_alarms_sp = make_shared<MentalAlarm>();
    perceived_alarms_sp->copyMentalAlarm(**perceived_alarms_itr);
    this->perceived_alarms.push_back(perceived_alarms_sp);
  }
  for (auto perceived_component_state_itr = _ic.perceived_component_state.begin();
       perceived_component_state_itr != _ic.perceived_component_state.end(); perceived_component_state_itr++) {
    auto perceived_component_state_sp = make_shared<MentalComponentState>();
    perceived_component_state_sp->copyMentalComponentState(**perceived_component_state_itr);
    this->perceived_component_state.push_back(perceived_component_state_sp);
  }
  for (auto perceived_support_system_state_itr = _ic.perceived_support_system_state.begin();
       perceived_support_system_state_itr != _ic.perceived_support_system_state.end(); perceived_support_system_state_itr++) {
    auto perceived_support_system_state_sp = make_shared<MentalSupportSystemState>();
    perceived_support_system_state_sp->copyMentalSupportSystemState(**perceived_support_system_state_itr);
    this->perceived_support_system_state.push_back(perceived_support_system_state_sp);
  }
  for (auto perceived_parameter_value_itr = _ic.perceived_parameter_value.begin();
       perceived_parameter_value_itr != _ic.perceived_parameter_value.end(); perceived_parameter_value_itr++) {
    auto perceived_parameter_value_sp = make_shared<MentalParameterValue>();
    perceived_parameter_value_sp->copyMentalParameterValue(**perceived_parameter_value_itr);
    this->perceived_parameter_value.push_back(perceived_parameter_value_sp);
  }
  for (auto perceived_parameter_trend_itr = _ic.perceived_parameter_trend.begin();
       perceived_parameter_trend_itr != _ic.perceived_parameter_trend.end(); perceived_parameter_trend_itr++) {
    auto perceived_parameter_trend_sp = make_shared<MentalParameterTrend>();
    perceived_parameter_trend_sp->copyMentalParameterTrend(**perceived_parameter_trend_itr);
    this->perceived_parameter_trend.push_back(perceived_parameter_trend_sp);
  }
  for (auto mental_belief_itr = _ic.mental_belief.begin(); mental_belief_itr != _ic.mental_belief.end();
       mental_belief_itr++) {
    auto mental_belief_sp = make_shared<ExpectedMentalBelief>();
    mental_belief_sp->copyExpectedMentalBelief(**mental_belief_itr);
    this->mental_belief.push_back(mental_belief_sp);
  }
}
bool InfoChunk::diagnosisIsIncluded(string _diagnosis) {
  bool is_included = false;
  auto diagnosis_itr = diagnosis.begin();
  while (diagnosis_itr != diagnosis.end() && !is_included) {
    if ((*diagnosis_itr)->getDiagnosis() == _diagnosis) {
      is_included = true;
    }
    diagnosis_itr++;
  }
  return is_included;
}
void InfoChunk::setStateOfAProcedureStep(string _procedure_name, string _step_name, int _state) {
  bool found = false;
  decltype(procedure_step)::reverse_iterator ritr;
  ritr = procedure_step.rbegin();
  // reverse iterator starts at end of queue (ie last procedure step added) and works backwards
  while (ritr != procedure_step.rend() && !found) {
    if ((*ritr)->getProcedureName() == _procedure_name && (*ritr)->getStepName() == _step_name) {
      found = true;
      (*ritr)->setStateOfActivation(_state);
    }
    ritr++;
  }
  if (!found) {
    ritr = this->instinctive_response_procedure.rbegin();
    while (ritr != this->instinctive_response_procedure.rend() && !found) {
      if ((*ritr)->getProcedureName() == _procedure_name && (*ritr)->getStepName() == _step_name) {
        found = true;
        (*ritr)->setStateOfActivation(_state);
      }
      ritr++;
    }
  }
}
int InfoChunk::getStateOfAProcedureStep(string _procedure_name, string _step_name) {
  bool found = false;
  int state = sim::None;
  decltype(procedure_step)::reverse_iterator ritr;
  ritr = procedure_step.rbegin();
  // reverse iterator starts at end of queue (ie last procedure step added) and works backwards
  while (ritr != procedure_step.rend() && !found) {
    if ((*ritr)->getProcedureName() == _procedure_name && (*ritr)->getStepName() == _step_name) {
      found = true;
      state = (*ritr)->getStateOfActivation();
    }
    ritr++;
  }
  if (!found) {
    ritr = this->instinctive_response_procedure.rbegin();
    while (ritr != this->instinctive_response_procedure.rend() && !found) {
      if ((*ritr)->getProcedureName() == _procedure_name && (*ritr)->getStepName() == _step_name) {
        found = true;
        state = (*ritr)->getStateOfActivation();
      }
      ritr++;
    }
  }
  return state;
}
 
int InfoChunk::getMentalPriorityOfAProcedureStep(string _procedure_name, string _step_name) {
  bool found = false;
  int state = sim::None;
  decltype(procedure_step)::reverse_iterator ritr;
  ritr = procedure_step.rbegin();
  // reverse iterator starts at end of queue (ie last procedure step added) and works backwards
  while (ritr != procedure_step.rend() && !found) {
    if ((*ritr)->getProcedureName() == _procedure_name && (*ritr)->getStepName() == _step_name) {
      found = true;
      state = (*ritr)->getPriority();
    }
    ritr++;
  }
  if (!found) {
    ritr = this->instinctive_response_procedure.rbegin();
    while (ritr != this->instinctive_response_procedure.rend() && !found) {
      if ((*ritr)->getProcedureName() == _procedure_name && (*ritr)->getStepName() == _step_name) {
        found = true;
        state = (*ritr)->getPriority();
      }
      ritr++;
    }
  }
  return state;
}
 
void InfoChunk::saveInfoChunkToFile(ofstream &fout) {
  fout << "GOAL " << this->goal.size() << '\n';
  for (auto goal_itr = goal.begin(); goal_itr != goal.end(); goal_itr++) {
    (*goal_itr)->saveDecisionGoalToFile(fout);
  }
  fout << "STRATEGY " << this->strategy.size() << '\n';
  for (auto strategy_itr = strategy.begin(); strategy_itr != strategy.end(); strategy_itr++) {
    (*strategy_itr)->saveDecisionStrategyToFile(fout);
  }
  fout << "SUBGOAL " << this->subgoal.size() << '\n';
  for (auto subgoal_itr = subgoal.begin(); subgoal_itr != subgoal.end(); subgoal_itr++) {
    (*subgoal_itr)->saveDecisionSubGoalToFile(fout);
  }
  fout << "DIAGNOSIS " << this->diagnosis.size() << '\n';
  for (auto diagnosis_itr = diagnosis.begin(); diagnosis_itr != diagnosis.end(); diagnosis_itr++) {
    (*diagnosis_itr)->saveDecisionDiagnosisToFile(fout);
  }
  fout << "ACTION_OBJECTIVE " << this->action_objective.size() << '\n';
  for (auto action_objective_itr = action_objective.begin(); action_objective_itr != action_objective.end();
       action_objective_itr++) {
    (*action_objective_itr)->saveDecisionActionObjectiveToFile(fout);
  }
  fout << "ACTION_PACK " << this->action_pack.size() << '\n';
  for (auto action_pack_itr = action_pack.begin(); action_pack_itr != action_pack.end(); action_pack_itr++) {
    (*action_pack_itr)->saveDecisionActionPackToFile(fout);
  }
  fout << "ACTION " << this->action.size() << '\n';
  for (auto action_itr = action.begin(); action_itr != action.end(); action_itr++) {
    (*action_itr)->saveDecisionActionToFile(fout);
  }
  fout << "PROCEDURE_STEP " << this->procedure_step.size() << '\n';
  for (auto procedure_step_itr = procedure_step.begin(); procedure_step_itr != procedure_step.end(); procedure_step_itr++) {
    (*procedure_step_itr)->saveDecisionProcedureStepToFile(fout);
  }
  fout << "INSTINCTIVE_RESPONSE " << this->instinctive_response_procedure.size() << '\n';
  for (auto procedure_step_itr = instinctive_response_procedure.begin();
       procedure_step_itr != instinctive_response_procedure.end(); procedure_step_itr++) {
    (*procedure_step_itr)->saveDecisionProcedureStepToFile(fout);
  }
  fout << "PERCEIVED_ALARM " << this->perceived_alarms.size() << '\n';
  for (auto perceived_alarms_itr = perceived_alarms.begin(); perceived_alarms_itr != perceived_alarms.end();
       perceived_alarms_itr++) {
    (*perceived_alarms_itr)->saveMentalAlarmToFile(fout);
  }
  fout << "PERCEIVED_COMPONENT_STATE " << this->perceived_component_state.size() << '\n';
  for (auto perceived_component_state_itr = perceived_component_state.begin();
       perceived_component_state_itr != perceived_component_state.end(); perceived_component_state_itr++) {
    (*perceived_component_state_itr)->saveMentalComponentStateToFile(fout);
  }
  fout << "PERCEIVED_SUPPORT_SYSTEM_STATE " << this->perceived_support_system_state.size() << '\n';
  for (auto perceived_support_system_state_itr = perceived_support_system_state.begin();
       perceived_support_system_state_itr != perceived_support_system_state.end(); perceived_support_system_state_itr++) {
    (*perceived_support_system_state_itr)->saveMentalSupportSystemStateToFile(fout);
  }
  fout << "PERCEIVED_PARAMETER_VALUE " << this->perceived_parameter_value.size() << '\n';
  for (auto perceived_parameter_value_itr = perceived_parameter_value.begin();
       perceived_parameter_value_itr != perceived_parameter_value.end(); perceived_parameter_value_itr++) {
    (*perceived_parameter_value_itr)->saveMentalParameterValueToFile(fout);
  }
  fout << "PERCEIVER_PARAMETER_TREND " << this->perceived_parameter_trend.size() << '\n';
  for (auto perceived_parameter_trend_itr = perceived_parameter_trend.begin();
       perceived_parameter_trend_itr != perceived_parameter_trend.end(); perceived_parameter_trend_itr++) {
    (*perceived_parameter_trend_itr)->saveMentalParameterTrendToFile(fout);
  }
  fout << "MENTAL_BELIEF " << this->mental_belief.size() << '\n';
  for (auto mental_belief_itr = mental_belief.begin(); mental_belief_itr != mental_belief.end(); mental_belief_itr++) {
    (*mental_belief_itr)->saveExpectedMentalBeliefToFile(fout);
  }
}
void InfoChunk::retrieveInfoChunkFromFile(ifstream &fin) {
  int i, num;
  string str;
  fin >> str >> num;
  if (str != "GOAL") {
    this->generateErrorMessage("GOAL");
    return;
  } else {
    for (i = 0; i < num; i++) {
      auto goal_sp = make_shared<DecisionGoal>();
      goal_sp->retrieveDecisionGoalFromFile(fin);
      this->goal.push_back(goal_sp);
    }
  }
//
  fin >> str >> num;
  if (str != "STRATEGY") {
    this->generateErrorMessage("SUBGOAL");
    return;
  } else {
    for (i = 0; i < num; i++) {
      auto strategy_sp = make_shared<DecisionStrategy>();
      strategy_sp->retrieveDecisionStrategyFromFile(fin);
      this->strategy.push_back(strategy_sp);
    }
  }
//
  fin >> str >> num;
  if (str != "SUBGOAL") {
    this->generateErrorMessage("SUBGOAL");
    return;
  } else {
    for (i = 0; i < num; i++) {
      auto subgoal_sp = make_shared<DecisionSubGoal>();
      subgoal_sp->retrieveDecisionSubGoalFromFile(fin);
      this->subgoal.push_back(subgoal_sp);
    }
  }
//
  fin >> str >> num;
  if (str != "DIAGNOSIS") {
    this->generateErrorMessage("DIAGNOSIS");
    return;
  } else {
    for (i = 0; i < num; i++) {
      auto diagnosis_sp = make_shared<DecisionDiagnosis>();
      diagnosis_sp->retrieveDecisionDiagnosisFromFile(fin);
      this->diagnosis.push_back(diagnosis_sp);
    }
  }
//
  fin >> str >> num;
  if (str != "ACTION_OBJECTIVE") {
    this->generateErrorMessage("ACTION_OBJECTIVE");
    return;
  } else {
    for (i = 0; i < num; i++) {
      auto action_objective_sp = make_shared<DecisionActionObjective>();
      action_objective_sp->retrieveDecisionActionObjectiveFromFile(fin);
      this->action_objective.push_back(action_objective_sp);
    }
  }
//
  fin >> str >> num;
  if (str != "ACTION_PACK") {
    this->generateErrorMessage("ACTION_PACK");
    return;
  } else {
    for (i = 0; i < num; i++) {
      auto action_pack_sp = make_shared<DecisionActionPack>();
      action_pack_sp->retrieveDecisionActionPackFromFile(fin);
      this->action_pack.push_back(action_pack_sp);
    }
  }
//
  fin >> str >> num;
  if (str != "ACTION") {
    this->generateErrorMessage("ACTION");
    return;
  } else {
    for (i = 0; i < num; i++) {
      auto action_sp = make_shared<DecisionAction>();
      action_sp->retrieveDecisionActionFromFile(fin);
      this->action.push_back(action_sp);
    }
  }
//
  fin >> str >> num;
  if (str != "PROCEDURE_STEP") {
    this->generateErrorMessage("PROCEDURE_STEP");
    return;
  } else {
    for (i = 0; i < num; i++) {
      auto procedure_step_sp = make_shared<DecisionProcedureStep>();
      procedure_step_sp->retrieveDecisionProcedureStepFromFile(fin);
      this->procedure_step.push_back(procedure_step_sp);
    }
  }
//
  fin >> str >> num;
  if (str != "INSTINCTIVE_RESPONSE") {
    this->generateErrorMessage("INSTINCTIVE_RESPONSE");
    return;
  } else {
    for (i = 0; i < num; i++) {
      auto procedure_step_sp = make_shared<DecisionProcedureStep>();
      procedure_step_sp->retrieveDecisionProcedureStepFromFile(fin);
      this->instinctive_response_procedure.push_back(procedure_step_sp);
    }
  }
//
  fin >> str >> num;
  if (str != "PERCEIVED_ALARM") {
    this->generateErrorMessage("PERCEIVED_ALARM");
    return;
  } else {
    for (i = 0; i < num; i++) {
      auto perceived_alarms_sp = make_shared<MentalAlarm>();
      perceived_alarms_sp->retrieveMentalAlarmFromFile(fin);
      this->perceived_alarms.push_back(perceived_alarms_sp);
    }
  }
//
  fin >> str >> num;
  if (str != "PERCEIVED_COMPONENT_STATE") {
    this->generateErrorMessage("PERCEIVED_COMPONENT_STATE");
    return;
  } else {
    for (i = 0; i < num; i++) {
      auto perceived_component_state_sp = make_shared<MentalComponentState>();
      perceived_component_state_sp->retrieveMentalComponentStateFromFile(fin);
      this->perceived_component_state.push_back(perceived_component_state_sp);
    }
  }
//
  fin >> str >> num;
  if (str != "PERCEIVED_SUPPORT_SYSTEM_STATE") {
    this->generateErrorMessage("PERCEIVED_SUPPORT_SYSTEM_STATE");
    return;
  } else {
    for (i = 0; i < num; i++) {
      auto perceived_support_system_state_sp = make_shared<MentalSupportSystemState>();
      perceived_support_system_state_sp->retrieveMentalSupportSystemStateFromFile(fin);
      this->perceived_support_system_state.push_back(perceived_support_system_state_sp);
    }
  }
//
  fin >> str >> num;
  if (str != "PERCEIVED_PARAMETER_VALUE") {
    this->generateErrorMessage("PERCEIVED_PARAMETER_VALUE");
    return;
  } else {
    for (i = 0; i < num; i++) {
      auto perceived_parameter_value_sp = make_shared<MentalParameterValue>();
      perceived_parameter_value_sp->retrieveMentalParameterValueFromFile(fin);
      this->perceived_parameter_value.push_back(perceived_parameter_value_sp);
    }
  }
//
  fin >> str >> num;
  if (str != "PERCEIVER_PARAMETER_TREND") {
    this->generateErrorMessage("PERCEIVER_PARAMETER_TREND");
    return;
  } else {
    for (i = 0; i < num; i++) {
      auto perceived_parameter_trend_sp = make_shared<MentalParameterTrend>();
      perceived_parameter_trend_sp->retrieveMentalParameterTrendFromFile(fin);
      this->perceived_parameter_trend.push_back(perceived_parameter_trend_sp);
    }
  }
//
  fin >> str >> num;
  if (str != "MENTAL_BELIEF") {
    this->generateErrorMessage("MENTAL_BELIEF");
    return;
  } else {
    for (i = 0; i < num; i++) {
      auto mental_belief_sp = make_shared<ExpectedMentalBelief>();
      mental_belief_sp->retrieveExpectedMentalBeliefFromFile(fin);
      this->mental_belief.push_back(mental_belief_sp);
    }
  }
}
 
void InfoChunk::replaceObjecByPointerForGroupedInfoAll(InfoChunk &_ic) {
  this->replaceObjecByPointerForGroupedInfoGoal(_ic);
  this->replaceObjecByPointerForGroupedInfoStrategy(_ic);
  this->replaceObjecByPointerForGroupedInfoSubGoal(_ic);
  this->replaceObjecByPointerForGroupedInfoDiagnosis(_ic);
  this->replaceObjecByPointerForGroupedInfoActionObjective(_ic);
  this->replaceObjecByPointerForGroupedInfoActionPack(_ic);
  this->replaceObjecByPointerForGroupedInfoAction(_ic);
  this->replaceObjecByPointerForGroupedInfoProcedureStep(_ic);
  this->replaceObjecByPointerForGroupedInfoInstinctiveResponseProcedure(_ic);
  this->replaceObjecByPointerForGroupedInfoAlarm(_ic);
  this->replaceObjecByPointerForGroupedInfoComponentState(_ic);
  this->replaceObjecByPointerForGroupedInfoSupportSystemState(_ic);
  this->replaceObjecByPointerForGroupedInfoParameterValue(_ic);
  this->replaceObjecByPointerForGroupedInfoParameterTrend(_ic);
  this->replaceObjecByPointerForGroupedInfoMentalBelief(_ic);
}
void InfoChunk::replaceObjecByPointerForGroupedInfoGoal(InfoChunk &_ic) {
  bool found = false;
  if (goal.size() == 0) return;
  for (auto goal_itr = goal.begin(); goal_itr != goal.end();
       goal_itr++) {//find teh corresponding goal in the ShortTermMemory::perceived_info
    auto goal_itr1 = _ic.goal.begin();
    auto goal_end = _ic.goal.end();
    found = false;
    while (goal_itr1 != goal_end && !found) {
      found = (*goal_itr)->checkIfIsIdenticalDecisionGoal(**goal_itr1);
      if (found) {
        *goal_itr = *goal_itr1;
      } else {
        goal_itr1++;
      }
    }
    if (!found) {//could not find teh corresponding goal
      cout << "Goal in ShortTermMemory::grouped_info " << (*goal_itr)->getDecision() << " generated at "
           << (*goal_itr)->getTimeAtWhichThisInfoIsPerceived()
           << " cound not find corresponding goal in the ShortTermMemory::perceived_info" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  Goal in ShortTermMemory::grouped_info " << (*goal_itr)->getDecision()
           << " generated at "
           << (*goal_itr)->getTimeAtWhichThisInfoIsPerceived()
           << " cound not find corresponding goal in the ShortTermMemory::perceived_info\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("InfoChunk::replaceObjecByPointerForGroupedInfoGoal err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      goal_itr->reset();
    }
  }
}
 
void InfoChunk::replaceObjecByPointerForGroupedInfoStrategy(InfoChunk &_ic) {
  bool found = false;
  if (strategy.size() == 0) return;
  for (auto strategy_itr = strategy.begin(); strategy_itr != strategy.end();
       strategy_itr++) {//find teh corresponding strategy in the ShortTermMemory::perceived_info
    auto strategy_itr1 = _ic.strategy.begin();
    auto strategy_end = _ic.strategy.end();
    found = false;
    while (strategy_itr1 != strategy_end && !found) {
      found = (*strategy_itr)->checkIfIsIdenticalDecisionStrategy(**strategy_itr1);
      if (found) {
        *strategy_itr = *strategy_itr1;
      } else {
        strategy_itr1++;
      }
    }
    if (!found) {//could not find teh corresponding strategy
      cout << "Strategy in ShortTermMemory::grouped_info " << (*strategy_itr)->getDecision() << " generated at "
           << (*strategy_itr)->getTimeAtWhichThisInfoIsPerceived()
           << " cound not find corresponding strategy in the ShortTermMemory::perceived_info" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  Strategy in ShortTermMemory::grouped_info " << (*strategy_itr)->getDecision()
           << " generated at "
           << (*strategy_itr)->getTimeAtWhichThisInfoIsPerceived()
           << " cound not find corresponding strategy in the ShortTermMemory::perceived_info\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("InfoChunk::replaceObjecByPointerForGroupedInfoStrategy err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      strategy_itr->reset();
    }
  }
}
 
void InfoChunk::replaceObjecByPointerForGroupedInfoSubGoal(InfoChunk &_ic) {
  bool found = false;
  if (subgoal.size() == 0) return;
  for (auto subgoal_itr = subgoal.begin(); subgoal_itr != subgoal.end();
       subgoal_itr++) {//find teh corresponding subgoal in the ShortTermMemory::perceived_info
    auto subgoal_itr1 = _ic.subgoal.begin();
    auto subgoal_end = _ic.subgoal.end();
    found = false;
    while (subgoal_itr1 != subgoal_end && !found) {
      found = (*subgoal_itr)->checkIfIsIdenticalDecisionSubGoal(**subgoal_itr1);
      if (found) {
        *subgoal_itr = *subgoal_itr1;
      } else {
        subgoal_itr1++;
      }
    }
    if (!found) {//could not find teh corresponding subgoal
      cout << "Subgoal in ShortTermMemory::grouped_info " << (*subgoal_itr)->getDecision() << " generated at "
           << (*subgoal_itr)->getTimeAtWhichThisInfoIsPerceived()
           << " cound not find corresponding subgoal in the ShortTermMemory::perceived_info" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  Subgoal in ShortTermMemory::grouped_info " << (*subgoal_itr)->getDecision()
           << " generated at "
           << (*subgoal_itr)->getTimeAtWhichThisInfoIsPerceived()
           << " cound not find corresponding subgoal in the ShortTermMemory::perceived_info\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("InfoChunk::replaceObjecByPointerForGroupedInfoSubGoal err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      subgoal_itr->reset();
    }
  }
}
 
void InfoChunk::replaceObjecByPointerForGroupedInfoDiagnosis(InfoChunk &_ic) {
  bool found = false;
  if (diagnosis.size() == 0) return;
  for (auto diagnosis_itr = diagnosis.begin(); diagnosis_itr != diagnosis.end();
       diagnosis_itr++) {//find teh corresponding diagnosis in the ShortTermMemory::perceived_info
    auto diagnosis_itr1 = _ic.diagnosis.begin();
    auto diagnosis_end = _ic.diagnosis.end();
    found = false;
    while (diagnosis_itr1 != diagnosis_end && !found) {
      found = (*diagnosis_itr)->checkIfIsIdenticalDecisionDiagnosis(**diagnosis_itr1);
      if (found) {
        *diagnosis_itr = *diagnosis_itr1;
      } else {
        diagnosis_itr1++;
      }
    }
    if (!found) {//could not find teh corresponding diagnosis
      cout << "Diagnosis in ShortTermMemory::grouped_info " << (*diagnosis_itr)->getDecision() << " generated at "
           << (*diagnosis_itr)->getTimeAtWhichThisInfoIsPerceived()
           << " cound not find corresponding diagnosis in the ShortTermMemory::perceived_info" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  Diagnosis in ShortTermMemory::grouped_info " << (*diagnosis_itr)->getDecision()
           << " generated at "
           << (*diagnosis_itr)->getTimeAtWhichThisInfoIsPerceived()
           << " cound not find corresponding diagnosis in the ShortTermMemory::perceived_info\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("InfoChunk::replaceObjecByPointerForGroupedInfoDiagnosis err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      diagnosis_itr->reset();
    }
  }
}
void InfoChunk::replaceObjecByPointerForGroupedInfoActionObjective(InfoChunk &_ic) {
  bool found = false;
  if (action_objective.size() == 0) return;
  for (auto action_objective_itr = action_objective.begin(); action_objective_itr != action_objective.end();
       action_objective_itr++) {//find teh corresponding action_objective in the ShortTermMemory::perceived_info
    auto action_objective_itr1 = _ic.action_objective.begin();
    auto action_objective_end = _ic.action_objective.end();
    found = false;
    while (action_objective_itr1 != action_objective_end && !found) {
      found = (*action_objective_itr)->checkIfIsIdenticalDecisionActionObjective(**action_objective_itr1);
      if (found) {
        *action_objective_itr = *action_objective_itr1;
      } else {
        action_objective_itr1++;
      }
    }
    if (!found) {//could not find teh corresponding action_objective
      cout << "ActionObjective in ShortTermMemory::grouped_info " << (*action_objective_itr)->getDecision()
           << " generated at "
           << (*action_objective_itr)->getTimeAtWhichThisInfoIsPerceived()
           << " cound not find corresponding action_objective in the ShortTermMemory::perceived_info" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  ActionObjective in ShortTermMemory::grouped_info "
           << (*action_objective_itr)->getDecision() << " generated at "
           << (*action_objective_itr)->getTimeAtWhichThisInfoIsPerceived()
           << " cound not find corresponding action_objective in the ShortTermMemory::perceived_info\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("InfoChunk::replaceObjecByPointerForGroupedInfoActionObjective err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      action_objective_itr->reset();
    }
  }
}
 
void InfoChunk::replaceObjecByPointerForGroupedInfoActionPack(InfoChunk &_ic) {
  bool found = false;
  if (action_pack.size() == 0) return;
  for (auto action_pack_itr = action_pack.begin(); action_pack_itr != action_pack.end();
       action_pack_itr++) {//find teh corresponding action_pack in the ShortTermMemory::perceived_info
    auto action_pack_itr1 = _ic.action_pack.begin();
    auto action_pack_end = _ic.action_pack.end();
    found = false;
    while (action_pack_itr1 != action_pack_end && !found) {
      found = (*action_pack_itr)->checkIfIsIdenticalDecisionActionPack(**action_pack_itr1);
      if (found) {
        *action_pack_itr = *action_pack_itr1;
      } else {
        action_pack_itr1++;
      }
    }
    if (!found) {//could not find teh corresponding action_pack
      cout << "ActionPack in ShortTermMemory::grouped_info " << (*action_pack_itr)->getActionPackName()
           << " generated at "
           << (*action_pack_itr)->getTimeAtWhichThisInfoIsPerceived()
           << " cound not find corresponding action_pack in the ShortTermMemory::perceived_info" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  ActionPack in ShortTermMemory::grouped_info "
           << (*action_pack_itr)->getActionPackName() << " generated at "
           << (*action_pack_itr)->getTimeAtWhichThisInfoIsPerceived()
           << " cound not find corresponding action_pack in the ShortTermMemory::perceived_info\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("InfoChunk::replaceObjecByPointerForGroupedInfoActionPack err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      action_pack_itr->reset();
    }
  }
}
void InfoChunk::replaceObjecByPointerForGroupedInfoAction(InfoChunk &_ic) {
  bool found = false;
  if (action.size() == 0) return;
  for (auto action_itr = action.begin(); action_itr != action.end();
       action_itr++) {//find teh corresponding action in the ShortTermMemory::perceived_info
    auto action_itr1 = _ic.action.begin();
    auto action_end = _ic.action.end();
    found = false;
    while (action_itr1 != action_end && !found) {
      found = (*action_itr)->checkIfIsIdenticalDecisionAction(**action_itr1);
      if (found) {
        *action_itr = *action_itr1;
      } else {
        action_itr1++;
      }
    }
    if (!found) {//could not find teh corresponding action
      cout << "Action in ShortTermMemory::grouped_info " << (*action_itr)->getActionName() << " generated at "
           << (*action_itr)->getTimeAtWhichThisInfoIsPerceived()
           << " cound not find corresponding action in the ShortTermMemory::perceived_info" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  Action in ShortTermMemory::grouped_info " << (*action_itr)->getActionName()
           << " generated at "
           << (*action_itr)->getTimeAtWhichThisInfoIsPerceived()
           << " cound not find corresponding action in the ShortTermMemory::perceived_info\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("InfoChunk::replaceObjecByPointerForGroupedInfoAction err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      action_itr->reset();
    }
  }
}
void InfoChunk::replaceObjecByPointerForGroupedInfoProcedureStep(InfoChunk &_ic) {
  bool found = false;
  if (procedure_step.size() == 0) return;
  for (auto procedure_step_itr = procedure_step.begin(); procedure_step_itr != procedure_step.end();
       procedure_step_itr++) {//find teh corresponding procedure_step in the ShortTermMemory::perceived_info
    auto procedure_step_itr1 = _ic.procedure_step.begin();
    auto procedure_step_end = _ic.procedure_step.end();
    found = false;
    while (procedure_step_itr1 != procedure_step_end && !found) {
      found = (*procedure_step_itr)->checkIfIsIdenticalDecisionProcedureStep(**procedure_step_itr1);
      if (found) {
        *procedure_step_itr = *procedure_step_itr1;
      } else {
        procedure_step_itr1++;
      }
    }
    if (!found) {//could not find teh corresponding procedure_step
      cout << "ProcedureStep in ShortTermMemory::grouped_info " << (*procedure_step_itr)->getProcedureName() << ' '
           << (*procedure_step_itr)->getStepName()
           << " cound not find corresponding procedure_step in the ShortTermMemory::perceived_info" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  ProcedureStep in ShortTermMemory::grouped_info "
           << (*procedure_step_itr)->getProcedureName() << ' '
           << (*procedure_step_itr)->getStepName()
           << " cound not find corresponding procedure_step in the ShortTermMemory::perceived_info\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("InfoChunk::replaceObjecByPointerForGroupedInfoProcedureStep err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      procedure_step_itr->reset();
    }
  }
}
void InfoChunk::replaceObjecByPointerForGroupedInfoInstinctiveResponseProcedure(InfoChunk &_ic) {
  bool found = false;
  if (instinctive_response_procedure.size() == 0) return;
  for (auto instinctive_response_procedure_itr = instinctive_response_procedure.begin();
       instinctive_response_procedure_itr != instinctive_response_procedure.end();
       instinctive_response_procedure_itr++) {//find teh corresponding instinctive_response_procedure in the ShortTermMemory::perceived_info
    auto instinctive_response_procedure_itr1 = _ic.instinctive_response_procedure.begin();
    auto instinctive_response_procedure_end = _ic.instinctive_response_procedure.end();
    found = false;
    while (instinctive_response_procedure_itr1 != instinctive_response_procedure_end && !found) {
      found =
          (*instinctive_response_procedure_itr)->checkIfIsIdenticalDecisionProcedureStep(**instinctive_response_procedure_itr1);
      if (found) {
        *instinctive_response_procedure_itr = *instinctive_response_procedure_itr1;
      } else {
        instinctive_response_procedure_itr1++;
      }
    }
    if (!found) {//could not find teh corresponding instinctive_response_procedure
      cout << "InstinctiveResponseProcedure in ShortTermMemory::grouped_info "
           << (*instinctive_response_procedure_itr)->getProcedureName() << ' '
           << (*instinctive_response_procedure_itr)->getStepName()
           << " cound not find corresponding instinctive_response_procedure in the ShortTermMemory::perceived_info"
           << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  InstinctiveResponseProcedure in ShortTermMemory::grouped_info "
           << (*instinctive_response_procedure_itr)->getProcedureName() << ' '
           << (*instinctive_response_procedure_itr)->getStepName()
           << " cound not find corresponding instinctive_response_procedure in the ShortTermMemory::perceived_info\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("InfoChunk::replaceObjecByPointerForGroupedInfoInstinctiveResponseProcedure err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      instinctive_response_procedure_itr->reset();
    }
  }
}
void InfoChunk::replaceObjecByPointerForGroupedInfoAlarm(InfoChunk &_ic) {
  bool found = false;
  if (perceived_alarms.size() == 0) return;
  for (auto perceived_alarms_itr = perceived_alarms.begin(); perceived_alarms_itr != perceived_alarms.end();
       perceived_alarms_itr++) {//find teh corresponding perceived_alarms in the ShortTermMemory::perceived_info
    auto perceived_alarms_itr1 = _ic.perceived_alarms.begin();
    auto perceived_alarms_end = _ic.perceived_alarms.end();
    found = false;
    while (perceived_alarms_itr1 != perceived_alarms_end && !found) {
      found = (*perceived_alarms_itr)->checkIfIsIdenticalMentalAlarm(**perceived_alarms_itr1);
      if (found) {
        *perceived_alarms_itr = *perceived_alarms_itr1;
      } else {
        perceived_alarms_itr1++;
      }
    }
    if (!found) {//could not find teh corresponding perceived_alarms
      cout << "Alarm in ShortTermMemory::grouped_info " << (*perceived_alarms_itr)->getAlarmName()
           << " cound not find corresponding perceived_alarms in the ShortTermMemory::perceived_info" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  Alarm in ShortTermMemory::grouped_info " << (*perceived_alarms_itr)->getAlarmName()
           << " cound not find corresponding perceived_alarms in the ShortTermMemory::perceived_info\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("InfoChunk::replaceObjecByPointerForGroupedInfoAlarm err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      perceived_alarms_itr->reset();
    }
  }
}
void InfoChunk::replaceObjecByPointerForGroupedInfoComponentState(InfoChunk &_ic) {
  bool found = false;
  if (perceived_component_state.size() == 0) return;
  for (auto perceived_component_state_itr = perceived_component_state.begin();
       perceived_component_state_itr != perceived_component_state.end();
       perceived_component_state_itr++) {//find teh corresponding perceived_component_state in the ShortTermMemory::perceived_info
    auto perceived_component_state_itr1 = _ic.perceived_component_state.begin();
    auto perceived_component_state_end = _ic.perceived_component_state.end();
    found = false;
    while (perceived_component_state_itr1 != perceived_component_state_end && !found) {
      found =
          (*perceived_component_state_itr)->checkIfIsIdenticalMentalComponentState(**perceived_component_state_itr1);
      if (found) {
        *perceived_component_state_itr = *perceived_component_state_itr1;
      } else {
        perceived_component_state_itr1++;
      }
    }
    if (!found) {//could not find teh corresponding perceived_component_state
      cout << "ComponentState in ShortTermMemory::grouped_info " << (*perceived_component_state_itr)->getDisplayName()
           << " cound not find corresponding perceived_component_state in the ShortTermMemory::perceived_info" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  ComponentState in ShortTermMemory::grouped_info "
           << (*perceived_component_state_itr)->getDisplayName()
           << " cound not find corresponding perceived_component_state in the ShortTermMemory::perceived_info\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("InfoChunk::replaceObjecByPointerForGroupedInfoComponentState err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      perceived_component_state_itr->reset();
    }
  }
}
void InfoChunk::replaceObjecByPointerForGroupedInfoSupportSystemState(InfoChunk &_ic) {
  bool found = false;
  if (perceived_support_system_state.size() == 0) return;
  for (auto perceived_support_system_state_itr = perceived_support_system_state.begin();
       perceived_support_system_state_itr != perceived_support_system_state.end();
       perceived_support_system_state_itr++) {//find teh corresponding perceived_component_state in the ShortTermMemory::perceived_info
    auto perceived_support_system_state_itr1 = _ic.perceived_support_system_state.begin();
    auto perceived_support_system_state_end = _ic.perceived_support_system_state.end();
    found = false;
    while (perceived_support_system_state_itr1 != perceived_support_system_state_end && !found) {
      found =
          (*perceived_support_system_state_itr)->checkIfIsIdenticalMentalSupportSystemState(**perceived_support_system_state_itr1);
      if (found) {
        *perceived_support_system_state_itr = *perceived_support_system_state_itr1;
      } else {
        perceived_support_system_state_itr1++;
      }
    }
    if (!found) {//could not find teh corresponding perceived_component_state
      cout << "SupportSystemState in ShortTermMemory::grouped_info " << (*perceived_support_system_state_itr)->getDisplayName()
           << " cound not find corresponding perceived_support_system_state in the ShortTermMemory::perceived_info" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  SupportSystemState in ShortTermMemory::grouped_info "
           << (*perceived_support_system_state_itr)->getDisplayName()
           << " cound not find corresponding perceived_support_system_state in the ShortTermMemory::perceived_info\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("InfoChunk::replaceObjecByPointerForGroupedInfoComponentState err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      perceived_support_system_state_itr->reset();
    }
  }
}
void InfoChunk::replaceObjecByPointerForGroupedInfoParameterValue(InfoChunk &_ic) {
  bool found = false;
  if (perceived_parameter_value.size() == 0) return;
  for (auto perceived_parameter_value_itr = perceived_parameter_value.begin();
       perceived_parameter_value_itr != perceived_parameter_value.end();
       perceived_parameter_value_itr++) {//find teh corresponding perceived_parameter_value in the ShortTermMemory::perceived_info
    auto perceived_parameter_value_itr1 = _ic.perceived_parameter_value.begin();
    auto perceived_parameter_value_end = _ic.perceived_parameter_value.end();
    found = false;
    while (perceived_parameter_value_itr1 != perceived_parameter_value_end && !found) {
      found =
          (*perceived_parameter_value_itr)->checkIfIsIdenticalMentalParameterValue(**perceived_parameter_value_itr1);
      if (found) {
        *perceived_parameter_value_itr = *perceived_parameter_value_itr1;
      } else {
        perceived_parameter_value_itr1++;
      }
    }
    if (!found) {//could not find teh corresponding perceived_parameter_value
      cout << "ParameterValue in ShortTermMemory::grouped_info " << (*perceived_parameter_value_itr)->getDisplayName()
           << " cound not find corresponding perceived_parameter_value in the ShortTermMemory::perceived_info" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  ParameterValue in ShortTermMemory::grouped_info "
           << (*perceived_parameter_value_itr)->getDisplayName()
           << " cound not find corresponding perceived_parameter_value in the ShortTermMemory::perceived_info\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("InfoChunk::replaceObjecByPointerForGroupedInfoComponentState err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      perceived_parameter_value_itr->reset();
    }
  }
}
void InfoChunk::replaceObjecByPointerForGroupedInfoParameterTrend(InfoChunk &_ic) {
  bool found = false;
  if (perceived_parameter_trend.size() == 0) return;
  for (auto perceived_parameter_trend_itr = perceived_parameter_trend.begin();
       perceived_parameter_trend_itr != perceived_parameter_trend.end();
       perceived_parameter_trend_itr++) {//find teh corresponding perceived_parameter_trend in the ShortTermMemory::perceived_info
    auto perceived_parameter_trend_itr1 = _ic.perceived_parameter_trend.begin();
    auto perceived_parameter_trend_end = _ic.perceived_parameter_trend.end();
    found = false;
    while (perceived_parameter_trend_itr1 != perceived_parameter_trend_end && !found) {
      found =
          (*perceived_parameter_trend_itr)->checkIfIsIdenticalMentalParameterTrend(**perceived_parameter_trend_itr1);
      if (found) {
        *perceived_parameter_trend_itr = *perceived_parameter_trend_itr1;
      } else {
        perceived_parameter_trend_itr1++;
      }
    }
    if (!found) {//could not find teh corresponding perceived_parameter_trend
      cout << "ParameterTrend in ShortTermMemory::grouped_info " << (*perceived_parameter_trend_itr)->getDisplayName()
           << " cound not find corresponding perceived_parameter_trend in the ShortTermMemory::perceived_info" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  ParameterTrend in ShortTermMemory::grouped_info "
           << (*perceived_parameter_trend_itr)->getDisplayName()
           << " cound not find corresponding perceived_parameter_trend in the ShortTermMemory::perceived_info\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("InfoChunk::replaceObjecByPointerForGroupedInfoComponentState err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      perceived_parameter_trend_itr->reset();
    }
  }
}
void InfoChunk::replaceObjecByPointerForGroupedInfoMentalBelief(InfoChunk &_ic) {
  bool found = false;
  if (mental_belief.size() == 0) return;
  for (auto mental_belief_itr = mental_belief.begin(); mental_belief_itr != mental_belief.end();
       mental_belief_itr++) {//find teh corresponding mental_belief in the ShortTermMemory::perceived_info
    auto mental_belief_itr1 = _ic.mental_belief.begin();
    auto mental_belief_end = _ic.mental_belief.end();
    found = false;
    while (mental_belief_itr1 != mental_belief_end && !found) {
      found = (*mental_belief_itr)->checkIfIsIdenticalExpectedMentalBelief(**mental_belief_itr1);
      if (found) {
        *mental_belief_itr = *mental_belief_itr1;
      } else {
        mental_belief_itr1++;
      }
    }
    if (!found) {//could not find teh corresponding mental_belief
      cout << "MentalBelief in ShortTermMemory::grouped_info " << (*mental_belief_itr)->getInfoName()
           << " cound not find corresponding mental_belief in the ShortTermMemory::perceived_info" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno << "  MentalBelief in ShortTermMemory::grouped_info "
           << (*mental_belief_itr)->getInfoName()
           << " cound not find corresponding mental_belief in the ShortTermMemory::perceived_info\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("InfoChunk::replaceObjecByPointerForGroupedInfoComponentState err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      mental_belief_itr->reset();
    }
  }
}
DecisionGoal *InfoChunk::getActiveGoalPt() {//for perceived_info uses
  DecisionGoal *goal_pt = nullptr;
  bool found_goal = false;
  auto goal_itr = this->goal.rbegin();
  auto goal_itr_end = this->goal.rend();
  while (goal_itr != goal_itr_end && !found_goal) {
    if ((*goal_itr)->getStateOfActivation() == sim::State::Active) {
      goal_pt = goal_itr->get();
      found_goal = true;
    } else {
      goal_itr++;
    }
  }
  return goal_pt;
}
DecisionStrategy *InfoChunk::getActiveStrategyPt() {
  DecisionStrategy *strategy_pt = nullptr;
  bool found_strategy = false;
  auto strategy_itr = this->strategy.rbegin();
  auto strategy_itr_end = this->strategy.rend();
  while (strategy_itr != strategy_itr_end && !found_strategy) {
    if ((*strategy_itr)->getStateOfActivation() == sim::State::Active) {
      strategy_pt = strategy_itr->get();
      found_strategy = true;
    } else {
      strategy_itr++;
    }
  }
  return strategy_pt;
}
DecisionSubGoal *InfoChunk::getActiveSubGoalPt() {
  DecisionSubGoal *subgoal_pt = nullptr;
  bool found_subgoal = false;
  auto subgoal_itr = this->subgoal.rbegin();
  auto subgoal_itr_end = this->subgoal.rend();
  while (subgoal_itr != subgoal_itr_end && !found_subgoal) {
    if ((*subgoal_itr)->getStateOfActivation() == sim::State::Active) {
      subgoal_pt = subgoal_itr->get();
      found_subgoal = true;
    } else {
      subgoal_itr++;
    }
  }
  return subgoal_pt;
}
void InfoChunk::generateErrorMessage(string _err_message) {
  string str;
  str = "InfoChunk::retrieveInfoChunkFromFile File retrieval error in a function prior to ";
  str += _err_message;
  ofstream fout("err messages.txt", ios::app);
  cout << "      " << r5pars_.timesno << "  " << str << endl;
  fout << str << '\n';
  fout.close();
  r5pars_.sim_err = true;
  g_sim.Branch_center.setTempESMessage(str);
  g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
};
 
int InfoChunk::ReturnPositionOfOneMentalComponentStateInTheVector(MentalComponentState *_mc_pt) {//index of the item in perceived_component_state, or -1 if absent
  int i;
  bool found = false;
  i = this->perceived_component_state.size() - 1;
  if (i < 0) { return i; }
 
  for (auto mc_ritr = this->perceived_component_state.rbegin();
       mc_ritr != this->perceived_component_state.rend() && found == false; mc_ritr++) {
    if (mc_ritr->get() == _mc_pt) {
      found = true;
      break;
    }
    i--;
  }
  return i;
}
 
int InfoChunk::ReturnPositionOfOneMentalSupportSystemStateInTheVector(MentalSupportSystemState *_mss_pt) {
  int i;
  bool found = false;
  i = this->perceived_support_system_state.size() - 1;
  if (i < 0) { return i; }
 
  for (auto mss_ritr = this->perceived_support_system_state.rbegin();
       mss_ritr != this->perceived_support_system_state.rend() && found == false; mss_ritr++) {
    if (mss_ritr->get() == _mss_pt) {
      found = true;
      break;
    }
    i--;
  }
  return i;
}
 
int InfoChunk::ReturnPositionOfOneMentalParameterValue(MentalParameterValue *_mp_pt) {//index of the item in perceived_parameter_value, or -1 if absent
  int i;
  bool found = false;
  i = this->perceived_parameter_value.size() - 1;
  if (i < 0) { return i; }
 
  for (auto mp_ritr = this->perceived_parameter_value.rbegin(); mp_ritr != this->perceived_parameter_value.rend();
       mp_ritr++) {
    if (mp_ritr->get() == _mp_pt) {
      found = true;
      break;
    }
    i--;
  }
  return i;
}
 
int InfoChunk::ReturnPositionOfOneMentalAlarmInTheVector(MentalAlarm *_ma_pt) {//index of the item in perceived_alarms, or -1 if absent
  int i;
  bool found = false;
  i = this->perceived_alarms.size() - 1;
  if (i < 0) { return i; }
 
  for (auto ma_ritr = this->perceived_alarms.rbegin(); ma_ritr != this->perceived_alarms.rend(); ma_ritr++) {
    if (ma_ritr->get() == _ma_pt) {
      found = true;
      break;
    }
    i--;
  }
  return i;
 
}