MentalRepresentation.cpp

Go to the documentation of this file.

// MentalRepresentation.cpp: implementation of the MentalRepresentation class.
//
 
#include <iostream>
#include <fstream>
#include <sstream>
 
#include "MentalRepresentation.h"
#include "../Global/TermConversions.h"
#include "../Scheduler/Scheduler.h"
#include "../Crew/OperatorDM.h"
#include "../Global/SimulationContext.h"
 
 
using namespace std;
 
// Construction/Destruction
 
MentalRepresentation::MentalRepresentation() {
  this->m_check_value_or_rate = 0;
  this->m_first_round_initiated_bl = 0;
  this->m_MR_A_itr = this->m_MRAlarm_list.begin();
  this->m_MR_C_itr = this->m_MRComponent_list.begin();
  this->m_MR_P_itr = this->m_MRParameter_list.begin();
 
  //0--check vale
  //1--check rate
}
 
MentalRepresentation::~MentalRepresentation() {
  // unique_ptr elements are automatically deleted when vectors are destroyed
}
 
void MentalRepresentation::ReadMentalRepresentationtInfoFromInputFile() {
  string file_name;
  string concept_ID, indicator_ID, str, str1, rate_indicator_ID, control_value_indicator_ID;
  int n_Unit, n_type;
  int i;
  MRParameterUnit *MRPar_pt;
  MRComponentStateUnit *MRComponentState_pt;
  MRSupportSystemStateUnit *MRSupportSystemState_pt;
  MRAlarmUnit *MRAlarm_pt;
  bool found_file;
  ifstream fin;
  ReasonMachine *RM_pt;
  double v1, v2, v3, v4;
  string err_mes;
  string ID_name;
  stringstream conv;
 
  //find corresponding ReasonMachine
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {
    err_mes = "could not identify operator type in MentalRepresentation::ReadMentalRepresentationtInfoFromInputFile()";
    this->ErrorMessage(err_mes);
    return;
  }
 
  if (this->m_operator == sim::Operator::ODM) {
    file_name = g_sim.SScheduler.getODMDirectory();
    file_name += "RM/";
    file_name += "KB_ODM_Mental_Representation.txt";
  } else if (this->m_operator == sim::Operator::OAT) {
    file_name = g_sim.SScheduler.getOATDirectory();
    file_name += "RM/";
    file_name += "KB_OAT_Mental_Representation.txt";
  } else {
    err_mes = "could not identify the operator in MentalRepresentation::ReadMentalRepresentationtInfoFromInputFile()";
    this->ErrorMessage(err_mes);
    return;
  }
 
  fin.open(file_name.c_str(), ios::in);
  if (!fin.is_open()) {
    err_mes = "can not find file: " + file_name;
    this->ErrorMessage(err_mes);
    found_file = false;
    return; //has to return and close this program if there is an error
  } else {
    found_file = true;
 
    //MR of parameters
    fin >> str >> n_Unit;
    for (i = 0; i < n_Unit; i++) {
      fin >> str >> concept_ID;
      if (str.compare("Parameter_Concept_ID") != 0) {
        err_mes = concept_ID + " is not aligned in the right position";
        this->ErrorMessage(err_mes);
        return;
      }
      fin >> str >> indicator_ID;
      if (str.compare("Corresponding_Value_Indicator") != 0) {
        err_mes = indicator_ID + " is not aligned in the right position";
        this->ErrorMessage(err_mes);
        return;
      }
      fin >> str >> rate_indicator_ID;
      if (str.compare("Corresponding_Rate_Indicator") != 0) {
        err_mes = "Corresponding_Rate_Indicator of " + rate_indicator_ID + " is not aligned in the right position";
        this->ErrorMessage(err_mes);
        return;
      }
      fin >> str >> v1;
      if (str.compare("increase_detect_threshold") != 0) {
        err_mes = "increase_dectect_threshold of " + concept_ID + " is not aligned in the right position";
        this->ErrorMessage(err_mes);
        return;
      }
      fin >> str >> v2;
      if (str.compare("decrease_detect_threshold") != 0) {
        err_mes = "decrease_dectect_threshold of " + concept_ID + " is not aligned in the right position";
        this->ErrorMessage(err_mes);
        return;
      }
      fin >> str >> v3;
      if (str.compare("increase_rate_detect_threshold") != 0) {
        err_mes = "increase_rate_detect_threshold of " + concept_ID + " is not aligned in the right position";
        this->ErrorMessage(err_mes);
        return;
      }
      fin >> str >> v4;
      if (str.compare("decrease_rate_detect_threshold") != 0) {
        err_mes = "decrease_rate_detect_threshold of " + concept_ID + " is not aligned in the right position";
        this->ErrorMessage(err_mes);
        return;
      }
 
      auto MRPar_upt = make_unique<MRParameterUnit>();
      MRPar_pt = MRPar_upt.get();
 
      conv.str("");
      conv << this->m_MRParameter_list.size();
      ID_name = "MR_Parameter_" + conv.str();
      MRPar_pt->m_ID = ID_name;
      MRPar_pt->m_operator = this->m_operator;
      MRPar_pt->m_parameter_concept_ID = concept_ID;
      MRPar_pt->m_Concept_ID_pt = RM_pt->m_Concept_Base->FindConceptByID(concept_ID);
      if (MRPar_pt->m_Concept_ID_pt == NULL) {
        err_mes = "could not find concept: " + concept_ID
            + " in semantic base, error location: Mental representation txt file";
        this->ErrorMessage(err_mes);
        return;
      }
      MRPar_pt->m_parameter_indicator_ID = indicator_ID;
      MRPar_pt->m_parameter_rate_indicator_ID = rate_indicator_ID;
      MRPar_pt->m_increase_threshold = v1;
      MRPar_pt->m_decrease_threshold = v2;
      MRPar_pt->m_increase_rate_threshold = v3;
      MRPar_pt->m_decrease_rate_threshold = v4;
      this->m_MRParameter_list.push_back(std::move(MRPar_upt));
    }
 
    //MR of component states
    fin >> str >> n_Unit;
    if (str.compare("No_of_Component_State_Concept") != 0) {
      err_mes = "No_of_Component_State_Concept is not aligned in the proper position in Mental Representation txt file";
      this->ErrorMessage(err_mes);
      return;
    }
    for (i = 0; i < n_Unit; i++) {
      control_value_indicator_ID = "NONE";
      fin >> str >> concept_ID;
      if (str.compare("Component_Concept_ID") != 0) {
        err_mes = "Component_Concept_ID of " + concept_ID
            + " is not aligned in the proper position in Mental Representation txt file";
        this->ErrorMessage(err_mes);
        return;
      }
      fin >> str >> n_type;
      if (str.compare("Component_State_Type") != 0) {
        err_mes = "Component_State_Type " + concept_ID
            + " is not aligned in the proper position in Mental Representation txt file";
        this->ErrorMessage(err_mes);
        return;
      }
      auto MRComp_upt = make_unique<MRComponentStateUnit>();
      MRComponentState_pt = MRComp_upt.get();
      conv.str("");
      conv << this->m_MRComponent_list.size();
      ID_name = "MR_Component_State_" + conv.str();
      MRComponentState_pt->m_ID = ID_name;
 
      MRComponentState_pt->m_operator = this->m_operator;
      MRComponentState_pt->m_concept_ID = concept_ID;
      MRComponentState_pt->m_Concept_ID_pt = RM_pt->m_Concept_Base->FindConceptByID(concept_ID);
      if (MRComponentState_pt->m_Concept_ID_pt == NULL) {
        err_mes = "could not find a corresponding concept in the semantic base for MR item " + concept_ID;
        this->ErrorMessage(err_mes);
        return;
      }
      MRComponentState_pt->m_CS_type = n_type;
      switch (n_type) {
        case 0: fin >> str >> str1;
          if (str.compare("Conponent_State_Indicator") != 0) {
            err_mes = "MR Item: " + concept_ID + ". Conponent_State_Indicator is not aligned in right posiiton";
            this->ErrorMessage(err_mes);
            return;
          }
          MRComponentState_pt->Component_State_Indicator_ID = str1;
          break;
        case 1: fin >> str >> str1;
          if (str.compare("Component_position_Indicator") != 0) {
            err_mes = "MR Item: " + concept_ID + ". Component_position_Indicator is not aligned in right posiiton";
            this->ErrorMessage(err_mes);
            return;
          }
          MRComponentState_pt->Control_Value_Indicator_ID = str1;
          fin >> str >> v1;
          if (str.compare("Component_position_change_detect_threshold") != 0) {
            err_mes = "MR Item: " + concept_ID
                + ". Component_position_change_detect_threshold is not aligned in right posiiton";
            this->ErrorMessage(err_mes);
            return;
          }
          MRComponentState_pt->m_change_threshold = v1;
          break;
        default: break;//error message, should not be here
      }
      this->m_MRComponent_list.push_back(std::move(MRComp_upt));
    }
 
    //MR of Support Systems
    fin >> str >> n_Unit;
    if (str.compare("No_of_Support_System_Concept") != 0) {
      err_mes = "No_of_Support_System_Concept is mis-aligned with " + str;
      this->ErrorMessage(err_mes);
      return;
    }
    for (i = 0; i < n_Unit; i++) {
      fin >> str >> concept_ID;
      if (str.compare("Support_System_State_Concept_ID") != 0) {
        err_mes = "Support_System_Concept_ID is mis-aligned with" + str;
        this->ErrorMessage(err_mes);
        return;
      }
      fin >> str >> indicator_ID;
      if (str.compare("Support_System_State_Indicator") != 0) {
        err_mes = "Support_System_Indicator is mis-aligned with" + str;
        this->ErrorMessage(err_mes);
        return;
      }
      auto MRSS_upt = make_unique<MRSupportSystemStateUnit>();
      MRSupportSystemState_pt = MRSS_upt.get();
 
      conv.str("");
      conv << this->m_MRSupportSystem_list.size();
      ID_name = "MR_Support_System_" + conv.str();
      MRSupportSystemState_pt->m_ID = ID_name;
 
      MRSupportSystemState_pt->m_operator = this->m_operator;
      MRSupportSystemState_pt->m_concept_ID = concept_ID;
      MRSupportSystemState_pt->m_Concept_ID_pt = RM_pt->m_Concept_Base->FindConceptByID(concept_ID);
      if (MRSupportSystemState_pt->m_Concept_ID_pt == NULL) {
        err_mes = "could not find concept: " + concept_ID
            + " in semantic base. Error location: Mental representation txt file";
        this->ErrorMessage(err_mes);
        return;
      }
      MRSupportSystemState_pt->Support_System_State_Indicator_ID = indicator_ID;
      this->m_MRSupportSystem_list.push_back(std::move(MRSS_upt));
    }
 
    //MR of Alarms
    fin >> str >> n_Unit;
    if (str.compare("No_of_Alarm_Concept") != 0) {
      err_mes = "No_of_Alarm_Concept is mis-aligned with " + str;
      this->ErrorMessage(err_mes);
      return;
    }
    for (i = 0; i < n_Unit; i++) {
      fin >> str >> concept_ID;
      if (str.compare("Alarm_Concept_ID") != 0) {
        err_mes = "Alarm_Concept_ID is mis-aligned with" + str;
        this->ErrorMessage(err_mes);
        return;
      }
      fin >> str >> indicator_ID;
      if (str.compare("Alarm_Indicator") != 0) {
        err_mes = "Alarm_Indicator is mis-aligned with" + str;
        this->ErrorMessage(err_mes);
        return;
      }
      auto MRAlarm_upt = make_unique<MRAlarmUnit>();
      MRAlarm_pt = MRAlarm_upt.get();
 
      conv.str("");
      conv << this->m_MRAlarm_list.size();
      ID_name = "MR_Alarm_" + conv.str();
      MRAlarm_pt->m_ID = ID_name;
 
      MRAlarm_pt->m_operator = this->m_operator;
      //MRComponentState_pt->Component_Concept_ID = concept_ID; to be modified
      MRAlarm_pt->m_Concept_ID = concept_ID;
      MRAlarm_pt->m_Concept_pt = RM_pt->m_Concept_Base->FindConceptByID(concept_ID);
      if (MRAlarm_pt->m_Concept_pt == NULL) {
        err_mes = "could not find concept: " + concept_ID
            + " in semantic base. Error location: Mental representation txt file";
        this->ErrorMessage(err_mes);
        return;
      }
      MRAlarm_pt->m_alarm_indicator_name = indicator_ID;
      this->m_MRAlarm_list.push_back(std::move(MRAlarm_upt));
    }
  }
  fin.close();
}
 
IDElement *MentalRepresentation::CheckExistenceByIndicationName(string _indicator) {
  IDElement *ID_pt = NULL;
  MRParameterUnit *P_pt;
  MRComponentStateUnit *C_pt;
  MRSupportSystemStateUnit *SS_pt;
  MRAlarmUnit *A_pt;
 
  bool found = false;
 
  for (auto P_itr = this->m_MRParameter_list.begin(); P_itr != this->m_MRParameter_list.end() && found == false; P_itr++) {
    P_pt = P_itr->get();
    if (P_pt->m_parameter_indicator_ID == _indicator || P_pt->m_parameter_rate_indicator_ID == _indicator) {
      found = true;
      ID_pt = P_pt;
    }
  }
  for (auto C_itr = this->m_MRComponent_list.begin(); C_itr != this->m_MRComponent_list.end() && found == false; C_itr++) {
    C_pt = C_itr->get();
    if (C_pt->Component_State_Indicator_ID == _indicator || C_pt->Control_Value_Indicator_ID == _indicator) {
      found = true;
      ID_pt = C_pt;
    }
  }
  for (auto SS_itr = this->m_MRSupportSystem_list.begin(); SS_itr != this->m_MRSupportSystem_list.end() && found == false;
       SS_itr++) {
    SS_pt = SS_itr->get();
    if (SS_pt->Support_System_State_Indicator_ID == _indicator) {
      found = true;
      ID_pt = SS_pt;
    }
  }
  for (auto A_itr = this->m_MRAlarm_list.begin(); A_itr != this->m_MRAlarm_list.end() && found == false; A_itr++) {
    A_pt = A_itr->get();
    if (A_pt->m_alarm_indicator_name == _indicator) {
      found = true;
      ID_pt = A_pt;
    }
  }
  return ID_pt;
 
}
 
IDElement *MentalRepresentation::CheckExistenceByConceptStrict(IDElement *_ID_pt) {
  IDElement *ID_pt = NULL;
  MRParameterUnit *P_pt;
  MRComponentStateUnit *C_pt;
  MRSupportSystemStateUnit *SS_pt;
  MRAlarmUnit *A_pt;
 
  bool found = false;
  for (auto P_itr = this->m_MRParameter_list.begin(); P_itr != this->m_MRParameter_list.end() && found == false; P_itr++) {
    P_pt = P_itr->get();
    if (P_pt->m_Concept_ID_pt->m_ID == _ID_pt->m_ID) {
      found = true;
      ID_pt = (IDElement *) P_pt;
    }
  }
  for (auto C_itr = this->m_MRComponent_list.begin(); C_itr != this->m_MRComponent_list.end() && found == false; C_itr++) {
    C_pt = C_itr->get();
    if (C_pt->m_Concept_ID_pt->m_ID == _ID_pt->m_ID) {
      found = true;
      ID_pt = (IDElement *) C_pt;
    }
  }
  for (auto SS_itr = this->m_MRSupportSystem_list.begin(); SS_itr != this->m_MRSupportSystem_list.end() && found == false;
       SS_itr++) {
    SS_pt = SS_itr->get();
    if (SS_pt->m_Concept_ID_pt->m_ID == _ID_pt->m_ID) {
      found = true;
      ID_pt = (IDElement *) SS_pt;
    }
  }
  for (auto A_itr = this->m_MRAlarm_list.begin(); A_itr != this->m_MRAlarm_list.end() && found == false; A_itr++) {
    A_pt = A_itr->get();
    if (A_pt->m_Concept_pt->m_ID == _ID_pt->m_ID) {
      found = true;
      ID_pt = (IDElement *) A_pt;
    }
  }
  return ID_pt;
 
}
 
IDElement *MentalRepresentation::CheckExistenceByConceptName(string _ID_str) {
  IDElement *ID_pt = NULL;
  MRParameterUnit *P_pt;
  MRComponentStateUnit *C_pt;
  MRSupportSystemStateUnit *SS_pt;
  MRAlarmUnit *A_pt;
 
  bool found = false;
  for (auto P_itr = this->m_MRParameter_list.begin(); P_itr != this->m_MRParameter_list.end() && found == false; P_itr++) {
    P_pt = P_itr->get();
    if (P_pt->m_Concept_ID_pt->m_ID == _ID_str) {
      found = true;
      ID_pt = (IDElement *) P_pt;
    }
  }
  for (auto C_itr = this->m_MRComponent_list.begin(); C_itr != this->m_MRComponent_list.end() && found == false; C_itr++) {
    C_pt = C_itr->get();
    if (C_pt->m_Concept_ID_pt->m_ID == _ID_str) {
      found = true;
      ID_pt = (IDElement *) C_pt;
    }
  }
  for (auto SS_itr = this->m_MRSupportSystem_list.begin(); SS_itr != this->m_MRSupportSystem_list.end() && found == false;
       SS_itr++) {
    SS_pt = SS_itr->get();
    if (SS_pt->m_Concept_ID_pt->m_ID == _ID_str) {
      found = true;
      ID_pt = (IDElement *) SS_pt;
    }
  }
  for (auto A_itr = this->m_MRAlarm_list.begin(); A_itr != this->m_MRAlarm_list.end() && found == false; A_itr++) {
    A_pt = A_itr->get();
    if (A_pt->m_Concept_pt->m_ID == _ID_str) {
      found = true;
      ID_pt = (IDElement *) A_pt;
    }
  }
  return ID_pt;
}
 
void MentalRepresentation::FirstRoundCheckOftheMR() {
  MRParameterUnit *P_pt;
  MRComponentStateUnit *C_pt;
  MRSupportSystemStateUnit *SS_pt;
  MRAlarmUnit *A_pt;
 
  ReasonMachine *RM_pt;
  string err_mes;
 
  //find corresponding ReasonMachine
  int operator_branch_num = 0;
  if (this->m_operator == sim::Operator::ODM) {
    RM_pt = g_sim.Decision_Maker.m_RM.get();
    operator_branch_num = g_sim.Branch_center.getNumOfODMBranch();
  } else if (this->m_operator == sim::Operator::OAT) {
    RM_pt = g_sim.Action_Taker.m_RM.get();
    operator_branch_num = g_sim.Branch_center.getNumOfOATBranch();
  } else {}//add error message
 
  if (operator_branch_num > 0) {
    RM_pt->WaitOneStepThereIsOneOrMoreOperatorBranches();
    return;
  }
 
  if (this->m_first_round_initiated_bl == false) {
    this->m_MR_P_itr = this->m_MRParameter_list.begin();
    this->m_MR_C_itr = this->m_MRComponent_list.begin();
    this->m_MR_SS_itr = this->m_MRSupportSystem_list.begin();
    this->m_MR_A_itr = this->m_MRAlarm_list.begin();
    this->m_first_round_initiated_bl = true;
  }
  if (this->m_MR_P_itr != this->m_MRParameter_list.end()) {
    P_pt = this->m_MR_P_itr->get();
    if (this->m_check_value_or_rate == 0) {
      P_pt->ReadParameterValue(0);
      this->m_check_value_or_rate = 1;
    } else {
      P_pt->ReadParameterRate(0);
      this->m_check_value_or_rate = 0;
      (this->m_MR_P_itr)++;
    }
  } else if (this->m_MR_C_itr != this->m_MRComponent_list.end()) {
    C_pt = this->m_MR_C_itr->get();
    C_pt->ReadComponentStateIndication(0);
    (this->m_MR_C_itr)++;
  } else if (this->m_MR_SS_itr != this->m_MRSupportSystem_list.end()) {
    SS_pt = this->m_MR_SS_itr->get();
    SS_pt->ReadSupportSystemStateIndication(0);
    (this->m_MR_SS_itr)++;
  } else if (this->m_MR_A_itr != this->m_MRAlarm_list.end()) {
    A_pt = this->m_MR_A_itr->get();
    A_pt->ReadAlarmIndication(0);
    (this->m_MR_A_itr)++;
  } else {
    RM_pt->m_first_round_check_done = true;
  }
}
 
void MentalRepresentation::ErrorMessage(string str) {
  cout << r5pars_.timesno << "  " << str << " in MentalRepresentation.cpp" << '\n';
  ofstream fout("err messages.txt", ios::app);
  fout << r5pars_.timesno << "  " << str << '\n';
  fout.close();
  //r5pars_.terminateall = true;
}
 
void MentalRepresentation::SaveMentalRepresentationInforToFile(string _path) {
  MRParameterUnit *P_pt;
  MRComponentStateUnit *C_pt;
  MRSupportSystemStateUnit *SS_pt;
  MRAlarmUnit *A_pt;
 
  ofstream fout(_path.c_str(), ios::out);
  fout << "ID" << '\t';
  fout << "Reading History" << '\n';
 
  //Add Alarm Information
  for (auto A_itr = this->m_MRAlarm_list.begin(); A_itr != this->m_MRAlarm_list.end(); A_itr++) {
    A_pt = A_itr->get();
    fout << A_pt->m_Concept_pt->m_ID << ": State" << '\t';
    for (const auto &e : A_pt->m_history_state_list) {
      if (e->m_perceived_state == true) {
        fout << "ON" << '\t';
      } else {
        fout << "OFF" << '\t';
      }
    }
    if (A_pt->m_recent_state != NULL) {
      if (A_pt->m_recent_state->m_perceived_state == true) {
        fout << "ON" << '\t';
      } else {
        fout << "OFF" << '\t';
      }
    }
    fout << '\n';
    fout << A_pt->m_Concept_pt->m_ID << ": Reading time" << '\t';
    for (const auto &e : A_pt->m_history_state_list) {
      fout << e->m_time_perceived << '\t';
    }
    if (A_pt->m_recent_state != NULL) {
      fout << A_pt->m_recent_state->m_time_perceived << '\t';
    }
    fout << '\n';
  }
 
  //Add parameter information
  for (auto P_itr = this->m_MRParameter_list.begin(); P_itr != this->m_MRParameter_list.end(); P_itr++) {
    P_pt = P_itr->get();
    //Add parameter reading
    fout << P_pt->m_Concept_ID_pt->m_ID << ": Value" << '\t';
    for (const auto &e : P_pt->m_parameter_history_value) {
      fout << e->m_perceived_value;
      fout << '\t';
    }
    if (P_pt->m_recent_parameter_value != NULL) {
      fout << P_pt->m_recent_parameter_value->m_perceived_value;
    }
    fout << '\n';
 
    fout << P_pt->m_Concept_ID_pt->m_ID << ": Value reading time" << '\t';
    for (const auto &e : P_pt->m_parameter_history_value) {
      fout << e->m_time_perceived;
      fout << '\t';
    }
    if (P_pt->m_recent_parameter_value != NULL) {
      fout << P_pt->m_recent_parameter_value->m_time_perceived;
    }
    fout << '\n';
 
    //Add the change rate reading
    if (P_pt->m_parameter_rate_indicator_ID == "NONE") { continue; }
 
    fout << P_pt->m_Concept_ID_pt->m_ID << ": Rate" << '\t';
    for (const auto &e : P_pt->m_parameter_history_rate) {
      fout << e->m_perceived_value;
      fout << '\t';
    }
    if (P_pt->m_recent_parameter_rate != NULL) {
      fout << P_pt->m_recent_parameter_rate->m_perceived_value;
    }
    fout << '\n';
 
    fout << P_pt->m_Concept_ID_pt->m_ID << ": Value reading time" << '\t';
    for (const auto &e : P_pt->m_parameter_history_rate) {
      fout << e->m_time_perceived;
      fout << '\t';
    }
    if (P_pt->m_recent_parameter_rate != NULL) {
      fout << P_pt->m_recent_parameter_rate->m_time_perceived;
    }
    fout << '\n';
  }
 
  //Add Component State Information
  for (auto C_itr = this->m_MRComponent_list.begin(); C_itr != this->m_MRComponent_list.end(); C_itr++) {
    C_pt = C_itr->get();
    switch (C_pt->m_CS_type) {
      case 0: fout << C_pt->m_Concept_ID_pt->m_ID << ": State" << '\t';
        for (const auto &e : C_pt->m_history_state) {
          if (e->m_perceived_state == true) {
            fout << "ON" << '\t';
          } else {
            fout << "OFF" << '\t';
          }
        }
        if (C_pt->m_recent_state != NULL) {
          if (C_pt->m_recent_state->m_perceived_state == true) {
            fout << "ON" << '\t';
          } else {
            fout << "OFF" << '\t';
          }
        }
        fout << '\n';
        fout << C_pt->m_Concept_ID_pt->m_ID << ": Reading time" << '\t';
        for (const auto &e : C_pt->m_history_state) {
          fout << e->m_time_perceived << '\t';
        }
        if (C_pt->m_recent_state != NULL) {
          fout << C_pt->m_recent_state->m_time_perceived << '\t';
        }
        fout << '\n';
        break;
 
      case 1: fout << C_pt->m_Concept_ID_pt->m_ID << ": Position" << '\t';
        for (const auto &e : C_pt->m_history_position_value) {
          fout << e->m_perceived_value << '\t';
        }
        if (C_pt->m_recent_position_value != NULL) {
          fout << C_pt->m_recent_position_value->m_perceived_value << '\t';
        }
        fout << '\n';
        fout << C_pt->m_Concept_ID_pt->m_ID << ": Reading time" << '\t';
        for (const auto &e : C_pt->m_history_position_value) {
          fout << e->m_time_perceived << '\t';
        }
        if (C_pt->m_recent_position_value != NULL) {
          fout << C_pt->m_recent_position_value->m_time_perceived << '\t';
        }
        fout << '\n';
        break;
      default: break;
    }
  }
 
  //Add Support System State Information
  for (auto SS_itr = this->m_MRSupportSystem_list.begin(); SS_itr != this->m_MRSupportSystem_list.end(); SS_itr++) {
    SS_pt = SS_itr->get();
    fout << SS_pt->m_Concept_ID_pt->m_ID << ": State" << '\t';
    for (const auto &e : SS_pt->m_history_state) {
      if (e->m_perceived_state == true) {
        fout << "ON" << '\t';
      } else {
        fout << "OFF" << '\t';
      }
    }
    if (SS_pt->m_recent_state != NULL) {
      if (SS_pt->m_recent_state->m_perceived_state == true) {
        fout << "ON" << '\t';
      } else {
        fout << "OFF" << '\t';
      }
    }
    fout << '\n';
    fout << SS_pt->m_Concept_ID_pt->m_ID << ": Reading time" << '\t';
    for (const auto &e : SS_pt->m_history_state) {
      fout << e->m_time_perceived << '\t';
    }
    if (SS_pt->m_recent_state != NULL) {
      fout << SS_pt->m_recent_state->m_time_perceived << '\t';
    }
    fout << '\n';
  }
 
  fout.close();
}
 
void MentalRepresentation::UpdateMRwithNewInference(Statement *_statement_pt) {
  IDElement *ID_pt;
  MRParameterUnit *P_pt;
  MRComponentStateUnit *C_pt;
  MRSupportSystemStateUnit *SS_pt;
  MRAlarmUnit *A_pt;
  MRStateSchema *S_schema_pt, *S_new_schema_pt = NULL;
  float value1, value2;
  SentenceUnit *found_sent_pt = NULL;
  SentenceUnit increase_sent, decrease_sent, open_bigger_sent, close_smaller_sent;
  SentenceUnit turn_on_sent, turn_off_sent, ON_sent, OFF_sent;
  SentenceUnit *increase_sent_pt = NULL, *decrease_sent_pt = NULL;
  SentenceUnit *open_bigger_sent_pt = NULL, *close_smaller_sent_pt = NULL;
  SentenceUnit *turn_on_sent_pt = NULL, *turn_off_sent_pt = NULL;
  SentenceUnit *ON_sent_pt = NULL, *OFF_sent_pt = NULL;
  ReasonMachine *RM_pt;
  Statement *new_statement_pt;
  Investigator *invest_pt;
 
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
 
  if (r5pars_.timesno > 886) { this->ErrorMessage(""); }
  //caution: only the type 3 sentence is included in this function
  ID_pt = this->CheckExistenceByConceptStrict(_statement_pt->m_sent_pt->m_subject_pt);
  if (ID_pt == NULL) { return; }
  switch (_statement_pt->m_sent_pt->m_sentence_type) {
    case 1: S_schema_pt = NULL;
      if (ID_pt->m_ID_Type == 201) {
        P_pt = (MRParameterUnit *) ID_pt;
        if (_statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getIncreasePt()
            || _statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getStablePt()
            || _statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getDecreasePt()) {
          if (P_pt->m_recent_trend != NULL) {
            if (_statement_pt->m_time_range.GetTimeBoundLater()
                > P_pt->m_recent_trend->m_time_range.GetTimeBoundLater()) {
              P_pt->m_recent_trend = _statement_pt;
              RM_pt->AddDeltaToSystemDynamics(0.12);
            }
          } else {
            P_pt->m_recent_trend = _statement_pt;
            RM_pt->AddDeltaToSystemDynamics(0.12);
          }
        }
      } else if (ID_pt->m_ID_Type == 202) {
        C_pt = (MRComponentStateUnit *) ID_pt;
        //update the statement
        if (_statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getBiggerPt()
            || _statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getCloseSmallerPt()
            || _statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOnPt()
            || _statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOffPt()) {
          if (C_pt->m_recent_action_statement != NULL) {
            if (_statement_pt->m_time_range.GetTimeBoundLater()
                > C_pt->m_recent_action_statement->m_time_range.GetTimeBoundLater()) {
              C_pt->m_recent_action_statement = _statement_pt;
              RM_pt->AddDeltaToSystemDynamics(0.12);
            }
          } else {
            C_pt->m_recent_action_statement = _statement_pt;
            RM_pt->AddDeltaToSystemDynamics(0.12);
          }
        }
        //update the ON/OFF state
        if (_statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOnPt()
            || _statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOffPt()) {
          if (C_pt->m_recent_state) {
            if (_statement_pt->m_time_range.GetTimeBoundLater() > C_pt->m_recent_state->m_time_perceived) {
              C_pt->m_history_state.push_back(std::move(C_pt->m_recent_state));
              C_pt->m_recent_state = make_unique<MRStateSchema>();
              if (_statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOnPt()) {
                C_pt->m_recent_state->m_perceived_state = true;
              } else { C_pt->m_recent_state->m_perceived_state = false; }
              C_pt->m_recent_state->m_time_perceived = _statement_pt->m_time_range.GetTimeBoundLater();
              S_schema_pt = C_pt->m_recent_state.get();
            }
          } else {
            C_pt->m_recent_state = make_unique<MRStateSchema>();
            if (_statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOnPt()) {
              C_pt->m_recent_state->m_perceived_state = true;
            } else { C_pt->m_recent_state->m_perceived_state = false; }
            C_pt->m_recent_state->m_time_perceived = _statement_pt->m_time_range.GetTimeBoundLater();
            S_schema_pt = C_pt->m_recent_state.get();
          }
        }
      } else if (ID_pt->m_ID_Type == 203) {
        A_pt = (MRAlarmUnit *) ID_pt;
        if (_statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOnPt()
            || _statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOffPt()) {
          if (A_pt->m_recent_action_statement != NULL) {
            if (_statement_pt->m_time_range.GetTimeBoundLater()
                > A_pt->m_recent_action_statement->m_time_range.GetTimeBoundLater()) {
              A_pt->m_recent_action_statement = _statement_pt;
              RM_pt->AddDeltaToSystemDynamics(0.12);
            }
          } else {
            A_pt->m_recent_action_statement = _statement_pt;
            RM_pt->AddDeltaToSystemDynamics(0.12);
          }
        }
        //update the ON/OFF state
        if (_statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOnPt()
            || _statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOffPt()) {
          if (A_pt->m_recent_state) {
            if (_statement_pt->m_time_range.GetTimeBoundLater() > A_pt->m_recent_state->m_time_perceived) {
              A_pt->m_history_state_list.push_back(std::move(A_pt->m_recent_state));
              A_pt->m_recent_state = make_unique<MRStateSchema>();
              if (_statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOnPt()) {
                A_pt->m_recent_state->m_perceived_state = true;
              } else { A_pt->m_recent_state->m_perceived_state = false; }
              A_pt->m_recent_state->m_time_perceived = _statement_pt->m_time_range.GetTimeBoundLater();
              S_schema_pt = A_pt->m_recent_state.get();
            }
          } else {
            A_pt->m_recent_state = make_unique<MRStateSchema>();
            if (_statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOnPt()) {
              A_pt->m_recent_state->m_perceived_state = true;
            } else { A_pt->m_recent_state->m_perceived_state = false; }
            A_pt->m_recent_state->m_time_perceived = _statement_pt->m_time_range.GetTimeBoundLater();
            S_schema_pt = A_pt->m_recent_state.get();
          }
        }
      } else if (ID_pt->m_ID_Type == 204) {
        SS_pt = (MRSupportSystemStateUnit *) ID_pt;
        //update the statement
        if (_statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOnPt()
            || _statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOffPt()) {
          if (SS_pt->m_recent_action_statement != NULL) {
            if (_statement_pt->m_time_range.GetTimeBoundLater()
                > SS_pt->m_recent_action_statement->m_time_range.GetTimeBoundLater()) {
              SS_pt->m_recent_action_statement = _statement_pt;
              RM_pt->AddDeltaToSystemDynamics(0.12);
            }
          } else {
            SS_pt->m_recent_action_statement = _statement_pt;
            RM_pt->AddDeltaToSystemDynamics(0.12);
          }
        }
        //update the ON/OFF state
        if (_statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOnPt()
            || _statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOffPt()) {
          if (SS_pt->m_recent_state) {
            if (_statement_pt->m_time_range.GetTimeBoundLater() > SS_pt->m_recent_state->m_time_perceived) {
              SS_pt->m_history_state.push_back(std::move(SS_pt->m_recent_state));
              SS_pt->m_recent_state = make_unique<MRStateSchema>();
              if (_statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOnPt()) {
                SS_pt->m_recent_state->m_perceived_state = true;
              } else { SS_pt->m_recent_state->m_perceived_state = false; }
              SS_pt->m_recent_state->m_time_perceived = _statement_pt->m_time_range.GetTimeBoundLater();
              S_schema_pt = SS_pt->m_recent_state.get();
            }
          } else {
            SS_pt->m_recent_state = make_unique<MRStateSchema>();
            if (_statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOnPt()) {
              SS_pt->m_recent_state->m_perceived_state = true;
            } else { SS_pt->m_recent_state->m_perceived_state = false; }
            SS_pt->m_recent_state->m_time_perceived = _statement_pt->m_time_range.GetTimeBoundLater();
            S_schema_pt = SS_pt->m_recent_state.get();
          }
        }
        if (S_schema_pt != NULL) {
          new_statement_pt = NULL;
          ON_sent_pt = NULL;
          OFF_sent_pt = NULL;
          found_sent_pt = NULL;
          if (C_pt != NULL) {
            if (S_schema_pt->m_perceived_state == true
                && C_pt->m_recent_state_statement->m_sent_pt->m_state_pt != RM_pt->m_Concept_Base->getONpt()) {
              ON_sent_pt = &ON_sent;
            } else if (S_schema_pt->m_perceived_state == false
                && C_pt->m_recent_state_statement->m_sent_pt->m_state_pt != RM_pt->m_Concept_Base->getOFFpt()) {
              OFF_sent_pt = &OFF_sent;
            }
          } else if (A_pt != NULL) {
            if (S_schema_pt->m_perceived_state == true
                && A_pt->m_recent_state_statement->m_sent_pt->m_state_pt != RM_pt->m_Concept_Base->getONpt()) {
              ON_sent_pt = &ON_sent;
            } else if (S_schema_pt->m_perceived_state == false
                && A_pt->m_recent_state_statement->m_sent_pt->m_state_pt != RM_pt->m_Concept_Base->getOFFpt()) {
              OFF_sent_pt = &OFF_sent;
            }
          } else if (SS_pt != NULL) {
            if (S_schema_pt->m_perceived_state == true
                && SS_pt->m_recent_state_statement->m_sent_pt->m_state_pt != RM_pt->m_Concept_Base->getONpt()) {
              ON_sent_pt = &ON_sent;
            } else if (S_schema_pt->m_perceived_state == false
                && SS_pt->m_recent_state_statement->m_sent_pt->m_state_pt != RM_pt->m_Concept_Base->getOFFpt()) {
              OFF_sent_pt = &OFF_sent;
            }
            if (ON_sent_pt != NULL) {
              ON_sent_pt->m_sentence_type = 2;
              ON_sent_pt->m_subject_pt = _statement_pt->m_sent_pt->m_subject_pt;
              ON_sent_pt->m_state_pt = RM_pt->m_Concept_Base->getONpt();
              found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(ON_sent_pt);
              ON_sent_pt = NULL;
            } else if (OFF_sent_pt != NULL) {
              OFF_sent_pt->m_sentence_type = 2;
              OFF_sent_pt->m_subject_pt = _statement_pt->m_sent_pt->m_subject_pt;
              OFF_sent_pt->m_state_pt = RM_pt->m_Concept_Base->getOFFpt();
              found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(OFF_sent_pt);
              OFF_sent_pt = NULL;
            }
 
            if (found_sent_pt != NULL) {
              auto stmt = make_unique<Statement>();
              stmt->m_sent_pt = found_sent_pt;
              if (_statement_pt->m_factual_type == 1 || _statement_pt->m_factual_type == 2) {
                stmt->m_factual_type = 2;
              } else { stmt->m_factual_type = 3; }
              stmt->m_confidence = _statement_pt->m_confidence;
              stmt->m_state = true;
              stmt->m_time_range.m_start_time = S_schema_pt->m_time_perceived;
              stmt->m_time_range.m_end_time = S_schema_pt->m_time_perceived;
              new_statement_pt = stmt.get();
              RM_pt->AddANewStatement(stmt.release());
              if (C_pt != NULL) {
                C_pt->m_recent_state_statement = new_statement_pt;
              } else if (A_pt != NULL) {
                A_pt->m_recent_state_statement = new_statement_pt;
              } else if (SS_pt != NULL) {
                SS_pt->m_recent_state_statement = new_statement_pt;
              }
            }
          }
 
          break;
          case 2:C_pt = NULL;
          SS_pt = NULL;
          A_pt = NULL;
          S_new_schema_pt = NULL;
          turn_on_sent_pt = NULL;
          turn_off_sent_pt = NULL;
          new_statement_pt = NULL;
          new_statement_pt = NULL;
          //caution
          if (_statement_pt->m_state == false) { return; }
          if (_statement_pt->m_sent_pt->m_state_pt != RM_pt->m_Concept_Base->getONpt()
              && _statement_pt->m_sent_pt->m_state_pt != RM_pt->m_Concept_Base->getOFFpt()) { return; }
 
          if (ID_pt->m_ID_Type == 202) {
            C_pt = (MRComponentStateUnit *) ID_pt;
            S_schema_pt = C_pt->m_recent_state.get();
          } else if (ID_pt->m_ID_Type == 203) {
            A_pt = (MRAlarmUnit *) ID_pt;
            S_schema_pt = A_pt->m_recent_state.get();
          } else if (ID_pt->m_ID_Type == 204) {
            SS_pt = (MRSupportSystemStateUnit *) ID_pt;
            S_schema_pt = SS_pt->m_recent_state.get();
          }
          if (S_schema_pt != NULL) {
            if (_statement_pt->m_time_range.GetTimeBoundLater()
                > S_schema_pt->m_time_perceived) {//Only in the following two situations , there is a need to generate new statements
              if (_statement_pt->m_sent_pt->m_state_pt == RM_pt->m_Concept_Base->getONpt()
                  && S_schema_pt->m_perceived_state == false) {
                S_new_schema_pt = new MRStateSchema(); // raw new: ownership transferred to unique_ptr via .reset() below
                S_new_schema_pt->m_perceived_state = true;
                S_new_schema_pt->m_time_perceived = _statement_pt->m_time_range.GetTimeBoundLater();
              } else if (_statement_pt->m_sent_pt->m_state_pt == RM_pt->m_Concept_Base->getOFFpt()
                  && S_schema_pt->m_perceived_state == true) {
                S_new_schema_pt = new MRStateSchema(); // raw new: ownership transferred to unique_ptr via .reset() below
                S_new_schema_pt->m_perceived_state = false;
                S_new_schema_pt->m_time_perceived = _statement_pt->m_time_range.GetTimeBoundLater();
              }
            }
            if (S_new_schema_pt != NULL) {//update the state schema and the statement
 
              if (_statement_pt->m_sent_pt->m_state_pt == RM_pt->m_Concept_Base->getONpt()) {
                turn_on_sent_pt = &turn_on_sent;
                turn_on_sent_pt->m_subject_pt = _statement_pt->m_sent_pt->m_subject_pt;
                turn_on_sent_pt->m_sentence_type = 1;
                turn_on_sent_pt->m_process_pt = RM_pt->m_Concept_Base->getTurnOnPt();
                found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(turn_on_sent_pt);
                turn_on_sent_pt = NULL;
              } else if (_statement_pt->m_sent_pt->m_state_pt == RM_pt->m_Concept_Base->getOFFpt()) {
                turn_off_sent_pt = &turn_off_sent;
                turn_off_sent_pt->m_subject_pt = _statement_pt->m_sent_pt->m_subject_pt;
                turn_off_sent_pt->m_sentence_type = 1;
                turn_off_sent_pt->m_process_pt = RM_pt->m_Concept_Base->getTurnOffPt();
                found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(turn_off_sent_pt);
                turn_off_sent_pt = NULL;
              }
              if (found_sent_pt == NULL) { this->ErrorMessage("Error!"); }
 
              if (C_pt != NULL) {
                if (C_pt->m_recent_action_statement != NULL) {
                  if (C_pt->m_recent_action_statement->m_sent_pt == found_sent_pt) {
                    found_sent_pt = NULL;
                  }
                }
              } else if (A_pt != NULL) {
                if (A_pt->m_recent_action_statement != NULL) {
                  if (A_pt->m_recent_action_statement->m_sent_pt == found_sent_pt) {
                    found_sent_pt = NULL;
                  }
                }
              } else if (SS_pt != NULL) {
                if (SS_pt->m_recent_action_statement != NULL) {
                  if (SS_pt->m_recent_action_statement->m_sent_pt == found_sent_pt) {
                    found_sent_pt = NULL;
                  }
                }
              }
 
              if (found_sent_pt != NULL) {
                auto stmt = make_unique<Statement>();
                stmt->m_confidence = _statement_pt->m_confidence;
                if (_statement_pt->m_factual_type == 1 || _statement_pt->m_factual_type == 2) {
                  stmt->m_factual_type = 2;
                } else { stmt->m_factual_type = 3; }
                stmt->m_state = _statement_pt->m_state;
                stmt->m_sent_pt = found_sent_pt;
                stmt->m_time_range.m_time_after = S_schema_pt->m_time_perceived;
                stmt->m_time_range.m_time_before = S_new_schema_pt->m_time_perceived;
                new_statement_pt = stmt.get();
                RM_pt->AddANewStatement(stmt.release());
                RM_pt->AddDeltaToSystemDynamics(0.12);
                if (C_pt != NULL) {
                  C_pt->m_recent_action_statement = new_statement_pt;
                } else if (A_pt != NULL) {
                  A_pt->m_recent_action_statement = new_statement_pt;
                } else if (SS_pt != NULL) {
                  SS_pt->m_recent_action_statement = new_statement_pt;
                }
 
                //Add an investigator for this statement
                auto inv = make_unique<Investigator>();
                inv->m_note = "by a statement";
                inv->m_motivation = 1;
                inv->m_Statement_pt = new_statement_pt;
                RM_pt->AddDeltaToCognitiveLoad(0.024);
                inv->m_Happen = 3;
                inv->m_operator = this->m_operator;
                inv->m_root_of_a_thought_line = true;
                invest_pt = inv.get();
                RM_pt->AddNewInvestigator(inv.release());
                //link the statement to the statement pointer
                new_statement_pt->m_investigator_ID_pt = (IDElement *) invest_pt;
 
                if (C_pt != NULL) {
                  C_pt->m_history_state.push_back(std::move(C_pt->m_recent_state));
                  C_pt->m_recent_state.reset(S_new_schema_pt);
                  C_pt->m_recent_state_statement = _statement_pt;
                  C_pt->m_recent_action_statement = new_statement_pt;
                } else if (A_pt != NULL) {
                  A_pt->m_history_state_list.push_back(std::move(A_pt->m_recent_state));
                  A_pt->m_recent_state.reset(S_new_schema_pt);
                  A_pt->m_recent_state_statement = _statement_pt;
                  A_pt->m_recent_action_statement = new_statement_pt;
                } else if (SS_pt != NULL) {
                  SS_pt->m_history_state.push_back(std::move(SS_pt->m_recent_state));
                  SS_pt->m_recent_state.reset(S_new_schema_pt);
                  SS_pt->m_recent_state_statement = _statement_pt;
                  SS_pt->m_recent_action_statement = new_statement_pt;
                }
              }
            }
          }
          break;
          case 3: new_statement_pt = NULL;
          if (ID_pt->m_ID_Type == 201) {
            P_pt = (MRParameterUnit *) ID_pt;
            if (P_pt->m_recent_parameter_value == NULL) { return; }
            if (P_pt->m_recent_parameter_value->m_time_perceived
                >= _statement_pt->m_time_range.m_start_time) { return; }
 
            value1 = P_pt->m_recent_parameter_value->m_perceived_value;
            value2 = _statement_pt->m_sent_pt->m_value;
            if (_statement_pt->m_sent_pt->m_comparison_pt == RM_pt->m_Concept_Base->getBiggerPt()
                && value2 > value1
                && _statement_pt->m_state == true) {
              increase_sent_pt = &increase_sent;
              increase_sent_pt->m_subject_pt = _statement_pt->m_sent_pt->m_subject_pt;
              increase_sent_pt->m_sentence_type = 1;
              increase_sent_pt->m_process_pt = RM_pt->m_Concept_Base->getIncreasePt();
            } else if (_statement_pt->m_sent_pt->m_comparison_pt == RM_pt->m_Concept_Base->getSmallerPt()
                && value2 < value1
                && _statement_pt->m_state == true) {
              decrease_sent_pt = &decrease_sent;
              decrease_sent_pt->m_subject_pt = _statement_pt->m_sent_pt->m_subject_pt;
              decrease_sent_pt->m_sentence_type = 1;
              decrease_sent_pt->m_process_pt = RM_pt->m_Concept_Base->getDecreasePt();
            } else if (_statement_pt->m_sent_pt->m_comparison_pt == RM_pt->m_Concept_Base->getSmallerPt()
                && value2 > value1
                && _statement_pt->m_state == false) {
              increase_sent_pt = &increase_sent;
              increase_sent_pt->m_subject_pt = _statement_pt->m_sent_pt->m_subject_pt;
              increase_sent_pt->m_sentence_type = 1;
              increase_sent_pt->m_process_pt = RM_pt->m_Concept_Base->getIncreasePt();
            } else if (_statement_pt->m_sent_pt->m_comparison_pt == RM_pt->m_Concept_Base->getBiggerPt()
                && value2 < value1
                && _statement_pt->m_state == false) {
              decrease_sent_pt = &decrease_sent;
              decrease_sent_pt->m_subject_pt = _statement_pt->m_sent_pt->m_subject_pt;
              decrease_sent_pt->m_sentence_type = 1;
              decrease_sent_pt->m_process_pt = RM_pt->m_Concept_Base->getDecreasePt();
            }
 
            if (increase_sent_pt != NULL) {
              found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(increase_sent_pt);
              increase_sent_pt = NULL;
            } else if (decrease_sent_pt != NULL) {
              found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(decrease_sent_pt);
              decrease_sent_pt = NULL;
            }
            if (found_sent_pt != NULL) {
              auto stmt = make_unique<Statement>();
              stmt->m_sent_pt = found_sent_pt;
              stmt->m_confidence = _statement_pt->m_confidence;
              if (_statement_pt->m_factual_type == 1 || _statement_pt->m_factual_type == 2) {
                stmt->m_factual_type = 2;
              } else { stmt->m_factual_type = 3; }
              stmt->m_state = true;
              stmt->m_time_range.m_time_after = P_pt->m_recent_parameter_value->m_time_perceived;
              if (_statement_pt->m_time_range.m_start_time != 0) {
                stmt->m_time_range.m_time_before = _statement_pt->m_time_range.m_start_time;
              } else {
                stmt->m_time_range.m_time_before = _statement_pt->m_time_range.m_time_after;
              }
 
              if (P_pt->m_recent_trend != NULL) {
                //if(new_statement_pt->m_time_range.m_time_before > P_pt->m_recent_trend->m_time_range.m_end_time
                //  &&new_statement_pt->m_time_range.m_time_before > P_pt->m_recent_trend->m_time_range.m_time_before)
                if (P_pt->m_recent_trend->m_sent_pt != stmt->m_sent_pt ||
                    P_pt->m_recent_trend->m_state != stmt->m_state) {
                  new_statement_pt = stmt.get();
                  RM_pt->AddANewStatement(stmt.release());
                  P_pt->m_recent_trend = new_statement_pt;
                  RM_pt->AddDeltaToSystemDynamics(0.12);
                } else {//only update the time
                  P_pt->m_recent_trend->RefreshStatementEndTimeToCurrentTime(0);
                  P_pt->UpdateTheRelevantInvestigator(this->m_operator);
                  // stmt is automatically deleted when unique_ptr goes out of scope
                  new_statement_pt = NULL;
                  if (P_pt->m_recent_trend->m_investigator_ID_pt == NULL) { new_statement_pt = P_pt->m_recent_trend; }
                }
              } else {
                new_statement_pt = stmt.get();
                RM_pt->AddANewStatement(stmt.release());
                P_pt->m_recent_trend = new_statement_pt;
              }
 
            }
          } else if (ID_pt->m_ID_Type == 202) {
            C_pt = (MRComponentStateUnit *) ID_pt;
            if (C_pt->m_CS_type == 0) { return; }
 
            if (C_pt->m_recent_position_value == NULL) { return; }
 
            if (C_pt->m_recent_position_value->m_time_perceived >= _statement_pt->m_time_range.m_start_time) { return; }
 
            value1 = C_pt->m_recent_position_value->m_perceived_value;
            value2 = _statement_pt->m_sent_pt->m_value;
 
            if (_statement_pt->m_sent_pt->m_comparison_pt == RM_pt->m_Concept_Base->getBiggerPt()
                && value2 > value1
                && _statement_pt->m_state == true) {
              open_bigger_sent_pt = &open_bigger_sent;
              open_bigger_sent_pt->m_subject_pt = _statement_pt->m_sent_pt->m_subject_pt;
              open_bigger_sent_pt->m_sentence_type = 1;
              open_bigger_sent_pt->m_process_pt = RM_pt->m_Concept_Base->getOpenBiggerPt();
            } else if (_statement_pt->m_sent_pt->m_comparison_pt == RM_pt->m_Concept_Base->getSmallerPt()
                && value2 < value1
                && _statement_pt->m_state == true) {
              close_smaller_sent_pt = &close_smaller_sent;
              close_smaller_sent_pt->m_subject_pt = _statement_pt->m_sent_pt->m_subject_pt;
              close_smaller_sent_pt->m_sentence_type = 1;
              close_smaller_sent_pt->m_process_pt = RM_pt->m_Concept_Base->getCloseSmallerPt();
            } else if (_statement_pt->m_sent_pt->m_comparison_pt == RM_pt->m_Concept_Base->getSmallerPt()
                && value2 > value1
                && _statement_pt->m_state == false) {
              open_bigger_sent_pt = &open_bigger_sent;
              open_bigger_sent_pt->m_subject_pt = _statement_pt->m_sent_pt->m_subject_pt;
              open_bigger_sent_pt->m_sentence_type = 1;
              open_bigger_sent_pt->m_process_pt = RM_pt->m_Concept_Base->getOpenBiggerPt();
            } else if (_statement_pt->m_sent_pt->m_comparison_pt == RM_pt->m_Concept_Base->getBiggerPt()
                && value2 < value1
                && _statement_pt->m_state == false) {
              close_smaller_sent_pt = &close_smaller_sent;
              close_smaller_sent_pt->m_subject_pt = _statement_pt->m_sent_pt->m_subject_pt;
              close_smaller_sent_pt->m_sentence_type = 1;
              close_smaller_sent_pt->m_process_pt = RM_pt->m_Concept_Base->getCloseSmallerPt();
            }
 
            if (open_bigger_sent_pt != NULL) {
              found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(open_bigger_sent_pt);
              open_bigger_sent_pt = NULL;
            } else if (close_smaller_sent_pt != NULL) {
              found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(close_smaller_sent_pt);
              close_smaller_sent_pt = NULL;
            }
            if (found_sent_pt != NULL) {
              auto stmt = make_unique<Statement>();
              stmt->m_sent_pt = found_sent_pt;
              stmt->m_confidence = _statement_pt->m_confidence;
              if (_statement_pt->m_factual_type == 1 || _statement_pt->m_factual_type == 2) {
                stmt->m_factual_type = 2;
              } else { stmt->m_factual_type = 3; }
              stmt->m_state = true;
              stmt->m_time_range.m_time_after = C_pt->m_recent_position_value->m_time_perceived;
              new_statement_pt = stmt.get();
              RM_pt->AddANewStatement(stmt.release());
              RM_pt->AddDeltaToSystemDynamics(0.12);
              if (_statement_pt->m_time_range.m_start_time != 0) {
                new_statement_pt->m_time_range.m_time_before = _statement_pt->m_time_range.m_start_time;
              } else {
                new_statement_pt->m_time_range.m_time_before = _statement_pt->m_time_range.m_time_after;
              }
 
              if (C_pt->m_recent_action_statement != NULL) {
                if (new_statement_pt->m_time_range.m_time_before
                    > C_pt->m_recent_action_statement->m_time_range.m_end_time
                    && new_statement_pt->m_time_range.m_time_before
                        > C_pt->m_recent_action_statement->m_time_range.m_time_before) {
                  C_pt->m_recent_action_statement = new_statement_pt;
                }
              } else {
                C_pt->m_recent_action_statement = new_statement_pt;
              }
 
            }
          } else if (ID_pt->m_ID_Type == 202) {
            C_pt = (MRComponentStateUnit *) ID_pt;
            if (C_pt->m_CS_type == 0) { return; }
 
            if (C_pt->m_recent_position_value == NULL) { return; }
 
            if (C_pt->m_recent_position_value->m_time_perceived >= _statement_pt->m_time_range.m_start_time) { return; }
 
            value1 = C_pt->m_recent_position_value->m_perceived_value;
            value2 = _statement_pt->m_sent_pt->m_value;
 
            if (_statement_pt->m_sent_pt->m_comparison_pt == RM_pt->m_Concept_Base->getBiggerPt()
                && value2 > value1
                && _statement_pt->m_state == true) {
              open_bigger_sent_pt = &open_bigger_sent;
              open_bigger_sent_pt->m_subject_pt = _statement_pt->m_sent_pt->m_subject_pt;
              open_bigger_sent_pt->m_sentence_type = 1;
              open_bigger_sent_pt->m_process_pt = RM_pt->m_Concept_Base->getOpenBiggerPt();
            } else if (_statement_pt->m_sent_pt->m_comparison_pt == RM_pt->m_Concept_Base->getSmallerPt()
                && value2 < value1
                && _statement_pt->m_state == true) {
              close_smaller_sent_pt = &close_smaller_sent;
              close_smaller_sent_pt->m_subject_pt = _statement_pt->m_sent_pt->m_subject_pt;
              close_smaller_sent_pt->m_sentence_type = 1;
              close_smaller_sent_pt->m_process_pt = RM_pt->m_Concept_Base->getCloseSmallerPt();
            } else if (_statement_pt->m_sent_pt->m_comparison_pt == RM_pt->m_Concept_Base->getSmallerPt()
                && value2 > value1
                && _statement_pt->m_state == false) {
              open_bigger_sent_pt = &open_bigger_sent;
              open_bigger_sent_pt->m_subject_pt = _statement_pt->m_sent_pt->m_subject_pt;
              open_bigger_sent_pt->m_sentence_type = 1;
              open_bigger_sent_pt->m_process_pt = RM_pt->m_Concept_Base->getOpenBiggerPt();
            } else if (_statement_pt->m_sent_pt->m_comparison_pt == RM_pt->m_Concept_Base->getBiggerPt()
                && value2 < value1
                && _statement_pt->m_state == false) {
              close_smaller_sent_pt = &close_smaller_sent;
              close_smaller_sent_pt->m_subject_pt = _statement_pt->m_sent_pt->m_subject_pt;
              close_smaller_sent_pt->m_sentence_type = 1;
              close_smaller_sent_pt->m_process_pt = RM_pt->m_Concept_Base->getCloseSmallerPt();
            }
 
            if (open_bigger_sent_pt != NULL) {
              found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(open_bigger_sent_pt);
              open_bigger_sent_pt = NULL;
            } else if (close_smaller_sent_pt != NULL) {
              found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(close_smaller_sent_pt);
              close_smaller_sent_pt = NULL;
            }
            if (found_sent_pt != NULL) {
              auto stmt = make_unique<Statement>();
              stmt->m_sent_pt = found_sent_pt;
              stmt->m_confidence = _statement_pt->m_confidence;
              if (_statement_pt->m_factual_type == 1 || _statement_pt->m_factual_type == 2) {
                stmt->m_factual_type = 2;
              } else { stmt->m_factual_type = 3; }
              stmt->m_state = true;
              stmt->m_time_range.m_time_after = C_pt->m_recent_position_value->m_time_perceived;
              new_statement_pt = stmt.get();
              RM_pt->AddANewStatement(stmt.release());
              RM_pt->AddDeltaToSystemDynamics(0.12);
              if (_statement_pt->m_time_range.m_start_time != 0) {
                new_statement_pt->m_time_range.m_time_before = _statement_pt->m_time_range.m_start_time;
              } else {
                new_statement_pt->m_time_range.m_time_before = _statement_pt->m_time_range.m_time_after;
              }
 
              if (C_pt->m_recent_action_statement != NULL) {
                if (new_statement_pt->m_time_range.m_time_before
                    > C_pt->m_recent_action_statement->m_time_range.m_end_time
                    && new_statement_pt->m_time_range.m_time_before
                        > C_pt->m_recent_action_statement->m_time_range.m_time_before) {
                  C_pt->m_recent_action_statement = new_statement_pt;
                }
              } else {
                C_pt->m_recent_action_statement = new_statement_pt;
              }
 
            }
          }
          if (new_statement_pt != NULL) {
            //Add an investigator for this statement
            auto inv = make_unique<Investigator>();
            inv->m_note = "by a statement";
            inv->m_motivation = 1;
            inv->m_Statement_pt = new_statement_pt;
            RM_pt->AddDeltaToCognitiveLoad(0.024);
            inv->m_Happen = 3;
            inv->m_invest_dormant = false;
            inv->m_operator = this->m_operator;
            inv->m_root_of_a_thought_line = true;
            invest_pt = inv.get();
            RM_pt->AddNewInvestigator(inv.release());
            //link the statement to the statement pointer
            new_statement_pt->m_investigator_ID_pt = (IDElement *) invest_pt;
          }
          break;
          default: break;
        }
      }
  }
}
 
void MentalRepresentation::CopyMentalRepresentationFromAnother(MentalRepresentation *_MR_pt) {
 
  this->m_operator = _MR_pt->m_operator;
  this->m_check_value_or_rate = _MR_pt->m_check_value_or_rate;
  this->m_first_round_initiated_bl = _MR_pt->m_first_round_initiated_bl;
 
  bool found;
 
  MRParameterUnit *P_pt;
  if (this->m_MRParameter_list.size() != 0) {
    this->ErrorMessage("this->m_MRParameter_list.size() != 0");
    return;
  }
 
  //m_MRParameter_list
  for (auto P_itr = _MR_pt->m_MRParameter_list.begin(); P_itr != _MR_pt->m_MRParameter_list.end(); P_itr++) {
    auto p = make_unique<MRParameterUnit>();
    p->CopyMRParameterUnitInforFromAnother(P_itr->get());
    this->m_MRParameter_list.push_back(std::move(p));
  }
  //copy the iterator position
  found = false;
  this->m_MR_P_itr = this->m_MRParameter_list.begin();
  auto P_src_itr = _MR_pt->m_MRParameter_list.begin();
  while (found == false && P_src_itr != _MR_pt->m_MRParameter_list.end()) {
    if (_MR_pt->m_MR_P_itr == P_src_itr) {
      found = true;
      break;
    } else {
      P_src_itr++;
      this->m_MR_P_itr++;
    }
  }
 
  //m_MRComponent_list
  MRComponentStateUnit *C_pt;
  if (this->m_MRComponent_list.size() != 0) {
    this->ErrorMessage("this->m_MRComponent_list.size() != 0");
    return;
  }
  for (auto C_itr = _MR_pt->m_MRComponent_list.begin(); C_itr != _MR_pt->m_MRComponent_list.end(); C_itr++) {
    auto c = make_unique<MRComponentStateUnit>();
    c->CopyMRComponentStateInfoFromAnother(C_itr->get());
    this->m_MRComponent_list.push_back(std::move(c));
  }
  //copy the iterator position
  found = false;
  this->m_MR_C_itr = this->m_MRComponent_list.begin();
  auto C_src_itr = _MR_pt->m_MRComponent_list.begin();
  while (found == false && C_src_itr != _MR_pt->m_MRComponent_list.end()) {
    if (C_src_itr == _MR_pt->m_MR_C_itr) {
      found = true;
      break;
    } else {
      C_src_itr++;
      this->m_MR_C_itr++;
    }
  }
 
  //m_MRSupportSystem_list
  MRSupportSystemStateUnit *SS_pt;
  if (this->m_MRSupportSystem_list.size() != 0) {
    this->ErrorMessage("this->m_MRSupportSystem_list.size() != 0");
    return;
  }
  for (auto SS_itr = _MR_pt->m_MRSupportSystem_list.begin(); SS_itr != _MR_pt->m_MRSupportSystem_list.end(); SS_itr++) {
    auto ss = make_unique<MRSupportSystemStateUnit>();
    ss->CopyMRSupportSystemStateUnitInfoFromAnother(SS_itr->get());
    this->m_MRSupportSystem_list.push_back(std::move(ss));
  }
  //copy the iterator position
  found = false;
  this->m_MR_SS_itr = this->m_MRSupportSystem_list.begin();
  auto SS_src_itr = _MR_pt->m_MRSupportSystem_list.begin();
  while (found == false && SS_src_itr != _MR_pt->m_MRSupportSystem_list.end()) {
    if (SS_src_itr == _MR_pt->m_MR_SS_itr) {
      found = true;
      break;
    } else {
      SS_src_itr++;
      this->m_MR_SS_itr++;
    }
  }
 
  MRAlarmUnit *A_pt;
  if (this->m_MRAlarm_list.size() != 0) {
    this->ErrorMessage("this->m_MRAlarm_list.size() != 0");
    return;
  }
 
  for (auto A_itr = _MR_pt->m_MRAlarm_list.begin(); A_itr != _MR_pt->m_MRAlarm_list.end(); A_itr++) {
    auto a = make_unique<MRAlarmUnit>();
    a->CopyMRAlarmUnitInfoFromAnother(A_itr->get());
    this->m_MRAlarm_list.push_back(std::move(a));
  }
  //copy the iterator position
  this->m_MR_A_itr = this->m_MRAlarm_list.begin();
  auto A_src_itr = _MR_pt->m_MRAlarm_list.begin();
  found = false;
  while (found == false && A_src_itr != _MR_pt->m_MRAlarm_list.end()) {
    if (A_src_itr == _MR_pt->m_MR_A_itr) {
      found = true;
      break;
    } else {
      this->m_MR_A_itr++;
      A_src_itr++;
    }
  }
}
 
IDElement *MentalRepresentation::FindMRUnitByID(string _ID) {
  IDElement *found_pt = NULL;
  for (auto P_itr = this->m_MRParameter_list.begin(); P_itr != this->m_MRParameter_list.end() && found_pt == NULL; P_itr++) {
    if ((*P_itr)->m_ID == _ID) { found_pt = (IDElement *) P_itr->get(); }
  }
  for (auto C_itr = this->m_MRComponent_list.begin(); C_itr != this->m_MRComponent_list.end() && found_pt == NULL; C_itr++) {
    if ((*C_itr)->m_ID == _ID) { found_pt = (IDElement *) C_itr->get(); }
  }
  for (auto SS_itr = this->m_MRSupportSystem_list.begin(); SS_itr != this->m_MRSupportSystem_list.end() && found_pt == NULL;
       SS_itr++) {
    if ((*SS_itr)->m_ID == _ID) { found_pt = (IDElement *) SS_itr->get(); }
  }
  for (auto A_itr = this->m_MRAlarm_list.begin(); A_itr != this->m_MRAlarm_list.end() && found_pt == NULL; A_itr++) {
    if ((*A_itr)->m_ID == _ID) { found_pt = (IDElement *) A_itr->get(); }
  }
  return found_pt;
}
 
void MentalRepresentation::BuildConnectionsForMentalRepresentation(void *_pt) {
  for (auto P_itr = this->m_MRParameter_list.begin(); P_itr != this->m_MRParameter_list.end();
       P_itr++) { (*P_itr)->BuildConnectionsForThisMRParameter(_pt); }
  for (auto C_itr = this->m_MRComponent_list.begin(); C_itr != this->m_MRComponent_list.end();
       C_itr++) { (*C_itr)->BuildConnectionsForThisMRComponentState(_pt); }
  for (auto SS_itr = this->m_MRSupportSystem_list.begin(); SS_itr != this->m_MRSupportSystem_list.end();
       SS_itr++) { (*SS_itr)->BuildConnectionsForThisMRSupportSystemStateUnit(_pt); }
  for (auto A_itr = this->m_MRAlarm_list.begin(); A_itr != this->m_MRAlarm_list.end();
       A_itr++) { (*A_itr)->BuildConnectionsForThisMRAlarmUnit(_pt); }
 
}