ShortTermMemory.cpp

Go to the documentation of this file.

// ShortTermMemory.cpp: implementation of the ShortTermMemory class.
//
 
#include "ShortTermMemory.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(ShortTermMemory)
using namespace std;
 
 
// Construction/Destruction
 
ShortTermMemory::ShortTermMemory() {
  info_gather_mode = sim::State::New;
}
 
ShortTermMemory::~ShortTermMemory() {
}
InfoChunkMental *ShortTermMemory::getWorkingMemory() {
  InfoChunkMental *working_memory = 0;
  bool found = false;
  double max_priority = -1.0e8;
  decltype(grouped_info)::reverse_iterator grouped_info_itr;
  grouped_info_itr = grouped_info.rbegin();
  while (grouped_info_itr != grouped_info.rend() && !found) {
    if ((*grouped_info_itr)->getStateOfActivation() == sim::State::Active) {
      working_memory = grouped_info_itr->get();
      found = true;
    }
    grouped_info_itr++;
  }
  if (!found) {
    for (grouped_info_itr = grouped_info.rbegin(); grouped_info_itr != grouped_info.rend(); grouped_info_itr++) {
      if ((*grouped_info_itr)->getPriority() > max_priority) {
        working_memory = grouped_info_itr->get();
        max_priority = (*grouped_info_itr)->getPriority();
      }
    }
  }
  working_memory->pointToAvtiveGoalAndStrategy(this->perceived_info);
  return working_memory;
}
 
void ShortTermMemory::clearNewInfo() {
  new_info.clearCommunicationPlaceAllPointers();
}
int ShortTermMemory::getTotalPieceOfInfoPerceived() {
  int r_n;
  r_n = perceived_info.getTotalPieceOfInfoPerceived();
  return r_n;
}
double ShortTermMemory::getTotalWeightOfAlarmPerceived() {
  return perceived_info.getTotalWeightOfAlarmPerceived();
}
int ShortTermMemory::getTotalNumberOfAlarmPerceived() {
  int r_n;
  r_n = perceived_info.getTotalNumberOfAlarmPerceived();
  return r_n;
}
int ShortTermMemory::getTotalFailedDiagnosis() {
  int r_n;
  r_n = perceived_info.getTotalNumberOfFailedDiagnosis();
  return r_n;
};
int ShortTermMemory::getTotalFailedActionPack() {
  int r_n = 0;
  return r_n;
}
//  double getIntensiveOfInformationPerceived();
void ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedAlarm(MentalAlarm *_ms, KB &_kb) {
  bool is_included, inclusion_1;
  map<string, KBSystemDecompositionUnit *>::iterator sd_map_itr;
  decltype(grouped_info)::iterator grouped_info_itr;
  InfoChunkMental *grouped_info_pt;
  KBSystemDecompositionUnit *sd_pt;
  int i, subsystem_n;
  sd_map_itr = _kb.system_decomposition_map.find(_ms->getAlarmName());
  if (sd_map_itr != _kb.system_decomposition_map.end()) {//identify the alarm from the systemDecomposition map
    sd_pt = sd_map_itr->second;
    inclusion_1 = false;
    for (grouped_info_itr = grouped_info.begin(); grouped_info_itr != grouped_info.end();
         grouped_info_itr++) {//for each info chunk in STM
      i = 0;
      is_included = false;
      while (i < sd_pt->getNumberOfRelatedSubsystem() && !is_included) {//the sub-systems relating to the info
        subsystem_n = sd_pt->getRelatedSubsystem(i);
        is_included = (*grouped_info_itr)->checkWhetherSubSystemIsIncluded(subsystem_n);
        if (is_included) {
          inclusion_1 = true;
          (*grouped_info_itr)->perceived_alarms.push_back(shared_ptr<MentalAlarm>(_ms, [](MentalAlarm*){}));
        } else {
          i++;
        }
      }
    }
    if (!inclusion_1) {
      grouped_info.push_back(make_unique<InfoChunkMental>());
      grouped_info_pt = grouped_info.back().get();
      grouped_info_pt->perceived_alarms.push_back(shared_ptr<MentalAlarm>(_ms, [](MentalAlarm*){}));
      for (i = 0; i < sd_pt->getNumberOfRelatedSubsystem(); i++) {
        subsystem_n = sd_pt->getRelatedSubsystem(i);
        grouped_info_pt->related_subsystem.push_back(subsystem_n);
      }
    }
  } else {//can not find t ecomponent from the map
    ofstream fout("err messages.txt", ios::app);
    cout << "ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedAlarm Mental Alarm: " << _ms->getAlarmName()
         << " can not be identified in KB.system_decomposition_map" << endl;
    fout << r5pars_.timesno << "  ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedAlarm Mental Alarm: "
         << _ms->getAlarmName()
         << " can not be identified in KB.system_decomposition_map\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedAlarm err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
}
void ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedAction(DecisionAction *_mc, KB &_kb) {
  bool is_included;
  bool inclusion_1;
  map<string, KBSystemDecompositionUnit *>::iterator sd_map_itr;
  decltype(grouped_info)::iterator grouped_info_itr;
  InfoChunkMental *grouped_info_pt;
  KBSystemDecompositionUnit *sd_pt;
  int i, subsystem_n;
  //
  sd_map_itr = _kb.system_decomposition_map.find(_mc->getDisplayName());
  if (sd_map_itr != _kb.system_decomposition_map.end()) {//identify the alarm from the systemDecomposition map
    sd_pt = sd_map_itr->second;
    inclusion_1 = false;
    for (grouped_info_itr = grouped_info.begin(); grouped_info_itr != grouped_info.end();
         grouped_info_itr++) {//for each info chunk in STM
      i = 0;
      is_included = false;
      while (i < sd_pt->getNumberOfRelatedSubsystem() && !is_included) {//the sub-systems relating to the info
        subsystem_n = sd_pt->getRelatedSubsystem(i);
        is_included = (*grouped_info_itr)->checkWhetherSubSystemIsIncluded(subsystem_n);
        if (is_included) {
          inclusion_1 = true;
          (*grouped_info_itr)->action.push_back(shared_ptr<DecisionAction>(_mc, [](DecisionAction*){}));
        } else {
          i++;
        }
      }
    }
    if (!inclusion_1) {
      grouped_info.push_back(make_unique<InfoChunkMental>());
      grouped_info_pt = grouped_info.back().get();
      grouped_info_pt->action.push_back(shared_ptr<DecisionAction>(_mc, [](DecisionAction*){}));
      for (i = 0; i < sd_pt->getNumberOfRelatedSubsystem(); i++) {
        subsystem_n = sd_pt->getRelatedSubsystem(i);
        grouped_info_pt->related_subsystem.push_back(subsystem_n);
      }
    }
  } else {//can not find t ecomponent from the map
    ofstream fout("err messages.txt", ios::app);
    cout << "ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedControl control: " << _mc->getDisplayName()
         << " can not be identified in KB.system_decomposition_map" << endl;
    fout << r5pars_.timesno << "  ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedControl control: "
         << _mc->getDisplayName()
         << " can not be identified in KB.system_decomposition_map\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedAction err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
};
void ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedComponentState(MentalComponentState *_mc, KB &_kb) {
  bool is_included;
  bool inclusion_1;
  map<string, KBSystemDecompositionUnit *>::iterator sd_map_itr;
  decltype(grouped_info)::iterator grouped_info_itr;
  InfoChunkMental *grouped_info_pt;
  KBSystemDecompositionUnit *sd_pt;
  int i, subsystem_n;
  //
  sd_map_itr = _kb.system_decomposition_map.find(_mc->getDisplayName());
  if (sd_map_itr != _kb.system_decomposition_map.end()) {//identify the alarm from the systemDecomposition map
    sd_pt = sd_map_itr->second;
    inclusion_1 = false;
    for (grouped_info_itr = grouped_info.begin(); grouped_info_itr != grouped_info.end(); grouped_info_itr++) {
      i = 0;
      is_included = false;
      while (i < sd_pt->getNumberOfRelatedSubsystem() && !is_included) {//the sub-systems relating to the info
        subsystem_n = sd_pt->getRelatedSubsystem(i);
        is_included = (*grouped_info_itr)->checkWhetherSubSystemIsIncluded(subsystem_n);
        if (is_included) {
          inclusion_1 = true;
          (*grouped_info_itr)->perceived_component_state.push_back(shared_ptr<MentalComponentState>(_mc, [](MentalComponentState*){}));
        } else {
          i++;
        }
      }
    }
    if (!inclusion_1) {
      grouped_info.push_back(make_unique<InfoChunkMental>());
      grouped_info_pt = grouped_info.back().get();
      grouped_info_pt->perceived_component_state.push_back(shared_ptr<MentalComponentState>(_mc, [](MentalComponentState*){}));
      for (i = 0; i < sd_pt->getNumberOfRelatedSubsystem(); i++) {
        subsystem_n = sd_pt->getRelatedSubsystem(i);
        grouped_info_pt->related_subsystem.push_back(subsystem_n);
      }
    }
  } else {//can not find t ecomponent from the map
    ofstream fout("err messages.txt", ios::app);
    cout << "ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedComponentState component: "
         << _mc->getDisplayName()
         << " can not be identified in KB.system_decomposition_map" << endl;
    fout << r5pars_.timesno << "  ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedComponentState component: "
         << _mc->getDisplayName()
         << " can not be identified in KB.system_decomposition_map\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedComponentState err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
}
void ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedSupportSystemState(MentalSupportSystemState *_mss, KB &_kb) {
  bool is_included;
  bool inclusion_1;
  map<string, KBSystemDecompositionUnit *>::iterator sd_map_itr;
  decltype(grouped_info)::iterator grouped_info_itr;
  InfoChunkMental *grouped_info_pt;
  KBSystemDecompositionUnit *sd_pt;
  int i, subsystem_n;
  //
  sd_map_itr = _kb.system_decomposition_map.find(_mss->getDisplayName());
  if (sd_map_itr != _kb.system_decomposition_map.end()) {//identify the alarm from the systemDecomposition map
    sd_pt = sd_map_itr->second;
    inclusion_1 = false;
    for (grouped_info_itr = grouped_info.begin(); grouped_info_itr != grouped_info.end(); grouped_info_itr++) {
      i = 0;
      is_included = false;
      while (i < sd_pt->getNumberOfRelatedSubsystem() && !is_included) {//the sub-systems relating to the info
        subsystem_n = sd_pt->getRelatedSubsystem(i);
        is_included = (*grouped_info_itr)->checkWhetherSubSystemIsIncluded(subsystem_n);
        if (is_included) {
          inclusion_1 = true;
          (*grouped_info_itr)->perceived_support_system_state.push_back(shared_ptr<MentalSupportSystemState>(_mss, [](MentalSupportSystemState*){}));
        } else {
          i++;
        }
      }
    }
    if (!inclusion_1) {
      grouped_info.push_back(make_unique<InfoChunkMental>());
      grouped_info_pt = grouped_info.back().get();
      grouped_info_pt->perceived_support_system_state.push_back(shared_ptr<MentalSupportSystemState>(_mss, [](MentalSupportSystemState*){}));
      for (i = 0; i < sd_pt->getNumberOfRelatedSubsystem(); i++) {
        subsystem_n = sd_pt->getRelatedSubsystem(i);
        grouped_info_pt->related_subsystem.push_back(subsystem_n);
      }
    }
  } else {//can not find support system in map
    ofstream fout("err messages.txt", ios::app);
    cout << "ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedSupportSystemState support system: "
         << _mss->getDisplayName()
         << " can not be identified in KB.system_decomposition_map" << endl;
    fout << r5pars_.timesno << "  ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedSupportSystemState support system: "
         << _mss->getDisplayName()
         << " can not be identified in KB.system_decomposition_map\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedSupportSystemState err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
}
void ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedParameterValue(MentalParameterValue *_mpv, KB &_kb) {
  bool is_included, inclusion_1;
  map<string, KBSystemDecompositionUnit *>::iterator sd_map_itr;
  decltype(grouped_info)::iterator grouped_info_itr;
  InfoChunkMental *grouped_info_pt;
  KBSystemDecompositionUnit *sd_pt;
  int i, subsystem_n;
  //
  sd_map_itr = _kb.system_decomposition_map.find(_mpv->getDisplayName());
  if (sd_map_itr != _kb.system_decomposition_map.end()) {//identify the alarm from the systemDecomposition map
    sd_pt = sd_map_itr->second;
    inclusion_1 = false;
    for (grouped_info_itr = grouped_info.begin(); grouped_info_itr != grouped_info.end(); grouped_info_itr++) {
      i = 0;
      is_included = false;
      while (i < sd_pt->getNumberOfRelatedSubsystem() && !is_included) {//the sub-systems relating to the info
        subsystem_n = sd_pt->getRelatedSubsystem(i);
        is_included = (*grouped_info_itr)->checkWhetherSubSystemIsIncluded(subsystem_n);
        if (is_included) {
          inclusion_1 = true;
          (*grouped_info_itr)->perceived_parameter_value.push_back(shared_ptr<MentalParameterValue>(_mpv, [](MentalParameterValue*){}));
        } else {
          i++;
        }
      }
    }
    if (!inclusion_1) {
      grouped_info.push_back(make_unique<InfoChunkMental>());
      grouped_info_pt = grouped_info.back().get();
      grouped_info_pt->perceived_parameter_value.push_back(shared_ptr<MentalParameterValue>(_mpv, [](MentalParameterValue*){}));
      for (i = 0; i < sd_pt->getNumberOfRelatedSubsystem(); i++) {
        subsystem_n = sd_pt->getRelatedSubsystem(i);
        grouped_info_pt->related_subsystem.push_back(subsystem_n);
      }
    }
  } else {//can not find the component from the map
    ofstream fout("err messages.txt", ios::app);
    cout << "ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedParameterValue Parameter: "
         << _mpv->getDisplayName()
         << " can not be identified in KB.system_decomposition_map" << endl;
    fout << r5pars_.timesno << "  ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedParameterValue Parameter: "
         << _mpv->getDisplayName()
         << " can not be identified in KB.system_decomposition_map\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedParameterValue err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
}
void ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedParameterTrend(MentalParameterTrend *_mpt, KB &_kb) {
  bool is_included, inclusion_1;
  map<string, KBSystemDecompositionUnit *>::iterator sd_map_itr;
  decltype(grouped_info)::iterator grouped_info_itr;
  InfoChunkMental *grouped_info_pt;
  KBSystemDecompositionUnit *sd_pt;
  int i, subsystem_n;
  //
  sd_map_itr = _kb.system_decomposition_map.find(_mpt->getDisplayName());
  if (sd_map_itr != _kb.system_decomposition_map.end()) {//identify the alarm from the systemDecomposition map
    sd_pt = sd_map_itr->second;
    inclusion_1 = false;
    for (grouped_info_itr = grouped_info.begin(); grouped_info_itr != grouped_info.end(); grouped_info_itr++) {
      i = 0;
      is_included = false;
      while (i < sd_pt->getNumberOfRelatedSubsystem() && !is_included) {//the sub-systems relating to the info
        subsystem_n = sd_pt->getRelatedSubsystem(i);
        is_included = (*grouped_info_itr)->checkWhetherSubSystemIsIncluded(subsystem_n);
        if (is_included) {
          inclusion_1 = true;
          (*grouped_info_itr)->perceived_parameter_trend.push_back(shared_ptr<MentalParameterTrend>(_mpt, [](MentalParameterTrend*){}));
        } else {
          i++;
        }
      }
    }
    if (!inclusion_1) {
      grouped_info.push_back(make_unique<InfoChunkMental>());
      grouped_info_pt = grouped_info.back().get();
      grouped_info_pt->perceived_parameter_trend.push_back(shared_ptr<MentalParameterTrend>(_mpt, [](MentalParameterTrend*){}));
      for (i = 0; i < sd_pt->getNumberOfRelatedSubsystem(); i++) {
        subsystem_n = sd_pt->getRelatedSubsystem(i);
        grouped_info_pt->related_subsystem.push_back(subsystem_n);
      }
    }
  } else {//can not find t ecomponent from the map
    ofstream fout("err messages.txt", ios::app);
    cout << "ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedParameterTrend Parameter: "
         << _mpt->getDisplayName()
         << " can not be identified in KB.system_decomposition_map" << endl;
    fout << r5pars_.timesno << "  ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedParameterTrend Parameter: "
         << _mpt->getDisplayName()
         << " can not be identified in KB.system_decomposition_map\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("ShortTermMemory::checkAndGenerateInfoChunkMentalForRelatedParameterTrend err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
}
void ShortTermMemory::failCurrentDiagnosisAndActivateAPausedDiagnosis() {
  bool found = false;
  auto dia_ritr = this->perceived_info.diagnosis.rbegin();
  if (dia_ritr != this->perceived_info.diagnosis.rend() && !found) {
    if ((*dia_ritr)->getStateOfActivation() == sim::State::Active) {
      found = true;
      (*dia_ritr)->setStateOfActivation(sim::State::Failed);
    }
    dia_ritr++;
  }
  found = false;
  dia_ritr = this->perceived_info.diagnosis.rbegin();
  if (dia_ritr != this->perceived_info.diagnosis.rend() && !found) {
    if ((*dia_ritr)->getStateOfActivation() == sim::State::Pause) {
      found = true;
      (*dia_ritr)->setStateOfActivation(sim::State::Active);
    }
    dia_ritr++;
  }
}
 
void ShortTermMemory::addNewInfoChunkMentalForTheDiagnosis(DecisionDiagnosis *_dia) {
  decltype(grouped_info)::iterator itr;
  InfoChunkMental *grouped_info_pt;
  //
  grouped_info.push_back(make_unique<InfoChunkMental>());
  grouped_info_pt = grouped_info.back().get();
  grouped_info_pt->diagnosis.push_back(shared_ptr<DecisionDiagnosis>(_dia, [](DecisionDiagnosis*){}));
  for (auto dia_itr = this->perceived_info.diagnosis.begin(); dia_itr != this->perceived_info.diagnosis.end(); dia_itr++) {
    if ((*dia_itr)->getStateOfActivation() == sim::State::Active) {
      (*dia_itr)->setStateOfActivation(sim::State::Pause);
    }
  }
  _dia->setStateOfActivation(sim::State::Active);
  grouped_info_pt->setStateOfActivation(sim::State::Active);
}
void ShortTermMemory::checkAndGenerateInfoChunkMentalForDiagnosis(DecisionDiagnosis *_dia) {//called from InfoPreProcessing::infochunking
  bool is_included = false;
  bool updated;
  decltype(grouped_info)::reverse_iterator ritr;
  decltype(grouped_info)::iterator itr;
  InfoChunkMental *grouped_info_pt;
  string _dia_name;
  //
  _dia_name = _dia->getDiagnosis();
  ritr = grouped_info.rbegin();
  while (ritr != grouped_info.rend() && !is_included) {
    if ((*ritr)->diagnosisIsIncluded(_dia_name)) {
      is_included = true;
      updated = (*ritr)->activateTheDiagnosis(_dia_name);
      for (itr = grouped_info.begin(); itr != grouped_info.end(); itr++) {
        if ((*itr)->getStateOfActivation() == sim::State::Active) {
          (*itr)->setStateOfActivation(sim::State::Pause);
        }
      }
      (*ritr)->setStateOfActivation(sim::State::Active);
    }
    ritr++;
  }
  if (!is_included) {
    grouped_info.push_back(make_unique<InfoChunkMental>());
    grouped_info_pt = grouped_info.back().get();
    grouped_info_pt->diagnosis.push_back(shared_ptr<DecisionDiagnosis>(_dia, [](DecisionDiagnosis*){}));
    for (itr = grouped_info.begin(); itr != grouped_info.end(); itr++) {
      if ((*itr)->getStateOfActivation() == sim::State::Active) {
        (*itr)->setStateOfActivation(sim::State::Pause);
      }
    }
    grouped_info_pt->setStateOfActivation(sim::State::Active);
  }
}
void ShortTermMemory::calculatePriorityAndSetStateOfActivation() {
  InfoChunkMental *_wm;
  decltype(grouped_info)::iterator grouped_info_itr;
  double max_priority = -1.0e8;
  for (grouped_info_itr = grouped_info.begin(); grouped_info_itr != grouped_info.end(); grouped_info_itr++) {
    (*grouped_info_itr)->calculatePriority();
    if ((*grouped_info_itr)->getPriority() > max_priority) {
      max_priority = (*grouped_info_itr)->getPriority();
      _wm = grouped_info_itr->get();
    }
  }
  if (_wm->getStateOfActivation() != sim::State::Active) {
    for (grouped_info_itr = grouped_info.begin(); grouped_info_itr != grouped_info.end(); grouped_info_itr++) {
      if ((*grouped_info_itr)->getStateOfActivation() == sim::State::Active) {
        (*grouped_info_itr)->setStateOfActivation(sim::State::Interrupted);
      }
    }
    _wm->setStateOfActivation(sim::State::Active);
  }
}
void ShortTermMemory::initiationForSimulation() {
  auto i_chunk = make_unique<InfoChunkMental>();
  i_chunk->setStateOfActivation(sim::State::Active);
  this->perceived_info.addANewGoal(sim::None, sim::State::Active);
  this->perceived_info.addANewStrategy(sim::None, sim::State::Active);
  auto goal_sp = this->perceived_info.goal.at(0);
  auto strategy_sp = this->perceived_info.strategy.at(0);
  i_chunk->goal.push_back(goal_sp);
  i_chunk->strategy.push_back(strategy_sp);
  grouped_info.push_back(std::move(i_chunk));
}
int ShortTermMemory::getTotalNumberOfInfoChunk() { return grouped_info.size(); }
InfoChunkMental *ShortTermMemory::getInfoChunkAt(int n) {
  InfoChunkMental *i_chunk_pt = 0;
  decltype(grouped_info)::iterator info_itr;
  int i;
  if (n > grouped_info.size()) {
  } else {
    info_itr = grouped_info.begin();
    for (i = 0; i < n; i++) {
      info_itr++;
    }
    i_chunk_pt = info_itr->get();
  }
  return i_chunk_pt;
}
/*
void copyShortTermMemoryToRestartInfo(ShortTermMemory &)
1.  Locate memory for each object within the group_info and copy the content from the reference ShortTermMemory to this ShortTermMemory
2.  Locate memory for each object within the perceived_info and copy the content from the reference ShortTermMemory to this ShortTermMemory
3.  do nothing about the new_info 
*/
void ShortTermMemory::copyShortTermMemoryToRestartInfo(ShortTermMemory &_stm) {
  decltype(grouped_info)::iterator grouped_info_itr;
  InfoChunkMental *grouped_info_pt;
  //
  info_gather_mode = _stm.getInfoGatherMode();
  this->alarm_update_time.copyTimer(_stm.alarm_update_time);
  this->component_update_time.copyTimer(_stm.component_update_time);
  this->support_system_update_time.copyTimer(_stm.support_system_update_time);
  this->parameter_update_time.copyTimer(_stm.parameter_update_time);
  //
  for (grouped_info_itr = _stm.grouped_info.begin(); grouped_info_itr != _stm.grouped_info.end(); grouped_info_itr++) {
    auto p = make_unique<InfoChunkMental>();
    p->copyInfoChunkMental(**grouped_info_itr);
    this->grouped_info.push_back(std::move(p));
  }
  this->perceived_info.copyInfoChunk(_stm.perceived_info);
}
/*
void clearShortTermMemoryForRestart()
1.  clear the memory located for the objects within the perceived_info
2.  clear the memory located for the pointers within the group_info
3.  clear the memory located for the pointers within the new_info
*/
void ShortTermMemory::clearShortTermMemoryForRestart() {
  decltype(grouped_info)::iterator grouped_info_itr;
  new_info.clearCommunicationPlaceAllPointers();
  perceived_info.clearInfoChunk();
  for (grouped_info_itr = grouped_info.begin(); grouped_info_itr != grouped_info.end(); grouped_info_itr++) {
    (*grouped_info_itr)->clearInfoChunkMentalPointers();
  }
  grouped_info.clear();
}
/*
void clearShortTermMemoryFromRestartInfo()
1.  clear the memory located for the objects within the perceived_info
2.  clear the memory located for the objects within the group_info
3.  clear the memory located for the pointers within the new_info
*/
void ShortTermMemory::clearShortTermMemoryFromRestartInfo() {
  decltype(grouped_info)::iterator grouped_info_itr;
  perceived_info.clearInfoChunk();
  for (grouped_info_itr = grouped_info.begin(); grouped_info_itr != grouped_info.end(); grouped_info_itr++) {
    (*grouped_info_itr)->clearInfoChunkMental();
  }
  grouped_info.clear();
  new_info.clearCommunicationPlaceAllPointers();
}
/*
void clearShortTermMemoryFromRestartNodeInfoMultiProcessors()
1.  clear the memory located for the objects within the perceived_info
2.  clear the memory located for the objects within the group_info
3.  clear the memory located for the objects within the new_info
*/
void ShortTermMemory::clearShortTermMemoryFromRestartNodeInfoMultiProcessors() {
  decltype(grouped_info)::iterator grouped_info_itr;
  for (grouped_info_itr = grouped_info.begin(); grouped_info_itr != grouped_info.end(); grouped_info_itr++) {
    (*grouped_info_itr)->clearInfoChunkMentalPointers();
  }
  grouped_info.clear();
  perceived_info.clearInfoChunk();
  new_info.clearCommunicationPlaceAll();
}
/*
ShortTermMemory::copyShortTermMemoryFromRestartInfo do the following things
  1. copy all objects of perceived_info with memory located
  2. add pointers in each group_info so the pointers pointing to the objects within the perceived_info
  3. do nothing about new_info
*/
void ShortTermMemory::copyShortTermMemoryFromRestartInfo(ShortTermMemory &_stm) {
  bool found;
  // Iterator types deduced via auto at point of use (vectors now hold shared_ptr<T>)
  decltype(grouped_info)::iterator grouped_info_itr;
  InfoChunkMental *grouped_info_pt;
//
  info_gather_mode = _stm.getInfoGatherMode();
  this->alarm_update_time.copyTimer(_stm.alarm_update_time);
  this->component_update_time.copyTimer(_stm.component_update_time);
  this->support_system_update_time.copyTimer(_stm.support_system_update_time);
  this->parameter_update_time.copyTimer(_stm.parameter_update_time);
  this->perceived_info.copyInfoChunk(_stm.perceived_info);
//
  for (grouped_info_itr = _stm.grouped_info.begin(); grouped_info_itr != _stm.grouped_info.end(); grouped_info_itr++) {
    this->grouped_info.push_back(make_unique<InfoChunkMental>());
    grouped_info_pt = this->grouped_info.back().get();
    grouped_info_pt->setPriority((*grouped_info_itr)->getPriority());
    for (auto goal_itr = (*grouped_info_itr)->goal.begin(); goal_itr != (*grouped_info_itr)->goal.end(); goal_itr++) {
      found = false;
      auto goal_itr1 = this->perceived_info.goal.begin();
      while (goal_itr1 != this->perceived_info.goal.end() && !found) {
        if (fabs((*goal_itr)->getTimeAtWhichThisInfoIsPerceived() - (*goal_itr1)->getTimeAtWhichThisInfoIsPerceived())
            < 0.001) {
          found = true;
          grouped_info_pt->goal.push_back(*goal_itr1);
        }
        goal_itr1++;
      }
    }
    for (auto strategy_itr = (*grouped_info_itr)->strategy.begin(); strategy_itr != (*grouped_info_itr)->strategy.end();
         strategy_itr++) {
      found = false;
      auto strategy_itr1 = this->perceived_info.strategy.begin();
      while (strategy_itr1 != this->perceived_info.strategy.end() && !found) {
        if (fabs((*strategy_itr)->getTimeAtWhichThisInfoIsPerceived()
                     - (*strategy_itr1)->getTimeAtWhichThisInfoIsPerceived()) < 0.001) {
          found = true;
          grouped_info_pt->strategy.push_back(*strategy_itr1);
        }
        strategy_itr1++;
      }
    }
    for (auto subgoal_itr = (*grouped_info_itr)->subgoal.begin(); subgoal_itr != (*grouped_info_itr)->subgoal.end();
         subgoal_itr++) {
      found = false;
      auto subgoal_itr1 = this->perceived_info.subgoal.begin();
      while (subgoal_itr1 != this->perceived_info.subgoal.end() && !found) {
        if (fabs(
            (*subgoal_itr)->getTimeAtWhichThisInfoIsPerceived() - (*subgoal_itr1)->getTimeAtWhichThisInfoIsPerceived())
            < 0.001) {
          found = true;
          grouped_info_pt->subgoal.push_back(*subgoal_itr1);
        }
        subgoal_itr1++;
      }
    }
    for (auto diagnosis_itr = (*grouped_info_itr)->diagnosis.begin(); diagnosis_itr != (*grouped_info_itr)->diagnosis.end();
         diagnosis_itr++) {
      found = false;
      auto diagnosis_itr1 = this->perceived_info.diagnosis.begin();
      while (diagnosis_itr1 != this->perceived_info.diagnosis.end() && !found) {
        if (fabs((*diagnosis_itr)->getTimeAtWhichThisInfoIsPerceived()
                     - (*diagnosis_itr1)->getTimeAtWhichThisInfoIsPerceived()) < 0.001) {
          found = true;
          grouped_info_pt->diagnosis.push_back(*diagnosis_itr1);
        }
        diagnosis_itr1++;
      }
    }
    for (auto action_objective_itr = (*grouped_info_itr)->action_objective.begin();
         action_objective_itr != (*grouped_info_itr)->action_objective.end(); action_objective_itr++) {
      found = false;
      auto action_objective_itr1 = this->perceived_info.action_objective.begin();
      while (action_objective_itr1 != this->perceived_info.action_objective.end() && !found) {
        if (fabs((*action_objective_itr)->getTimeAtWhichThisInfoIsPerceived()
                     - (*action_objective_itr1)->getTimeAtWhichThisInfoIsPerceived()) < 0.001) {
          found = true;
          grouped_info_pt->action_objective.push_back(*action_objective_itr1);
        }
        action_objective_itr1++;
      }
    }
    for (auto action_pack_itr = (*grouped_info_itr)->action_pack.begin();
         action_pack_itr != (*grouped_info_itr)->action_pack.end(); action_pack_itr++) {
      found = false;
      auto action_pack_itr1 = this->perceived_info.action_pack.begin();
      while (action_pack_itr1 != this->perceived_info.action_pack.end() && !found) {
        if (fabs((*action_pack_itr)->getTimeAtWhichThisInfoIsPerceived()
                     - (*action_pack_itr1)->getTimeAtWhichThisInfoIsPerceived()) < 0.001) {
          found = true;
          grouped_info_pt->action_pack.push_back(*action_pack_itr1);
        }
        action_pack_itr1++;
      }
    }
    for (auto action_itr = (*grouped_info_itr)->action.begin(); action_itr != (*grouped_info_itr)->action.end();
         action_itr++) {
      found = false;
      auto action_itr1 = this->perceived_info.action.begin();
      while (action_itr1 != this->perceived_info.action.end() && !found) {
        if (fabs(
            (*action_itr)->getTimeAtWhichThisInfoIsPerceived() - (*action_itr1)->getTimeAtWhichThisInfoIsPerceived())
            < 0.001) {
          found = true;
          grouped_info_pt->action.push_back(*action_itr1);
        }
        action_itr1++;
      }
    }
    for (auto procedure_step_itr = (*grouped_info_itr)->procedure_step.begin();
         procedure_step_itr != (*grouped_info_itr)->procedure_step.end(); procedure_step_itr++) {
      found = false;
      auto procedure_step_itr1 = this->perceived_info.procedure_step.begin();
      while (procedure_step_itr1 != this->perceived_info.procedure_step.end() && !found) {
        if (((*procedure_step_itr)->getProcedureName() == (*procedure_step_itr1)->getProcedureName()) &&
            ((*procedure_step_itr)->getStepName() == (*procedure_step_itr1)->getStepName())) {
          found = true;
          grouped_info_pt->procedure_step.push_back(*procedure_step_itr1);
        }
        procedure_step_itr1++;
      }
    }
    for (auto perceived_alarms_itr = (*grouped_info_itr)->perceived_alarms.begin();
         perceived_alarms_itr != (*grouped_info_itr)->perceived_alarms.end(); perceived_alarms_itr++) {
      found = false;
      auto perceived_alarms_itr1 = this->perceived_info.perceived_alarms.begin();
      while (perceived_alarms_itr1 != this->perceived_info.perceived_alarms.end() && !found) {
        if (fabs((*perceived_alarms_itr)->getTimeAtWhichThisInfoIsPerceived()
                     - (*perceived_alarms_itr1)->getTimeAtWhichThisInfoIsPerceived()) < 0.001) {
          found = true;
          grouped_info_pt->perceived_alarms.push_back(*perceived_alarms_itr1);
        }
        perceived_alarms_itr1++;
      }
    }
    for (auto perceived_component_state_itr = (*grouped_info_itr)->perceived_component_state.begin();
         perceived_component_state_itr != (*grouped_info_itr)->perceived_component_state.end();
         perceived_component_state_itr++) {
      found = false;
      auto perceived_component_state_itr1 = this->perceived_info.perceived_component_state.begin();
      while (perceived_component_state_itr1 != this->perceived_info.perceived_component_state.end() && !found) {
        if (fabs((*perceived_component_state_itr)->getTimeAtWhichThisInfoIsPerceived()
                     - (*perceived_component_state_itr1)->getTimeAtWhichThisInfoIsPerceived()) < 0.001) {
          found = true;
          grouped_info_pt->perceived_component_state.push_back(*perceived_component_state_itr1);
        }
        perceived_component_state_itr1++;
      }
    }
    for (auto perceived_support_system_state_itr = (*grouped_info_itr)->perceived_support_system_state.begin();
         perceived_support_system_state_itr != (*grouped_info_itr)->perceived_support_system_state.end();
         perceived_support_system_state_itr++) {
      found = false;
      auto perceived_support_system_state_itr1 = this->perceived_info.perceived_support_system_state.begin();
      while (perceived_support_system_state_itr1 != this->perceived_info.perceived_support_system_state.end() && !found) {
        if (fabs((*perceived_support_system_state_itr)->getTimeAtWhichThisInfoIsPerceived()
                     - (*perceived_support_system_state_itr1)->getTimeAtWhichThisInfoIsPerceived()) < 0.001) {
          found = true;
          grouped_info_pt->perceived_support_system_state.push_back(*perceived_support_system_state_itr1);
        }
        perceived_support_system_state_itr1++;
      }
    }
    for (auto perceived_parameter_value_itr = (*grouped_info_itr)->perceived_parameter_value.begin();
         perceived_parameter_value_itr != (*grouped_info_itr)->perceived_parameter_value.end();
         perceived_parameter_value_itr++) {
      found = false;
      auto perceived_parameter_value_itr1 = this->perceived_info.perceived_parameter_value.begin();
      while (perceived_parameter_value_itr1 != this->perceived_info.perceived_parameter_value.end() && !found) {
        if (fabs((*perceived_parameter_value_itr)->getTimeAtWhichThisInfoIsPerceived()
                     - (*perceived_parameter_value_itr1)->getTimeAtWhichThisInfoIsPerceived()) < 0.001) {
          found = true;
          grouped_info_pt->perceived_parameter_value.push_back(*perceived_parameter_value_itr1);
        }
        perceived_parameter_value_itr1++;
      }
    }
    for (auto perceived_parameter_trend_itr = (*grouped_info_itr)->perceived_parameter_trend.begin();
         perceived_parameter_trend_itr != (*grouped_info_itr)->perceived_parameter_trend.end();
         perceived_parameter_trend_itr++) {
      found = false;
      auto perceived_parameter_trend_itr1 = this->perceived_info.perceived_parameter_trend.begin();
      while (perceived_parameter_trend_itr1 != this->perceived_info.perceived_parameter_trend.end() && !found) {
        if (fabs((*perceived_parameter_trend_itr)->getTimeAtWhichThisInfoIsPerceived()
                     - (*perceived_parameter_trend_itr1)->getTimeAtWhichThisInfoIsPerceived()) < 0.001) {
          found = true;
          grouped_info_pt->perceived_parameter_trend.push_back(*perceived_parameter_trend_itr1);
        }
        perceived_parameter_trend_itr1++;
      }
    }
    for (auto related_subsystem_itr = (*grouped_info_itr)->related_subsystem.begin();
         related_subsystem_itr != (*grouped_info_itr)->related_subsystem.end(); related_subsystem_itr++) {
      grouped_info_pt->related_subsystem.push_back(*related_subsystem_itr);
    }
  }
}
void ShortTermMemory::activatePausedInfoChunck() {
  decltype(grouped_info)::reverse_iterator ritr;//grouped_info;
  bool found = false;
  ritr = grouped_info.rbegin();
  while (ritr != grouped_info.rend() && !found) {
    if ((*ritr)->getStateOfActivation() == sim::State::Pause) {
      found = true;
      (*ritr)->setStateOfActivation(sim::State::Active);
    }
    ritr++;
  }
  if (!found) {
    ofstream fout("err messages.txt", ios::app);
    cout << "ShortTermMemory::activatePausedInfoChunck cound not find paused info chunk" << endl;
    fout << r5pars_.timesno << "  ShortTermMemory::activatePausedInfoChunck cound not find paused info chunk\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("ShortTermMemory::activatePausedInfoChunck err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
}
void ShortTermMemory::setInfoGatherMode(int n) { info_gather_mode = n; }
int ShortTermMemory::getInfoGatherMode() { return info_gather_mode; }
void ShortTermMemory::saveShortTermMemoryToFile(ofstream &fout) {
  int num;
  decltype(grouped_info)::iterator grouped_info_itr;
  fout << "ShortTermMemory\n";
  perceived_info.saveInfoChunkToFile(fout);
  num = grouped_info.size();
  fout << "Info_Chunks " << num << '\n';
  for (grouped_info_itr = grouped_info.begin(); grouped_info_itr != grouped_info.end(); grouped_info_itr++) {
    (*grouped_info_itr)->saveInfoChunkMentalToFile(fout);
  }
  fout << info_gather_mode << '\n';
  this->alarm_update_time.saveTimerToFile(fout);
  this->component_update_time.saveTimerToFile(fout);
  this->support_system_update_time.saveTimerToFile(fout);
  this->parameter_update_time.saveTimerToFile(fout);
}
void ShortTermMemory::retrieveShortTermMemoryFromFile(ifstream &fin) {
  int i, num;
  string str;
  InfoChunkMental *grouped_info_pt;
  decltype(grouped_info)::iterator grouped_info_itr;
  fin >> str;
  if (str != "ShortTermMemory") {
    ofstream fout("err messages.txt", ios::app);
    cout << "ShortTermMemory::retrieveShortTermMemoryFromFile File retrieval error in previous function" << endl;
    fout << r5pars_.timesno
         << "  ShortTermMemory::retrieveShortTermMemoryFromFile File retrieval error in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("ShortTermMemory::retrieveShortTermMemoryFromFile Prior error");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
  perceived_info.retrieveInfoChunkFromFile(fin);
 
  fin >> str >> num;
  if (str != "Info_Chunks") {
    ofstream fout("err messages.txt", ios::app);
    cout << "ShortTermMemory::retrieveShortTermMemoryFromFile File retrieval error in perceived_info" << endl;
    fout << r5pars_.timesno
         << "  ShortTermMemory::retrieveShortTermMemoryFromFile File retrieval error in perceived_info\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("ShortTermMemory::retrieveShortTermMemoryFromFile perceived_info error");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
  for (i = 0; i < num; i++) {
    auto p = make_unique<InfoChunkMental>();
    p->retrieveInfoChunkMentalFromFile(fin);
    grouped_info.push_back(std::move(p));
  }
  for (grouped_info_itr = grouped_info.begin(); grouped_info_itr != grouped_info.end(); grouped_info_itr++) {
    (*grouped_info_itr)->replaceObjecByPointerForGroupedInfoAll(this->perceived_info);
  }
  fin >> info_gather_mode;
  this->alarm_update_time.retrieveTimerFromFile(fin);
  this->component_update_time.retrieveTimerFromFile(fin);
  this->support_system_update_time.retrieveTimerFromFile(fin);
  this->parameter_update_time.retrieveTimerFromFile(fin);
 
}
int ShortTermMemory::getCurrentGoal() {
  bool found_goal = false;
  int current_goal = sim::None;
  auto goal_itr = this->perceived_info.goal.rbegin();
  auto goal_end = this->perceived_info.goal.rend();
  while (goal_itr != goal_end && !found_goal) {
    if ((*goal_itr)->getStateOfActivation() == sim::State::Active) {
      current_goal = (*goal_itr)->getDecision();
      found_goal = true;
    }
    goal_itr++;
  }
  return current_goal;
}