ReasonMachine.cpp

Go to the documentation of this file.

// ReasonMachine.cpp: implementation of the ReasonMachine class.
//
 
#include "ReasonMachine.h"
#include "RMTokens.h"
#include "../Crew/OperatorDM.h"
#include "../ControlPanel/ControlPanel.h"
#include "../Global/SimulationContext.h"
using namespace std;
 
// Construction/Destruction
 
ReasonMachine::ReasonMachine() {
 
  this->m_initial_fatigue_level = 0;
  this->m_fatigue_level = 0;
  this->m_diagnosis_complexity = 0;
  this->m_expert_level = 0.5;
  this->m_cognitive_load = 0;
  this->m_overall_stress = 0;
  this->m_cognitive_resource_use = 0.2;
  this->m_system_dynamic_level = 0;
  this->m_load_stress_integration_of_time = 0;
  this->m_decay_time_base_value = 300;
 
  this->m_routine_monitor_interval_multiplier = 1;
  this->m_decay_time = 300;
  // Deterministic defaults: the HAMLET/Neutral profiles do not set the
  // attention-span base, and these fields are copied + serialized at every
  // branch point. The defaults match m_attention_span / the memory-span
  // base value set below.
  this->m_attention_span_base_value = 20;
  this->m_memory_span = 4;
  this->m_time_constraint = nullptr;
  //
 
  // m_current_thought_line_info and m_current_investigation_info default to nullptr
  this->m_problem_solving_style = ProblemSolvingStyle::Neutral;
  this->m_routine_monitor_threshold = 1;
  this->m_interuptiveness = 1;
  //
  this->m_cognitive_time_cost_multiplier = 1;
  this->m_cognitive_time_cost_base_multiplier = 1.5;
  this->m_ability_of_integrating_evidence = 1;
  this->m_attention_span = 20;
  this->m_memory_span_base_value = 4;
  this->m_goofy_start_time = 0;
  //
 
  this->m_alarm_disruption_time_consumption = 0;
  this->m_leisure_time = 0;
 
  this->m_investigator_number = 1;
  this->m_statement_number = 1;
  this->m_investigator_link_number = 1;
  this->m_RM_Token = rm::RoutineMonitor; //the default set is to start with routine monitor
  this->m_max_length_of_alarms_stack = 5;
  this->m_block_alarm_jam = false;
  this->m_time_length = 0.5;
  this->m_timer_RM = 0;
  this->m_consumed_time = 0;
  this->m_first_round_check_done = false;
  this->m_Interpretation_time_consumption = 0.3;
  this->m_decay_constant_lamda = 0.1;
  this->m_decay_lamda = 0.1;
 
  this->m_Concept_Base = make_unique<KBConcept>();
  this->m_IB = make_unique<InstantiationBase>();
  this->m_MR = make_unique<MentalRepresentation>();
  this->m_event_schema_base = make_unique<EventSchemaBase>();
  this->m_routine_monitor = make_unique<RoutineMonitor>();
 
  this->m_working_on_invest_link_pt = NULL;
  this->m_working_on_invest_pt = NULL;
  this->m_reading_indication_ID_pt = NULL;
  // m_proximity defaults to nullptr
 
  this->m_ID_working_on_invest = "";
  this->m_ID_working_on_invest_link = "";
  this->m_ID_reading_indication = "";
  this->m_ID_buffer_invest_pt = "";
  this->m_buffer_invest_pt = NULL;
  this->m_buffer_used_bl = false;
}
 
ReasonMachine::~ReasonMachine() {
  this->m_Semantic_list.clear();
  this->m_KE_list.clear();
  this->m_KN_list.clear();
  this->m_Knowledge_list.clear();
 
  this->m_Statement_list.clear();
  this->m_investigator_pool.clear();
  this->m_investigator_link_pool.clear();
 
  this->m_RM_Token_history.clear();
  this->m_RM_token_endtime_history.clear();
  this->m_temporary_statement_list.clear();
  this->m_new_Statement_list.clear();
  this->m_ID_temporary_statement_list.clear();
  this->m_ID_new_statement_list.clear();
 
  this->m_unresolved_investigator_pool.clear();
  this->m_resolved_investigator_pool.clear();
  this->m_success_investigator_pool.clear(); //3098, 3030
  this->m_failed_investigator_pool.clear(); //
  this->m_undetermined_investigator_pool.clear(); //3031
  this->m_discarded_investigator_pool.clear(); //3090
  this->m_cause_undetermined_investigato_pool.clear(); //3097
  this->m_feedback_stack.clear();
  this->m_investigation_trace.clear();
 
  this->m_ID_unresolved_invest_pool.clear();
  this->m_ID_resolved_invest_pool.clear();
  this->m_ID_succes_invest_pool.clear();
  this->m_ID_failed_invest_pool.clear();
  this->m_ID_undertermined_invest_pool.clear();
  this->m_ID_discarded_invest_pool.clear();
  this->m_ID_cause_undertermined_invest_pool.clear();
  this->m_ID_feedback_stack.clear();
  this->m_ID_invest_trace.clear();
 
  this->m_tbi_P_list.clear();
  this->m_tbi_A_list.clear();
  this->m_tbi_C_list.clear();
  this->m_tbi_SS_list.clear();
 
  this->m_position_tbi_P_list.clear();
  this->m_position_tbi_A_list.clear();
  this->m_position_tbi_C_list.clear();
  this->m_position_tbi_SS_list.clear();
}
 
SentenceUnit *ReasonMachine::CheckExistInSemanticPoolBySentence(SentenceUnit *_input_sent_pt) {
  SentenceUnit *sent_pt = NULL;
  bool found = false;
  for (auto sent_itr = this->m_Semantic_list.begin(); sent_itr != this->m_Semantic_list.end() && found == false;
       sent_itr++) {
    if ((*sent_itr)->CheckMatchBySentence(_input_sent_pt) == true) {
      found = true;
      sent_pt = sent_itr->get();
    }
  }
  return sent_pt;
}
 
Statement *ReasonMachine::FindRecentStatementBySentence(SentenceUnit *_sent_pt) {
  //bool found = false;
  Statement *state_pt;
  auto state_itr = this->m_Statement_list.rbegin();
  while (state_itr != this->m_Statement_list.rend()) {
    if ((*state_itr)->m_sent_pt->CheckMatchBySentence(_sent_pt)) {
      if (state_pt != 0) {
        //this is to find the newest statement
        if ((*state_itr)->m_time_range.m_end_time != 0 &&
            state_pt->m_time_range.m_end_time != 0 &&
            (*state_itr)->m_time_range.m_end_time > state_pt->m_time_range.m_end_time) { state_pt = state_itr->get(); }
        if ((*state_itr)->m_time_range.m_time_before != 0 &&
            state_pt->m_time_range.m_time_before != 0 &&
            (*state_itr)->m_time_range.m_time_before > state_pt->m_time_range.m_time_before) {
          state_pt = state_itr->get();
        }
      } else { state_pt = state_itr->get(); }
    }
  }
  return state_pt;
}
 
void ReasonMachine::AddOneInvestigatorByStatement(Statement *_state_pt) {
  stringstream conv;
  string ID_name;
  conv << this->m_investigator_number;
  ID_name = "investigator_" + conv.str();
  this->m_investigator_number += 1;
  auto Invest_owned = make_unique<Investigator>();
  Investigator *Invest_pt = Invest_owned.get();
  Invest_pt->m_motivation = 1;
  Invest_pt->m_Happen = 3;
  Invest_pt->m_Statement_pt = _state_pt;
  this->AddDeltaToCognitiveLoad(0.024); //type 4
  Invest_pt->m_ID = ID_name;
  this->m_unresolved_investigator_pool.push_back(Invest_pt);
  this->m_investigator_pool.push_back(std::move(Invest_owned));
}
 
void ReasonMachine::FindCorrespondingStatementWithinTimeRange(SentenceUnit *_sent_pt, int _start, int _end) {
  //the output is stored in this->m_temporary_statement_list
  //KBConcept::getAntonymList is not finished yet
  //semantic search
  //this function returns the latest statement that has the same sentence as the input or the antonymy sentence of the input sentence.
 
//  float end1, end2;
  Statement *happen_statement_pt = NULL;
  Statement *not_happen_statement_pt = NULL;
  Statement *found_statement_pt = NULL;
  Statement *found_antonymy_statement_pt = NULL;
 
  vector<SentenceUnit *> antonymy_sent_list;
  SentenceUnit *antonymy_sent_pt;
  SentenceUnit *found_sent_pt;
 
  vector<IDElement *> antonym_list;
  vector<IDElement *>::iterator antonym_itr;
  IDElement *ID_pt;
  ConceptBasicUnit *Concept_B_pt;
  bool within_range;
  bool found = false;
  bool found_antonymy = false;
  float start_compare, end_compare;
 
 
  //to be added, add the searching for the conflicting/negation statement
  switch (_sent_pt->m_sentence_type) {
    case 1: ID_pt = _sent_pt->m_process_pt;
      break;
    case 2: ID_pt = _sent_pt->m_state_pt;
      break;
    case 3: ID_pt = _sent_pt->m_comparison_pt;
      break;
    case 4: ID_pt = _sent_pt->m_comparison_pt;
      break;
    case 5: ID_pt = _sent_pt->m_attribute_pt;
      break;
  }
  //get all the antonyms
  Concept_B_pt = (ConceptBasicUnit *) ID_pt;
  antonym_list = Concept_B_pt->m_antonym_list;
  //create corresponding antonymy sentences
  for (antonym_itr = antonym_list.begin(); antonym_itr != antonym_list.end(); antonym_itr++) {
    SentenceUnit antonymy_sent;
    antonymy_sent.CopyFromAnotherSentence(_sent_pt);
    switch (_sent_pt->m_sentence_type) {
      case 1: antonymy_sent.m_process_pt = *antonym_itr;
        break;
      case 2: antonymy_sent.m_state_pt = *antonym_itr;
      case 3: antonymy_sent.m_comparison_pt = *antonym_itr;
      case 4: antonymy_sent.m_comparison_pt = *antonym_itr;
      case 5: antonymy_sent.m_attribute_pt = *antonym_itr;
    }
    found_sent_pt = this->CheckExistInSemanticPoolBySentence(&antonymy_sent);
    if (found_sent_pt != NULL) { antonymy_sent_list.push_back(found_sent_pt); }
  }
 
  //
  for (auto statement_ritr = this->m_Statement_list.rbegin(); statement_ritr != this->m_Statement_list.rend();
       statement_ritr++) {
    within_range = false;
    //to be added, add a filter for activation threshold
    //caution about the uninitiated variable
    if ((*statement_ritr)->m_time_range.m_end_time != 0) {
      end_compare = (*statement_ritr)->m_time_range.m_end_time;
    } else if ((*statement_ritr)->m_time_range.m_time_before != 0) {
      end_compare = (*statement_ritr)->m_time_range.m_time_before;
    } else {}//warning message, this statement doesn't specify an end time range
    if ((*statement_ritr)->m_time_range.m_start_time != 0) {
      start_compare = (*statement_ritr)->m_time_range.m_start_time;
    } else if ((*statement_ritr)->m_time_range.m_time_after != 0) {
      start_compare = (*statement_ritr)->m_time_range.m_time_after;
    } else {}//warning message, this statement doesn't specify a start time range
 
    //compare whether there is overlap between the statement time range and the target range
    if (end_compare >= _start && end_compare <= _end) {
      within_range = true;
    } else if (start_compare >= _start && start_compare <= _end) {
      within_range = true;
    } else if (start_compare <= _start && end_compare >= _end) {
      within_range = true;
    }
    //compare the statement with the input sentence
    //strict comparison
    //to be added, make the comparison more flexible
    if (within_range == true) {
      auto cur_stmt = statement_ritr->get();
      if (cur_stmt->m_sent_pt == _sent_pt) {
        if (cur_stmt->m_state == true) {//happen
          if (happen_statement_pt == NULL) {
            happen_statement_pt = cur_stmt;
          } else if (happen_statement_pt->m_time_range.GetTimeBoundLater()
              < cur_stmt->m_time_range.GetTimeBoundLater()) {
            happen_statement_pt = cur_stmt;
          }
        } else {//not happen
          if (not_happen_statement_pt == NULL) {
            not_happen_statement_pt = cur_stmt;
          } else if (not_happen_statement_pt->m_time_range.GetTimeBoundLater()
              < cur_stmt->m_time_range.GetTimeBoundLater()) {
            not_happen_statement_pt = cur_stmt;
          }
        }
        /*
                if(found == false)
                {
                    found_statement_pt = *statement_ritr;
                    found = true;
                }
                else
                {
                    if(end_compare > found_statement_pt->m_time_range.m_end_time && end_compare > found_statement_pt->m_time_range.m_time_before)
                    {found_statement_pt = *statement_ritr;}
                }   */
      } else if (cur_stmt->m_sent_pt->m_sentence_type == _sent_pt->m_sentence_type
          && cur_stmt->m_sent_pt->m_subject_pt == _sent_pt->m_subject_pt) {
        // start to compare the statement witht the antonymy sentences
        for (auto antonymy_sent_itr = antonymy_sent_list.begin(); antonymy_sent_itr != antonymy_sent_list.end();
             antonymy_sent_itr++) {
          if (cur_stmt->m_sent_pt == (*antonymy_sent_itr)) {
            if (cur_stmt->m_state == true) {//not happen
              if (not_happen_statement_pt == NULL) {
                not_happen_statement_pt = cur_stmt;
              } else if (not_happen_statement_pt->m_time_range.GetTimeBoundLater()
                  < cur_stmt->m_time_range.GetTimeBoundLater()) {
                not_happen_statement_pt = cur_stmt;
              }
            } else {
              if (cur_stmt->m_sent_pt->WhetherItIsBiState() == true) {//happen
                if (happen_statement_pt == NULL) {
                  happen_statement_pt = cur_stmt;
                } else if (happen_statement_pt->m_time_range.GetTimeBoundLater()
                    < cur_stmt->m_time_range.GetTimeBoundLater()) {
                  happen_statement_pt = cur_stmt;
                }
              } else {}//unknown
            }
            /*
                        if(found_antonymy  == false)
                        {
                            found_antonymy_statement_pt = *statement_ritr;
                            found_antonymy = true;
                        }
                        else
                        {
                            if(end_compare > found_antonymy_statement_pt->m_time_range.m_end_time && end_compare > found_antonymy_statement_pt->m_time_range.m_time_before)
                            {found_antonymy_statement_pt = *statement_ritr;}
                        }
                        */
          }
        }// end of iteration of antonymy_sent_itr
      }//end of sentence type check
    }//end of if(within_range == true)
  }//end of iteration of statements
  //clear the memory usage
  antonymy_sent_list.clear();
  antonym_list.clear();
 
  this->m_temporary_statement_list.clear();
  this->m_temporary_statement_list.push_back(happen_statement_pt);
  this->m_temporary_statement_list.push_back(not_happen_statement_pt);
  /*
    end1 = 0;
    end2 = 0;
    if(found_statement_pt != NULL)
    {
        end1 = found_statement_pt->m_time_range.m_end_time;
        if(found_statement_pt->m_time_range.m_time_before > found_statement_pt->m_time_range.m_end_time)
        {end1 = found_statement_pt->m_time_range.m_time_before;}
    }
 
    if(found_antonymy_statement_pt != NULL)
    {
        end2 = found_antonymy_statement_pt->m_time_range.m_end_time;
        if(found_antonymy_statement_pt->m_time_range.m_time_before > found_antonymy_statement_pt->m_time_range.m_end_time)
        {end2 = found_antonymy_statement_pt->m_time_range.m_time_before;}
    }
 
    if(end1 > end2)
    {return found_statement_pt;}
    else
    {return found_antonymy_statement_pt;}
    */
}
 
Statement *ReasonMachine::CheckWhetherASentenceIsTrueFromMR(SentenceUnit *_sent_pt, int _start, int _end) {
 
  Statement *new_statement_pt;
  IDElement *ID_pt;
  MRParameterUnit *P_pt;
  MRComponentStateUnit *C_pt;
  MRSupportSystemStateUnit *SS_pt;
  MRValueSchema *value_schema_pt;
  float value1, value2;
  bool exist_on_CP = false;
  bool IsTrue = false;
 
  //get the value of the subject
  ID_pt = this->m_MR->CheckExistenceByConceptStrict(_sent_pt->m_subject_pt);
  if (ID_pt == 0) {
    return NULL;
  }
  if (ID_pt->m_ID_Type == 201) {//this is a MRParameterUnit, compare the reading with a value
    P_pt = (MRParameterUnit *) ID_pt;
    value_schema_pt = P_pt->FoundAValueReadingWithinTimeRange(_start, _end);
    if (value_schema_pt == 0) { return NULL; }
  } else if (ID_pt->m_ID_Type == 202) {//this is a MRComponentStateUnit, compare the current position with a value
    C_pt = (MRComponentStateUnit *) ID_pt;
    value_schema_pt = C_pt->FoundAPositionReadingWithinTimeRange(_start, _end);
    if (value_schema_pt == 0) { return NULL; }
  } else { return NULL; }
  value1 = value_schema_pt->m_perceived_value;
 
  //get the value of the object
  if (_sent_pt->m_sentence_type == 4) {
    ID_pt = this->m_MR->CheckExistenceByConceptStrict(_sent_pt->m_object_pt);
    if (ID_pt == 0) {
      return NULL;
    }
    if (ID_pt->m_ID_Type == 201) {//this is a MRParameterUnit, compare the reading with a value
      P_pt = (MRParameterUnit *) ID_pt;
      value_schema_pt = P_pt->FoundAValueReadingWithinTimeRange(_start, _end);
      if (value_schema_pt == 0) { return NULL; }
    } else if (ID_pt->m_ID_Type == 202) {//this is a MRComponentStateUnit, compare the current position with a value
      C_pt = (MRComponentStateUnit *) ID_pt;
      value_schema_pt = C_pt->FoundAPositionReadingWithinTimeRange(_start, _end);
      if (value_schema_pt == 0) { return NULL; }
    } else { return NULL; }
    value2 = value_schema_pt->m_perceived_value;
  } else if (_sent_pt->m_sentence_type == 3) {
    value2 = _sent_pt->m_value;
  } else { return NULL; }//error message, the sentence type is beyond the scope
 
  //Compare
  if (_sent_pt->m_comparison_pt == this->m_Concept_Base->getBiggerPt()) {
    if (value1 > value2) { IsTrue = true; }//create a statement to say it is true;
  } else if (value1 == value2) {
    if (value1 < value2) { IsTrue = true; }
  } else if (_sent_pt->m_comparison_pt == this->m_Concept_Base->getEqualPt()) {
    if (value1 == value2) { IsTrue = true; }
  } else {}//warning message
  //caution here
  auto new_statement_owned = make_unique<Statement>();
  new_statement_pt = new_statement_owned.get();
  new_statement_pt->m_sent_pt = _sent_pt;
  new_statement_pt->m_confidence = 1;
  new_statement_pt->m_factual_type = 1;
  new_statement_pt->m_time_range.m_start_time = value_schema_pt->m_time_perceived;
  new_statement_pt->m_time_range.m_end_time = value_schema_pt->m_perceived_value;
  new_statement_pt->m_state = IsTrue;
  this->AddANewStatement(new_statement_owned.release());
  return new_statement_pt;
}
 
KnowledgeElement *ReasonMachine::FindKnowledgeElementByStatement(Statement *statement_pt) {
  KnowledgeElement *found_KE_pt;
  bool found = false;
  for (auto KE_itr = this->m_KE_list.begin(); KE_itr != this->m_KE_list.end() && found == false; KE_itr++) {
    //firstly compare the sentence
    if ((*KE_itr)->m_SentenceUnit_pt->CheckMatchBySentence(statement_pt->m_sent_pt) == true) {
      //then compare the negation and statement state(true or false)
      if ((*KE_itr)->m_negation == false && statement_pt->m_state == true) {
        found = true;
        found_KE_pt = KE_itr->get();
      } else if ((*KE_itr)->m_negation == true && statement_pt->m_state == false) {
        found = true;
        found_KE_pt = KE_itr->get();
      }
    }
  }
  if (found == true) {
    return found_KE_pt;
  } else {
    return NULL;
  }
}
 
Investigator *ReasonMachine::FindAMatchInvestigatorByKnowledgeElement(KnowledgeElement *_KE_pt, int _start, int _end) {
  Investigator *found_invest_pt = NULL;
  KnowledgeElement *KE_pt;
  bool found = false;
  bool SameContent = false;
  float IV_start, IV_end;
  //think about using reverse iterator to increase the efficiency
  for (auto invest_ritr = this->m_investigator_pool.rbegin();
       invest_ritr != this->m_investigator_pool.rend() && found == false; invest_ritr++) {
    if ((*invest_ritr)->m_Statement_pt != 0) {
      if ((*invest_ritr)->m_Happen == 4) { continue; }
      if ((*invest_ritr)->m_Statement_pt->m_sent_pt->CheckMatchBySentence(_KE_pt->m_SentenceUnit_pt)
          == true) {//it's the same sentence
        if ((*invest_ritr)->m_Statement_pt->m_state != _KE_pt->m_negation) {//verified the negation symbol
          //compare the time range of the statement with the required time range of the KE
          if ((*invest_ritr)->m_Statement_pt->m_time_range.m_end_time != 0) {
            IV_end = (*invest_ritr)->m_Statement_pt->m_time_range.m_end_time;
          } else if ((*invest_ritr)->m_Statement_pt->m_time_range.m_time_before != 0) {
            IV_end = (*invest_ritr)->m_Statement_pt->m_time_range.m_end_time;
          }
 
          if ((*invest_ritr)->m_Statement_pt->m_time_range.m_start_time != 0) {
            IV_start = (*invest_ritr)->m_Statement_pt->m_time_range.m_start_time;
          } else if ((*invest_ritr)->m_Statement_pt->m_time_range.m_time_after != 0) {
            IV_start = (*invest_ritr)->m_Statement_pt->m_time_range.m_time_after;
          }
 
          if (IV_end >= _start && IV_end <= _end) {
            found = true;
            found_invest_pt = invest_ritr->get();
          } else if (IV_start >= _start && IV_start <= _end) {
            found = true;
            found_invest_pt = invest_ritr->get();
          } else if (IV_start <= _start && IV_end >= _end) {
            found = true;
            found_invest_pt = invest_ritr->get();
          }
        }
      }
    } else if ((*invest_ritr)->m_KElement_ID_pt != 0) {
      //caution, this directly compare the ID of the KnowledgeElements
 
      if ((*invest_ritr)->m_Happen == 2 && (*invest_ritr)->m_upperstream_ID_list.size() == 0) { continue; }
      if ((*invest_ritr)->m_Happen == 3 && (*invest_ritr)->m_Statement_pt == NULL) { continue; }
 
      //if((*invest_ritr)->m_Happen != 3 && (*invest_ritr)->m_Happen != 1)
      //{continue;}
 
      if ((*invest_ritr)->m_KElement_ID_pt->m_ID == (_KE_pt->m_ID)) {//It's the same knowledge element
        KE_pt = (KnowledgeElement *) invest_ritr->get();
        if ((*invest_ritr)->m_effective_end >= _start && (*invest_ritr)->m_effective_start <= _end) {
          found = true;
          found_invest_pt = invest_ritr->get();
        } else if ((*invest_ritr)->m_effective_start >= _start && (*invest_ritr)->m_effective_start <= _end) {
          found = true;
          found_invest_pt = invest_ritr->get();
        } else if ((*invest_ritr)->m_effective_start <= _start && (*invest_ritr)->m_effective_end >= _end) {
          found = true;
          found_invest_pt = invest_ritr->get();
        }
      }
    } else {} //warning message, this investigator doesn't have either a statement or a knowledgeElement
  }//end of iteration
  if (found == true) {
    return found_invest_pt;
  } else {
    return NULL;
  }
}//end of function
 
 
void ReasonMachine::OneStepOfReasonMachine() {
 
  bool stay_on_the_current_item = false;
  float fl_value;
  string str;
 
  Investigator *invest_pt;
 
  //Activation Decay
 
  this->ActivationDecayofRM();
 
  //This is first round check process
//  if (r5pars_.timesno <= 700) {
    if (r5pars_.timesno <= 200) {
    this->m_tbi_A_list.clear();
    return;
//    } else if (r5pars_.timesno > 700 && r5pars_.timesno < 800) {
  } else if (r5pars_.timesno > 200 && r5pars_.timesno < 250) {
    this->FirstRoundCheckInterpretation();
    return;
  }
 
  if (r5pars_.timesno >= 1809) { this->PrintMessage(""); }
 
  //ReasonMachine starts from here
 
  this->m_consumed_time = 0;
  this->m_time_length = 0.5; //to be modified
  this->m_leisure_time = false;
 
  //update at the beginning of this step
  this->m_system_dynamic_level *= exp(-0.013 * this->m_time_length);
  this->m_cognitive_load *= exp(-0.013 * this->m_time_length);
 
  this->CutTheLengthOfAlarmStack();
  this->m_event_schema_base->CrossCheckProcedureUse();
  this->BalanceTimerWithUnconsumedTime();
 
  //Performance Shaping Factor Update
  //passive alarm load
  this->m_passive_alarm_load->AddNewDataPoint(this->m_tbi_A_list.size());
 
  if (r5pars_.timesno < 850 && r5pars_.timesno > 848) {
    /*while(this->m_investigator_pool.size() > 0)
        {
            invest_itr = this->m_investigator_pool.begin();
            invest_pt = *invest_itr;
            this->m_investigator_pool.erase(invest_itr);
            //delete (invest_pt);there is a memory leakage here
        }*/
    this->m_investigator_pool.clear();
    this->m_unresolved_investigator_pool.clear();
    /*this->m_resolved_investigator_pool.clear();
        this->m_success_investigator_pool.clear();
        this->m_failed_investigator_pool.clear();
        this->m_undetermined_investigator_pool.clear();
        this->m_discarded_investigator_pool.clear();
        this->m_cause_undetermined_investigato_pool.clear();
        this->m_feedback_stack.clear();
        this->m_investigation_trace.clear();
        this->m_investigator_link_pool.clear(); */
    this->m_working_on_invest_pt = NULL;
    this->m_working_on_invest_link_pt = NULL;
 
    for (auto &stmt : this->m_Statement_list) {
      stmt->m_ID_investigator = "";
      stmt->m_investigator_ID_pt = NULL;
    }
  }
 
  while (this->m_consumed_time < this->m_time_length && this->m_leisure_time == false) {
    if (this->m_tbi_A_list.size() > 0 || this->m_tbi_C_list.size() > 0 || this->m_tbi_P_list.size() > 0 || this->m_tbi_SS_list.size() > 0) {
      this->OneStepInterpretation20();
      if (this->m_unresolved_investigator_pool.size() > 0) {
        if (this->m_working_on_invest_pt != NULL) {//don't interrupt the must-continuous process
          if (this->m_working_on_invest_pt->m_investigator_token == inv::RequestInfoRead) { stay_on_the_current_item = true; }
        }
        if (this->m_problem_solving_style == ProblemSolvingStyle::GardenPath) {
          if (this->m_RM_Token == rm::WorkOnInvestigator || this->m_RM_Token == rm::WorkOnInvestigatorLink) { stay_on_the_current_item = true; }
        }
        if (this->m_working_on_invest_link_pt != NULL && this->m_working_on_invest_pt != NULL) {
          stay_on_the_current_item = true;
          if (this->m_RM_Token != rm::WorkOnInvestigatorLink && this->m_RM_Token != rm::WorkOnInvestigator) {
            if (this->m_working_on_invest_link_pt->m_ID
                == this->m_current_investigation_info->m_name) { this->ChangeRMTokenValue(rm::WorkOnInvestigatorLink); }
            else if (this->m_working_on_invest_pt->m_ID
                == this->m_current_investigation_info->m_name) { this->ChangeRMTokenValue(rm::WorkOnInvestigator); }
            else { this->ChangeRMTokenValue(rm::Prioritize); }
          }
        }
        //need to add the InvestigatorLink expection here
        if (stay_on_the_current_item == false) { this->ChangeRMTokenValue(rm::Prioritize); }
      }
    } else {
      switch (this->m_RM_Token) {
        case rm::RoutineMonitor: this->OneStepRoutineMonitor10();
          break;
        case rm::Prioritize: this->OneStepPrioritizeInvestigation30();
          break;
        case rm::WorkOnInvestigator: this->OneStepWorkOnSelectedInvestigator3000();
          break;
        case rm::WorkOnInvestigatorLink: this->OneStepWorkOnSelectedInvestigatorLink3100();
          break;
        default:
          //error message, unexpected situation, check the m_RM_Token;
          break;
      }
    }
  }
  this->m_Concept_Base->AddDataSetOfTheConceptBase();
 
  this->UpdatePSFAtEndOfATimeStep();
  this->UpdateManifestationParameterAtEndOfATimeStep();
  this->AddPSFandManifestationDataSet();
}
 
void ReasonMachine::OneStepRoutineMonitor10() {
  //Token 0010: Routine Monitoring
  vector<float>::reverse_iterator fl_ritr;
  float fl;
  switch (this->m_routine_monitor->m_routine_monitor_Token) {
    case 11:
      if (this->m_RM_token_endtime_history.size() != 0) {
        fl_ritr = this->m_RM_token_endtime_history.rbegin();
        fl = *fl_ritr;
        if (r5pars_.timesno - fl > 30) {
          if (this->m_event_schema_base->GenerateANewInvestigatorOrNot() == true) {
            this->ChangeRMTokenValue(rm::Prioritize);
            break;
          }
          if (this->m_decayed_item_pt_list.size() > 0) {
            this->ReOpenItemWithActivationLevelAboveAGivenValue(max(0.2,
                                                                    exp(-0.04 * (r5pars_.timesno
                                                                        - this->m_goofy_start_time))));
          }
        }
      }
      if (this->m_routine_monitor->GetaMonitorUnit11() < 1.0
          && this->m_routine_monitor->m_routine_monitor_Token == 11) { this->NotDoingAnything(); }
      break;
    case 12: this->m_routine_monitor->WorkOnASelectedUnit12();
      break;
    default: break;
  }
}
 
void ReasonMachine::OneStepInterpretation20() {
  //Token 0020: Interpretation, preprocessing of the newly perceived information
  vector<MentalParameterValue *>::iterator M_P_itr;
  vector<MentalAlarm *>::iterator M_A_itr;
  vector<MentalComponentState *>::iterator M_C_itr;
  vector<MentalSupportSystemState *>::iterator M_SS_itr;
  MentalParameterValue *M_P_pt;
  MentalAlarm *M_A_pt;
  MentalComponentState *M_C_pt;
  MentalSupportSystemState *M_SS_pt;
  IDElement *ID_pt;
  MRParameterUnit *MR_P_pt, *MR_P_pt2;
  MRComponentStateUnit *MR_C_pt, *MR_C_pt2;
  MRSupportSystemStateUnit *MR_SS_pt, *MR_SS_pt2;
  MRAlarmUnit *MR_A_pt, *MR_A_pt2;
  bool expecting_indication_bl = false;
  ProximityGroupUnit *pu_pt = NULL;
  string MR_name, CP_name;
  string indicator_name;
  vector<string>::iterator str_itr;
  float perceived_value;
  int perceived_state;
 
  //firstly check the newly coming alarms. To be added based on the passive information load, if there
  //are too many alarms sounding/flashing and cause a jam, the operator might choose to block and ignore
  //the new coming alarms.
 
  //then process the new parameter and component state information.
  //"MentalParameter" could be associated with either a power plant parameter, or a valve position indication
  //"MentalComponentState" is only associated with component State.
 
  //*
  //Processing Alarms
  //*
  //PSF slot: passive information load
  MR_P_pt = NULL;
  MR_P_pt2 = NULL;
  MR_C_pt = NULL;
  MR_C_pt2 = NULL;
  MR_A_pt = NULL;
  MR_A_pt2 = NULL;
  if (r5pars_.timesno > 1347) { MR_P_pt = NULL; }
 
  if (this->m_tbi_A_list.size() > 1) { this->PrintMessage(""); }
  if ((this->m_tbi_A_list.size() > 0) && this->m_block_alarm_jam == false) {
    if (this->m_block_alarm_jam == false) {
      M_A_itr = this->m_tbi_A_list.begin();
      M_A_pt = *M_A_itr;
      //get alarm name
      indicator_name = M_A_pt->getAlarmName();
      if (indicator_name.empty() == true) {}//error message
 
      ID_pt = this->m_MR->CheckExistenceByIndicationName(indicator_name);
      if (ID_pt != NULL) {//If there is a mapping on the Mental Representation, then interpret the alarm information
        if (ID_pt->m_ID_Type != 203) {//error message
          return;
        }
 
        //check whether it is expected indication
        if (ID_pt == this->m_reading_indication_ID_pt) {
          expecting_indication_bl = true;
        }
 
        MR_A_pt = (MRAlarmUnit *) ID_pt;
        MR_A_pt->AddNewAlarmState(M_A_pt->getObservedAlarmState(), this->m_operator, expecting_indication_bl);
        //add the proximity feature here
        pu_pt = NULL;
        pu_pt = this->m_proximity->FindAProximityGroupUnitByOneMemberName(MR_A_pt->m_Concept_pt->m_ID);
        this->AddConsumptedDeltaT(1);
      }
      //Clean this from the m_tbi_A_list
      this->m_tbi_A_list.erase(M_A_itr);
      //add time consumption here
      this->AddConsumptedDeltaT(this->m_Interpretation_time_consumption);
 
    } else {
      //add time consumption here
      //need a place to record intended alarm/parameter/componentstate
      //to be added, pick out the intended alarms
      this->AddConsumptedDeltaT(this->m_alarm_disruption_time_consumption * this->m_tbi_A_list.size());
      this->m_tbi_A_list.clear();
    }
  }
 
    //*
    //Processing Parameters
    //*
 
  else if (this->m_tbi_P_list.size() > 0) {
    M_P_itr = this->m_tbi_P_list.begin();
    M_P_pt = *M_P_itr;
    //get parameter name
    { indicator_name = M_P_pt->getDisplayName(); }
    if (indicator_name == "SG_A_NR_Level") { this->PrintMessage(""); }
    if (indicator_name.empty() == true) {}//error message
 
    ID_pt = this->m_MR->CheckExistenceByIndicationName(indicator_name);
    if (ID_pt != NULL) {//interpret
      if (ID_pt == this->m_reading_indication_ID_pt) {//it is an expecting indication from the onging investigator
        expecting_indication_bl = true;
      }
 
      switch (ID_pt->m_ID_Type) {
        case 201: // it is a MRParameterUnit
          MR_P_pt = (MRParameterUnit *) ID_pt;
          if (MR_P_pt->m_parameter_indicator_ID == indicator_name) {
            MR_P_pt->AddNewValue(M_P_pt->getObservedParameterValue(), this->m_operator, expecting_indication_bl);
          } else if (MR_P_pt->m_parameter_rate_indicator_ID == indicator_name) {
            MR_P_pt->AddNewRate(M_P_pt->getObservedParameterValue(), this->m_operator, expecting_indication_bl);
          } else {}//error message
 
          //add the proximity feature here
          pu_pt = NULL;
          pu_pt = this->m_proximity->FindAProximityGroupUnitByOneMemberName(MR_P_pt->m_Concept_ID_pt->m_ID);
          break;
        case 202: // it is a MRComponentStateUnit
          MR_C_pt = (MRComponentStateUnit *) ID_pt;
          MR_C_pt->AddNewPositionValue(M_P_pt->getObservedParameterValue(), this->m_operator, expecting_indication_bl);
          //add the proximity feature here
          pu_pt = NULL;
          pu_pt = this->m_proximity->FindAProximityGroupUnitByOneMemberName(MR_C_pt->m_Concept_ID_pt->m_ID);
          //note to cancel the same request in the list
          //add the time cost
          break;
 
        default:
          //error message
          break;
      }
      //add time consumption
      this->AddConsumptedDeltaT(this->m_Interpretation_time_consumption);
    }
    //Clean this from the m_tbi_P_list
    this->m_tbi_P_list.erase(M_P_itr);
  }
 
    //*
    //Processing Component States
    //*
  else if (this->m_tbi_C_list.size() > 0) {
    M_C_itr = this->m_tbi_C_list.begin();
    M_C_pt = *M_C_itr;
 
    //get componentstate name
    { indicator_name = M_C_pt->getDisplayName(); }
    if (indicator_name.empty() == true) {}//error message
 
    ID_pt = this->m_MR->CheckExistenceByIndicationName(indicator_name);
    if (ID_pt != NULL) {//interpret
      if (ID_pt->m_ID_Type != 202) {//error message
        return;
      }
 
      if (ID_pt == this->m_reading_indication_ID_pt) {//it is an expecting indication from the onging investigator
        expecting_indication_bl = true;
      }
 
      MR_C_pt = (MRComponentStateUnit *) ID_pt;
      MR_C_pt->AddNewState(M_C_pt->getObservedComponentState(), this->m_operator, expecting_indication_bl);
 
      pu_pt = NULL;
      pu_pt = this->m_proximity->FindAProximityGroupUnitByOneMemberName(MR_C_pt->m_Concept_ID_pt->m_ID);
    }
    //Clean this from the m_tbi_C_list
    this->m_tbi_C_list.erase(M_C_itr);
    //add time consumption
    this->AddConsumptedDeltaT(this->m_Interpretation_time_consumption);
  }
    //*
    //Processing Support System States
    //*
  else if (this->m_tbi_SS_list.size() > 0) {
    M_SS_itr = this->m_tbi_SS_list.begin();
    M_SS_pt = *M_SS_itr;
 
    //get support system state name
    { indicator_name = M_SS_pt->getDisplayName(); }
    if (indicator_name.empty() == true) {}//error message
 
    ID_pt = this->m_MR->CheckExistenceByIndicationName(indicator_name);
    if (ID_pt != NULL) {//interpret
      if (ID_pt->m_ID_Type != 204) {//error message
        return;
      }
 
      if (ID_pt == this->m_reading_indication_ID_pt) {//it is an expecting indication from the onging investigator
        expecting_indication_bl = true;
      }
 
      MR_SS_pt = (MRSupportSystemStateUnit *) ID_pt;
      MR_SS_pt->AddNewState(M_SS_pt->getObservedSupportSystemState(), this->m_operator, expecting_indication_bl);
 
      pu_pt = NULL;
      pu_pt = this->m_proximity->FindAProximityGroupUnitByOneMemberName(MR_SS_pt->m_Concept_ID_pt->m_ID);
    }
    //Clean this from the m_tbi_SS_list
    this->m_tbi_SS_list.erase(M_SS_itr);
    //add time consumption
    this->AddConsumptedDeltaT(this->m_Interpretation_time_consumption);
  } else {
    //PSF slot: idle time
    if (this->m_unresolved_investigator_pool.size() > 0) { this->m_RM_Token = rm::Prioritize; }
    else { this->m_RM_Token = rm::RoutineMonitor; }
  }
  //finish the current reading
  if (expecting_indication_bl == true) { this->m_reading_indication_ID_pt = NULL; }
 
  //Read the proximate indications
 
  if (pu_pt == NULL) { return; }
 
  for (str_itr = pu_pt->indication_concept_ID_list.begin(); str_itr != pu_pt->indication_concept_ID_list.end();
       str_itr++) {
    MR_name = *str_itr;
    if (MR_A_pt != NULL) {
      if (MR_A_pt->m_Concept_pt->m_ID.compare(MR_name) == 0) { continue; }
    }
    if (MR_P_pt != NULL) {
      if (MR_P_pt->m_Concept_ID_pt->m_ID.compare(MR_name) == 0) { continue; }
    }
    if (MR_C_pt != NULL) {
      if (MR_C_pt->m_Concept_ID_pt->m_ID.compare(MR_name) == 0) { continue; }
    }
    ID_pt = this->m_MR->CheckExistenceByConceptName(MR_name);
    if (ID_pt == NULL) { this->ErrorMessage("Error: could not find a MR unit for a proximity item: " + MR_name); }
 
    if (ID_pt->m_ID_Type == 201) {
      MR_P_pt2 = (MRParameterUnit *) ID_pt;
      if (MR_P_pt != NULL) {
        if (MR_P_pt->m_parameter_indicator_ID == indicator_name) {
          if (MR_P_pt2->m_parameter_indicator_ID.compare("NONE") != 0) {
            perceived_value = this->GetAParameterValueImediately(MR_P_pt2->m_parameter_indicator_ID);
            MR_P_pt2->AddNewValue(perceived_value, this->m_operator, false);
          }
        } else if (MR_P_pt->m_parameter_rate_indicator_ID == indicator_name) {
          if (MR_P_pt2->m_parameter_rate_indicator_ID.compare("NONE") != 0) {
            perceived_value = this->GetAParameterValueImediately(MR_P_pt2->m_parameter_rate_indicator_ID);
            MR_P_pt2->AddNewRate(perceived_value, this->m_operator, false);
          }
        }
      } else {
        perceived_value = this->GetAParameterValueImediately(MR_P_pt2->m_parameter_indicator_ID);
        MR_P_pt2->AddNewValue(perceived_value, this->m_operator, false);
      }
 
    } else if (ID_pt->m_ID_Type == 202) {
      MR_C_pt2 = (MRComponentStateUnit *) ID_pt;
      if (MR_C_pt2->m_CS_type == 0) {//state indication
        if (MR_C_pt2->Component_State_Indicator_ID.compare("NONE") != 0) {
          perceived_state = this->GetAComponentStateImediately(MR_C_pt2->Component_State_Indicator_ID);
          MR_C_pt2->AddNewState(perceived_state, this->m_operator, false);
        }
      } else if (MR_C_pt2->m_CS_type == 1) {//position indication
        if (MR_C_pt2->Control_Value_Indicator_ID.compare("NONE") != 0) {
          perceived_value = this->GetAParameterValueImediately(MR_C_pt2->Control_Value_Indicator_ID);
          MR_C_pt2->AddNewPositionValue(perceived_value, this->m_operator, false);
        }
      }
    } else if (ID_pt->m_ID_Type == 204) {
      MR_SS_pt2 = (MRSupportSystemStateUnit *) ID_pt;
      if (MR_SS_pt2->Support_System_State_Indicator_ID.compare("NONE") != 0) {
        perceived_state = this->GetASupportSystemStateImediately(MR_SS_pt2->Support_System_State_Indicator_ID);
        MR_SS_pt2->AddNewState(perceived_state, this->m_operator, false);
      }
    } else if (ID_pt->m_ID_Type == 203) {
      MR_A_pt2 = (MRAlarmUnit *) ID_pt;
      perceived_state = this->GetAlarmStateImediately(MR_A_pt2->m_alarm_indicator_name);
      MR_A_pt2->AddNewAlarmState(perceived_state, this->m_operator, false);
    }//to be added for the proximity of alarm position
 
    this->AddConsumptedDeltaT(1);
  }
}
 
void ReasonMachine::OneStepPrioritizeInvestigation30() {
  //Token 0030: Prioritize the unfinished Investigators and InvestigatorLinks and chose one
  //To be added
  IDElement *ID_pt;
  vector<IDElement *>::reverse_iterator ID_ritr;
  vector<string>::iterator str_itr;
 
  vector<StringTimeIntervalUnit *> recent_lines; //
 
  Investigator *newest_invest_pt = NULL;
  Investigator *current_invest_pt = NULL;
  Investigator *invest_in_early_line = NULL;
 
  Investigator *newest_invest_in_current_line = NULL;
  InvestigatorLink *newest_link_in_current_line = NULL;
 
  InvestigatorLink *current_link_pt = NULL;
  InvestigatorLink *link_in_early_line = NULL;
 
  int position_in_lines;
  int largest_position_in_lines = 0;
 
  Investigator *next_invest_pt = NULL;
  InvestigatorLink *next_invest_link_pt = NULL;
 
  Investigator *invest_pt = NULL;
  InvestigatorLink *link_pt = NULL;
 
  float invest_score, highest_invest_score = 0;
  float invest_link_score, highest_invest_link_score = 0;
 
  float newest_time = 0;
  float newest_link_time = 0;
 
  float link_time = 0;
  float invest_time = 0;
 
  bool use_neutral_style = false;
  bool added_bl = false;
  bool use_these_codes = true;
 
  int thought_line_distance;
  int investigation_distance;
 
  int smallest_line_distance = 0;
  int smallest_invest_distance = 0;
 
  int smallest_link_line_distance = 0;
  int smallest_link_invest_distance = 0;
 
  int n_Count;
  int i;
 
  bool compare_invest_distance;
  bool open_to_routine_monitor = false;
 
  stringstream conv;
 
  if (r5pars_.timesno > 948) { this->PrintMessage(""); }
 
  if (this->m_feedback_stack.size() > 0) {
    //depth first
    ID_ritr = this->m_feedback_stack.rbegin();
    ID_pt = *ID_ritr;
    if (ID_pt->m_ID == "Investigator_228") { this->PrintMessage(""); }
    switch (ID_pt->m_ID_Type) {
      case 301: this->m_working_on_invest_pt = (Investigator *) ID_pt;
        this->ChangeRMTokenValue(rm::WorkOnInvestigator);
        break;
      case 302: this->m_working_on_invest_link_pt = (InvestigatorLink *) ID_pt;
        this->ChangeRMTokenValue(rm::WorkOnInvestigatorLink);
        break;
      default:
        //error message
        break;
    }
    return;
  }
 
  this->DecayOfForgottenInvestigator();
  this->ZeroAllTheInterestFromSymptomInvestigator();
  this->m_event_schema_base->UpdateTheInterestForInvestigatorOrInvestigatorLink();
  this->m_event_schema_base->GenerateANewInvestigatorOrNot();
 
  if (this->m_problem_solving_style == ProblemSolvingStyle::GardenPath) {
    open_to_routine_monitor = false;
/*      open_to_routine_monitor = true;
        for(invest_itr = this->m_unresolved_investigator_pool.begin(); invest_itr != this->m_unresolved_investigator_pool.end() && open_to_routine_monitor == true; invest_itr++)
        {
            if((*invest_itr)->m_invest_dormant == true || (*invest_itr)->m_invest_pause == true)
            {continue;}
            if(this->WetherAnInvestigationItemBelongsToTheCurrentThoughtLine(*invest_itr) == true)
            {open_to_routine_monitor = false;}
        }
        for(invest_link_itr = this->m_investigator_link_pool.begin(); invest_link_itr != this->m_investigator_link_pool.end() && open_to_routine_monitor == true; invest_link_itr++)
        {
            if((*invest_link_itr)->m_invest_link_dormant == true || (*invest_link_itr)->m_invest_link_pause == true)
            {continue;}
            if(this->WetherAnInvestigationItemBelongsToTheCurrentThoughtLine(*invest_link_itr) == true)
            {open_to_routine_monitor = false;}
        }
*/    }
 
  if (this->m_problem_solving_style == ProblemSolvingStyle::Vagabond) {
    //fill the recent thought line list for Vagabond style
    if (this->m_current_thought_line_info != nullptr) { recent_lines.push_back(this->m_current_thought_line_info.get()); }
    auto line_ritr1 = this->m_thought_line_history.rbegin();
    i = 0;
    while (i <= this->m_memory_span
        && line_ritr1 != this->m_thought_line_history.rend()) {//these codes are for Vagabond style
      //push this back to the recent line list if new to the list
      added_bl = false;
      auto line_itr2 = recent_lines.begin();
      while (line_itr2 != recent_lines.end() && added_bl == false) {
        if ((*line_ritr1)->CompareThisUnitWithAnotherStringTimeIntervalUnitOnThoughtLineList(*line_itr2) == true) {
          added_bl = true;
        }
        line_itr2++;
      }
      if (added_bl == false) {
        recent_lines.push_back(line_ritr1->get());// ealier position means more recent line
        if ((*line_ritr1)->m_interrupted_bl == true) {
          i++;
        } else {
          if ((*line_ritr1)->m_interval_end - (*line_ritr1)->m_interval_start > 0) { i++; }
        }
      }
      line_ritr1++;
    }
  }
 
  //These codes are for HamletB style
  if (this->m_problem_solving_style == ProblemSolvingStyle::HamletB) {
    for (str_itr = this->m_ongoing_item_stack.begin();
         str_itr != this->m_ongoing_item_stack.end() && next_invest_pt == NULL && next_invest_link_pt == NULL;
         str_itr++) {
      invest_pt = this->FindInvestigatorByID(*str_itr);
      if (invest_pt != NULL) {
        invest_score = invest_pt->CalculateFilteredPrioritizingScoreOfInvestigator();
        if (invest_score != 0 && invest_pt->m_investigator_token == inv::RetrieveNextLink) {
          next_invest_pt = invest_pt;
        }
        continue;
      }
 
    }
 
    /* for test, restore this will get back to the old stable codes
        for(str_itr = this->m_ongoing_item_stack.begin(); str_itr != this->m_ongoing_item_stack.end() && next_invest_pt == NULL && next_invest_link_pt == NULL; str_itr++)
        {
            invest_pt = this->FindInvestigatorByID(*str_itr);
            if(invest_pt != NULL)
            {
                invest_score = invest_pt->CalculateFilteredPrioritizingScoreOfInvestigator();
                if(invest_score != 0)
                {next_invest_pt = invest_pt;}
                continue;
            }
 
            link_pt = this->FindInvestigatorLinkByID(*str_itr);
            if(link_pt != NULL)
            {
                if(link_pt->m_forgotten_bl == true)
                {continue;}
                invest_link_score = link_pt->CalculateFilteredPrioritizingScoreOfInvestigatorLink();
                if(invest_link_score != 0)
                {next_invest_link_pt = link_pt;}
                continue;
            }
            else
            {this->ErrorMessage("unable to identify this item " + *str_itr);}
        }
        */
 
    if (next_invest_pt != NULL || next_invest_link_pt != NULL) { use_these_codes = false; }
    else {
      use_these_codes = true;
      use_neutral_style = true;
      if (this->m_unresolved_investigator_pool.size() == 0
          || this->m_routine_monitor->GetTheLongestIntervalRatio() > 3) {
        open_to_routine_monitor = true;
      }//normally conduct routine monitor when the operator finishes his investigation. But do the routine monitor if it has been a long while not checking an  indication
    }
  }
 
  if (this->m_unresolved_investigator_pool.size() == 0) {
    if (this->m_routine_monitor->GetTheLongestIntervalRatio() < 1) { this->NotDoingAnything(); }
    else { this->ChangeRMTokenValue(rm::RoutineMonitor); }
    return;
  }
 
  if (open_to_routine_monitor == true && this->m_routine_monitor->GetTheLongestIntervalRatio() >= 1) {
    this->ChangeRMTokenValue(rm::RoutineMonitor);
    return;
  }
 
  //
  /*
    Prioritization Factors:
    1, activation level
    2, interest from the event schema
    3, whether it is following the same thought line
    4, whether it is a thougth line newly generated
    5, depth first or width first
    6,
    */
  //if(this->m_problem_solving_style == HAMLET || this->m_problem_solving_style == NEUTRAL)
  if (this->m_problem_solving_style == ProblemSolvingStyle::Neutral) {
    use_neutral_style = true;
  } else if (this->m_problem_solving_style == ProblemSolvingStyle::GardenPath) {
    if (this->m_current_thought_line_info == nullptr) { use_neutral_style = true; }
    else if (this->m_current_investigation_info == nullptr) {
      use_neutral_style = true;
    }
  } else if (this->m_problem_solving_style == ProblemSolvingStyle::Hamlet) { use_neutral_style = false; }
 
  if (this->m_working_on_invest_pt != NULL) {
    if (this->m_working_on_invest_pt->m_ID == "Investigator_224" && r5pars_.timesno > 1191) { this->PrintMessage(""); }
  }
 
  n_Count = 0;
 
  for (auto invest_itr = this->m_unresolved_investigator_pool.begin();
       invest_itr != this->m_unresolved_investigator_pool.end() && use_these_codes == true; invest_itr++) {
    if ((*invest_itr)->m_ID == "Investigator_3") { this->PrintMessage(""); }
 
    invest_score = (*invest_itr)->CalculateFilteredPrioritizingScoreOfInvestigator();
    if (invest_score == 0) { continue; }
    //modify this score
    /*if(this->m_problem_solving_style == HAMLET)
        {
            if((*invest_itr) == this->m_working_on_invest_pt)
            {invest_score *= 1.2;}
            else if(this->FindThePositionInTheThoughtLineHistory((IDElement*)(*invest_itr)) == 1)
            {invest_score *= 1.5;}
        }
        else if(this->m_problem_solving_style == VAGABOND)
        {
            if((*invest_itr) == this->m_working_on_invest_pt)
            {invest_score *= 0.8;}
        }*/
 
    n_Count++;
    if ((*invest_itr)->m_ID == "Investigator_221") { this->PrintMessage(""); }
 
    switch (this->m_problem_solving_style) {
      case ProblemSolvingStyle::Vagabond:
        //the priority order of Vagabond style
        //1--new coming phenomenal, active time > the current investigation line start time
        //2--current investigation within attention span
        //3--if the current investigation is out of attention span. Shifts to the newest uninvestigated item
        //4--the item has the largest position in the recent lines. newest of the euqal lines
        //5--the current item that is out of attention span
        if ((((*invest_itr)->m_downstream_ID_list.size() == 0 || (*invest_itr)->m_motivation == 1) &&
            ((*invest_itr)->m_investigator_token == inv::GetCorrespondingKE || (*invest_itr)->m_investigator_token == inv::FindMatchingStatement))
            || ((*invest_itr)->m_investigator_token == 3012
                && (*invest_itr)->m_investigator_token_history.size() == 0)) {// find the newest original invest
          invest_time = (*invest_itr)->GetInitiationTimeOrStatementTimeOrLastActiveTime();
          if (invest_time > newest_time) {
            newest_time = invest_time;
            newest_invest_pt = (*invest_itr);
          }
        } else {
          //for other investigators which have been started already, find the position in the recent thougth lines
          //the decay of the investigators is seperate from the inclusion in the recent thougth lines
          //find the position in the recent thought line
          if ((*invest_itr) == this->m_working_on_invest_pt) {
            current_invest_pt = (*invest_itr);
            newest_invest_in_current_line = current_invest_pt;
            break;
          }
 
          auto line_itr2 = recent_lines.begin();
          position_in_lines = 0;
          i = 1;
          while (line_itr2 != recent_lines.end() && position_in_lines == 0) {
            if ((*line_itr2)->CheckWhetherContainsAnItemInTheThoughtLine((IDElement *) (*invest_itr)) == true) {
              position_in_lines = i;
            }
            i++;
            line_itr2++;
          }
 
          if (position_in_lines == 1 && current_invest_pt == NULL) {
            if (newest_invest_in_current_line == NULL) { newest_invest_in_current_line = *invest_itr; }
            else if ((*invest_itr)->GetInitiationTimeOrStatementTimeOrLastActiveTime()
                > newest_invest_in_current_line->GetInitiationTimeOrStatementTimeOrLastActiveTime()) {
              newest_invest_in_current_line = *invest_itr;
            }
          }
 
          if (position_in_lines > largest_position_in_lines) {
            largest_position_in_lines = position_in_lines;
            invest_in_early_line = *invest_itr;
          } else if (position_in_lines != 0 && position_in_lines == largest_position_in_lines) {
            if ((*invest_itr)->GetInitiationTimeOrStatementTimeOrLastActiveTime()
                > invest_in_early_line->GetInitiationTimeOrStatementTimeOrLastActiveTime()) {
              largest_position_in_lines = position_in_lines;
              invest_in_early_line = *invest_itr;
            }
          }
        }
        break;
 
      case ProblemSolvingStyle::Hamlet:
      case ProblemSolvingStyle::GardenPath:
        if (use_neutral_style == false) {
          compare_invest_distance = false;
          thought_line_distance = this->FindThePositionInTheThoughtLineHistory((IDElement *) (*invest_itr));
          investigation_distance = this->FindThePositionInTheInvestigationHistory((*invest_itr)->m_ID);
          if (smallest_line_distance == 0) {
            if (thought_line_distance > 0 || next_invest_pt == NULL) {//switch
              smallest_line_distance = thought_line_distance;
              smallest_invest_distance = investigation_distance;
              next_invest_pt = (*invest_itr);
              highest_invest_score = invest_score;
            } else { compare_invest_distance = true; }
          } else {
            if (thought_line_distance > 0) {
              if (thought_line_distance < smallest_line_distance) {//switch
                smallest_link_line_distance = thought_line_distance;
                smallest_invest_distance = investigation_distance;
                next_invest_pt = (*invest_itr);
                highest_invest_score = invest_score;
              } else if (thought_line_distance == smallest_line_distance) { compare_invest_distance = true; }
            }
          }
 
          if (compare_invest_distance == true) {
            if (investigation_distance == smallest_invest_distance || next_invest_pt == NULL) {
              if (invest_score > highest_invest_score) {
                smallest_line_distance = thought_line_distance;
                smallest_invest_distance = investigation_distance;
                next_invest_pt = (*invest_itr);
                highest_invest_score = invest_score;
              }
            } else if (smallest_invest_distance == 0 || investigation_distance < smallest_invest_distance) {
              smallest_line_distance = thought_line_distance;
              smallest_invest_distance = investigation_distance;
              next_invest_pt = (*invest_itr);
              highest_invest_score = invest_score;
            }
          }
        }
        break;
      case ProblemSolvingStyle::HamletB: thought_line_distance = this->FindThePositionInTheThoughtLineHistory((IDElement *) (*invest_itr));
        if (thought_line_distance == 1) {
          invest_score *= 1 + exp(-0.128 * (18 / this->m_attention_span) * (r5pars_.timesno
              - this->m_current_thought_line_info->m_interval_start));
        }
        break;
      case ProblemSolvingStyle::Neutral: break;
    }
 
    if (use_neutral_style == true) {
      if (invest_score > highest_invest_score) {
        next_invest_pt = (*invest_itr);
        highest_invest_score = invest_score;
      }
    }
  }
 
  newest_link_time = 0;
  for (auto invest_link_itr = this->m_investigator_link_pool.begin();
       invest_link_itr != this->m_investigator_link_pool.end() && use_these_codes == true; invest_link_itr++) {
    if ((*invest_link_itr)->m_ID == "InvestigatorLink_64") { this->PrintMessage("check"); }
    if ((*invest_link_itr)->m_forgotten_bl == true) { continue; }
    invest_link_score = (*invest_link_itr)->CalculateFilteredPrioritizingScoreOfInvestigatorLink();
    if (invest_link_score == 0) { continue; }
    n_Count++;
 
    switch (this->m_problem_solving_style) {
      case ProblemSolvingStyle::Vagabond: {
 
        if (invest_link_itr->get() == this->m_working_on_invest_link_pt) {
          current_link_pt = invest_link_itr->get();
          newest_link_in_current_line = current_link_pt;
          break;
        }
 
        auto line_itr2 = recent_lines.begin();
        position_in_lines = 0;
        i = 1;
        while (line_itr2 != recent_lines.end() && position_in_lines == 0) {
          if ((*line_itr2)->CheckWhetherContainsAnItemInTheThoughtLine((IDElement *) invest_link_itr->get()) == true) {
            position_in_lines = i;
          }
          i++;
          line_itr2++;
        }
        if (position_in_lines == 1 && current_invest_pt == NULL && current_link_pt == NULL) {
          if (newest_link_in_current_line != NULL) {
            if ((*invest_link_itr)->GetDownstreamInitiationTimeOrStatementTime()
                > newest_link_in_current_line->GetDownstreamInitiationTimeOrStatementTime()) {
              newest_link_in_current_line = invest_link_itr->get();
            }
          } else if (newest_invest_in_current_line != NULL) {
            if ((*invest_link_itr)->GetDownstreamInitiationTimeOrStatementTime()
                > newest_invest_in_current_line->GetInitiationTimeOrStatementTimeOrLastActiveTime()) {
              newest_link_in_current_line = invest_link_itr->get();
            }
          } else { newest_link_in_current_line = invest_link_itr->get(); }
        }
        if (position_in_lines > largest_position_in_lines) {
          largest_position_in_lines = position_in_lines;
          link_in_early_line = invest_link_itr->get();
        } else if (position_in_lines != 0 && position_in_lines == largest_position_in_lines) {
          if (link_in_early_line != NULL) {
            if ((*invest_link_itr)->GetDownstreamInitiationTimeOrStatementTime()
                > link_in_early_line->GetDownstreamInitiationTimeOrStatementTime()) {
              largest_position_in_lines = position_in_lines;
              link_in_early_line = invest_link_itr->get();
            }
          } else if (invest_in_early_line != NULL) {
            if ((*invest_link_itr)->GetDownstreamInitiationTimeOrStatementTime()
                > invest_in_early_line->GetInitiationTimeOrStatementTimeOrLastActiveTime()) {
              largest_position_in_lines = position_in_lines;
              link_in_early_line = invest_link_itr->get();
            }
          }
        }
 
        /*link_time = (*invest_link_itr)->GetDownstreamInitiationTimeOrStatementTime();
            if(link_time > newest_link_time)
            {
                next_invest_link_pt = (*invest_link_itr);
                newest_link_time = link_time;
            }*/
        break;
      }
      case ProblemSolvingStyle::Hamlet:
      case ProblemSolvingStyle::GardenPath:
        if (use_neutral_style == false) {
          compare_invest_distance = false;
          thought_line_distance = this->FindThePositionInTheThoughtLineHistory((IDElement *) invest_link_itr->get());
          investigation_distance = this->FindThePositionInTheInvestigationHistory((*invest_link_itr)->m_ID);
          if (smallest_link_line_distance == 0) {
            if (thought_line_distance > 0 || next_invest_link_pt == NULL) {//switch
              smallest_link_line_distance = thought_line_distance;
              smallest_link_invest_distance = investigation_distance;
              next_invest_link_pt = invest_link_itr->get();
              highest_invest_link_score = invest_link_score;
            } else { compare_invest_distance = true; }
          } else {
            if (thought_line_distance > 0) {
              if (thought_line_distance < smallest_link_line_distance) {//switch
                smallest_link_line_distance = thought_line_distance;
                smallest_link_invest_distance = investigation_distance;
                next_invest_link_pt = invest_link_itr->get();
                highest_invest_link_score = invest_link_score;
              } else if (thought_line_distance == smallest_link_line_distance) { compare_invest_distance = true; }
            }
          }
 
          if (compare_invest_distance == true) {
            if (smallest_link_invest_distance)
              investigation_distance = this->FindThePositionInTheInvestigationHistory((*invest_link_itr)->m_ID);
            if (investigation_distance == smallest_link_invest_distance || next_invest_link_pt == NULL) {
              if (invest_link_score > highest_invest_link_score) {
                smallest_link_line_distance = thought_line_distance;
                smallest_link_invest_distance = investigation_distance;
                next_invest_link_pt = invest_link_itr->get();
                highest_invest_link_score = invest_link_score;
              }
            } else if (smallest_link_invest_distance == 0 || investigation_distance < smallest_link_invest_distance) {
              smallest_link_line_distance = thought_line_distance;
              smallest_link_invest_distance = investigation_distance;
              next_invest_link_pt = invest_link_itr->get();
              highest_invest_link_score = invest_link_score;
            }
          }
        }
        break;
      case ProblemSolvingStyle::Neutral: break;
    }
    //
    if (use_neutral_style == true) {
      if (invest_link_score > highest_invest_link_score) {
        next_invest_link_pt = invest_link_itr->get();
        highest_invest_link_score = invest_link_score;
      }
    }
 
  }
 
  int selection = 0;
 
 
 
/*  if(this->m_problem_solving_style == HAMLET)
    {
        if(max(highest_invest_score, highest_invest_link_score) < this->m_routine_monitor->GetTheLongestIntervalRatio()/this->m_routine_monitor_threshold)
        {
            this->m_working_on_invest_link_pt = NULL;
            this->m_working_on_invest_pt = NULL;
            this->ChangeRMTokenValue(rm::RoutineMonitor);
            return;
        }
    }*/
  bool move_to_next = true;
  if (this->m_problem_solving_style == ProblemSolvingStyle::Vagabond) {
    open_to_routine_monitor = false;
    if (newest_invest_pt == NULL && this->m_current_thought_line_info == nullptr) {
      next_invest_pt = NULL;
      next_invest_link_pt = NULL;
      move_to_next = false;
    }
 
    if (move_to_next == true && newest_invest_pt != NULL) {//priority 1
      if (this->m_current_thought_line_info == nullptr) {
        next_invest_pt = newest_invest_pt;
        next_invest_link_pt = NULL;
        move_to_next = false;
      } else if (newest_invest_pt->GetInitiationTimeOrStatementTimeOrLastActiveTime()
          > this->m_current_thought_line_info->m_interval_start) {
        next_invest_pt = newest_invest_pt;
        next_invest_link_pt = NULL;
        move_to_next = false;
      }
    }
 
    if (move_to_next == true && (r5pars_.timesno - this->m_current_thought_line_info->m_interval_start
        < this->m_attention_span)) {//priority 2, the current investigation line is still within bound
      //if(current_invest_pt != NULL)
 
      if (newest_link_in_current_line != NULL) {
        next_invest_pt = NULL;
        next_invest_link_pt = newest_link_in_current_line;
        move_to_next = false;
      } else if (newest_invest_in_current_line != NULL) {
        next_invest_pt = newest_invest_in_current_line;
        next_invest_link_pt = NULL;
        move_to_next = false;
      }
    }
 
    if (move_to_next == true) { open_to_routine_monitor = true; }
    if (move_to_next == true && newest_invest_pt != NULL) {//priority 3, investigate a new item
      next_invest_pt = newest_invest_pt;
      next_invest_link_pt = NULL;
      move_to_next = false;
    }
 
    if (move_to_next == true && largest_position_in_lines != 0) {//priority 4, investigate an early thought line
      if (link_in_early_line != NULL) {
        next_invest_pt = NULL;
        next_invest_link_pt = link_in_early_line;
        move_to_next = false;
 
      } else if (invest_in_early_line != NULL) {
        next_invest_pt = invest_in_early_line;
        next_invest_link_pt = NULL;
        move_to_next = false;
      }
    }
 
    if (move_to_next == true) {//priority 5, continue to work on the current line
      if (newest_link_in_current_line != NULL) {
        next_invest_pt = NULL;
        next_invest_link_pt = newest_link_in_current_line;
        move_to_next = false;
      } else if (newest_invest_in_current_line != NULL) {
        next_invest_pt = newest_invest_in_current_line;
        next_invest_link_pt = NULL;
        move_to_next = false;
      }
    }
  }
 
  if (next_invest_link_pt == NULL && next_invest_pt == NULL) {
    //HAMELET_B only conduct routine monitor when he finish his current task
 
    this->m_working_on_invest_link_pt = NULL;
    this->m_working_on_invest_pt = NULL;
    if (this->m_routine_monitor->GetTheLongestIntervalRatio() < 1) { this->NotDoingAnything(); }
    else { this->ChangeRMTokenValue(rm::RoutineMonitor); }
    return;
  }
 
  if (next_invest_link_pt == NULL) { selection = 1; }
  else if (next_invest_pt == NULL) { selection = 2; }
  else {
    if (use_neutral_style == true) {
      if (highest_invest_score > highest_invest_link_score) { selection = 1; }
      else { selection = 2; }
    } else if (this->m_problem_solving_style == ProblemSolvingStyle::Vagabond) {
      if (newest_time > newest_link_time) { selection = 1; }
      else { selection = 2; }
    } else if (this->m_problem_solving_style == ProblemSolvingStyle::GardenPath || this->m_problem_solving_style == ProblemSolvingStyle::Hamlet) {
      compare_invest_distance = false;
      if (smallest_line_distance == smallest_link_line_distance) { compare_invest_distance = true; }
      else if (smallest_link_line_distance == 0) { selection = 1; }
      else if (smallest_line_distance == 0) { selection = 2; }
      else if (smallest_line_distance < smallest_link_invest_distance) { selection = 1; }
      else if (smallest_line_distance > smallest_link_invest_distance) { selection = 2; }
 
      if (compare_invest_distance == true) {
        if (smallest_invest_distance == smallest_link_invest_distance) {
          if (highest_invest_score > highest_invest_link_score) { selection = 1; }
          else { selection = 2; }
        } else if (smallest_invest_distance == 0) { selection = 2; }
        else if (smallest_link_invest_distance == 0) { selection = 1; }
        else if (smallest_invest_distance < smallest_link_invest_distance) { selection = 1; }
        else { selection = 2; }
      }
    } else { this->ErrorMessage("Unrecongnized problem solving style"); }
  }
 
  if (selection == 1) {
    conv.str("");
    conv << highest_invest_score;
    this->WriteAuxInfo("Prioritization Score: " + conv.str());
    this->m_working_on_invest_pt = next_invest_pt;
    this->m_working_on_invest_link_pt = NULL;
    this->ChangeRMTokenValue(rm::WorkOnInvestigator);
  } else if (selection == 2) {
    conv.str("");
    conv << highest_invest_link_score;
    this->WriteAuxInfo("Prioritization Score: " + conv.str());
    this->m_working_on_invest_link_pt = next_invest_link_pt;
    this->m_working_on_invest_pt = NULL;
    this->ChangeRMTokenValue(rm::WorkOnInvestigatorLink);
  }
}
 
void ReasonMachine::OneStepWorkOnSelectedInvestigator3000() {
  //Token 3000: work on a specified Investigator
  //To be added
  vector<string>::iterator str_itr;
  string line_ID;
  SentenceUnit *sent_pt;
  vector<IDElement *>::iterator ID_itr;
  sent_pt = this->m_working_on_invest_pt->GetSemanticSentenceOfThisInvestigator();
  bool exist_bl = false;
 
  this->m_goofy_start_time = 0;
 
  if (sent_pt->m_activation < 1) {
    this->CrankASentenceUnitActivationToAGivenValue(sent_pt, 1.0);
  }
  if (this->m_working_on_invest_pt != NULL) {
    //check point
    if (this->m_working_on_invest_pt->m_ID == "Investigator_22") { this->PrintMessage("check"); }
 
    //update thought line info
    if (this->m_current_thought_line_info == nullptr) {
      this->m_current_thought_line_info = make_unique<StringTimeIntervalUnit>();
      this->m_current_thought_line_info->m_interval_start = r5pars_.timesno;
      if (this->m_working_on_invest_pt->m_root_of_a_thought_line == true) {
        this->m_current_thought_line_info->m_thought_line_list.push_back(this->m_working_on_invest_pt->m_ID);
      }
      for (str_itr = this->m_working_on_invest_pt->m_thoughtline_roots_list.begin();
           str_itr != this->m_working_on_invest_pt->m_thoughtline_roots_list.end(); str_itr++) {
        line_ID = *str_itr;
        this->m_current_thought_line_info->m_thought_line_list.push_back(line_ID);
      }
    } else {
      this->CheckWhetherTheThoughtLineHasChanged(); //line update has to be earlier than the investigation info updates
    }
 
    //update investigation info
    if (this->m_current_investigation_info == nullptr) {
      this->m_current_investigation_info = make_unique<StringTimeIntervalUnit>();
      this->m_current_investigation_info->m_interval_start = r5pars_.timesno;
      this->m_current_investigation_info->m_name = this->m_working_on_invest_pt->m_ID;
    } else {
      if (this->m_working_on_invest_pt->m_investigator_token != inv::EvaluateNewFeedback) {
        if (this->m_working_on_invest_pt->m_ID.compare(this->m_current_investigation_info->m_name) != 0) {
          this->m_current_investigation_info->m_interval_end = r5pars_.timesno;
          this->m_investigation_history.push_back(std::move(this->m_current_investigation_info));
 
          this->m_current_investigation_info = make_unique<StringTimeIntervalUnit>();
          this->m_current_investigation_info->m_interval_start = r5pars_.timesno;
          this->m_current_investigation_info->m_name = this->m_working_on_invest_pt->m_ID;
        }
      }
    }
 
    if (this->m_problem_solving_style == ProblemSolvingStyle::HamletB) {
      this->AddItemToOngoingItemStack(this->m_working_on_invest_pt->m_ID);
    }
    //
    this->m_working_on_invest_pt->OneStepWorkOnThisInvestigator();
  } else {}//error message
}
 
void ReasonMachine::OneStepWorkOnSelectedInvestigatorLink3100() {
  //Token 3100: work on a specified InvestigatorLink
  //To be added
  vector<string>::iterator str_itr;
  string line_ID;
 
  if (this->m_working_on_invest_link_pt != NULL) {
    this->m_goofy_start_time = 0;
 
    //update thought line info
    if (this->m_current_thought_line_info == nullptr) {
      this->m_current_thought_line_info = make_unique<StringTimeIntervalUnit>();
      this->m_current_thought_line_info->m_interval_start = r5pars_.timesno;
      for (str_itr = this->m_working_on_invest_link_pt->m_thoughtline_roots_list.begin();
           str_itr != this->m_working_on_invest_link_pt->m_thoughtline_roots_list.end(); str_itr++) {
        line_ID = *str_itr;
        this->m_current_thought_line_info->m_thought_line_list.push_back(line_ID);
      }
    } else {
      this->CheckWhetherTheThoughtLineHasChanged();
    }
    //update investigation info
    if (this->m_current_investigation_info == nullptr) {
      this->m_current_investigation_info = make_unique<StringTimeIntervalUnit>();
      this->m_current_investigation_info->m_interval_start = r5pars_.timesno;
      this->m_current_investigation_info->m_name = this->m_working_on_invest_link_pt->m_ID;
    } else {
      if (this->m_working_on_invest_link_pt->m_invest_link_Token != inv_link::CheckPathStatus) {
        if (this->m_working_on_invest_link_pt->m_ID.compare(this->m_current_investigation_info->m_name) != 0) {
          this->m_current_investigation_info->m_interval_end = r5pars_.timesno;
          this->m_investigation_history.push_back(std::move(this->m_current_investigation_info));
 
          this->m_current_investigation_info = make_unique<StringTimeIntervalUnit>();
          this->m_current_investigation_info->m_interval_start = r5pars_.timesno;
          this->m_current_investigation_info->m_name = this->m_working_on_invest_link_pt->m_ID;
        }
      }
    }
    this->AddItemToOngoingItemStack(this->m_working_on_invest_link_pt->m_ID);
    //
    this->m_working_on_invest_link_pt->OneStepWorkOnThisInvestigatorLink();
  } else {}//error message
}
 
void ReasonMachine::EraseItemFromFeedbackStack(IDElement *_ID_pt) {
  bool finished = false;
  vector<IDElement *>::iterator ID_itr;
  for (ID_itr = this->m_feedback_stack.begin(); ID_itr != this->m_feedback_stack.end(); ID_itr++) {
    if ((*ID_itr) == _ID_pt) {
      this->m_feedback_stack.erase(ID_itr);
      break;
    }
  }
}
 
void ReasonMachine::InitiationOfReasonMachineFromInputFile() {
 
  if (this->m_operator == 0) {}//error message: the m_operator has not been initiated
 
  this->m_passive_alarm_load = make_unique<PassiveAlarmLoadUnit>();
 
  //
  this->ReadOperatorReasonMachineProfile();
 
  //initiate the concept base
  this->m_Concept_Base->m_operator = this->m_operator;
  this->m_Concept_Base->ReadKBConceptInfoFromInputFile();
  this->m_Concept_Base->ReadAntonymBaseFromInputFile();
 
  //initiate the Instantiation Base
  this->m_IB->m_operator = this->m_operator;
  this->m_IB->ReadInstantiationBaseFromInputFile();
 
  //initiate the mental representation m_MR
  this->m_MR->m_operator = this->m_operator;
  this->m_MR->ReadMentalRepresentationtInfoFromInputFile();
 
  //initiate the m_Semantic_list
  this->ReadSemanticSentencesFromInputFile();
  this->PrintSemanticBase();
 
  //initiate the KnowledgeUnitBase
  this->ReadKnowledgeBaseFromInputFile();
 
  //initiate the EventSchemaBase
  this->m_event_schema_base->m_operator = this->m_operator;
  this->m_event_schema_base->ReadEventSchemaBaseFromInputFile();
 
  //initiate the Routine Monitor
  this->m_routine_monitor->m_operator = this->m_operator;
  this->m_routine_monitor->ReadRoutineMonitorInforFromInputFile();
 
  //initiate the Proximity Models
  this->m_proximity = make_unique<ProximityModel>();
  this->m_proximity->m_operator = this->m_operator;
  this->m_proximity->ReadProximityModelFromInputFile();
 
  //
  if (this->m_operator == sim::Operator::ODM) {
    this->m_time_constraint = &(g_sim.Decision_Maker.time_constrained_load);
  } else {
    this->m_time_constraint = &(g_sim.Action_Taker.time_constrained_load);
  }
  //
  this->ConvertRMStaticInfoToStringForm();
  this->RandomlyGenerateKnowledgeBug();
 
  this->PrintKnowledgeWeb();
}
 
void ReasonMachine::ReadSemanticSentencesFromInputFile() {
  string directory, str, str1, str2, str_ID, file_name;
  ifstream fin;
  int n_Unit, i;
  unique_ptr<SentenceUnit> sent_pt;
  unique_ptr<SentenceUnit> sent2_pt;
  IDElement *ID_pt;
  string err_mes;
  stringstream conv;
 
  //Automatically create some sentences based on the Mental Representation
  string ID_name;
  IDElement *ID_X_pt;
  vector<IDElement *> processed_X_list;
  vector<IDElement *>::iterator ID_X_itr;
  bool for_X_bl;
  Label label_pt;
  Label label_obj_pt;
  Instantiation *Inst_pt;
  Instantiation *Inst_obj_pt;
  ConceptComposedUnit *CC_pt;
  ConceptComposedUnit *CC_obj_pt;
 
  for (size_t MR_P_idx = 1; MR_P_idx < this->m_MR->m_MRParameter_list.size(); MR_P_idx++) {
    auto &MR_P_pt = this->m_MR->m_MRParameter_list[MR_P_idx];
    for_X_bl = false;
    ID_X_pt = NULL;
 
    if (MR_P_pt->m_Concept_ID_pt->m_ID_Type == 002) {
      CC_pt = (ConceptComposedUnit *) (MR_P_pt->m_Concept_ID_pt);
      ID_X_pt = CC_pt->m_Indefinite_Concept_ID_pt;
    }
    if (ID_X_pt != NULL) {
      for_X_bl = true;
      for (ID_X_itr = processed_X_list.begin(); ID_X_itr != processed_X_list.end() && for_X_bl == true; ID_X_itr++) {
        if ((*ID_X_itr) == ID_X_pt) {
          for_X_bl = false;
        }
      }
      if (for_X_bl == true) {
        processed_X_list.push_back(ID_X_pt);
      }
    }
 
    sent_pt = make_unique<SentenceUnit>();
    sent_pt->m_ID = MR_P_pt->m_Concept_ID_pt->m_ID + "_increase";
    sent_pt->m_sentence_type = 1;
    sent_pt->m_subject_pt = MR_P_pt->m_Concept_ID_pt;
    sent_pt->m_process_pt = this->m_Concept_Base->getIncreasePt();
    this->m_Semantic_list.push_back(std::move(sent_pt));
 
    sent_pt = make_unique<SentenceUnit>();
    sent_pt->m_ID = MR_P_pt->m_Concept_ID_pt->m_ID + "_decrease";
    sent_pt->m_sentence_type = 1;
    sent_pt->m_subject_pt = MR_P_pt->m_Concept_ID_pt;
    sent_pt->m_process_pt = this->m_Concept_Base->getDecreasePt();
    this->m_Semantic_list.push_back(std::move(sent_pt));
 
    sent_pt = make_unique<SentenceUnit>();
    sent_pt->m_ID = MR_P_pt->m_Concept_ID_pt->m_ID + "_stable";
    sent_pt->m_sentence_type = 1;
    sent_pt->m_subject_pt = MR_P_pt->m_Concept_ID_pt;
    sent_pt->m_process_pt = this->m_Concept_Base->getStablePt();
    this->m_Semantic_list.push_back(std::move(sent_pt));
 
    if (for_X_bl == true) {
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = ID_X_pt->m_ID + "_increase";
      sent_pt->m_sentence_type = 1;
      sent_pt->m_subject_pt = ID_X_pt;
      sent_pt->m_process_pt = this->m_Concept_Base->getIncreasePt();
      this->m_Semantic_list.push_back(std::move(sent_pt));
 
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = ID_X_pt->m_ID + "_decrease";
      sent_pt->m_sentence_type = 1;
      sent_pt->m_subject_pt = ID_X_pt;
      sent_pt->m_process_pt = this->m_Concept_Base->getDecreasePt();
      this->m_Semantic_list.push_back(std::move(sent_pt));
 
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = ID_X_pt->m_ID + "_stable";
      sent_pt->m_sentence_type = 1;
      sent_pt->m_subject_pt = ID_X_pt;
      sent_pt->m_process_pt = this->m_Concept_Base->getStablePt();
      this->m_Semantic_list.push_back(std::move(sent_pt));
    }
  }
 
  for (auto &MR_C_pt : this->m_MR->m_MRComponent_list) {
    for_X_bl = false;
    ID_X_pt = NULL;
    if (MR_C_pt->m_Concept_ID_pt->m_ID_Type == 002) {
      CC_pt = (ConceptComposedUnit *) (MR_C_pt->m_Concept_ID_pt);
      ID_X_pt = CC_pt->m_Indefinite_Concept_ID_pt;
    }
    if (ID_X_pt != NULL) {
      for_X_bl = true;
      for (ID_X_itr = processed_X_list.begin(); ID_X_itr != processed_X_list.end() && for_X_bl == true; ID_X_itr++) {
        if ((*ID_X_itr) == ID_X_pt) {
          for_X_bl = false;
        }
      }
      if (for_X_bl == true) {
        processed_X_list.push_back(ID_X_pt);
      }
    }
 
    if (MR_C_pt->m_CS_type == 0) {
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = MR_C_pt->m_Concept_ID_pt->m_ID + "_ON";
      sent_pt->m_sentence_type = 2;
      sent_pt->m_subject_pt = MR_C_pt->m_Concept_ID_pt;
      sent_pt->m_state_pt = this->m_Concept_Base->getONpt();
      this->m_Semantic_list.push_back(std::move(sent_pt));
 
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = MR_C_pt->m_Concept_ID_pt->m_ID + "_OFF";
      sent_pt->m_sentence_type = 2;
      sent_pt->m_subject_pt = MR_C_pt->m_Concept_ID_pt;
      sent_pt->m_state_pt = this->m_Concept_Base->getOFFpt();
      this->m_Semantic_list.push_back(std::move(sent_pt));
 
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = MR_C_pt->m_Concept_ID_pt->m_ID + "_turn_on";
      sent_pt->m_sentence_type = 1;
      sent_pt->m_subject_pt = MR_C_pt->m_Concept_ID_pt;
      sent_pt->m_process_pt = this->m_Concept_Base->getTurnOnPt();
      this->m_Semantic_list.push_back(std::move(sent_pt));
 
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = MR_C_pt->m_Concept_ID_pt->m_ID + "_turn_off";
      sent_pt->m_sentence_type = 1;
      sent_pt->m_subject_pt = MR_C_pt->m_Concept_ID_pt;
      sent_pt->m_process_pt = this->m_Concept_Base->getTurnOffPt();
      this->m_Semantic_list.push_back(std::move(sent_pt));
 
      if (for_X_bl == true) {
        sent_pt = make_unique<SentenceUnit>();
        sent_pt->m_ID = ID_X_pt->m_ID + "_ON";
        sent_pt->m_sentence_type = 2;
        sent_pt->m_subject_pt = ID_X_pt;
        sent_pt->m_state_pt = this->m_Concept_Base->getONpt();
        this->m_Semantic_list.push_back(std::move(sent_pt));
 
        sent_pt = make_unique<SentenceUnit>();
        sent_pt->m_ID = ID_X_pt->m_ID + "_OFF";
        sent_pt->m_sentence_type = 2;
        sent_pt->m_subject_pt = ID_X_pt;
        sent_pt->m_state_pt = this->m_Concept_Base->getOFFpt();
        this->m_Semantic_list.push_back(std::move(sent_pt));
 
        sent_pt = make_unique<SentenceUnit>();
        sent_pt->m_ID = ID_X_pt->m_ID + "_turn_on";
        sent_pt->m_sentence_type = 1;
        sent_pt->m_subject_pt = ID_X_pt;
        sent_pt->m_process_pt = this->m_Concept_Base->getTurnOnPt();
        this->m_Semantic_list.push_back(std::move(sent_pt));
 
        sent_pt = make_unique<SentenceUnit>();
        sent_pt->m_ID = ID_X_pt->m_ID + "_turn_off";
        sent_pt->m_sentence_type = 1;
        sent_pt->m_subject_pt = ID_X_pt;
        sent_pt->m_process_pt = this->m_Concept_Base->getTurnOffPt();
        this->m_Semantic_list.push_back(std::move(sent_pt));
      }
    } else if (MR_C_pt->m_CS_type == 1) {
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = MR_C_pt->m_Concept_ID_pt->m_ID + "_open_bigger";
      sent_pt->m_sentence_type = 1;
      sent_pt->m_subject_pt = MR_C_pt->m_Concept_ID_pt;
      sent_pt->m_process_pt = this->m_Concept_Base->getOpenBiggerPt();
      this->m_Semantic_list.push_back(std::move(sent_pt));
 
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = MR_C_pt->m_Concept_ID_pt->m_ID + "_close_smaller";
      sent_pt->m_sentence_type = 1;
      sent_pt->m_subject_pt = MR_C_pt->m_Concept_ID_pt;
      sent_pt->m_process_pt = this->m_Concept_Base->getCloseSmallerPt();
      this->m_Semantic_list.push_back(std::move(sent_pt));
 
      if (for_X_bl == true) {
        sent_pt = make_unique<SentenceUnit>();
        sent_pt->m_ID = ID_X_pt->m_ID + "_open_bigger";
        sent_pt->m_sentence_type = 1;
        sent_pt->m_subject_pt = ID_X_pt;
        sent_pt->m_process_pt = this->m_Concept_Base->getOpenBiggerPt();
        this->m_Semantic_list.push_back(std::move(sent_pt));
 
        sent_pt = make_unique<SentenceUnit>();
        sent_pt->m_ID = ID_X_pt->m_ID + "_close_smaller";
        sent_pt->m_sentence_type = 1;
        sent_pt->m_subject_pt = ID_X_pt;
        sent_pt->m_process_pt = this->m_Concept_Base->getCloseSmallerPt();
        this->m_Semantic_list.push_back(std::move(sent_pt));
      }
    } else {}//error message
  }
 
  for (auto &MR_SS_pt : this->m_MR->m_MRSupportSystem_list) {
    for_X_bl = false;
    ID_X_pt = NULL;
    if (MR_SS_pt->m_Concept_ID_pt->m_ID_Type == 002) {
      CC_pt = (ConceptComposedUnit *) (MR_SS_pt->m_Concept_ID_pt);
      ID_X_pt = CC_pt->m_Indefinite_Concept_ID_pt;
    }
    if (ID_X_pt != NULL) {
      for_X_bl = true;
      for (ID_X_itr = processed_X_list.begin(); ID_X_itr != processed_X_list.end() && for_X_bl == true; ID_X_itr++) {
        if ((*ID_X_itr) == ID_X_pt) {
          for_X_bl = false;
        }
      }
      if (for_X_bl == true) {
        processed_X_list.push_back(ID_X_pt);
      }
    }
 
    sent_pt = make_unique<SentenceUnit>();
    sent_pt->m_ID = MR_SS_pt->m_Concept_ID_pt->m_ID + "_ON";
    sent_pt->m_sentence_type = 2;
    sent_pt->m_subject_pt = MR_SS_pt->m_Concept_ID_pt;
    sent_pt->m_state_pt = this->m_Concept_Base->getONpt();
    this->m_Semantic_list.push_back(std::move(sent_pt));
 
    sent_pt = make_unique<SentenceUnit>();
    sent_pt->m_ID = MR_SS_pt->m_Concept_ID_pt->m_ID + "_OFF";
    sent_pt->m_sentence_type = 2;
    sent_pt->m_subject_pt = MR_SS_pt->m_Concept_ID_pt;
    sent_pt->m_state_pt = this->m_Concept_Base->getOFFpt();
    this->m_Semantic_list.push_back(std::move(sent_pt));
 
    sent_pt = make_unique<SentenceUnit>();
    sent_pt->m_ID = MR_SS_pt->m_Concept_ID_pt->m_ID + "_turn_on";
    sent_pt->m_sentence_type = 1;
    sent_pt->m_subject_pt = MR_SS_pt->m_Concept_ID_pt;
    sent_pt->m_process_pt = this->m_Concept_Base->getTurnOnPt();
    this->m_Semantic_list.push_back(std::move(sent_pt));
 
    sent_pt = make_unique<SentenceUnit>();
    sent_pt->m_ID = MR_SS_pt->m_Concept_ID_pt->m_ID + "_turn_off";
    sent_pt->m_sentence_type = 1;
    sent_pt->m_subject_pt = MR_SS_pt->m_Concept_ID_pt;
    sent_pt->m_process_pt = this->m_Concept_Base->getTurnOffPt();
    this->m_Semantic_list.push_back(std::move(sent_pt));
 
    if (for_X_bl == true) {
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = ID_X_pt->m_ID + "_ON";
      sent_pt->m_sentence_type = 2;
      sent_pt->m_subject_pt = ID_X_pt;
      sent_pt->m_state_pt = this->m_Concept_Base->getONpt();
      this->m_Semantic_list.push_back(std::move(sent_pt));
 
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = ID_X_pt->m_ID + "_OFF";
      sent_pt->m_sentence_type = 2;
      sent_pt->m_subject_pt = ID_X_pt;
      sent_pt->m_state_pt = this->m_Concept_Base->getOFFpt();
      this->m_Semantic_list.push_back(std::move(sent_pt));
 
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = ID_X_pt->m_ID + "_turn_on";
      sent_pt->m_sentence_type = 1;
      sent_pt->m_subject_pt = ID_X_pt;
      sent_pt->m_process_pt = this->m_Concept_Base->getTurnOnPt();
      this->m_Semantic_list.push_back(std::move(sent_pt));
 
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = ID_X_pt->m_ID + "_turn_off";
      sent_pt->m_sentence_type = 1;
      sent_pt->m_subject_pt = ID_X_pt;
      sent_pt->m_process_pt = this->m_Concept_Base->getTurnOffPt();
      this->m_Semantic_list.push_back(std::move(sent_pt));
    }
  }
 
  for (auto &MR_A_pt : this->m_MR->m_MRAlarm_list) {
    for_X_bl = false;
    ID_X_pt = NULL;
    if (MR_A_pt->m_Concept_pt->m_ID_Type == 002) {
      CC_pt = (ConceptComposedUnit *) (MR_A_pt->m_Concept_pt);
      ID_X_pt = CC_pt->m_Indefinite_Concept_ID_pt;
    }
    if (ID_X_pt != NULL) {
      for_X_bl = true;
      for (ID_X_itr = processed_X_list.begin(); ID_X_itr != processed_X_list.end() && for_X_bl == true; ID_X_itr++) {
        if ((*ID_X_itr) == ID_X_pt) {
          for_X_bl = false;
        }
      }
      if (for_X_bl == true) {
        processed_X_list.push_back(ID_X_pt);
      }
    }
 
    sent_pt = make_unique<SentenceUnit>();
    sent_pt->m_ID = MR_A_pt->m_Concept_pt->m_ID + "_turn_on";
    sent_pt->m_sentence_type = 1;
    sent_pt->m_subject_pt = MR_A_pt->m_Concept_pt;
    sent_pt->m_process_pt = this->m_Concept_Base->getTurnOnPt();
    this->m_Semantic_list.push_back(std::move(sent_pt));
 
    sent_pt = make_unique<SentenceUnit>();
    sent_pt->m_ID = MR_A_pt->m_Concept_pt->m_ID + "_turn_off";
    sent_pt->m_sentence_type = 1;
    sent_pt->m_subject_pt = MR_A_pt->m_Concept_pt;
    sent_pt->m_process_pt = this->m_Concept_Base->getTurnOffPt();
    this->m_Semantic_list.push_back(std::move(sent_pt));
 
    sent_pt = make_unique<SentenceUnit>();
    sent_pt->m_ID = MR_A_pt->m_Concept_pt->m_ID + "_ON";
    sent_pt->m_sentence_type = 2;
    sent_pt->m_subject_pt = MR_A_pt->m_Concept_pt;
    sent_pt->m_state_pt = this->m_Concept_Base->getONpt();
    this->m_Semantic_list.push_back(std::move(sent_pt));
 
    sent_pt = make_unique<SentenceUnit>();
    sent_pt->m_ID = MR_A_pt->m_Concept_pt->m_ID + "_OFF";
    sent_pt->m_sentence_type = 2;
    sent_pt->m_subject_pt = MR_A_pt->m_Concept_pt;
    sent_pt->m_state_pt = this->m_Concept_Base->getOFFpt();
    this->m_Semantic_list.push_back(std::move(sent_pt));
 
    if (for_X_bl == true) {
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = ID_X_pt->m_ID + "_turn_on";
      sent_pt->m_sentence_type = 1;
      sent_pt->m_subject_pt = ID_X_pt;
      sent_pt->m_process_pt = this->m_Concept_Base->getTurnOnPt();
      this->m_Semantic_list.push_back(std::move(sent_pt));
 
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = ID_X_pt->m_ID + "_turn_off";
      sent_pt->m_sentence_type = 1;
      sent_pt->m_subject_pt = ID_X_pt;
      sent_pt->m_process_pt = this->m_Concept_Base->getTurnOffPt();
      this->m_Semantic_list.push_back(std::move(sent_pt));
 
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = ID_X_pt->m_ID + "_ON";
      sent_pt->m_sentence_type = 2;
      sent_pt->m_subject_pt = ID_X_pt;
      sent_pt->m_state_pt = this->m_Concept_Base->getONpt();
      this->m_Semantic_list.push_back(std::move(sent_pt));
 
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = ID_X_pt->m_ID + "_OFF";
      sent_pt->m_sentence_type = 2;
      sent_pt->m_subject_pt = ID_X_pt;
      sent_pt->m_state_pt = this->m_Concept_Base->getOFFpt();
      this->m_Semantic_list.push_back(std::move(sent_pt));
    }
  }
 
  //get the directory "Input\Crew\DecisionMaker\RM\KB_ODM_Semantic_Base.txt"
  if (this->m_operator == sim::Operator::ODM) {
    file_name = g_sim.SScheduler.getODMDirectory();
    file_name += "RM/";
    file_name += "KB_ODM_Semantic_Base.txt";
  } else if (this->m_operator == sim::Operator::OAT) {
    file_name = g_sim.SScheduler.getOATDirectory();
    file_name += "RM/";
    file_name += "KB_OAT_Semantic_Base.txt";
  } else {
    err_mes = "unable to identify operator type in ReasonMachine::ReadSemanticSentencesFromInputFile()";
    this->ErrorMessage(err_mes);
    return;
  }
 
  //
  fin.open(file_name.c_str(), ios::in);
  if (!fin.is_open()) {
    err_mes = "could not open the file: " + file_name;
    this->ErrorMessage(err_mes);
    return;
  } else {
    //start to read this input file
 
    //read type 1 semantic sentence. E.g. "PRZ_pres decrease"
    fin >> str >> n_Unit;
    if (str.compare("No_of_Type_1_Semantic_Sentences") != 0) {
      err_mes = "format error in " + file_name + "Location: ReasonMachine::ReadSemanticSentencesFromInputFile()";
      err_mes += '\n';
      err_mes += "No_of_Type_1_Semantic_Sentences is not aligned";
      this->ErrorMessage(err_mes);
      return;
    }
    for (i = 0; i < n_Unit; i++) {
      sent_pt = make_unique<SentenceUnit>();
      fin >> str >> str_ID;
      if (this->SearchSentenceByID(str_ID) != NULL) {
        err_mes = "Sentence: " + str_ID + " already exists! use a different ID name!";
        this->ErrorMessage(err_mes);
        return;
      }
      sent_pt->m_ID = str_ID;
      sent_pt->m_sentence_type = 1;
 
      //subject ID
      fin >> str;
      ID_pt = this->m_Concept_Base->FindConceptByID(str);
      if (ID_pt == NULL) {
        err_mes = "can not find " + str + "Location: ReasonMachine::ReadSemanticSentencesFromInputFile()";
        this->ErrorMessage(err_mes);
        return;
      } else { sent_pt->m_subject_pt = ID_pt; }
 
      //process ID
      fin >> str;
      ID_pt = this->m_Concept_Base->FindConceptByID(str);
      if (ID_pt == NULL) {
        err_mes = "can not find " + str + "Location: ReasonMachine::ReadSemanticSentencesFromInputFile()";
        this->ErrorMessage(err_mes);
        return;
      } else {
        sent_pt->m_process_pt = ID_pt;
      }
      SentenceUnit *sent_raw = sent_pt.get();
      this->m_Semantic_list.push_back(std::move(sent_pt));
 
      Inst_pt = this->m_IB->CheckExistanceOfInstantiationGroupByIndefiniteConceptName(sent_raw->m_subject_pt->m_ID);
      if (Inst_pt != NULL) {
        for (auto CC_itr = Inst_pt->m_instance_list.begin(); CC_itr != Inst_pt->m_instance_list.end(); CC_itr++) {
          sent2_pt = make_unique<SentenceUnit>();
          sent2_pt->CopyFromAnotherSentence(sent_raw);
          sent2_pt->m_subject_pt = (IDElement *) (*CC_itr);
          SentenceUnit *sent2_raw = sent2_pt.get();
          this->m_Semantic_list.push_back(std::move(sent2_pt));
          sent2_raw->m_ID = sent2_raw->m_subject_pt->m_ID + "_" + sent2_raw->m_process_pt->m_ID;
        }
      }
    }
 
    //read type 2 semantic sentence, e.g. "AFWP ON"
    fin >> str >> n_Unit;
    if (str.compare("No_of_Type_2_Semantic_Sentences") != 0) {
      err_mes = "format error in " + file_name + "Location: ReasonMachine::ReadSemanticSentencesFromInputFile()";
      err_mes += '\n';
      err_mes += "No_of_Type_2_Semantic_Sentences is not aligned";
      this->ErrorMessage(err_mes);
      return;
    }
    for (i = 0; i < n_Unit; i++) {
      sent_pt = make_unique<SentenceUnit>();
      fin >> str >> str_ID;
      if (this->SearchSentenceByID(str_ID) != NULL) {
        err_mes = "Sentence: " + str_ID + " already exists! use a different ID name!";
        this->ErrorMessage(err_mes);
        return;
      }
      sent_pt->m_ID = str_ID;
      sent_pt->m_sentence_type = 2;
 
      //subject ID
      fin >> str;
      ID_pt = this->m_Concept_Base->FindConceptByID(str);
      if (ID_pt == NULL) {
        err_mes = "can not find " + str + "Location: ReasonMachine::ReadSemanticSentencesFromInputFile()";
        this->ErrorMessage(err_mes);
        return;
      } else { sent_pt->m_subject_pt = ID_pt; }
 
      //state ID
      fin >> str;
      ID_pt = this->m_Concept_Base->FindConceptByID(str);
      if (ID_pt == NULL) {
        err_mes = "can not find " + str + "Location: ReasonMachine::ReadSemanticSentencesFromInputFile()";
        this->ErrorMessage(err_mes);
        return;
      } else { sent_pt->m_state_pt = ID_pt; }
      SentenceUnit *sent_raw = sent_pt.get();
      this->m_Semantic_list.push_back(std::move(sent_pt));
      Inst_pt = this->m_IB->CheckExistanceOfInstantiationGroupByIndefiniteConceptName(sent_raw->m_subject_pt->m_ID);
      if (Inst_pt != NULL) {
        for (auto CC_itr = Inst_pt->m_instance_list.begin(); CC_itr != Inst_pt->m_instance_list.end(); CC_itr++) {
          sent2_pt = make_unique<SentenceUnit>();
          sent2_pt->CopyFromAnotherSentence(sent_raw);
          sent2_pt->m_subject_pt = (IDElement *) (*CC_itr);
          sent2_pt->m_ID = sent2_pt->m_subject_pt->m_ID + "_" + sent2_pt->m_state_pt->m_ID;
          this->m_Semantic_list.push_back(std::move(sent2_pt));
        }
      }
    }
    //read type 3 semantic sentence, e.g. "PRZ_pres <   1800"
    fin >> str >> n_Unit;
    if (str.compare("No_of_Type_3_Semantic_Sentences") != 0) {
      err_mes = "format error in " + file_name + "Location: ReasonMachine::ReadSemanticSentencesFromInputFile()";
      err_mes += '\n';
      err_mes += "No_of_Type_3_Semantic_Sentences is not aligned";
      this->ErrorMessage(err_mes);
      return;
    }
    for (i = 0; i < n_Unit; i++) {
      sent_pt = make_unique<SentenceUnit>();
      fin >> str >> str_ID;
      if (this->SearchSentenceByID(str_ID) != NULL) {
        err_mes = "Sentence: " + str_ID + " already exists! use a different ID name!";
        this->ErrorMessage(err_mes);
        return;
      }
      sent_pt->m_ID = str_ID;
      sent_pt->m_sentence_type = 3;
 
      //subject ID
      fin >> str;
      ID_pt = this->m_Concept_Base->FindConceptByID(str);
      if (ID_pt == NULL) {
        err_mes = "can not find " + str + "Location: ReasonMachine::ReadSemanticSentencesFromInputFile()";
        this->ErrorMessage(err_mes);
        return;
      } else { sent_pt->m_subject_pt = ID_pt; }
 
      //comparison ID
      fin >> str;
      ID_pt = this->m_Concept_Base->FindConceptByID(str);
      if (ID_pt == NULL) {
        err_mes = "can not find " + str + "Location: ReasonMachine::ReadSemanticSentencesFromInputFile()";
        this->ErrorMessage(err_mes);
        return;
      } else { sent_pt->m_comparison_pt = ID_pt; }
 
      //value
      fin >> sent_pt->m_value;
      SentenceUnit *sent_raw = sent_pt.get();
      this->m_Semantic_list.push_back(std::move(sent_pt));
      Inst_pt = this->m_IB->CheckExistanceOfInstantiationGroupByIndefiniteConceptName(sent_raw->m_subject_pt->m_ID);
      if (Inst_pt != NULL) {
        for (auto CC_itr = Inst_pt->m_instance_list.begin(); CC_itr != Inst_pt->m_instance_list.end(); CC_itr++) {
          sent2_pt = make_unique<SentenceUnit>();
          sent2_pt->CopyFromAnotherSentence(sent_raw);
          sent2_pt->m_subject_pt = (IDElement *) (*CC_itr);
          conv.str("");
          conv << sent2_pt->m_value;
          sent2_pt->m_ID = sent2_pt->m_subject_pt->m_ID + "_" + sent2_pt->m_comparison_pt->m_ID + "_" + conv.str();
          this->m_Semantic_list.push_back(std::move(sent2_pt));
        }
      }
    }
 
    //read type 4 semantic sentence, e.g. "SG_A_temp    <   PRZ_temp"
    fin >> str >> n_Unit;
    if (str.compare("No_of_Type_4_Semantic_Sentences") != 0) {
      err_mes = "format error in " + file_name + "Location: ReasonMachine::ReadSemanticSentencesFromInputFile()";
      err_mes += '\n';
      err_mes += "No_of_Type_4_Semantic_Sentences is not aligned";
      this->ErrorMessage(err_mes);
      return;
    }
    for (i = 0; i < n_Unit; i++) {
      sent_pt = make_unique<SentenceUnit>();
      fin >> str >> str_ID;
      if (this->SearchSentenceByID(str_ID) != NULL) {
        err_mes = "Sentence: " + str_ID + " already existed!";
        this->ErrorMessage(err_mes);
        return;
      }
      sent_pt->m_ID = str_ID;
      sent_pt->m_sentence_type = 4;
 
      //subject ID
      fin >> str;
      ID_pt = this->m_Concept_Base->FindConceptByID(str);
      if (ID_pt == NULL) {
        err_mes = "can not find" + str + "Location: ReasonMachine::ReadSemanticSentencesFromInputFile()";
        this->ErrorMessage(err_mes);
        return;
      } else { sent_pt->m_subject_pt = ID_pt; }
 
      //comparison ID
      fin >> str;
      ID_pt = this->m_Concept_Base->FindConceptByID(str);
      if (ID_pt == NULL) {
        err_mes = "can not find" + str + "Location: ReasonMachine::ReadSemanticSentencesFromInputFile()";
        this->ErrorMessage(err_mes);
        return;
      } else { sent_pt->m_comparison_pt = ID_pt; }
 
      //object ID
      fin >> str;
      ID_pt = this->m_Concept_Base->FindConceptByID(str);
      if (ID_pt == NULL) {
        err_mes = "can not find " + str + "Location: ReasonMachine::ReadSemanticSentencesFromInputFile()";
        this->ErrorMessage(err_mes);
        return;
      } else { sent_pt->m_object_pt = ID_pt; }
 
      fin >> sent_pt->m_delta_value;
      SentenceUnit *sent_raw = sent_pt.get();
      this->m_Semantic_list.push_back(std::move(sent_pt));
 
      Inst_pt = this->m_IB->CheckExistanceOfInstantiationGroupByIndefiniteConceptName(sent_raw->m_subject_pt->m_ID);
      Inst_obj_pt = this->m_IB->CheckExistanceOfInstantiationGroupByIndefiniteConceptName(sent_raw->m_object_pt->m_ID);
      if (Inst_pt != NULL && Inst_obj_pt == NULL) {
        for (auto CC_itr = Inst_pt->m_instance_list.begin(); CC_itr != Inst_pt->m_instance_list.end(); CC_itr++) {
          sent2_pt = make_unique<SentenceUnit>();
          sent2_pt->CopyFromAnotherSentence(sent_raw);
          sent2_pt->m_subject_pt = (IDElement *) (*CC_itr);
          sent2_pt->m_ID =
              sent2_pt->m_subject_pt->m_ID + "_" + sent2_pt->m_comparison_pt->m_ID + "_" + sent2_pt->m_object_pt->m_ID;
          this->m_Semantic_list.push_back(std::move(sent2_pt));
        }
      } else if (Inst_pt == NULL && Inst_obj_pt != NULL) {
        for (auto CC_obj_itr = Inst_obj_pt->m_instance_list.begin(); CC_obj_itr != Inst_obj_pt->m_instance_list.end();
             CC_obj_itr++) {
          sent2_pt = make_unique<SentenceUnit>();
          sent2_pt->CopyFromAnotherSentence(sent_raw);
          sent2_pt->m_object_pt = (IDElement *) (*CC_obj_itr);
          sent2_pt->m_ID =
              sent2_pt->m_subject_pt->m_ID + "_" + sent2_pt->m_comparison_pt->m_ID + "_" + sent2_pt->m_object_pt->m_ID;
          this->m_Semantic_list.push_back(std::move(sent2_pt));
        }
      } else if (Inst_pt != NULL && Inst_obj_pt != NULL) {
        if (Inst_pt->m_label_pt == Inst_obj_pt->m_label_pt) {
          for (auto CC_itr = Inst_pt->m_instance_list.begin(); CC_itr != Inst_pt->m_instance_list.end(); CC_itr++) {
            CC_pt = (ConceptComposedUnit *) (*CC_itr);
            sent2_pt = make_unique<SentenceUnit>();
            SentenceUnit *sent2_raw = sent2_pt.get();
            for (auto CC_obj_itr = Inst_obj_pt->m_instance_list.begin();
                 CC_obj_itr != Inst_obj_pt->m_instance_list.end() && sent2_raw->m_object_pt == NULL; CC_obj_itr++) {
              CC_obj_pt = (ConceptComposedUnit *) (*CC_obj_itr);
              if (CC_pt->m_label_ID_pt == CC_obj_pt->m_label_ID_pt) {
                sent2_pt->CopyFromAnotherSentence(sent_raw);
                sent2_pt->m_subject_pt = (IDElement *) (*CC_itr);
                sent2_pt->m_object_pt = (IDElement *) (*CC_obj_itr);
                sent2_pt->m_ID = sent2_pt->m_subject_pt->m_ID + "_" + sent2_pt->m_comparison_pt->m_ID + "_"
                    + sent2_pt->m_object_pt->m_ID;
                this->m_Semantic_list.push_back(std::move(sent2_pt));
              }
            }
            if (sent2_raw->m_object_pt == NULL) {
              err_mes = (*CC_itr)->m_ID + " could not find a matching objective in " + sent_raw->m_ID;
            }
          }
 
        } else {
          for (auto CC_itr = Inst_pt->m_instance_list.begin(); CC_itr != Inst_pt->m_instance_list.end(); CC_itr++) {
            CC_pt = (ConceptComposedUnit *) (*CC_itr);
            for (auto CC_obj_itr = Inst_obj_pt->m_instance_list.begin(); CC_obj_itr != Inst_obj_pt->m_instance_list.end();
                 CC_obj_itr++) {
              CC_obj_pt = (ConceptComposedUnit *) (*CC_obj_itr);
              sent2_pt = make_unique<SentenceUnit>();
              sent2_pt->CopyFromAnotherSentence(sent_raw);
              sent2_pt->m_subject_pt = (IDElement *) (*CC_itr);
              sent2_pt->m_object_pt = (IDElement *) (*CC_obj_itr);
              sent2_pt->m_ID = sent2_pt->m_subject_pt->m_ID + "_" + sent2_pt->m_comparison_pt->m_ID + "_"
                  + sent2_pt->m_object_pt->m_ID;
              this->m_Semantic_list.push_back(std::move(sent2_pt));
            }
 
          }
        }
      }
    }
 
    //read type 5 semantic sentence, e.g. "SG_A ruptured"
    fin >> str >> n_Unit;
    if (str.compare("No_of_Type_5_Semantic_Sentences") != 0) {
      err_mes = "format error in " + file_name + "Location: ReasonMachine::ReadSemanticSentencesFromInputFile()";
      err_mes += '\n';
      err_mes += "No_of_Type_5_Semantic_Sentences is not aligned";
      this->ErrorMessage(err_mes);
      return;
 
    }
    for (i = 0; i < n_Unit; i++) {
      fin >> str >> str_ID;
      if (this->SearchSentenceByID(str_ID) != NULL) {
        err_mes = "Sentence: " + str_ID + " already exists! use a different ID name!";
        this->ErrorMessage(err_mes);
        return;
      }
      sent_pt = make_unique<SentenceUnit>();
      sent_pt->m_ID = str_ID;
      sent_pt->m_sentence_type = 5;
 
      //subject ID
      fin >> str;
      ID_pt = this->m_Concept_Base->FindConceptByID(str);
      if (ID_pt == NULL) {
        err_mes = "can not find" + str + "Location: ReasonMachine::ReadSemanticSentencesFromInputFile()";
        this->ErrorMessage(err_mes);
        return;
      } else { sent_pt->m_subject_pt = ID_pt; }
 
      //attributive ID
      fin >> str;
      ID_pt = this->m_Concept_Base->FindConceptByID(str);
      if (ID_pt == NULL) {
        err_mes = "can not find" + str + "Location: ReasonMachine::ReadSemanticSentencesFromInputFile()";
        this->ErrorMessage(err_mes);
        return;
      } else { sent_pt->m_attribute_pt = ID_pt; }
 
      SentenceUnit *sent_raw = sent_pt.get();
      this->m_Semantic_list.push_back(std::move(sent_pt));
      Inst_pt = this->m_IB->CheckExistanceOfInstantiationGroupByIndefiniteConceptName(sent_raw->m_subject_pt->m_ID);
      if (Inst_pt != NULL) {
        for (auto CC_itr = Inst_pt->m_instance_list.begin(); CC_itr != Inst_pt->m_instance_list.end(); CC_itr++) {
          sent2_pt = make_unique<SentenceUnit>();
          sent2_pt->CopyFromAnotherSentence(sent_raw);
          sent2_pt->m_subject_pt = (IDElement *) (*CC_itr);
          sent2_pt->m_ID = sent2_pt->m_subject_pt->m_ID + "_" + sent2_pt->m_attribute_pt->m_ID;
          this->m_Semantic_list.push_back(std::move(sent2_pt));
        }
      }
    }
  }
  fin.close();
}
 
void ReasonMachine::ReadKnowledgeBaseFromInputFile() {
  string directory, str, str1, file_name;
  string err_mes;
  ifstream fin;
  int n_Unit, i;
  KnowledgeUnit *KU_pt;
 
  this->ReadKEBaseAndKNFromInputFile();
 
  //get the directory "Input\Crew\DecisionMaker\RM\KB_ODM_Knowledge_Unit_Base.txt"
  if (this->m_operator == sim::Operator::ODM) {
    file_name = g_sim.SScheduler.getODMDirectory();
    file_name += "RM/";
    file_name += "KB_ODM_Knowledge_Unit_Base.txt";
  } else if (this->m_operator == sim::Operator::OAT) {
    file_name = g_sim.SScheduler.getOATDirectory();
    file_name += "RM/";
    file_name += "KB_ODM_Knowledge_Unit_Base.txt";
  } else {} //error message, unable to identify the operator type in ReasonMachine::ReadSemanticSentencesFromInputFile()
 
  //
  fin.open(file_name.c_str(), ios::in);
  if (!fin.is_open()) {
    err_mes = "could not open file: " + file_name;
    this->ErrorMessage(err_mes);
    return;
  } else {
    fin >> str >> n_Unit;
    if (str.compare("Number_of_Knowledge_Unit") != 0) {
      err_mes = "Missing line: Number_of_Knowledge_Unit";
      this->ErrorMessage(err_mes);
      return;
    }
    for (i = 0; i < n_Unit; i++) {
      auto KU_owned = make_unique<KnowledgeUnit>();
      KU_pt = KU_owned.get();
      KU_pt->m_operator = this->m_operator;
      KU_pt->ReadKnowledgeUnitFromInputFile(fin);
      if (this->FindKnowledgeUnitByID(KU_pt->m_ID) != NULL) {
        this->ErrorMessage(KU_pt->m_ID + " already exist!");
        return;
      }
      this->AddANewKnowledgeUnit(KU_owned.release());
    }
  }
  fin.close();
}
 
SentenceUnit *ReasonMachine::SearchSentenceByID(string _ID) {
  SentenceUnit *sent_pt;
  SentenceUnit *found_sent_pt = NULL;
 
  for (auto sent_itr = this->m_Semantic_list.begin(); sent_itr != this->m_Semantic_list.end() && found_sent_pt == NULL;
       sent_itr++) {
    sent_pt = sent_itr->get();
    if (sent_pt->m_ID == _ID) {
      found_sent_pt = sent_pt;
    }
  }
  return found_sent_pt;
}
 
//DEL void ReasonMachine::PropagateActivationFromSemanticSentenceToConceptBase(SentenceUnit *)
//DEL {
//DEL
//DEL }
 
void ReasonMachine::ActivationDecayofRM() {
  //decay of concept
  this->m_Concept_Base->ActivationDecayOfConcept(this->m_decay_lamda);
  //decay of semantic sentence
  for (auto sent_itr = this->m_Semantic_list.begin(); sent_itr != this->m_Semantic_list.end(); sent_itr++) {
    (*sent_itr)->ActivationDecay(this->m_decay_lamda);
  }
  //decay of statement
  for (auto statement_itr = this->m_Statement_list.begin(); statement_itr != this->m_Statement_list.end(); statement_itr++) {
    (*statement_itr)->ActivationDecay(this->m_decay_lamda);
  }
}
 
void ReasonMachine::PropagateActivationFromConceptToSemanticSentence() {
  SentenceUnit *sent_pt;
  for (auto sent_itr = this->m_Semantic_list.begin(); sent_itr != this->m_Semantic_list.end(); sent_itr++) {
    sent_pt = sent_itr->get();
    sent_pt->ActivationPropagationFromConceptBottomUp(this->m_operator);
  }
 
}
 
//DEL void ReasonMachine::PropagateActivationFromSemanticSentenceToConceptUnit(SentenceUnit *)
//DEL {
//DEL
//DEL }
 
void ReasonMachine::OneRoundActivationSpreadingFromASentence(SentenceUnit *_sent_pt) {
 
  if (_sent_pt->m_change_ratio == 1) { return; }
 
  this->m_Concept_Base->SaveActivationToOldActivationVariable();
  for (auto sent_itr = this->m_Semantic_list.begin(); sent_itr != this->m_Semantic_list.end(); sent_itr++) {
    (*sent_itr)->m_old_activation = (*sent_itr)->m_activation;
  }
 
  //top down activation propagation
  _sent_pt->PropagateActivationToConceptUnitsTopDown(this->m_operator);
  this->m_Concept_Base->PropagateActivationAmongConceptsTopDown();
 
  //refill the ConceptComposedUnitUpdateList
  this->m_Concept_Base->FillTheConceptCompsedUnitUpdateList();
 
  //bottom up activation propagation
  this->m_Concept_Base->PropagateActivationFromBasicConceptToComposedConcept();
  this->m_Concept_Base->PropagateActivationAmongComposedConceptBottomUp();
  this->m_Concept_Base->FillTheConceptCompsedUnitUpdateList();
  this->PropagateActivationFromConceptToSemanticSentence();
 
  //clean activation_change_ratio
  this->m_Concept_Base->SetAllConceptActivationChangeBackToOneAndCleanTheUpdateList();
  this->SetAllSentenceActivationRatioToOne();
}
 
void ReasonMachine::AddConsumptedDeltaT(double _deltaT) {
  double sum;
  sum = this->m_consumed_time
      + _deltaT * this->m_cognitive_time_cost_multiplier * this->m_cognitive_time_cost_base_multiplier;
  if (sum > this->m_time_length) {
    this->m_consumed_time = this->m_time_length;
    this->m_timer_RM = sum - this->m_time_length;
  } else {
    this->m_consumed_time = sum;
  }
}
 
void ReasonMachine::BalanceTimerWithUnconsumedTime() {
  if (this->m_timer_RM == 0) { return; }
  if (this->m_timer_RM > (this->m_time_length - this->m_consumed_time)) {
    this->m_timer_RM -= (this->m_time_length - this->m_consumed_time);
    this->m_consumed_time = this->m_time_length;
  } else {
    this->m_consumed_time += this->m_timer_RM;
    this->m_timer_RM = 0;
  }
}
 
void ReasonMachine::CutTheLengthOfAlarmStack() {
  vector<MentalAlarm *>::iterator m_A_itr;
  IDElement *ID_pt;
  string indicator_name;
  string alarm_size;
  MentalAlarm *M_A_pt;
  bool found_expected_one = false;
  int keep_i = 0;
  int i = 0;
  string rm_aux_info;
  stringstream conv;
 
  conv.str("");
  conv << this->m_tbi_A_list.size();
  alarm_size = conv.str();
 
  m_A_itr = this->m_tbi_A_list.begin();
  //to be removed
  //if(this->m_problem_solving_style == HAMLET_B)
  //{return;}
  while (this->m_tbi_A_list.size() > this->m_max_length_of_alarms_stack) {
    //get alarm name
    //keep_i = 0;
    M_A_pt = *m_A_itr;
    indicator_name = M_A_pt->getAlarmName();
    if (indicator_name.empty() == true) {}//error message
    ID_pt = this->m_MR->CheckExistenceByIndicationName(indicator_name);
    if (ID_pt != NULL && ID_pt == this->m_reading_indication_ID_pt) {
      found_expected_one = true;
      keep_i++;
    } else {
      //write aux information
      rm_aux_info = "slipped information: ";
      rm_aux_info += (*m_A_itr)->getAlarmName();
      rm_aux_info += ": ";
      if ((*m_A_itr)->getObservedAlarmState() == sim::State::On) { rm_aux_info += "ON "; }
      else { rm_aux_info += "OFF "; }
      rm_aux_info += alarm_size;
      rm_aux_info += "/";
      conv.str("");
      conv << this->m_max_length_of_alarms_stack;
      rm_aux_info += conv.str();
 
      this->WriteAuxInfo(rm_aux_info);
 
      //erase this alarm information
      this->m_tbi_A_list.erase(m_A_itr);
    }
    m_A_itr = this->m_tbi_A_list.begin();
    if (found_expected_one == true) {
      if (this->m_tbi_A_list.size() == 1) { break; }
      for (i = 0; i < keep_i; i++) { m_A_itr++; }
      if (keep_i >= this->m_tbi_A_list.size()) { break; }
    }
  }
}
 
void ReasonMachine::ActivationUpdateByRefreshAStatement(Statement *_statement_pt) {
  //activation propagation
  _statement_pt->m_activation = 1;
  _statement_pt->m_last_activated_time = r5pars_.timesno;
  this->CrankASentenceUnitActivationToAGivenValue(_statement_pt->m_sent_pt, 1.0);
}
 
void ReasonMachine::AddANewStatement(Statement *_statement_pt) {
  string ID_name;
  stringstream conv;
  string prompt;
 
  this->m_Statement_list.push_back(unique_ptr<Statement>(_statement_pt));
  this->AddDeltaToCognitiveLoad(0.04);
  //check point
  //if(_statement_pt->m_sent_pt->m_ID == "SG_C_level_>_SG_B_level" || _statement_pt->m_sent_pt->m_ID == "SG_C_level_>_SG_A_level" || _statement_pt->m_sent_pt->m_ID == "SG_A_NR_level_>_SG_B_NR_level" || _statement_pt->m_sent_pt->m_ID == "SG_A_WR_level_>_SG_B_WR_level")
  if (_statement_pt->m_sent_pt->m_ID == "SG_C_level_>_SG_B_level"
      || _statement_pt->m_sent_pt->m_ID == "SG_C_level_>_SG_A_level") {
    this->PrintMessage("Check point");
  }
  //
 
  conv.str(""); // clean the conv
  conv << this->m_Statement_list.size();
  ID_name = "statement_" + conv.str();
  _statement_pt->m_ID = ID_name;
  _statement_pt->m_time_generated = r5pars_.timesno;
  _statement_pt->m_last_activated_time = r5pars_.timesno;
  _statement_pt->m_operator = this->m_operator;
 
  //
  if (ID_name == "statement_2472") { this->PrintMessage("Check"); }
 
 
  //activation propagation
  _statement_pt->m_activation = 1;
  this->CrankASentenceUnitActivationToAGivenValue(_statement_pt->m_sent_pt, 1.0);
 
  //print prompt
  prompt = "A new Statement is generated: ";
 
  if (_statement_pt->m_sent_pt == NULL) {
    prompt = "A new state is NULL!";
    this->ErrorMessage(prompt);
  } else {
    prompt += _statement_pt->GetThisStatementWords();
  }
  this->PrintMessage(prompt);
 
  this->MakeOneStepInferenceFromAStatement(_statement_pt);
}
 
void ReasonMachine::AddNewInvestigator(Investigator *_invest_pt) {
  string ID_name;
  stringstream conv;
  string prompt;
  string rm_aux_info;
 
  this->m_investigator_pool.push_back(unique_ptr<Investigator>(_invest_pt));
  this->m_unresolved_investigator_pool.push_back(_invest_pt);
 
  conv.str(""); // clean the conv
  conv << this->m_investigator_pool.size();
  ID_name = "Investigator_" + conv.str();
 
  if (ID_name == "Investigator_159") { this->PrintMessage(""); }
  //check point
  /*if(_invest_pt->m_KElement_ID_pt != NULL)
    {
        if(_invest_pt->m_KElement_ID_pt->m_ID == "KE_MSI_OFF")
        {
            this->PrintMessage("check point");
        }
    }
    */
  _invest_pt->m_ID = ID_name;
  if (_invest_pt->m_Statement_pt != NULL) {
    _invest_pt->m_investigator_token = inv::GetCorrespondingKE;
  }
  _invest_pt->m_investigation_initiate_time = r5pars_.timesno;
  _invest_pt->m_operator = this->m_operator;
 
  prompt = "A new investigator is generated";
  cout << "Time: " << r5pars_.timesno << ": " << prompt << " ";
 
  //test
  ofstream fout("RMI.txt", ios::app);
  fout << "Time: " << r5pars_.timesno << ": " << prompt << " ";
  fout.close();
 
  if (_invest_pt->m_Statement_pt != NULL) {
    prompt = "To investigate this statement: ";
    cout << prompt << " ";
    ofstream fout("RMI.txt", ios::app);
    fout << prompt;
    fout.close();
 
    _invest_pt->m_Statement_pt->PrintThisStatement();
    //check point
    if (_invest_pt->m_Statement_pt->m_sent_pt->m_ID == "power_increase") {
      this->PrintMessage("Check point");
    }
  } else {
    prompt = "To investigate this Knowledge Element:  ";
    cout << prompt << _invest_pt->m_KElement_ID_pt->m_ID;
    ofstream fout("RMI.txt", ios::app);
    fout << prompt << _invest_pt->m_KElement_ID_pt->m_ID;
    fout.close();
  }
  //
  this->m_event_schema_base->AddNewSymptomCaseWithNewInvestigatorIfNecessary(_invest_pt);
 
  if ((this->FindASimilarInvestigatorRecentlyResolved(_invest_pt) != NULL
      || this->FindASimilarOngoingInvestigator(_invest_pt) != NULL) && _invest_pt->m_active_investigation == false) {
    rm_aux_info = "Item forgotten: ";
    rm_aux_info += _invest_pt->m_ID;
    this->WriteAuxInfo(rm_aux_info);
    _invest_pt->m_investigation_closed = true;
    this->RemoveInvestigatorFromUnresolvedPool(_invest_pt);
  }
}
 
void ReasonMachine::ChangeRMTokenValue(int _token) {
  string prompt;
  int old_token = this->m_RM_Token;
  this->m_RM_Token_history.push_back(this->m_RM_Token);
  this->m_RM_token_endtime_history.push_back(r5pars_.timesno);
  this->m_RM_Token = _token;
 
  //output text
  prompt = "The Token of Reasoning Module changed from ";
  prompt += this->TranslateRMTokenToWords(old_token);
  prompt += " to ";
  prompt += this->TranslateRMTokenToWords(_token);
  if (_token == rm::WorkOnInvestigator) {
    prompt += "\n";
    prompt += "now work on this investigator:\n";
    prompt += this->m_working_on_invest_pt->GetASimpleDescriptionOfThisInvestigator();
  } else if (_token == rm::WorkOnInvestigatorLink) {
    prompt += "\n";
    prompt += "now work on this InvestigatorLink: \n";
    prompt += this->m_working_on_invest_link_pt->GetASimpleDescriptionOfTheInvestigatorLink();
  }
  this->PrintMessage(prompt);
}
 
void ReasonMachine::RemoveInvestigatorFromUnresolvedPool(Investigator *_invest_pt) {
  vector<Investigator *>::iterator invest_itr;
  string prompt;
  bool found = false;
 
  for (auto invest_itr = this->m_unresolved_investigator_pool.begin();
       invest_itr != this->m_unresolved_investigator_pool.end() && found == false; invest_itr++) {
    if ((*invest_itr) == _invest_pt) {
      found = true;
      this->m_unresolved_investigator_pool.erase(invest_itr);
    }
  }
}
 
void ReasonMachine::AddNewInvestigatorLink(InvestigatorLink *_link_pt) {
  string ID_name;
  stringstream conv;
 
  this->m_investigator_link_pool.push_back(unique_ptr<InvestigatorLink>(_link_pt));
  conv.str(""); // clean the conv
  conv << this->m_investigator_link_pool.size();
  ID_name = "InvestigatorLink_" + conv.str();
  _link_pt->m_ID = ID_name;
  _link_pt->m_operator = this->m_operator;
  _link_pt->m_invest_link_Token = inv_link::RetrieveNextInvestigator;
  // check point
  if (_link_pt->m_K_unit_pt->m_ID == "KE_MFWP_X_trip_turn_on->KE_MFW_X_flow_decrease") {
    this->PrintMessage("Check point");
  }
}
 
void ReasonMachine::ReadKEBaseAndKNFromInputFile() {
  ifstream fin;
  KnowledgeElement *KE_pt;
  KnowledgeNode *KN_pt;
  int i, n_unit;
  string str, ID_name;
  string file_name;
  string err_mes;
 
  SentenceUnit *sent_pt;
 
  //Create a true KE and a false KE for each sentence in the semantic pool
  for (auto sent_itr = this->m_Semantic_list.begin(); sent_itr != this->m_Semantic_list.end(); sent_itr++) {
    sent_pt = sent_itr->get();
    ID_name = "KE_" + sent_pt->m_ID;
    auto KE_owned = make_unique<KnowledgeElement>();
    KE_pt = KE_owned.get();
    KE_pt->m_operator = this->m_operator;
    KE_pt->m_ID = ID_name;
    KE_pt->m_negation = false;
    KE_pt->m_SentenceUnit_pt = sent_pt;
    this->m_KE_list.push_back(std::move(KE_owned));
  }
  for (auto sent_itr = this->m_Semantic_list.begin(); sent_itr != this->m_Semantic_list.end(); sent_itr++) {
    sent_pt = sent_itr->get();
    ID_name = "KE_FALSE_" + sent_pt->m_ID;
    auto KE_owned = make_unique<KnowledgeElement>();
    KE_pt = KE_owned.get();
    KE_pt->m_operator = this->m_operator;
    KE_pt->m_ID = ID_name;
    KE_pt->m_negation = true;
    KE_pt->m_SentenceUnit_pt = sent_pt;
    this->m_KE_list.push_back(std::move(KE_owned));
  }
 
  //get the directory "Input\Crew\DecisionMaker\RM\KB_ODM_Knowledge_Unit_Base.txt"
  if (this->m_operator == sim::Operator::ODM) {
    file_name = g_sim.SScheduler.getODMDirectory();
    file_name += "RM/";
    file_name += "KB_ODM_Knowledge_Node_Base.txt";
  } else if (this->m_operator == sim::Operator::OAT) {
    file_name = g_sim.SScheduler.getOATDirectory();
    file_name += "RM/";
    file_name += "KB_ODM_Knowledge_Node_Base.txt";
  } else {} //error message, unable to identify the operator type in ReasonMachine::ReadSemanticSentencesFromInputFile()
 
  fin.open(file_name.c_str(), ios::in);
  if (!fin.is_open()) {
    err_mes = "could not open file: " + file_name;
    this->ErrorMessage(err_mes);
    return;
  } else {
/*
        fin >> str >> n_unit;
        if(str.compare("Number_of_Knowledge_Element") != 0)
        {
            err_mes = "missing line: Number_of_Knowledge_Element";
            this->ErrorMessage(err_mes);
            return;
        }
 
        for(i = 0; i < n_unit; i++)
        {
            KE_pt = new KnowledgeElement();
            KE_pt->m_operator = this->m_operator;
            KE_pt->ReadThisKEFromFile(fin);
            this->m_KE_list.push_back(unique_ptr<KnowledgeElement>(KE_pt));
        }
*/
    fin >> str >> n_unit;
    if (str.compare("Number_of_Knowledge_Node") != 0) {}//error message
 
    for (i = 0; i < n_unit; i++) {
      auto KN_owned = make_unique<KnowledgeNode>();
      KN_pt = KN_owned.get();
      KN_pt->m_operator = this->m_operator;
      KN_pt->ReadThisKNinfoFromFile(fin);
      this->m_KN_list.push_back(std::move(KN_owned));
    }
  }
  fin.close();
}
 
KnowledgeElement *ReasonMachine::FindKnowledgeElementByID(string _ID_name) {
 
  KnowledgeElement *found_KE_pt = NULL;
  for (auto KE_itr = this->m_KE_list.begin(); KE_itr != this->m_KE_list.end() && found_KE_pt == NULL; KE_itr++) {
    if ((*KE_itr)->m_ID == _ID_name) {
      found_KE_pt = KE_itr->get();
    }
  }
  return found_KE_pt;
}
 
KnowledgeNode *ReasonMachine::FindKNByID(string _ID_name) {
  KnowledgeNode *found_KN_pt = NULL;
 
  for (auto KN_itr = this->m_KN_list.begin(); KN_itr != this->m_KN_list.end() && found_KN_pt == NULL; KN_itr++) {
    if ((*KN_itr)->m_ID == _ID_name) {
      found_KN_pt = KN_itr->get();
    }
  }
  return found_KN_pt;
}
 
void ReasonMachine::FirstRoundCheck() {
  this->m_MR->FirstRoundCheckOftheMR();
}
 
void ReasonMachine::FirstRoundCheckInterpretation() {
  //Token 0020: Interpretation, preprocessing of the newly perceived information
  vector<MentalParameterValue *>::iterator M_P_itr;
  vector<MentalAlarm *>::iterator M_A_itr;
  vector<MentalComponentState *>::iterator M_C_itr;
  vector<MentalSupportSystemState *>::iterator M_SS_itr;
  MentalParameterValue *M_P_pt;
  MentalAlarm *M_A_pt;
  MentalComponentState *M_C_pt;
  MentalSupportSystemState *M_SS_pt;
  IDElement *ID_pt;
  MRParameterUnit *MR_P_pt;
  MRComponentStateUnit *MR_C_pt;
  MRSupportSystemStateUnit *MR_SS_pt;
  MRAlarmUnit *MR_A_pt;
  bool expecting_indication_bl = false;
 
  string indicator_name;
 
  for (M_A_itr = this->m_tbi_A_list.begin(); M_A_itr != this->m_tbi_A_list.end(); M_A_itr++) {
    M_A_pt = *M_A_itr;
    //get alarm name
    indicator_name = M_A_pt->getAlarmName();
    if (indicator_name.empty() == true) {
      cout << "Indicator name does not exist: " << indicator_name << endl;
    }//error message
 
    ID_pt = this->m_MR->CheckExistenceByIndicationName(indicator_name);
    if (ID_pt != NULL) {//If there is a mapping on the Mental Representation, then interpret the alarm information
      if (ID_pt->m_ID_Type != 203) {//error message
        return;
      }
      MR_A_pt = (MRAlarmUnit *) ID_pt;
      MR_A_pt->AddNewAlarmStateForFirstRoundCheck(M_A_pt->getObservedAlarmState(), this->m_operator);
    }
  }
  this->m_tbi_A_list.clear();
 
 
  //*
  //Processing Parameters
  //*
 
  for (M_P_itr = this->m_tbi_P_list.begin(); M_P_itr != this->m_tbi_P_list.end(); M_P_itr++) {
    M_P_pt = *M_P_itr;
    //get parameter name
    { indicator_name = M_P_pt->getDisplayName(); }
    if (indicator_name.empty() == true) {
      cout << "Indicator name does not exist: " << indicator_name << endl;
    }//error message
 
    ID_pt = this->m_MR->CheckExistenceByIndicationName(indicator_name);
    if (ID_pt != NULL) {//interpret
      switch (ID_pt->m_ID_Type) {
        case 201: // it is a MRParameterUnit
          MR_P_pt = (MRParameterUnit *) ID_pt;
          if (MR_P_pt->m_parameter_indicator_ID == indicator_name) {
            MR_P_pt->AddNewValueForFirstRoundCheck(M_P_pt->getObservedParameterValue(), this->m_operator);
          } else if (MR_P_pt->m_parameter_rate_indicator_ID == indicator_name) {
            MR_P_pt->AddNewRateForFirstRoundCheck(M_P_pt->getObservedParameterValue(), this->m_operator);
          } else {}//error message
          break;
        case 202: // it is a MRComponentStateUnit
          // MR_C_pt = (MRComponentStateUnit *)ID_pt;
          // MR_C_pt->AddNewPositionValueForFirstRoundCheck(M_P_pt->getObservedParameterValue(), this->m_operator);
          break;
        default:
          //error message
          break;
      }
    }
  }
  this->m_tbi_P_list.clear();
 
  //*
  //Processing Component States
  //*
  for (M_C_itr = this->m_tbi_C_list.begin(); M_C_itr != this->m_tbi_C_list.end(); M_C_itr++) {
    M_C_pt = *M_C_itr;
 
    //get componentstate name
    { indicator_name = M_C_pt->getDisplayName(); }
    if (indicator_name.empty() == true) {}//error message
 
    ID_pt = this->m_MR->CheckExistenceByIndicationName(indicator_name);
    if (ID_pt != NULL) {//interpret
      if (ID_pt->m_ID_Type != 202) {//error message
        return;
      }
      MR_C_pt = (MRComponentStateUnit *) ID_pt;
      MR_C_pt->AddNewStateForFirstRoundCheck(M_C_pt->getObservedComponentState(), this->m_operator);
    }
  }
  this->m_tbi_C_list.clear();
 
  //*
  //Processing Support System States
  //*
  for (M_SS_itr = this->m_tbi_SS_list.begin(); M_SS_itr != this->m_tbi_SS_list.end(); M_SS_itr++) {
    M_SS_pt = *M_SS_itr;
 
    //get support system state name
    { indicator_name = M_SS_pt->getDisplayName(); }
    if (indicator_name.empty() == true) {}//error message
 
    ID_pt = this->m_MR->CheckExistenceByIndicationName(indicator_name);
    if (ID_pt != NULL) {//interpret
      if (ID_pt->m_ID_Type != 202) {//error message
        return;
      }
      MR_SS_pt = (MRSupportSystemStateUnit *) ID_pt;
      MR_SS_pt->AddNewStateForFirstRoundCheck(M_SS_pt->getObservedSupportSystemState(), this->m_operator);
    }
  }
  this->m_tbi_SS_list.clear();
}
 
void ReasonMachine::ErrorMessage(string str) {
  cout << r5pars_.timesno << "  " << str << " in ReasonMachine.cpp" << '\n';
  ofstream fout("err messages.txt", ios::app);
  fout << r5pars_.timesno << "  " << str << '\n';
  fout.close();
  //r5pars_.terminateall = true;
}
 
void ReasonMachine::AddANewKnowledgeUnit(KnowledgeUnit *_KU_pt) {
  string ID_name;
  stringstream conv;
  this->m_Knowledge_list.push_back(unique_ptr<KnowledgeUnit>(_KU_pt));
 
  conv.str(""); // clean the conv
  conv << this->m_Statement_list.size();
  ID_name = "KnowledgeUnit_" + conv.str();
  //_KU_pt->m_ID = ID_name;
}
 
void ReasonMachine::PrintMessage(string str) {
  cout << "Time: " << r5pars_.timesno << ": " << str << '\n';
 
  //test
  ofstream fout("RMI.txt", ios::app);
  fout << "Time: " << r5pars_.timesno << ": " << str << '\n';
  fout.close();
 
}
void ReasonMachine::SetAllSentenceActivationRatioToOne() {
  for (auto sent_itr = this->m_Semantic_list.begin(); sent_itr != this->m_Semantic_list.end(); sent_itr++) {
    (*sent_itr)->m_change_ratio = 1;
  }
}
 
string ReasonMachine::TranslateRMTokenToWords(int _token) {
  string str;
  switch (_token) {
    case rm::RoutineMonitor: str = "OneStepRoutineMonitor10";
      break;
    case rm::Prioritize: str = "OneStepPrioritizeInvestigation30";
      break;
    case rm::WorkOnInvestigator: str = "OneStepWorkOnSelectedInvestigator3000";
      break;
    case rm::WorkOnInvestigatorLink: str = "OneStepWorkOnSelectedInvestigatorLink3100";
      break;
    default:
      //error message, unexpected situation, check the m_RM_Token;
      str = "Unrecognized RM token!";
      break;
  }
  return str;
}
 
void ReasonMachine::PrintSemanticBase() {
  /*
    fout <<"\n" << "Time: " << r5pars_.timesno << ":\n" << str << '\n';
    fout.close();
    */
  string file_name;
  file_name = g_sim.SScheduler.getOutputDirectory();
  file_name += "RMOutPut/";
  file_name += "ODM_Semantic_Base.txt";
  ofstream fout(file_name.c_str(), ios::out);
  vector<SentenceUnit *>::iterator sent_itr;
  fout << "There are " << this->m_Semantic_list.size() << " sentences in total" << '\n';
  for (auto sent_itr = this->m_Semantic_list.begin(); sent_itr != this->m_Semantic_list.end(); sent_itr++) {
    fout << (*sent_itr)->m_ID << '\n';
  }
  fout.close();
 
}
 
SentenceUnit *ReasonMachine::FindAnIndefiniteSentenceMatchTheInputSentence(SentenceUnit *_sent_pt) {
  unique_ptr<SentenceUnit> sent_X_owned;
  SentenceUnit *sent_return_pt = NULL;
  ConceptComposedUnit *CC_pt;
  IDElement *sub_X_pt = NULL;
  IDElement *obj_X_pt = NULL;
  IDElement *sub_label_pt = NULL;
  IDElement *obj_label_pt = NULL;
  string err_mes;
 
  if (_sent_pt->m_subject_pt->m_ID_Type == 002) {
    CC_pt = (ConceptComposedUnit *) (_sent_pt->m_subject_pt);
    sub_X_pt = CC_pt->m_Indefinite_Concept_ID_pt;
    sub_label_pt = CC_pt->m_label_ID_pt;
  }
  if (_sent_pt->m_object_pt != NULL) {
    if (_sent_pt->m_object_pt->m_ID_Type == 002) {
      CC_pt = (ConceptComposedUnit *) (_sent_pt->m_object_pt);
      obj_X_pt = CC_pt->m_Indefinite_Concept_ID_pt;
      obj_label_pt = CC_pt->m_label_ID_pt;
    }
  }
  if (sub_X_pt == NULL && obj_X_pt == NULL) {
    return NULL;
  }
  if (sub_label_pt != NULL && obj_label_pt != NULL && sub_label_pt != obj_label_pt) {
    err_mes = _sent_pt->m_ID + " belongs to two lable groups which is beyond the current source codes";
    this->ErrorMessage(err_mes);
    return NULL;
  }
  sent_X_owned = make_unique<SentenceUnit>();
  sent_X_owned->CopyFromAnotherSentence(_sent_pt);
  if (sub_X_pt != NULL) {
    sent_X_owned->m_subject_pt = (IDElement *) sub_X_pt;
  }
  if (obj_X_pt != NULL) {
    sent_X_owned->m_object_pt = (IDElement *) obj_X_pt;
  }
  sent_return_pt = this->CheckExistInSemanticPoolBySentence(sent_X_owned.get());
  if (sent_return_pt == NULL) {
    err_mes = "could not find a indefinite sentence for " + _sent_pt->m_ID;
    this->ErrorMessage(err_mes);
    return NULL;
  }
  return sent_return_pt;
 
}
 
KnowledgeElement *ReasonMachine::FindAKEbySentenceAndNegationSign(SentenceUnit *_sent_pt, bool _Neg_bl) {
  vector<KnowledgeElement *>::iterator KE_itr;
  KnowledgeElement *KE_found_pt = NULL;
  for (auto KE_itr = this->m_KE_list.begin(); KE_itr != this->m_KE_list.end() && KE_found_pt == NULL; KE_itr++) {
    if ((*KE_itr)->m_SentenceUnit_pt == _sent_pt && (*KE_itr)->m_negation == _Neg_bl) {
      KE_found_pt = KE_itr->get();
    }
  }
  return KE_found_pt;
}
 
SentenceUnit *ReasonMachine::InstantiateAnIndefiniteSentenceWithLabel(SentenceUnit *sent_X_pt, IDElement *label_ID_pt) {
  SentenceUnit *sent_found_pt = NULL;
  SentenceUnit *instance_sent_pt;
  vector<Instantiation *>::iterator inst_itr;
  vector<ConceptComposedUnit *>::iterator CC_itr;
  bool change_bl = false;
  ConceptComposedUnit *CC_pt1 = NULL;
  ConceptComposedUnit *CC_pt2 = NULL;
 
  if (sent_X_pt->m_subject_pt->m_ID_Type == 002) {
    CC_pt1 = (ConceptComposedUnit *) (sent_X_pt->m_subject_pt);
  }
  if (sent_X_pt->m_object_pt != 0) {
    if (sent_X_pt->m_object_pt->m_ID_Type == 002) {
      CC_pt2 = (ConceptComposedUnit *) (sent_X_pt->m_object_pt);
    }
  }
 
  if (CC_pt1 == NULL && CC_pt2 == NULL) {
    return NULL;
  }
  SentenceUnit instance_sent;
  instance_sent.CopyFromAnotherSentence(sent_X_pt);
  for (auto inst_itr = this->m_IB->m_instantiation_list.begin(); inst_itr != this->m_IB->m_instantiation_list.end();
       inst_itr++) {
    if ((*inst_itr)->m_indefinite_instance_pt == CC_pt1) {
      change_bl = true;
      for (auto CC_itr = (*inst_itr)->m_instance_list.begin(); CC_itr != (*inst_itr)->m_instance_list.end(); CC_itr++) {
        if ((*CC_itr)->m_label_ID_pt == label_ID_pt)
          instance_sent.m_subject_pt = (IDElement *) (*CC_itr);
      }
    }
    if ((*inst_itr)->m_indefinite_instance_pt == CC_pt2) {
      change_bl = true;
      for (auto CC_itr = (*inst_itr)->m_instance_list.begin(); CC_itr != (*inst_itr)->m_instance_list.end(); CC_itr++) {
        if ((*CC_itr)->m_label_ID_pt == label_ID_pt)
          instance_sent.m_object_pt = (IDElement *) (*CC_itr);
      }
    }
  }
  if (change_bl == false) {
    return NULL;
  }
  sent_found_pt = this->CheckExistInSemanticPoolBySentence(&instance_sent);
  if (sent_found_pt == NULL) {
    this->ErrorMessage("could not find the instance sentence");
    return NULL;
  } else {
    return sent_found_pt;
  }
}
 
void ReasonMachine::MakeOneStepInferenceFromAStatement(Statement *_statement_pt) {
  KnowledgeElement *KE_starting_pt;
  KnowledgeElement *KE_starting_X_pt = NULL;
  KnowledgeElement *KE_down_X_pt = NULL;
  KnowledgeElement *KE_pt;
  KnowledgeElement *KE_buffer_pt;
  KnowledgeNode *KN_pt;
  vector<KnowledgeElement *>::iterator KE_itr;
  Statement *new_statement_pt;
  SentenceUnit *sent_pt;
  IDElement *label_ID_pt;
  Label *label_group_pt;
  vector<IDElement *>::iterator ID_itr;
  Investigator *invest_pt;
  int match = 0;
 
  KE_starting_pt = this->FindAKEbySentenceAndNegationSign(_statement_pt->m_sent_pt, !_statement_pt->m_state);
  if (KE_starting_pt == NULL) {
    return;
  }
 
  sent_pt = this->FindAnIndefiniteSentenceMatchTheInputSentence(KE_starting_pt->m_SentenceUnit_pt);
  if (sent_pt != NULL) {
    KE_starting_X_pt = this->FindAKEbySentenceAndNegationSign(sent_pt, KE_starting_pt->m_negation);
    label_ID_pt = _statement_pt->m_sent_pt->GetLabelOfThisSentence();
  }
  for (auto KU_itr = this->m_Knowledge_list.begin(); KU_itr != this->m_Knowledge_list.end(); KU_itr++) {
    if ((*KU_itr)->m_accessable_bl == false) { continue; }
 
    //First check the upperstream of this KnowledgeUnit
 
    if ((*KU_itr)->m_inference_type == 1 || (*KU_itr)->m_inference_type == 3) {
      match = 0;
      //0--not match
      //1--match witht the KE_starting_pt
      //2--match witht the KE_starting_X_pt
      if ((*KU_itr)->m_Ancestor_pt->m_ID_Type == 401) {
        KE_pt = (KnowledgeElement *) (*KU_itr)->m_Ancestor_pt;
        if (KE_pt == KE_starting_pt) {
          match = 1;
        } else if (KE_pt == KE_starting_X_pt) {
          match = 2;
        }
      } else if ((*KU_itr)->m_Ancestor_pt->m_ID_Type == 402) {
        KN_pt = (KnowledgeNode *) (*KU_itr)->m_Ancestor_pt;
        if (KN_pt->m_Node_Type == 3) {
          for (auto KE_itr = KN_pt->M_KElement_list.begin(); KE_itr != KN_pt->M_KElement_list.end(); KE_itr++) {
            if ((*KE_itr) == KE_starting_pt) {
              match = 1;
            }
          }
        }
      }
 
      if (match == 1) {
        KE_buffer_pt = (KnowledgeElement *) ((*KU_itr)->m_Descendant_pt);
        label_group_pt = this->m_IB->CheckWhetherASentenceContainIndefiniteItem(KE_buffer_pt->m_SentenceUnit_pt);
        if (label_group_pt != NULL) {
          for (ID_itr = label_group_pt->m_label_option_list.begin();
               ID_itr != label_group_pt->m_label_option_list.end(); ID_itr++) {
            sent_pt = this->InstantiateAnIndefiniteSentenceWithLabel(KE_buffer_pt->m_SentenceUnit_pt, (*ID_itr));
            if (sent_pt == NULL) {
              this->ErrorMessage("Error!");
              return;
            }
            { auto stmt_owned = make_unique<Statement>();
            new_statement_pt = stmt_owned.get();
            if (_statement_pt->m_factual_type == 1 || _statement_pt->m_factual_type == 2) {
              new_statement_pt->m_factual_type = 2;
            } else { new_statement_pt->m_factual_type = 3; }
            new_statement_pt->m_sent_pt = sent_pt;
            new_statement_pt->m_state = !KE_buffer_pt->m_negation;
            new_statement_pt->m_time_generated = r5pars_.timesno;
            new_statement_pt->m_time_range.CopyTimeRangeFromAnother(_statement_pt->m_time_range);
            new_statement_pt->CopyAuxInfoFromUpperstreamStatement(_statement_pt);
            new_statement_pt->m_upperstream_statement_list.push_back(_statement_pt);
            this->AddANewStatement(stmt_owned.release()); }
            this->m_MR->UpdateMRwithNewInference(new_statement_pt);
            _statement_pt->m_downstream_statement_list.push_back(new_statement_pt);
 
            if (this->FoundASimilarStatementInLast10Seconds(new_statement_pt) == NULL
                && this->FindAMatchingInvestigatorForAStatement(new_statement_pt) == false) {
              //add investigator for this new statement
              { auto invest_owned = make_unique<Investigator>();
              invest_pt = invest_owned.get();
              invest_pt->m_note = "by a statement";
              invest_pt->m_motivation = 1;
              invest_pt->m_Statement_pt = new_statement_pt;
              this->AddDeltaToCognitiveLoad(0.024); //type 4
              invest_pt->m_Happen = 3;
              invest_pt->m_operator = this->m_operator;
              invest_pt->m_root_of_a_thought_line = true;
              this->AddNewInvestigator(invest_owned.release());
              //link the statement to the statement pointer
              new_statement_pt->m_investigator_ID_pt = (IDElement *) invest_pt; }
            }
          }
        } else {
          { auto stmt_owned = make_unique<Statement>();
          new_statement_pt = stmt_owned.get();
          if (_statement_pt->m_factual_type == 1 || _statement_pt->m_factual_type == 2) {
            new_statement_pt->m_factual_type = 2;
          } else { new_statement_pt->m_factual_type = 3; }
          new_statement_pt->m_sent_pt = KE_buffer_pt->m_SentenceUnit_pt;
          new_statement_pt->m_state = !KE_buffer_pt->m_negation;
          new_statement_pt->m_time_generated = r5pars_.timesno;
          new_statement_pt->CopyAuxInfoFromUpperstreamStatement(_statement_pt);
          new_statement_pt->m_time_range.CopyTimeRangeFromAnother(_statement_pt->m_time_range);
          new_statement_pt->m_upperstream_statement_list.push_back(_statement_pt);
          _statement_pt->m_downstream_statement_list.push_back(new_statement_pt);
          this->AddANewStatement(stmt_owned.release()); }
          this->m_MR->UpdateMRwithNewInference(new_statement_pt);
 
          if (this->FoundASimilarStatementInLast10Seconds(new_statement_pt) == NULL
              && this->FindAMatchingInvestigatorForAStatement(new_statement_pt) == false) {
            //add investigator for this new statement
            { auto invest_owned = make_unique<Investigator>();
            invest_pt = invest_owned.get();
            invest_pt->m_note = "by a statement";
            invest_pt->m_motivation = 1;
            invest_pt->m_Statement_pt = new_statement_pt;
            this->AddDeltaToCognitiveLoad(0.024); //type 4
            invest_pt->m_Happen = 3;
            invest_pt->m_operator = this->m_operator;
            invest_pt->m_root_of_a_thought_line = true;
            this->AddNewInvestigator(invest_owned.release());
            //link the statement to the statement pointer
            new_statement_pt->m_investigator_ID_pt = (IDElement *) invest_pt; }
          }
        }
      } else if (match == 2) {
        KE_buffer_pt = (KnowledgeElement *) (*KU_itr)->m_Descendant_pt;
        sent_pt = this->InstantiateAnIndefiniteSentenceWithLabel(KE_buffer_pt->m_SentenceUnit_pt, label_ID_pt);
        if (sent_pt == NULL) {
          sent_pt = KE_buffer_pt->m_SentenceUnit_pt;
        }
        { auto stmt_owned = make_unique<Statement>();
        new_statement_pt = stmt_owned.get();
        if (_statement_pt->m_factual_type == 1 || _statement_pt->m_factual_type == 2) {
          new_statement_pt->m_factual_type = 2;
        } else { new_statement_pt->m_factual_type = 3; }
        new_statement_pt->m_sent_pt = sent_pt;
        new_statement_pt->m_state = !KE_buffer_pt->m_negation;
        new_statement_pt->m_time_generated = r5pars_.timesno;
        new_statement_pt->CopyAuxInfoFromUpperstreamStatement(_statement_pt);
        new_statement_pt->m_time_range.CopyTimeRangeFromAnother(_statement_pt->m_time_range);
        new_statement_pt->m_upperstream_statement_list.push_back(_statement_pt);
        _statement_pt->m_downstream_statement_list.push_back(new_statement_pt);
        this->AddANewStatement(stmt_owned.release()); }
        this->m_MR->UpdateMRwithNewInference(new_statement_pt);
        //add investigator for this new statement
        if (this->FoundASimilarStatementInLast10Seconds(new_statement_pt) == NULL
            && this->FindAMatchingInvestigatorForAStatement(new_statement_pt) == false) {
          { auto invest_owned = make_unique<Investigator>();
          invest_pt = invest_owned.get();
          invest_pt->m_note = "by a statement";
          invest_pt->m_motivation = 1;
          invest_pt->m_Statement_pt = new_statement_pt;
          this->AddDeltaToCognitiveLoad(0.024); //type 4
          invest_pt->m_Happen = 3;
          invest_pt->m_operator = this->m_operator;
          invest_pt->m_root_of_a_thought_line = true;
          this->AddNewInvestigator(invest_owned.release());
          //link the statement to the statement pointer
          new_statement_pt->m_investigator_ID_pt = (IDElement *) invest_pt; }
        }
      }
    }
 
    if ((*KU_itr)->m_inference_type == 2 || (*KU_itr)->m_inference_type == 3) {
      KE_pt = (KnowledgeElement *) (*KU_itr)->m_Descendant_pt;
 
      //caution: the inference only applies to one to one, KnowledgeNode is not included in the reference mechanism.
      if ((*KU_itr)->m_Ancestor_pt->m_ID_Type == 401) {//upperstream is a knowledge element
        if (KE_pt == KE_starting_pt) {
          KE_buffer_pt = (KnowledgeElement *) (*KU_itr)->m_Ancestor_pt;
          label_group_pt = this->m_IB->CheckWhetherASentenceContainIndefiniteItem(KE_buffer_pt->m_SentenceUnit_pt);
          if (label_group_pt != NULL) {
            for (ID_itr = label_group_pt->m_label_option_list.begin();
                 ID_itr != label_group_pt->m_label_option_list.end(); ID_itr++) {
              sent_pt = this->InstantiateAnIndefiniteSentenceWithLabel(KE_buffer_pt->m_SentenceUnit_pt, (*ID_itr));
              if (sent_pt == NULL) {
                this->ErrorMessage("Error!");
                return;
              }
              { auto stmt_owned = make_unique<Statement>();
              new_statement_pt = stmt_owned.get();
              if (_statement_pt->m_factual_type == 1 || _statement_pt->m_factual_type == 2) {
                new_statement_pt->m_factual_type = 2;
              } else { new_statement_pt->m_factual_type = 3; }
              new_statement_pt->m_sent_pt = sent_pt;
              new_statement_pt->m_state = !KE_buffer_pt->m_negation;
              new_statement_pt->m_time_generated = r5pars_.timesno;
              new_statement_pt->CopyAuxInfoFromUpperstreamStatement(_statement_pt);
              new_statement_pt->m_time_range.CopyTimeRangeFromAnother(_statement_pt->m_time_range);
              new_statement_pt->m_upperstream_statement_list.push_back(_statement_pt);
              _statement_pt->m_downstream_statement_list.push_back(new_statement_pt);
              this->AddANewStatement(stmt_owned.release()); }
              this->m_MR->UpdateMRwithNewInference(new_statement_pt);
              //add investigator for this new statement
              if (this->FoundASimilarStatementInLast10Seconds(new_statement_pt) == NULL
                  && this->FindAMatchingInvestigatorForAStatement(new_statement_pt) == false) {
                { auto invest_owned = make_unique<Investigator>();
                invest_pt = invest_owned.get();
                invest_pt->m_note = "by a statement";
                invest_pt->m_motivation = 1;
                invest_pt->m_Statement_pt = new_statement_pt;
                this->AddDeltaToCognitiveLoad(0.024); //type 4
                invest_pt->m_Happen = 3;
                invest_pt->m_operator = this->m_operator;
                invest_pt->m_root_of_a_thought_line = true;
                this->AddNewInvestigator(invest_owned.release());
                //link the statement to the statement pointer
                new_statement_pt->m_investigator_ID_pt = (IDElement *) invest_pt; }
              }
            }
          } else {
            { auto stmt_owned = make_unique<Statement>();
            new_statement_pt = stmt_owned.get();
            if (_statement_pt->m_factual_type == 1 || _statement_pt->m_factual_type == 2) {
              new_statement_pt->m_factual_type = 2;
            } else { new_statement_pt->m_factual_type = 3; }
            new_statement_pt->m_sent_pt = KE_buffer_pt->m_SentenceUnit_pt;
            new_statement_pt->m_state = !KE_buffer_pt->m_negation;
            new_statement_pt->m_time_generated = r5pars_.timesno;
            new_statement_pt->CopyAuxInfoFromUpperstreamStatement(_statement_pt);
            new_statement_pt->m_time_range.CopyTimeRangeFromAnother(_statement_pt->m_time_range);
            new_statement_pt->m_upperstream_statement_list.push_back(_statement_pt);
            _statement_pt->m_downstream_statement_list.push_back(new_statement_pt);
            this->AddANewStatement(stmt_owned.release()); }
            this->m_MR->UpdateMRwithNewInference(new_statement_pt);
            //add investigator for this new statement
            if (this->FoundASimilarStatementInLast10Seconds(new_statement_pt) == NULL
                && this->FindAMatchingInvestigatorForAStatement(new_statement_pt) == false) {
              { auto invest_owned = make_unique<Investigator>();
              invest_pt = invest_owned.get();
              invest_pt->m_note = "by a statement";
              invest_pt->m_motivation = 1;
              invest_pt->m_Statement_pt = new_statement_pt;
              this->AddDeltaToCognitiveLoad(0.024); //type 4
              invest_pt->m_Happen = 3;
              invest_pt->m_operator = this->m_operator;
              invest_pt->m_root_of_a_thought_line = true;
              this->AddNewInvestigator(invest_owned.release());
              //link the statement to the statement pointer
              new_statement_pt->m_investigator_ID_pt = (IDElement *) invest_pt; }
            }
          }
        } else if (KE_pt == KE_starting_X_pt) {
          KE_buffer_pt = (KnowledgeElement *) (*KU_itr)->m_Ancestor_pt;
          sent_pt = this->InstantiateAnIndefiniteSentenceWithLabel(KE_buffer_pt->m_SentenceUnit_pt, label_ID_pt);
          if (sent_pt == NULL) {
            sent_pt = KE_buffer_pt->m_SentenceUnit_pt;
          }
          { auto stmt_owned = make_unique<Statement>();
          new_statement_pt = stmt_owned.get();
          if (_statement_pt->m_factual_type == 1 || _statement_pt->m_factual_type == 2) {
            new_statement_pt->m_factual_type = 2;
          } else { new_statement_pt->m_factual_type = 3; }
          new_statement_pt->m_sent_pt = sent_pt;
          new_statement_pt->m_state = !KE_buffer_pt->m_negation;
          new_statement_pt->m_time_generated = r5pars_.timesno;
          new_statement_pt->CopyAuxInfoFromUpperstreamStatement(_statement_pt);
          new_statement_pt->m_time_range.CopyTimeRangeFromAnother(_statement_pt->m_time_range);
          new_statement_pt->m_upperstream_statement_list.push_back(_statement_pt);
          _statement_pt->m_downstream_statement_list.push_back(new_statement_pt);
          this->AddANewStatement(stmt_owned.release()); }
          this->m_MR->UpdateMRwithNewInference(new_statement_pt);
          //add investigator for this new statement
          {
            auto invest_owned = make_unique<Investigator>();
            invest_pt = invest_owned.get();
            invest_pt->m_note = "by a statement";
            invest_pt->m_motivation = 1;
            invest_pt->m_Statement_pt = new_statement_pt;
            this->AddDeltaToCognitiveLoad(0.024); //type 4
            invest_pt->m_Happen = 3;
            invest_pt->m_operator = this->m_operator;
            invest_pt->m_root_of_a_thought_line = true;
            this->AddNewInvestigator(invest_owned.release());
            //link the statement to the statement pointer
            new_statement_pt->m_investigator_ID_pt = (IDElement *) invest_pt;
          }
        }
      } else if ((*KU_itr)->m_Ancestor_pt->m_ID_Type == 402) {// upperstream is a knowledge node
      }
    }
  }
 
}
 
void ReasonMachine::SaveSequenceInfoToFile() {
  string dir_path, statement_path, invest_path, MR_path, esb_path, link_path, history_path, dynamic_path,
      thought_line_path, activation_path;
  stringstream conv;
 
  //get the output file directory
  int es_id = g_sim.Branch_center.getIDOfRecentGeneratedES();
  conv.str("");
  conv << es_id;
 
  dir_path = g_sim.SScheduler.getOutputDirectory();
  dir_path += "RMOutPut/";
  statement_path = dir_path + "ODM_statements_" + conv.str() + ".txt";
  invest_path = dir_path + "ODM_investigations_" + conv.str() + ".txt";
  MR_path = dir_path + "ODM_MentalRepresentation_" + conv.str() + ".txt";
  esb_path = dir_path + "ODM_DiagnoseInvestigation_" + conv.str() + ".txt";
  link_path = dir_path + "ODM_InvestigationLink_" + conv.str() + ".txt";
  history_path = dir_path + "ODM_History_" + conv.str() + ".txt";
  dynamic_path = dir_path + "ODM_PSF_Dynamic_Parameter_History_" + conv.str() + ".txt";
  thought_line_path = dir_path + "ODM_thougt_line_history_" + conv.str() + ".txt";
  //activation_path = "C://ADS//examples//Beaver_Valley_benchmark//Output//KPS//KPSFolder_0//";
  //activation_path += "ZKPS_" + conv.str() + ".txt";
  activation_path = dir_path + "ODM_Activation_" + conv.str() + ".txt";
 
  this->SaveStatementsToFile(statement_path);
  this->SaveInvestigationsToFile(invest_path);
  this->SaveInvestigationLinkInfo(link_path);
  this->SaveRMHisoty(history_path);
  this->SaveThoughtLineHistory(thought_line_path);
  this->m_MR->SaveMentalRepresentationInforToFile(MR_path);
  this->m_event_schema_base->SaveAllDiagnoseInvestigatorInforToFile(esb_path);
  this->SavePSFandDynamicParametersToFile(dynamic_path);
  this->m_Concept_Base->SaveConceptActivationIntoOutputFile(activation_path);
}
 
void ReasonMachine::SaveStatementsToFile(string _path) {
  vector<Statement *>::iterator statement_itr;
  Statement *statement_pt;
 
  ofstream fout(_path.c_str(), ios::out);
  for (auto statement_itr = this->m_Statement_list.begin(); statement_itr != this->m_Statement_list.end(); statement_itr++) {
    statement_pt = statement_itr->get();
    fout
        << statement_pt->m_ID << '\t'
        << statement_pt->m_time_generated << '\t'
        << statement_pt->m_sent_pt->m_ID << '\t';
    if (statement_pt->m_state == true) {
      fout << "true" << '\t';
    } else {
      fout << "false" << '\t';
    }
 
    fout << "confidence: " << statement_pt->m_confidence << '\t';
 
    if (statement_pt->m_time_range.m_start_time != 0) {
      fout << "<" << statement_pt->m_time_range.m_start_time << " , ";
    } else {
      fout << "(" << statement_pt->m_time_range.m_time_after << " , ";
    }
    if (statement_pt->m_time_range.m_end_time != 0) {
      fout << statement_pt->m_time_range.m_end_time << ">";
    } else {
      fout << statement_pt->m_time_range.m_time_before << ")";
    }
    fout << '\n';
  }
  fout.close();
}
 
void ReasonMachine::SaveInvestigationsToFile(string _path) {
  vector<Investigator *>::iterator invest_itr;
  Investigator *invest_pt;
  Investigator *invest_buffer_pt;
  InvestigatorLink *invest_link_pt;
  KnowledgeElement *KE_pt;
  vector<int>::iterator token_itr;
  vector<IDElement *>::iterator link_ID_itr;
  vector<IDElement *>::iterator invest_ID_itr;
  vector<float>::iterator fl_itr;
 
  ofstream fout(_path.c_str(), ios::out);
 
 
  //Add the header line
  fout
      << "Investigator ID" << '\t'
      << "Is a Root" << '\t'
      << "Statement Info" << '\t'
      << "KnowledgeElement Info" << '\t'
      << "Happen or Not" << '\t'
      << "Explained or Not" << '\t'
      << "Investigator Token history" << '\t'
      << "Upperstream Investigators" << '\t'
      << "Derived by" << '\t'
      << "investigation initiate time" << '\t'
      << "investigation cease time" << '\t'
      << "Dormant or Not" << '\t'
      << "Link to SymptomInvestigator" << '\t'
      << "Open status" << '\n';
 
  for (auto invest_itr = this->m_investigator_pool.begin(); invest_itr != this->m_investigator_pool.end(); invest_itr++) {
    invest_pt = invest_itr->get();
    //if(invest_pt->m_invest_dormant == true)
    //{continue;}
    //ID
    fout << invest_pt->m_ID << '\t';
    //Is it the first one in the thread
    if (invest_pt->m_downstream_ID_list.size() == 0 || invest_pt->m_motivation == 1) {
      fout << "Origin" << '\t';
    } else {
      fout << "Derived" << '\t';
    }
    //statement info
    if (invest_pt->m_Statement_pt != NULL) {
      fout << invest_pt->m_Statement_pt->m_ID << ": ";
      fout << invest_pt->m_Statement_pt->m_sent_pt->m_ID << " ";
      if (invest_pt->m_Statement_pt->m_state == true) {
        //fout << "true ";
      } else {
        fout << "false ";
      }
    } else if (invest_pt->m_possible_statement_pt != NULL) {
      fout << invest_pt->m_possible_statement_pt->m_ID << ": ";
      fout << invest_pt->m_possible_statement_pt->m_sent_pt->m_ID << " ";
      if (invest_pt->m_possible_statement_pt->m_state == true) {
        //fout << "true ";
      } else {
        fout << "false ";
      }
    } else if (invest_pt->m_inconsistant_statement != NULL) {
      fout << invest_pt->m_inconsistant_statement->m_ID << ": ";
      fout << invest_pt->m_inconsistant_statement->m_sent_pt->m_ID << " ";
      if (invest_pt->m_inconsistant_statement->m_state == true) {
        //fout << "true ";
      } else {
        fout << "false ";
      }
    }
    fout << '\t';
 
    //KnoweldgeElement Info
    if (invest_pt->m_KElement_ID_pt != NULL) {
      KE_pt = (KnowledgeElement *) invest_pt->m_KElement_ID_pt;
      fout << KE_pt->m_SentenceUnit_pt->m_ID << " ";
      if (KE_pt->m_negation == false) {
        //fout << " true ";
      } else {
        fout << " false ";
      }
      fout << "(" << invest_pt->m_effective_start;
      fout << " , ";
      fout << invest_pt->m_effective_end << ")";
    }
    fout << '\t';
 
    //Happen of Not?
    switch (invest_pt->m_Happen) {
      case 1: fout << "?";
        break;
      case 2: fout << "U";
        break;
      case 3: fout << "Yes";
        break;
      case 4: fout << "No";
        break;
    }
    fout << '\t';
 
    //Explained or Not?
    switch (invest_pt->m_explained) {
      case 1: fout << "?";
        break;
      case 2: fout << "U";
        break;
      case 3: fout << "Succeeded";
        break;
      case 4: fout << "Failed";
        break;
      default: break;
    }
    fout << '\t';
    // to be added, the explanation information
    /*if(invest_pt->m_explanation_link_list.size() > 0)
        {
            invest_link_pt = (InvestigatorLink *)(*invest_pt->m_explanation_link_list.begin());
            fout << (*invest_link_pt->m_upperstream_ID_list.begin())->m_ID ;
        }
        fout << '\t';*/
    fl_itr = invest_pt->m_invest_token_endtime_history.begin();
    for (token_itr = invest_pt->m_investigator_token_history.begin();
         token_itr != invest_pt->m_investigator_token_history.end(); token_itr++) {
      fout << "(" << (*token_itr) << "-" << (*fl_itr) << ") ";
      fl_itr++;
    }
 
    fout << invest_pt->m_investigator_token;
    fout << '\t';
 
    for (link_ID_itr = invest_pt->m_upperstream_ID_list.begin(); link_ID_itr != invest_pt->m_upperstream_ID_list.end();
         link_ID_itr++) {
      invest_link_pt = (InvestigatorLink *) (*link_ID_itr);
      for (invest_ID_itr = invest_link_pt->m_upperstream_ID_list.begin();
           invest_ID_itr != invest_link_pt->m_upperstream_ID_list.end(); invest_ID_itr++) {
        invest_buffer_pt = (Investigator *) (*invest_ID_itr);
        fout << (*invest_ID_itr)->m_ID << ": " << invest_buffer_pt->m_Happen;
      }
    }
    fout << '\t';
    fout << invest_pt->m_note;
    fout << '\t';
    fout << invest_pt->m_investigation_initiate_time << '\t';
    fout << invest_pt->m_investigation_cease_time << '\t';
    fout << invest_pt->m_invest_dormant << '\t';
    if (invest_pt->m_SI_ID_pt != NULL) { fout << invest_pt->m_SI_ID_pt->m_ID; }
    else { fout << "NONE"; }
    if (invest_pt->m_investigation_closed == true) { fout << "closed"; }
    else { fout << "open"; }
    fout << '\n';
  }
  fout.close();
}
 
KnowledgeUnit *ReasonMachine::FindKnowledgeUnitByID(string str_ID) {
  KnowledgeUnit *KU_found_pt = NULL;
  for (auto KU_itr = this->m_Knowledge_list.begin(); KU_itr != this->m_Knowledge_list.end() && KU_found_pt == NULL;
       KU_itr++) {
    if ((*KU_itr)->m_ID == str_ID) {
      KU_found_pt = KU_itr->get();
    }
  }
  return KU_found_pt;
}
 
void ReasonMachine::AddANewDiagnoseInvestigator(DiagnoseInvestigator *_diagnose_invest_pt) {
 
}
 
void ReasonMachine::ZeroAllTheInterestFromSymptomInvestigator() {
  vector<Investigator *>::iterator invest_itr;
  vector<InvestigatorLink *>::iterator invest_link_itr;
 
  for (auto invest_itr = this->m_unresolved_investigator_pool.begin();
       invest_itr != this->m_unresolved_investigator_pool.end(); invest_itr++) {
    (*invest_itr)->m_interest_from_SymptomInvestigator = 0;
  }
  for (auto invest_link_itr = this->m_investigator_link_pool.begin();
       invest_link_itr != this->m_investigator_link_pool.end(); invest_link_itr++) {
    (*invest_link_itr)->m_interest_from_SymptomInvestigator = 0;
  }
}
 
void ReasonMachine::WaitOneStepThereIsOneOrMoreOperatorBranches() {
  this->BalanceTimerWithUnconsumedTime();
  if (this->m_consumed_time < this->m_time_length) {
    this->m_consumed_time = this->m_time_length;
  }
  return;
}
 
void ReasonMachine::CopyReasonMachineFromAnotherRM(ReasonMachine *_RM_pt) {
 
  /*
    StringTimeIntervalUnit * m_current_thought_line_info;
    vector<StringTimeIntervalUnit *> m_thought_line_history;
 
    StringTimeIntervalUnit * m_current_investigation_info;
    vector<StringTimeIntervalUnit *> m_investigation_history;
 
    //float m_ability_of_integrating_evidence;
    */
  StringTimeIntervalUnit *info_pt;
 
  if (_RM_pt->m_current_thought_line_info != nullptr) {
    this->m_current_thought_line_info = make_unique<StringTimeIntervalUnit>();
    this->m_current_thought_line_info->CopyFromAnotherStringTimeIntervalUnit(_RM_pt->m_current_thought_line_info.get());
  }
  if (_RM_pt->m_current_investigation_info != nullptr) {
    this->m_current_investigation_info = make_unique<StringTimeIntervalUnit>();
    this->m_current_investigation_info->CopyFromAnotherStringTimeIntervalUnit(_RM_pt->m_current_investigation_info.get());
  }
 
  if (this->m_investigation_history.size() != 0) {
    this->ErrorMessage("this->m_investigation_history.size() != 0");
    return;
  }
  if (this->m_thought_line_history.size() != 0) {
    this->ErrorMessage("this->m_thought_line_history.size() != 0");
    return;
  }
 
  for (auto info_itr = _RM_pt->m_investigation_history.begin(); info_itr != _RM_pt->m_investigation_history.end();
       info_itr++) {
    auto info_owned = make_unique<StringTimeIntervalUnit>();
    info_owned->CopyFromAnotherStringTimeIntervalUnit(info_itr->get());
    this->m_investigation_history.push_back(std::move(info_owned));
  }
 
  for (auto info_itr = _RM_pt->m_thought_line_history.begin(); info_itr != _RM_pt->m_thought_line_history.end();
       info_itr++) {
    auto info_owned = make_unique<StringTimeIntervalUnit>();
    info_owned->CopyFromAnotherStringTimeIntervalUnit(info_itr->get());
    this->m_thought_line_history.push_back(std::move(info_owned));
  }
 
 
  //firstly, copy the short variables
  this->m_alarm_disruption_time_consumption = _RM_pt->m_alarm_disruption_time_consumption;
  this->m_block_alarm_jam = _RM_pt->m_block_alarm_jam;
  this->m_consumed_time = _RM_pt->m_consumed_time;
  this->m_decay_constant_lamda = _RM_pt->m_decay_constant_lamda;
  this->m_decay_lamda = _RM_pt->m_decay_lamda;
  this->m_first_round_check_done = _RM_pt->m_first_round_check_done;
  this->m_Interpretation_time_consumption = _RM_pt->m_Interpretation_time_consumption;
  this->m_leisure_time = _RM_pt->m_leisure_time;
  this->m_max_length_of_alarms_stack = _RM_pt->m_max_length_of_alarms_stack;
  this->m_operator = _RM_pt->m_operator;
  this->m_RM_Token = _RM_pt->m_RM_Token;
  this->m_time_length = _RM_pt->m_time_length;
  this->m_timer_RM = _RM_pt->m_timer_RM;
  this->m_problem_solving_style = _RM_pt->m_problem_solving_style;
  this->m_proximity = make_unique<ProximityModel>();
  this->m_proximity->CopyProximityModelFromAnother(_RM_pt->m_proximity.get());
  this->m_ability_of_integrating_evidence = _RM_pt->m_ability_of_integrating_evidence;
  this->m_attention_span = _RM_pt->m_attention_span;
  this->m_memory_span = _RM_pt->m_memory_span;
  this->m_interuptiveness = _RM_pt->m_interuptiveness;
  this->m_goofy_start_time = _RM_pt->m_goofy_start_time;
 
  this->m_initial_fatigue_level = _RM_pt->m_initial_fatigue_level;
  this->m_fatigue_level = _RM_pt->m_fatigue_level;
  this->m_diagnosis_complexity = _RM_pt->m_diagnosis_complexity;
  this->m_expert_level = _RM_pt->m_expert_level;
  this->m_cognitive_load = _RM_pt->m_cognitive_load;
  this->m_overall_stress = _RM_pt->m_overall_stress;
  this->m_routine_monitor_threshold = _RM_pt->m_routine_monitor_threshold;
 
  this->m_cognitive_resource_use = _RM_pt->m_cognitive_resource_use;
  this->m_system_dynamic_level = _RM_pt->m_system_dynamic_level;
  this->m_load_stress_integration_of_time = _RM_pt->m_load_stress_integration_of_time;
  this->m_attention_span_base_value = _RM_pt->m_attention_span_base_value;
  this->m_memory_span_base_value = _RM_pt->m_memory_span_base_value;
  this->m_decay_time_base_value = _RM_pt->m_decay_time_base_value;
  this->m_routine_monitor_interval_multiplier = _RM_pt->m_routine_monitor_interval_multiplier;
  this->m_decay_time = _RM_pt->m_decay_time;
 
 
  // moderate complex variables
  //this->m_RM_Token_history
  vector<int>::iterator i_itr;
  vector<float>::iterator fl_itr;
  for (i_itr = _RM_pt->m_RM_Token_history.begin(); i_itr != _RM_pt->m_RM_Token_history.end(); i_itr++) {
    this->m_RM_Token_history.push_back(*i_itr);
  }
  for (fl_itr = _RM_pt->m_RM_token_endtime_history.begin(); fl_itr != _RM_pt->m_RM_token_endtime_history.end();
       fl_itr++) {
    this->m_RM_token_endtime_history.push_back(*fl_itr);
  }
/*
    vector<ValueTimeLineUnit *> m_max_alarm_length_timeline;
    vector<ValueTimeLineUnit *> m_cognitive_time_cost_multiplier_timeline;*/
  vector<ValueTimeLineUnit *>::iterator v_itr;
  ValueTimeLineUnit *v_pt;
 
  if (this->m_max_alarm_length_timeline.size()
      > 0) { this->ErrorMessage("this->m_max_alarm_length_timeline.size() > 0"); }
  if (this->m_cognitive_time_cost_multiplier_timeline.size() > 0) {
    this->ErrorMessage("this->m_max_alarm_length_timeline.size() > 0");
  }
 
  //PSF history
 
  for (auto v_itr = _RM_pt->m_time_load_history.begin(); v_itr != _RM_pt->m_time_load_history.end(); v_itr++) {
    auto v_owned = make_unique<ValueTimeLineUnit>();
    v_owned->CopyFromAnotherVTLU(v_itr->get());
    this->m_time_load_history.push_back(std::move(v_owned));
  }
  for (auto v_itr = _RM_pt->m_fatigue_history.begin(); v_itr != _RM_pt->m_fatigue_history.end(); v_itr++) {
    auto v_owned = make_unique<ValueTimeLineUnit>();
    v_owned->CopyFromAnotherVTLU(v_itr->get());
    this->m_fatigue_history.push_back(std::move(v_owned));
  }
  for (auto v_itr = _RM_pt->m_diagnosis_complexity_history.begin(); v_itr != _RM_pt->m_diagnosis_complexity_history.end();
       v_itr++) {
    auto v_owned = make_unique<ValueTimeLineUnit>();
    v_owned->CopyFromAnotherVTLU(v_itr->get());
    this->m_diagnosis_complexity_history.push_back(std::move(v_owned));
  }
  for (auto v_itr = _RM_pt->m_cognitive_load_history.begin(); v_itr != _RM_pt->m_cognitive_load_history.end(); v_itr++) {
    auto v_owned = make_unique<ValueTimeLineUnit>();
    v_owned->CopyFromAnotherVTLU(v_itr->get());
    this->m_cognitive_load_history.push_back(std::move(v_owned));
  }
  for (auto v_itr = _RM_pt->m_stress_history.begin(); v_itr != _RM_pt->m_stress_history.end(); v_itr++) {
    auto v_owned = make_unique<ValueTimeLineUnit>();
    v_owned->CopyFromAnotherVTLU(v_itr->get());
    this->m_stress_history.push_back(std::move(v_owned));
  }
//manifestation parameters
  for (auto v_itr = _RM_pt->m_cognitive_resouse_use_history.begin(); v_itr != _RM_pt->m_cognitive_resouse_use_history.end();
       v_itr++) {
    auto v_owned = make_unique<ValueTimeLineUnit>();
    v_owned->CopyFromAnotherVTLU(v_itr->get());
    this->m_cognitive_resouse_use_history.push_back(std::move(v_owned));
  }
 
  for (auto v_itr = _RM_pt->m_routine_monitor_interval_multiplier_history.begin();
       v_itr != _RM_pt->m_routine_monitor_interval_multiplier_history.end(); v_itr++) {
    auto v_owned = make_unique<ValueTimeLineUnit>();
    v_owned->CopyFromAnotherVTLU(v_itr->get());
    this->m_routine_monitor_interval_multiplier_history.push_back(std::move(v_owned));
  }
  for (auto v_itr = _RM_pt->m_attention_span_history.begin(); v_itr != _RM_pt->m_attention_span_history.end(); v_itr++) {
    auto v_owned = make_unique<ValueTimeLineUnit>();
    v_owned->CopyFromAnotherVTLU(v_itr->get());
    this->m_attention_span_history.push_back(std::move(v_owned));
  }
  for (auto v_itr = _RM_pt->m_memory_span_history.begin(); v_itr != _RM_pt->m_memory_span_history.end(); v_itr++) {
    auto v_owned = make_unique<ValueTimeLineUnit>();
    v_owned->CopyFromAnotherVTLU(v_itr->get());
    this->m_memory_span_history.push_back(std::move(v_owned));
  }
  for (auto v_itr = _RM_pt->m_decay_time_history.begin(); v_itr != _RM_pt->m_decay_time_history.end(); v_itr++) {
    auto v_owned = make_unique<ValueTimeLineUnit>();
    v_owned->CopyFromAnotherVTLU(v_itr->get());
    this->m_decay_time_history.push_back(std::move(v_owned));
  }
  for (auto v_itr = _RM_pt->m_cognitive_time_cost_multiplier_history.begin();
       v_itr != _RM_pt->m_cognitive_time_cost_multiplier_history.end(); v_itr++) {
    auto v_owned = make_unique<ValueTimeLineUnit>();
    v_owned->CopyFromAnotherVTLU(v_itr->get());
    this->m_cognitive_time_cost_multiplier_history.push_back(std::move(v_owned));
  }
 
  for (auto v_itr = _RM_pt->m_max_alarm_length_timeline.begin(); v_itr != _RM_pt->m_max_alarm_length_timeline.end();
       v_itr++) {
    auto v_owned = make_unique<ValueTimeLineUnit>();
    v_owned->CopyFromAnotherVTLU(v_itr->get());
    this->m_max_alarm_length_timeline.push_back(std::move(v_owned));
  }
 
  for (auto v_itr = _RM_pt->m_cognitive_time_cost_multiplier_timeline.begin();
       v_itr != _RM_pt->m_cognitive_time_cost_multiplier_timeline.end(); v_itr++) {
    auto v_owned = make_unique<ValueTimeLineUnit>();
    v_owned->CopyFromAnotherVTLU(v_itr->get());
    this->m_cognitive_time_cost_multiplier_timeline.push_back(std::move(v_owned));
  }
  //complex structured variables
  //this->m_Concept_Base
  this->m_Concept_Base->CopyStaticKBConceptFromAnother(_RM_pt->m_Concept_Base.get());
 
  //this->m_IB
  this->m_IB->CopyInstantiationBaseFromAnotherIB(_RM_pt->m_IB.get());
 
  //this->m_Semantic_list
  this->CopySemanticInfoFromAnotherSemanticBase(_RM_pt);
 
  //this->m_KE_list
  this->CopyStaticKEfromAnotherRM(_RM_pt);
 
  //this->m_KN_list
  this->CopyStaticKNfromAnotherRM(_RM_pt);
 
  //this->m_Knowledge_list
  KnowledgeUnit *KU_pt;
  if (this->m_Knowledge_list.size() != 0) {
    this->ErrorMessage("this->m_Knowledge_list.size() != 0");
  }
  for (auto KU_itr = _RM_pt->m_Knowledge_list.begin(); KU_itr != _RM_pt->m_Knowledge_list.end(); KU_itr++) {
    auto KU_owned = make_unique<KnowledgeUnit>();
    KU_owned->CopyStaticKnowledgeUnitInfoFromAnother(KU_itr->get());
    this->m_Knowledge_list.push_back(std::move(KU_owned));
  }
 
  //this->m_routine_monitor
  this->m_routine_monitor->CopyRoutineMonitorInfoFromAnother(_RM_pt->m_routine_monitor.get());
 
 
  //this->m_event_schema_base
  this->m_event_schema_base->CopyESBinfoFromAnother(_RM_pt->m_event_schema_base.get());
  //need to copy the dynamic information
 
  //this->m_MR
  this->m_MR->CopyMentalRepresentationFromAnother(_RM_pt->m_MR.get());
 
  vector<Investigator *>::iterator invest_itr;
  Investigator *invest_pt;
  //this->m_investigator_pool
  if (this->m_investigator_pool.size() != 0) {
    this->ErrorMessage("if(this->m_investigator_pool.size() != 0");
    return;
  }
  for (auto invest_itr = _RM_pt->m_investigator_pool.begin(); invest_itr != _RM_pt->m_investigator_pool.end();
       invest_itr++) {
    auto invest_owned = make_unique<Investigator>();
    invest_owned->CopyInvestigatorInfoFromAnother(invest_itr->get());
    this->m_investigator_pool.push_back(std::move(invest_owned));
  }
 
  //this->m_Statement_list
  vector<Statement *>::iterator state_itr;
  Statement *state_pt;
  if (this->m_Statement_list.size() != 0) {
    this->ErrorMessage("this->m_Statement_list.size() != 0");
    return;
  }
  for (auto state_itr = _RM_pt->m_Statement_list.begin(); state_itr != _RM_pt->m_Statement_list.end(); state_itr++) {
    auto state_owned = make_unique<Statement>();
    state_owned->CopyStatementInfoFromAnother(state_itr->get());
    this->m_Statement_list.push_back(std::move(state_owned));
  }
 
  //this->m_investigator_link_pool
  vector<InvestigatorLink *>::iterator link_itr;
  InvestigatorLink *link_pt;
  if (this->m_investigator_link_pool.size() != 0) {
    this->ErrorMessage("this->m_investigator_link_pool.size() != 0");
    return;
  }
  for (auto link_itr = _RM_pt->m_investigator_link_pool.begin(); link_itr != _RM_pt->m_investigator_link_pool.end();
       link_itr++) {
    auto link_owned = make_unique<InvestigatorLink>();
    link_owned->CopyInvestigatorLinkInfoFromAnother(link_itr->get());
    this->m_investigator_link_pool.push_back(std::move(link_owned));
  }
 
  //this->m_working_on_invest_link_pt
  //this->m_working_on_invest_pt
  //this->m_reading_indication_ID_pt
/*
    string m_ID_working_on_invest;
    string m_ID_working_on_invest_link;
    string m_ID_reading_indication;
*/
  if (_RM_pt->m_working_on_invest_link_pt != NULL) {
    this->m_ID_working_on_invest_link = _RM_pt->m_working_on_invest_link_pt->m_ID;
  } else { this->m_ID_working_on_invest_link = _RM_pt->m_ID_working_on_invest_link; }
 
  if (_RM_pt->m_working_on_invest_pt != NULL) { this->m_ID_working_on_invest = _RM_pt->m_working_on_invest_pt->m_ID; }
  else { this->m_ID_working_on_invest = _RM_pt->m_ID_working_on_invest; }
 
  if (_RM_pt->m_reading_indication_ID_pt != NULL) {
    this->m_ID_reading_indication = _RM_pt->m_reading_indication_ID_pt->m_ID;
  } else { this->m_ID_reading_indication = _RM_pt->m_ID_reading_indication; }
 
  if (this->m_ID_unresolved_invest_pool.size() != 0) {
    this->ErrorMessage("this->m_ID_unresolved_invest_pool.size() != 0");
    return;
  }
  if (this->m_ID_resolved_invest_pool.size() != 0) {
    this->ErrorMessage("this->m_ID_resolved_invest_pool.size() != 0");
    return;
  }
  if (this->m_ID_succes_invest_pool.size() != 0) {
    this->ErrorMessage("this->m_ID_succes_invest_pool.size() != 0");
    return;
  }
  if (this->m_ID_failed_invest_pool.size() != 0) {
    this->ErrorMessage("this->m_ID_failed_invest_pool.size() != 0");
    return;
  }
  if (this->m_ID_undertermined_invest_pool.size() != 0) {
    this->ErrorMessage("this->m_ID_undertermined_invest_pool.size() != 0");
    return;
  }
  if (this->m_ID_discarded_invest_pool.size() != 0) {
    this->ErrorMessage("this->m_ID_discarded_invest_pool.size() != 0");
    return;
  }
  if (this->m_ID_cause_undertermined_invest_pool.size() != 0) {
    this->ErrorMessage("this->m_ID_cause_undertermined_invest_pool.size() != 0");
    return;
  }
  if (this->m_ID_feedback_stack.size() != 0) {
    this->ErrorMessage("this->m_ID_feedback_stack.size() != 0");
    return;
  }
  if (this->m_ID_invest_trace.size() != 0) {
    this->ErrorMessage("this->m_ID_invest_trace.size() != 0");
    return;
  }
  //this->m_cause_undetermined_investigato_pool
  //this->m_discarded_investigator_pool
  //this->m_failed_investigator_pool
  //this->m_resolved_investigator_pool
  //this->m_success_investigator_pool
  //this->m_undetermined_investigator_pool
  //this->m_unresolved_investigator_pool
  //this->m_feedback_stack
  //this->m_investigation_trace
/*
    vector<Investigator *> m_unresolved_investigator_pool;
    vector<Investigator *> m_resolved_investigator_pool;
    vector<Investigator *> m_success_investigator_pool; //3098, 3030
    vector<Investigator *> m_failed_investigator_pool; //
    vector<Investigator *> m_undetermined_investigator_pool; //3031
    vector<Investigator *> m_discarded_investigator_pool; //3090
    vector<Investigator *> m_cause_undetermined_investigato_poolm_cause_undetermined_investigato_pool; //3097
    vector<IDElement*> m_feedback_stack;
    vector<IDElement *> m_investigation_trace;
 
    vector<string> m_ID_unresolved_invest_pool;
    vector<string> m_ID_resolved_invest_pool;
    vector<string> m_ID_succes_invest_pool;
    vector<string> m_ID_failed_invest_pool;
    vector<string> m_ID_undertermined_invest_pool;
    vector<string> m_ID_discarded_invest_pool;
    vector<string> m_ID_cause_undertermined_invest_pool;
    vector<string> m_ID_feedback_stack;
    vector<string> m_ID_invest_trace;
*/
  vector<string>::iterator str_itr;
  string ID;
 
  if (this->m_ongoing_item_stack.size() != 0) { this->ErrorMessage("this->m_ongoing_item_stack.size() != 0"); }
 
  for (str_itr = _RM_pt->m_ongoing_item_stack.begin(); str_itr != _RM_pt->m_ongoing_item_stack.end(); str_itr++) {
    ID = *str_itr;
    this->m_ongoing_item_stack.push_back(ID);
  }
 
  if (_RM_pt->m_unresolved_investigator_pool.size() != 0) {
    for (auto invest_itr = _RM_pt->m_unresolved_investigator_pool.begin();
         invest_itr != _RM_pt->m_unresolved_investigator_pool.end(); invest_itr++) {
      ID = (*invest_itr)->m_ID;
      this->m_ID_unresolved_invest_pool.push_back(ID);
    }
  } else {
    for (str_itr = _RM_pt->m_ID_unresolved_invest_pool.begin(); str_itr != _RM_pt->m_ID_unresolved_invest_pool.end();
         str_itr++) {
      ID = *str_itr;
      this->m_ID_unresolved_invest_pool.push_back(ID);
    }
  }
 
  if (_RM_pt->m_resolved_investigator_pool.size() != 0) {
    for (auto invest_itr = _RM_pt->m_resolved_investigator_pool.begin();
         invest_itr != _RM_pt->m_resolved_investigator_pool.end(); invest_itr++) {
      ID = (*invest_itr)->m_ID;
      this->m_ID_resolved_invest_pool.push_back(ID);
    }
  } else {
    for (str_itr = _RM_pt->m_ID_resolved_invest_pool.begin(); str_itr != _RM_pt->m_ID_resolved_invest_pool.end();
         str_itr++) {
      ID = *str_itr;
      this->m_ID_resolved_invest_pool.push_back(ID);
    }
  }
 
  if (_RM_pt->m_success_investigator_pool.size() != 0) {
    for (auto invest_itr = _RM_pt->m_success_investigator_pool.begin();
         invest_itr != _RM_pt->m_success_investigator_pool.end(); invest_itr++) {
      ID = (*invest_itr)->m_ID;
      this->m_ID_succes_invest_pool.push_back(ID);
    }
  } else {
    for (str_itr = _RM_pt->m_ID_succes_invest_pool.begin(); str_itr != _RM_pt->m_ID_succes_invest_pool.end();
         str_itr++) {
      ID = *str_itr;
      this->m_ID_succes_invest_pool.push_back(ID);
    }
  }
  if (_RM_pt->m_failed_investigator_pool.size() != 0) {
    for (auto invest_itr = _RM_pt->m_failed_investigator_pool.begin();
         invest_itr != _RM_pt->m_failed_investigator_pool.end(); invest_itr++) {
      ID = (*invest_itr)->m_ID;
      this->m_ID_failed_invest_pool.push_back(ID);
    }
  } else {
    for (str_itr = _RM_pt->m_ID_failed_invest_pool.begin(); str_itr != _RM_pt->m_ID_failed_invest_pool.end();
         str_itr++) {
      ID = *str_itr;
      this->m_ID_failed_invest_pool.push_back(ID);
    }
  }
 
  if (_RM_pt->m_undetermined_investigator_pool.size() != 0) {
    for (auto invest_itr = _RM_pt->m_undetermined_investigator_pool.begin();
         invest_itr != _RM_pt->m_undetermined_investigator_pool.end(); invest_itr++) {
      ID = (*invest_itr)->m_ID;
      this->m_ID_undertermined_invest_pool.push_back(ID);
    }
  } else {
    for (str_itr = _RM_pt->m_ID_undertermined_invest_pool.begin();
         str_itr != _RM_pt->m_ID_undertermined_invest_pool.end(); str_itr++) {
      ID = *str_itr;
      this->m_ID_undertermined_invest_pool.push_back(ID);
    }
  }
  if (_RM_pt->m_discarded_investigator_pool.size() != 0) {
    for (auto invest_itr = _RM_pt->m_discarded_investigator_pool.begin();
         invest_itr != _RM_pt->m_discarded_investigator_pool.end(); invest_itr++) {
      ID = (*invest_itr)->m_ID;
      this->m_ID_discarded_invest_pool.push_back(ID);
    }
  } else {
    for (str_itr = _RM_pt->m_ID_discarded_invest_pool.begin(); str_itr != _RM_pt->m_ID_discarded_invest_pool.end();
         str_itr++) {
      ID = *str_itr;
      this->m_ID_discarded_invest_pool.push_back(ID);
    }
  }
 
  if (_RM_pt->m_cause_undetermined_investigato_pool.size() != 0) {
    for (auto invest_itr = _RM_pt->m_cause_undetermined_investigato_pool.begin();
         invest_itr != _RM_pt->m_cause_undetermined_investigato_pool.end(); invest_itr++) {
      ID = (*invest_itr)->m_ID;
      this->m_ID_cause_undertermined_invest_pool.push_back(ID);
    }
  } else {
    for (str_itr = _RM_pt->m_ID_cause_undertermined_invest_pool.begin();
         str_itr != _RM_pt->m_ID_cause_undertermined_invest_pool.end(); str_itr++) {
      ID = *str_itr;
      this->m_ID_cause_undertermined_invest_pool.push_back(ID);
    }
  }
 
  vector<IDElement *>::iterator ID_itr;
 
  if (_RM_pt->m_decayed_item_pt_list.size() != 0) {
    for (ID_itr = _RM_pt->m_decayed_item_pt_list.begin(); ID_itr != _RM_pt->m_decayed_item_pt_list.end(); ID_itr++) {
      ID = (*ID_itr)->m_ID;
      this->m_decayed_item_ID_list.push_back(ID);
    }
  } else {
    for (str_itr = _RM_pt->m_decayed_item_ID_list.begin(); str_itr != _RM_pt->m_decayed_item_ID_list.end(); str_itr++) {
      ID = *str_itr;
      this->m_decayed_item_ID_list.push_back(ID);
    }
  }
 
  if (_RM_pt->m_feedback_stack.size() != 0) {
    for (ID_itr = _RM_pt->m_feedback_stack.begin(); ID_itr != _RM_pt->m_feedback_stack.end(); ID_itr++) {
      ID = (*ID_itr)->m_ID;
      this->m_ID_feedback_stack.push_back(ID);
    }
  } else {
    for (str_itr = _RM_pt->m_ID_feedback_stack.begin(); str_itr != _RM_pt->m_ID_feedback_stack.end(); str_itr++) {
      ID = *str_itr;
      this->m_ID_feedback_stack.push_back(ID);
    }
  }
 
  if (_RM_pt->m_investigation_trace.size() != 0) {
    for (ID_itr = _RM_pt->m_investigation_trace.begin(); ID_itr != _RM_pt->m_investigation_trace.end(); ID_itr++) {
      ID = (*ID_itr)->m_ID;
      this->m_ID_invest_trace.push_back(ID);
    }
  } else {
    for (str_itr = _RM_pt->m_ID_invest_trace.begin(); str_itr != _RM_pt->m_ID_invest_trace.end(); str_itr++) {
      ID = *str_itr;
      this->m_ID_invest_trace.push_back(ID);
    }
  }
 
  if (this->m_position_tbi_A_list.size() != 0) {
    this->ErrorMessage("this->m_position_tbi_A_list.size() != 0");
    return;
  }
  if (this->m_position_tbi_C_list.size() != 0) {
    this->ErrorMessage("this->m_position_tbi_C_list.size() != 0");
    return;
  }
  if (this->m_position_tbi_SS_list.size() != 0) {
    this->ErrorMessage("this->m_position_tbi_SS_list.size() != 0");
    return;
  }
  if (this->m_position_tbi_P_list.size() != 0) {
    this->ErrorMessage("this->m_position_tbi_P_list.size() != 0");
    return;
  }
  //this->m_tbi_A_list
  //this->m_tbi_C_list
  //this->m_tbi_P_list
/*
    vector<MentalParameterValue *> m_tbi_P_list;
    vector<MentalAlarm *> m_tbi_A_list;
    vector<MentalComponentState *> m_tbi_C_list;
 
    vector<int> m_position_tbi_p_list;
    vector<int> m_position_tbi_A_list;
    vector<int> m_position_tbi_C_list;
 
*/
 
  vector<int>::iterator int_itr;
  int i;
  InfoChunk *perceived_pt;
  vector<MentalComponentState *>::iterator mc_itr;
  vector<MentalSupportSystemState *>::iterator mss_itr;
  vector<MentalAlarm *>::iterator ma_itr;
  vector<MentalParameterValue *>::iterator mp_itr;
 
  if (_RM_pt->m_operator == sim::Operator::ODM) { perceived_pt = &(g_sim.Decision_Maker.memory.perceived_info); }
  else if (_RM_pt->m_operator == sim::Operator::OAT) { perceived_pt = &(g_sim.Action_Taker.memory.perceived_info); }
 
  if (_RM_pt->m_tbi_P_list.size() != 0) {
    for (mp_itr = _RM_pt->m_tbi_P_list.begin(); mp_itr != _RM_pt->m_tbi_P_list.end(); mp_itr++) {
      i = perceived_pt->ReturnPositionOfOneMentalParameterValue(*mp_itr);
      this->m_position_tbi_P_list.push_back(i);
    }
  } else {
    for (int_itr = _RM_pt->m_position_tbi_P_list.begin(); int_itr != _RM_pt->m_position_tbi_P_list.end(); int_itr++) {
      i = *int_itr;
      this->m_position_tbi_P_list.push_back(i);
    }
  }
 
  //
  if (r5pars_.timesno > 1050 && r5pars_.timesno < 1054) { this->PrintMessage(""); }
  //
  if (_RM_pt->m_tbi_A_list.size() != 0) {
    for (ma_itr = _RM_pt->m_tbi_A_list.begin(); ma_itr != _RM_pt->m_tbi_A_list.end(); ma_itr++) {
      i = perceived_pt->ReturnPositionOfOneMentalAlarmInTheVector(*ma_itr);
      this->m_position_tbi_A_list.push_back(i);
    }
  } else {
    for (int_itr = _RM_pt->m_position_tbi_A_list.begin(); int_itr != _RM_pt->m_position_tbi_A_list.end(); int_itr++) {
      i = *int_itr;
      this->m_position_tbi_A_list.push_back(i);
    }
  }
 
  if (_RM_pt->m_tbi_C_list.size() != 0) {
    for (mc_itr = _RM_pt->m_tbi_C_list.begin(); mc_itr != _RM_pt->m_tbi_C_list.end(); mc_itr++) {
      i = perceived_pt->ReturnPositionOfOneMentalComponentStateInTheVector(*mc_itr);
      this->m_position_tbi_C_list.push_back(i);
    }
  } else {
    for (int_itr = _RM_pt->m_position_tbi_C_list.begin(); int_itr != _RM_pt->m_position_tbi_C_list.end(); int_itr++) {
      i = *int_itr;
      this->m_position_tbi_C_list.push_back(i);
    }
  }
 
  if (_RM_pt->m_tbi_SS_list.size() != 0) {
    for (mss_itr = _RM_pt->m_tbi_SS_list.begin(); mss_itr != _RM_pt->m_tbi_SS_list.end(); mss_itr++) {
      i = perceived_pt->ReturnPositionOfOneMentalSupportSystemStateInTheVector(*mss_itr);
      this->m_position_tbi_SS_list.push_back(i);
    }
  } else {
    for (int_itr = _RM_pt->m_position_tbi_SS_list.begin(); int_itr != _RM_pt->m_position_tbi_SS_list.end(); int_itr++) {
      i = *int_itr;
      this->m_position_tbi_SS_list.push_back(i);
    }
  }
 
  //useful but won't be needed for restart
  //this->m_temporary_statement_list
  //this->m_new_Statement_list
  //this->m_recent_finished_invest_pt
 
  //unused variable
  //this->m_investigator_number
  //this->m_investigator_link_number
 
/*
    PassiveAlarmLoadUnit * m_passive_alarm_load;
    TimeConstrainedModule * m_time_constraint;
    float m_cognitive_time_cost_base_multiplier;
    bool m_buffer_used_bl;
    Investigator * m_buffer_invest_pt;
*/
  this->m_buffer_used_bl = _RM_pt->m_buffer_used_bl;
  this->m_cognitive_time_cost_base_multiplier = _RM_pt->m_cognitive_time_cost_base_multiplier;
  this->m_cognitive_time_cost_multiplier = _RM_pt->m_cognitive_time_cost_multiplier;
 
  this->m_passive_alarm_load = make_unique<PassiveAlarmLoadUnit>();
  this->m_passive_alarm_load->CopyFromAnotherPassiveAlarmLoadUnit(_RM_pt->m_passive_alarm_load.get());
 
  if (_RM_pt->m_buffer_invest_pt != NULL) { this->m_ID_buffer_invest_pt = _RM_pt->m_buffer_invest_pt->m_ID; }
 
}
 
void ReasonMachine::ConvertRMStaticInfoToStringForm() {
  //concept base
  this->m_Concept_Base->ConvertConnectionToStringForm();
  this->m_IB->ConvertIBInfoToStringForm();
 
  //semantic base
  vector<SentenceUnit *>::iterator sent_itr;
  for (auto sent_itr = this->m_Semantic_list.begin(); sent_itr != this->m_Semantic_list.end(); sent_itr++) {
    (*sent_itr)->ConvertSentenceInfoToStringForm();
  }
 
  //KnowledgeElement
  vector<KnowledgeElement *>::iterator KE_itr;
  for (auto KE_itr = this->m_KE_list.begin(); KE_itr != this->m_KE_list.end(); KE_itr++) {
    (*KE_itr)->ConvertKEinfoToStringForm();
  }
 
  //KnowledgeNode
  vector<KnowledgeNode *>::iterator KN_itr;
  for (auto KN_itr = this->m_KN_list.begin(); KN_itr != this->m_KN_list.end(); KN_itr++) {
    (*KN_itr)->ConvertKNinfoToStringForm();
  }
 
  //KnowledgeUnit
  for (auto KU_itr = this->m_Knowledge_list.begin(); KU_itr != this->m_Knowledge_list.end(); KU_itr++) {
    (*KU_itr)->ConvertKnowledgeLinkInfoToString();
  }
 
  //EventSchemaBase
  this->m_event_schema_base->ConvertStaticESBinfoToString();
 
}
 
void ReasonMachine::CopySemanticInfoFromAnotherSemanticBase(ReasonMachine *_RM_pt) {
  if (this->m_Semantic_list.size() == 0) {
    for (auto sent_itr = _RM_pt->m_Semantic_list.begin(); sent_itr != _RM_pt->m_Semantic_list.end(); sent_itr++) {
      auto sent_pt = make_unique<SentenceUnit>();
      sent_pt->CopyStaticInfoFromAnotherSentence(sent_itr->get());
      this->m_Semantic_list.push_back(std::move(sent_pt));
    }
  }
}
 
void ReasonMachine::CopyStaticKEfromAnotherRM(ReasonMachine *_RM_pt) {
  vector<KnowledgeElement *>::iterator KE_itr;
  KnowledgeElement *KE_pt;
  if (this->m_KE_list.size() != 0) {
    this->ErrorMessage("this->m_KE_list.size() != 0");
  }
  for (auto KE_itr = _RM_pt->m_KE_list.begin(); KE_itr != _RM_pt->m_KE_list.end(); KE_itr++) {
    auto KE_owned = make_unique<KnowledgeElement>();
    KE_owned->CopyStaticKEinfoFromAnother(KE_itr->get());
    this->m_KE_list.push_back(std::move(KE_owned));
  }
}
 
void ReasonMachine::CopyStaticKNfromAnotherRM(ReasonMachine *_RM_pt) {
  vector<KnowledgeNode *>::iterator KN_itr;
  KnowledgeNode *KN_pt;
  if (this->m_KN_list.size() != 0) {
    this->ErrorMessage("this->m_KN_list.size() != 0");
  }
 
  for (auto KN_itr = _RM_pt->m_KN_list.begin(); KN_itr != _RM_pt->m_KN_list.end(); KN_itr++) {
    auto KN_owned = make_unique<KnowledgeNode>();
    KN_owned->CopyStaticKNinfoFromAnother(KN_itr->get());
    this->m_KN_list.push_back(std::move(KN_owned));
  }
}
 
void ReasonMachine::BuildTheConnectionsWithinRM() {
  //
  if (this->m_operator == sim::Operator::ODM) {
    this->m_time_constraint = &(g_sim.Decision_Maker.time_constrained_load);
  } else {
    this->m_time_constraint = &(g_sim.Action_Taker.time_constrained_load);
  }
  //
 
  //KBConcept * m_Concept_Base;
  this->m_Concept_Base->BuidConnectionsWithinKBConcept();
 
  //vector<SentenceUnit *> m_Semantic_list; //Yuandan LI
  vector<SentenceUnit *>::iterator sent_itr;
  for (auto sent_itr = this->m_Semantic_list.begin(); sent_itr != this->m_Semantic_list.end();
       sent_itr++) { (*sent_itr)->BuildTheConnectionsToThisSentence((void *) this); }
 
  //vector<KnowledgeElement *> m_KE_list;
  vector<KnowledgeElement *>::iterator KE_itr;
  for (auto KE_itr = this->m_KE_list.begin(); KE_itr != this->m_KE_list.end();
       KE_itr++) { (*KE_itr)->BuildTheConnectionsToThisKE((void *) this); }
 
  //vector<KnowledgeNode *> m_KN_list;
  vector<KnowledgeNode *>::iterator KN_itr;
  for (auto KN_itr = this->m_KN_list.begin(); KN_itr != this->m_KN_list.end();
       KN_itr++) { (*KN_itr)->BuildConnectionsToThisKN((void *) this); }
 
  //vector<KnowledgeUnit *> m_Knowledge_list;
  for (auto KU_itr = this->m_Knowledge_list.begin(); KU_itr != this->m_Knowledge_list.end();
       KU_itr++) { (*KU_itr)->BuildConnectionsToThisKU((void *) this); }
 
  //InstantiationBase * m_IB;
  this->m_IB->BuildConnectionsForTheInstantiationBase((void *) this);
 
 
  //vector<Statement *> m_Statement_list; //Yuandan LI
  vector<Statement *>::iterator state_itr;
  for (auto state_itr = this->m_Statement_list.begin(); state_itr != this->m_Statement_list.end();
       state_itr++) { (*state_itr)->BuildConnectionsToThisStatement((void *) this); }
 
  //vector<Statement *> m_temporary_statement_list;
  for (auto state_itr = this->m_temporary_statement_list.begin(); state_itr != this->m_temporary_statement_list.end();
       state_itr++) { (*state_itr)->BuildConnectionsToThisStatement((void *) this); }
 
  //vector<Statement *> m_new_Statement_list;
  for (auto state_itr = this->m_new_Statement_list.begin(); state_itr != this->m_new_Statement_list.end();
       state_itr++) { (*state_itr)->BuildConnectionsToThisStatement((void *) this); }
 
  //vector<Investigator *> m_investigator_pool;
  vector<Investigator *>::iterator invest_itr;
  for (auto invest_itr = this->m_investigator_pool.begin(); invest_itr != this->m_investigator_pool.end();
       invest_itr++) { (*invest_itr)->BuildTheConnectionsToThisInvestigator((void *) this); }
 
  //vector<InvestigatorLink *> m_investigator_link_pool;
  vector<InvestigatorLink *>::iterator link_itr;
  for (auto link_itr = this->m_investigator_link_pool.begin(); link_itr != this->m_investigator_link_pool.end();
       link_itr++) { (*link_itr)->BuildConnectionsToThisInvestigatorLink((void *) this); }
 
  vector<string>::iterator str_itr;
  Investigator *invest_pt;
 
  //vector<Investigator *> m_unresolved_investigator_pool;
  for (str_itr = this->m_ID_unresolved_invest_pool.begin(); str_itr != this->m_ID_unresolved_invest_pool.end();
       str_itr++) {
    invest_pt = this->FindInvestigatorByID(*str_itr);
    if (invest_pt == NULL) {
      this->ErrorMessage("could not find this investigator " + *str_itr);
      return;
    }
    this->m_unresolved_investigator_pool.push_back(invest_pt);
  }
  this->m_ID_unresolved_invest_pool.clear();
 
  //vector<Investigator *> m_resolved_investigator_pool;
  for (str_itr = this->m_ID_resolved_invest_pool.begin(); str_itr != this->m_ID_resolved_invest_pool.end(); str_itr++) {
    invest_pt = this->FindInvestigatorByID(*str_itr);
    if (invest_pt == NULL) {
      this->ErrorMessage("could not find this investigator " + *str_itr);
      return;
    }
    this->m_resolved_investigator_pool.push_back(invest_pt);
  }
  this->m_ID_resolved_invest_pool.clear();
 
  //vector<Investigator *> m_success_investigator_pool; //3098, 3030
  for (str_itr = this->m_ID_succes_invest_pool.begin(); str_itr != this->m_ID_succes_invest_pool.end(); str_itr++) {
    invest_pt = this->FindInvestigatorByID(*str_itr);
    if (invest_pt == NULL) {
      this->ErrorMessage("could not find this investigator " + *str_itr);
      return;
    }
    this->m_success_investigator_pool.push_back(invest_pt);
  }
  this->m_ID_succes_invest_pool.clear();
 
  //vector<Investigator *> m_failed_investigator_pool;
  for (str_itr = this->m_ID_failed_invest_pool.begin(); str_itr != this->m_ID_failed_invest_pool.end(); str_itr++) {
    invest_pt = this->FindInvestigatorByID(*str_itr);
    if (invest_pt == NULL) {
      this->ErrorMessage("could not find this investigator " + *str_itr);
      return;
    }
    this->m_failed_investigator_pool.push_back(invest_pt);
  }
  this->m_ID_failed_invest_pool.clear();
 
  //vector<Investigator *> m_undetermined_investigator_pool; //3031
  for (str_itr = this->m_ID_undertermined_invest_pool.begin(); str_itr != this->m_ID_undertermined_invest_pool.end();
       str_itr++) {
    invest_pt = this->FindInvestigatorByID(*str_itr);
    if (invest_pt == NULL) {
      this->ErrorMessage("could not find this investigator " + *str_itr);
      return;
    }
    this->m_undetermined_investigator_pool.push_back(invest_pt);
  }
  this->m_ID_undertermined_invest_pool.clear();
 
  //vector<Investigator *> m_discarded_investigator_pool; //3090
  for (str_itr = this->m_ID_discarded_invest_pool.begin(); str_itr != this->m_ID_discarded_invest_pool.end();
       str_itr++) {
    invest_pt = this->FindInvestigatorByID(*str_itr);
    if (invest_pt == NULL) {
      this->ErrorMessage("could not find this investigator " + *str_itr);
      return;
    }
    this->m_discarded_investigator_pool.push_back(invest_pt);
  }
  this->m_ID_discarded_invest_pool.clear();
 
  //vector<Investigator *> m_cause_undetermined_investigato_pool; //3097
  for (str_itr = this->m_ID_cause_undertermined_invest_pool.begin();
       str_itr != this->m_ID_cause_undertermined_invest_pool.end(); str_itr++) {
    invest_pt = this->FindInvestigatorByID(*str_itr);
    if (invest_pt == NULL) {
      this->ErrorMessage("could not find this investigator " + *str_itr);
      return;
    }
    this->m_cause_undetermined_investigato_pool.push_back(invest_pt);
  }
  this->m_ID_cause_undertermined_invest_pool.clear();
 
  //Investigator * m_working_on_invest_pt;
  if (this->m_ID_working_on_invest.compare("") != 0) {
    this->m_working_on_invest_pt = this->FindInvestigatorByID(this->m_ID_working_on_invest);
    if (this->m_working_on_invest_pt == NULL) {
      this->ErrorMessage("could not find this investigator " + this->m_ID_working_on_invest);
      return;
    }
  }
  this->m_ID_working_on_invest = "";
 
  //InvestigatorLink * m_working_on_invest_link_pt;
  if (this->m_ID_working_on_invest_link.compare("") != 0) {
    this->m_working_on_invest_link_pt = this->FindInvestigatorLinkByID(this->m_ID_working_on_invest_link);
    if (this->m_working_on_invest_link_pt == NULL) {
      this->ErrorMessage("could not find this investigatorlink " + this->m_ID_working_on_invest_link);
      return;
    }
  }
  this->m_ID_working_on_invest_link = "";
 
  //IDElement * m_reading_indication_ID_pt;
  if (this->m_ID_reading_indication.compare("") != 0) {
    this->m_reading_indication_ID_pt = this->m_MR->FindMRUnitByID(this->m_ID_reading_indication);
    if (this->m_reading_indication_ID_pt == NULL) {
      this->ErrorMessage("could not find the reading indication unit " + this->m_ID_reading_indication);
      return;
    }
  }
  this->m_ID_reading_indication = "";
 
  //MentalRepresentation * m_MR;
  this->m_MR->BuildConnectionsForMentalRepresentation((void *) this);
 
  //vector<string> m_ID_temporary_statement_list;
  Statement *state_pt = NULL;
  for (str_itr = this->m_ID_temporary_statement_list.begin(); str_itr != this->m_ID_temporary_statement_list.end();
       str_itr++) {
    state_pt = this->FindStatementByID(*str_itr);
    if (state_pt == NULL) {
      this->ErrorMessage("could not find this statement " + *str_itr);
      return;
    }
    this->m_temporary_statement_list.push_back(state_pt);
  }
  this->m_ID_temporary_statement_list.clear();
 
  //vector<string> m_ID_new_statement_list;
  for (str_itr = this->m_ID_new_statement_list.begin(); str_itr != this->m_ID_new_statement_list.end(); str_itr++) {
    state_pt = this->FindStatementByID(*str_itr);
    if (state_pt == NULL) {
      this->ErrorMessage("could not find this statement " + *str_itr);
      return;
    }
    this->m_new_Statement_list.push_back(state_pt);
  }
  this->m_ID_new_statement_list.clear();
 
  //vector<string> m_ID_feedback_stack;
  IDElement *ID_pt;
  for (str_itr = this->m_ID_feedback_stack.begin(); str_itr != this->m_ID_feedback_stack.end(); str_itr++) {
    ID_pt = this->FindInvestigatorOrLinkByID(*str_itr);
    if (ID_pt == NULL) {
      this->ErrorMessage("could not find this " + *str_itr);
      return;
    }
    this->AddToRMFeedbackStack(ID_pt);
  }
  this->m_ID_feedback_stack.clear();
 
  for (str_itr = this->m_decayed_item_ID_list.begin(); str_itr != this->m_decayed_item_ID_list.end(); str_itr++) {
    ID_pt = this->FindInvestigatorOrLinkByID(*str_itr);
    if (ID_pt == NULL) {
      this->ErrorMessage("could not find this " + *str_itr);
      return;
    }
    this->m_decayed_item_pt_list.push_back(ID_pt);
  }
  this->m_decayed_item_ID_list.clear();
 
  //vector<IDElement *> m_investigation_trace;
  for (str_itr = this->m_ID_invest_trace.begin(); str_itr != this->m_ID_invest_trace.end(); str_itr++) {
    ID_pt = this->FindInvestigatorOrLinkByID(*str_itr);
    if (ID_pt == NULL) {
      this->ErrorMessage("could not find this " + *str_itr);
      return;
    }
    this->m_investigation_trace.push_back(ID_pt);
  }
  this->m_ID_invest_trace.clear();
 
  //RoutineMonitor * m_routine_monitor;
  this->m_routine_monitor->BuildConnectionsForRoutineMonitor((void *) this);
 
  //
  this->m_event_schema_base->BuildTheConnectionsForThisEventSchemaBase((void *) this);
 
/*
    vector<MentalParameterValue *> m_tbi_P_list;
    vector<MentalAlarm *> m_tbi_A_list;
    vector<MentalComponentState *> m_tbi_C_list;
*/
  ShortTermMemory *stm_pt;
  if (this->m_operator == sim::Operator::ODM) { stm_pt = &(g_sim.Decision_Maker.memory); }
  else if (this->m_operator == sim::Operator::OAT) { stm_pt = &(g_sim.Action_Taker.memory); }
 
  vector<int>::iterator int_itr;
  MentalAlarm *a_pt;
  MentalComponentState *c_pt;
  MentalSupportSystemState *ss_pt;
  MentalParameterValue *p_pt;
 
  for (int_itr = this->m_position_tbi_A_list.begin(); int_itr != this->m_position_tbi_A_list.end(); int_itr++) {
    a_pt = stm_pt->perceived_info.perceived_alarms[*int_itr].get();
    this->m_tbi_A_list.push_back(a_pt);
  }
  this->m_position_tbi_A_list.clear();
 
  for (int_itr = this->m_position_tbi_C_list.begin(); int_itr != this->m_position_tbi_C_list.end(); int_itr++) {
    c_pt = stm_pt->perceived_info.perceived_component_state[*int_itr].get();
    this->m_tbi_C_list.push_back(c_pt);
  }
  this->m_position_tbi_C_list.clear();
 
  for (int_itr = this->m_position_tbi_SS_list.begin(); int_itr != this->m_position_tbi_SS_list.end(); int_itr++) {
    ss_pt = stm_pt->perceived_info.perceived_support_system_state[*int_itr].get();
    this->m_tbi_SS_list.push_back(ss_pt);
  }
  this->m_position_tbi_SS_list.clear();
 
  for (int_itr = this->m_position_tbi_P_list.begin(); int_itr != this->m_position_tbi_P_list.end(); int_itr++) {
    p_pt = stm_pt->perceived_info.perceived_parameter_value[*int_itr].get();
    this->m_tbi_P_list.push_back(p_pt);
  }
  this->m_position_tbi_P_list.clear();
 
  /*
    PassiveAlarmLoadUnit * m_passive_alarm_load;
    TimeConstrainedModule * m_time_constraint;
    Investigator * m_buffer_invest_pt;
*/
  if (this->m_ID_buffer_invest_pt.compare("") != 0) {
    this->m_buffer_invest_pt = this->FindInvestigatorByID(this->m_ID_buffer_invest_pt);
    if (this->m_buffer_invest_pt == NULL) {
      this->ErrorMessage("could not find this investigator " + this->m_ID_buffer_invest_pt);
    }
  }
  //
  if (this->m_operator == sim::Operator::ODM) {
    this->m_time_constraint = &(g_sim.Decision_Maker.time_constrained_load);
  } else {
    this->m_time_constraint = &(g_sim.Action_Taker.time_constrained_load);
  }
  //
}
 
Investigator *ReasonMachine::FindInvestigatorByID(string _ID) {
  vector<Investigator *>::iterator invest_itr;
  Investigator *found_invest = NULL;
 
  for (auto invest_itr = this->m_investigator_pool.begin();
       invest_itr != this->m_investigator_pool.end() && found_invest == NULL; invest_itr++) {
    if ((*invest_itr)->m_ID == _ID) {
      found_invest = invest_itr->get();
    }
  }
  return found_invest;
}
 
Statement *ReasonMachine::FindStatementByID(string _ID) {
  vector<Statement *>::iterator state_itr;
  Statement *found_state = NULL;
  for (auto state_itr = this->m_Statement_list.begin(); state_itr != this->m_Statement_list.end() && found_state == NULL;
       state_itr++) {
    if ((*state_itr)->m_ID == _ID) { found_state = state_itr->get(); }
  }
  return found_state;
}
 
InvestigatorLink *ReasonMachine::FindInvestigatorLinkByID(string _ID) {
  InvestigatorLink *found_link = NULL;
  vector<InvestigatorLink *>::iterator link_itr;
 
  for (auto link_itr = this->m_investigator_link_pool.begin();
       link_itr != this->m_investigator_link_pool.end() && found_link == NULL; link_itr++) {
    if ((*link_itr)->m_ID == _ID) { found_link = link_itr->get(); }
  }
  return found_link;
}
 
IDElement *ReasonMachine::FindInvestigatorOrLinkByID(string _ID) {
  IDElement *found_pt = NULL;
  found_pt = this->FindInvestigatorByID(_ID);
  if (found_pt == NULL) { found_pt = this->FindInvestigatorLinkByID(_ID); }
  return found_pt;
}
 
void ReasonMachine::ClearThisReasonMachine() {
}
 
// RM gate: with the cycle disabled the live RM persists across sequence
// restores instead of being cloned from the snapshot. Clearing the to-be-
// investigated queues makes its state match what a fresh clone would carry
// (see docs/developer/internals/reason-machine-status.md).
void ReasonMachine::ClearTBIListsForRestart() {
  this->m_tbi_P_list.clear();
  this->m_tbi_A_list.clear();
  this->m_tbi_C_list.clear();
  this->m_tbi_SS_list.clear();
  this->m_position_tbi_P_list.clear();
  this->m_position_tbi_A_list.clear();
  this->m_position_tbi_C_list.clear();
  this->m_position_tbi_SS_list.clear();
}
 
void ReasonMachine::SaveRMHisoty(string _path) {
  vector<IDElement *>::iterator ID_itr;
  Investigator *invest_pt;
  InvestigatorLink *link_pt;
 
  ofstream fout(_path.c_str(), ios::out);
  fout << "ID" << '\t' << "starting time" << '\t' << "ending time" << '\n';
  for (auto info_itr = this->m_investigation_history.begin(); info_itr != this->m_investigation_history.end(); info_itr++) {
    fout << (*info_itr)->m_name << '\t';
    fout << (*info_itr)->m_interval_start << '\t';
    fout << (*info_itr)->m_interval_end << '\t';
    if ((*info_itr)->m_name.compare(0, 13, "Investigator_") == 0) {
      invest_pt = this->FindInvestigatorByID((*info_itr)->m_name);
      if (invest_pt == NULL) { fout << "error" << '\t'; }
      else {
        if (invest_pt->m_KElement_ID_pt != NULL) { fout << invest_pt->m_KElement_ID_pt->m_ID << "||"; }
        if (invest_pt->m_Statement_pt != NULL) { fout << invest_pt->m_Statement_pt->m_sent_pt->m_ID << "||"; }
        fout << invest_pt->m_Happen << " " << invest_pt->m_explained;
      }
    } else if ((*info_itr)->m_name.compare(0, 17, "InvestigatorLink_") == 0) {
      link_pt = this->FindInvestigatorLinkByID((*info_itr)->m_name);
      if (link_pt == NULL) { fout << "error" << '\t'; }
      else {
        fout << link_pt->m_ID << " links " << link_pt->m_downstream_ID_pt->m_ID << " and ";
        for (ID_itr = link_pt->m_upperstream_ID_list.begin(); ID_itr != link_pt->m_upperstream_ID_list.end();
             ID_itr++) {
          fout << (*ID_itr)->m_ID << " , ";
        }
      }
    } else {}
    fout << '\n';
  }
  fout.close();
}
 
void ReasonMachine::SaveInvestigationLinkInfo(string _path) {
  vector<InvestigatorLink *>::iterator link_itr;
  InvestigatorLink *link_pt;
  Investigator *invest_pt;
  vector<int>::iterator int_itr;
  vector<IDElement *>::iterator ID_itr;
  string str;
 
  ofstream fout(_path.c_str(), ios::out);
  fout
      << "Link ID" << '\t'
      << "Path status" << '\t'
      << "Upperstream ID" << '\t'
      << "Downstream ID" << '\t'
      << "Condition ID" << '\t'
      << "Token History" << '\t'
      << "Dormant" << '\n';
  for (auto link_itr = this->m_investigator_link_pool.begin(); link_itr != this->m_investigator_link_pool.end();
       link_itr++) {
    link_pt = link_itr->get();
    fout << link_pt->m_ID << '\t';
    fout << link_pt->m_path_status << '\t';
    for (ID_itr = link_pt->m_upperstream_ID_list.begin(); ID_itr != link_pt->m_upperstream_ID_list.end(); ID_itr++) {
      invest_pt = (Investigator *) (*ID_itr);
      fout << invest_pt->m_ID;
      fout << ": ";
      fout << invest_pt->m_Happen << "; ";
    }
    fout << '\t';
 
    invest_pt = (Investigator *) (link_pt->m_downstream_ID_pt);
    if (invest_pt != NULL) {
      fout << invest_pt->m_ID;
      fout << ": " << invest_pt->m_Happen;
    }
    fout << '\t';
 
    invest_pt = (Investigator *) (link_pt->m_condition_ID_pt);
    if (invest_pt != NULL) {
      fout << invest_pt->m_ID;
      fout << ": " << invest_pt->m_Happen;
    }
    fout << '\t';
 
    for (int_itr = link_pt->m_invest_link_Token_history.begin(); int_itr != link_pt->m_invest_link_Token_history.end();
         int_itr++) {
      fout << *int_itr;
      fout << '-';
    }
    fout << '\t';
 
    fout << link_pt->m_invest_link_dormant;
    fout << '\n';
  }
  fout.close();
}
 
void ReasonMachine::AddToRMFeedbackStack(IDElement *_ID_pt) {
  bool existing = false;
  vector<IDElement *>::iterator ID_itr;
  if (_ID_pt->m_ID == "Investigator_228" && r5pars_.timesno > 600) { this->PrintMessage(""); }
 
  for (ID_itr = this->m_feedback_stack.begin(); ID_itr != this->m_feedback_stack.end(); ID_itr++) {
    if (*ID_itr == _ID_pt) { existing = true; }
  }
  if (existing == true) { return; }
  else { this->m_feedback_stack.push_back(_ID_pt); }
}
 
void ReasonMachine::ReadOperatorReasonMachineProfile() {
  string directory, str, str1, file_name;
  string err_mes;
  ifstream fin;
 
  //get the directory "Input\Crew\DecisionMaker\RM\KB_ODM_Knowledge_Unit_Base.txt"
  if (this->m_operator == sim::Operator::ODM) {
    file_name = g_sim.SScheduler.getODMDirectory();
    file_name += "RM/";
    file_name += "KB_ODM_RM_Profile.txt";
  } else if (this->m_operator == sim::Operator::OAT) {
    file_name = g_sim.SScheduler.getOATDirectory();
    file_name += "RM/";
    file_name += "KB_OAT_RM_Profile.txt";
  } else {} //error message, unable to identify the operator type in ReasonMachine::ReadSemanticSentencesFromInputFile()
 
  //
  fin.open(file_name.c_str(), ios::in);
  if (!fin.is_open()) {
    err_mes = "could not open file: " + file_name;
    this->ErrorMessage(err_mes);
    return;
  } else {
    fin >> str;
    fin >> str;
    fin >> str;
    fin >> str;
    fin >> str;
    fin >> str;
 
    fin >> str;
    if (str.compare("Problem_solving_style:") != 0) {
      err_mes = "Missing line: Problem_solving_style:" + file_name + " " + str;
      this->ErrorMessage(err_mes);
      return;
    }
    fin >> str;
    if (str.compare("NEUTRAL") == 0) {
      this->m_problem_solving_style = ProblemSolvingStyle::Neutral;
    } else if (str.compare("VAGABOND") == 0) {
      this->m_problem_solving_style = ProblemSolvingStyle::Vagabond;
      this->m_ability_of_integrating_evidence = 0.7;
      this->m_routine_monitor_threshold = 1.5;
      this->m_interuptiveness = 2;
      this->m_attention_span_base_value = 10;
    } else if (str.compare("HAMLET_B") == 0) {
      this->m_problem_solving_style = ProblemSolvingStyle::HamletB;
      this->m_routine_monitor_threshold = 0.5;
      this->m_interuptiveness = 1;
      this->m_attention_span_base_value = 20;
    } else if (str.compare("HAMLET") == 0) {
      this->m_problem_solving_style = ProblemSolvingStyle::Hamlet;
      this->m_routine_monitor_threshold = 1;
      this->m_interuptiveness = 1;
    } else if (str.compare("GARDEN_PATH") == 0) {
      this->m_problem_solving_style = ProblemSolvingStyle::GardenPath;
      this->m_routine_monitor_threshold = 1;
      this->m_interuptiveness = 0.5;
      this->m_attention_span_base_value = 30;
    } else { this->ErrorMessage("Unrecognized problem solving style!"); }
 
    fin >> str;
    if (str.compare("Initial_fatigue_level:") != 0) {
      err_mes = "Missing line: Initial_fatigue_level:";
      this->ErrorMessage(err_mes);
      return;
    }
    fin >> this->m_initial_fatigue_level;
 
    fin >> str;
    if (str.compare("Expert_Level:") != 0) {
      err_mes = "Missing line: Expert_Level:";
      this->ErrorMessage(err_mes);
      return;
    }
    fin >> this->m_expert_level;
  }
  fin.close();
}
 
void ReasonMachine::SettingForVagabondStyle() {
 
}
 
//DEL void ReasonMachine::UpdateTimeLineOfDynamicParameters()
//DEL {
//DEL
//DEL
//DEL }
 
void ReasonMachine::SavePSFandDynamicParametersToFile(string _path) {
  ValueTimeLineUnit *v_pt;
  int n_row = 0;
  int i;
 
//6 PSFs
  n_row = max<int>(n_row, this->m_time_load_history.size());
  n_row = max<int>(n_row, this->m_passive_alarm_load->m_passive_alarm_load_timeline.size());
  n_row = max<int>(n_row, this->m_cognitive_load_history.size());
  n_row = max<int>(n_row, this->m_diagnosis_complexity_history.size());
  n_row = max<int>(n_row, this->m_stress_history.size());
  n_row = max<int>(n_row, this->m_fatigue_history.size());
 
//7 manifestation parameters
  n_row = max<int>(n_row, this->m_max_alarm_length_timeline.size());
  n_row = max<int>(n_row, this->m_cognitive_resouse_use_history.size());
  n_row = max<int>(n_row, this->m_cognitive_time_cost_multiplier_timeline.size());
  n_row = max<int>(n_row, this->m_routine_monitor_interval_multiplier_history.size());
  n_row = max<int>(n_row, this->m_attention_span_history.size());
  n_row = max<int>(n_row, this->m_memory_span_history.size());
  n_row = max<int>(n_row, this->m_decay_time_history.size());
 
  ofstream fout(_path.c_str(), ios::out);
  fout << 14 << n_row + 1 << '\n';
  fout << "Time" << '\t'
       << "PSF_Time_Constraint_Load" << '\t'
       << "PSF_Passive_Alarm_Load" << '\t'
       << "PSF_Cognitive_Load" << '\t'
       << "PSF_Diagnosis_Complexity" << '\t'
       << "PSF_Stress" << '\t'
       << "PSF_Fatigue" << '\t'
 
       << "Model_Parameter_Max_Alarm_Stack_Length" << '\t'
       << "Model_Parameter_Cognitive_Resouse_Use" << '\t'
       << "Model_Parameter_Cognitive_Time_Cost_Multiplier" << '\t'
       << "Model_Parameter_Routin_Monitor_Interval_Multiplier" << '\t'
       << "Model_Parameter_Attention_Span" << '\t'
       << "Model_Parameter_Memory_Span" << '\t'
       << "Model_Parameter_Investigation_Item_Decay_Time" << '\t'
       << '\n';
 
  i = 0;
  while (i < n_row) {
//time and psfs
    if (i < this->m_time_load_history.size()) {
      v_pt = this->m_time_load_history[i].get();
      fout << v_pt->m_time << '\t';
      fout << v_pt->m_fl << '\t';
    }
 
    if (i < this->m_passive_alarm_load->m_passive_alarm_load_timeline.size()) {
      v_pt = this->m_passive_alarm_load->m_passive_alarm_load_timeline[i].get();
      fout << v_pt->m_fl << '\t';
    }
 
    if (i < this->m_cognitive_load_history.size()) {
      v_pt = this->m_cognitive_load_history[i].get();
      fout << v_pt->m_fl << '\t';
    }
 
    if (i < this->m_diagnosis_complexity_history.size()) {
      v_pt = this->m_diagnosis_complexity_history[i].get();
      fout << v_pt->m_fl << '\t';
    }
 
    if (i < this->m_stress_history.size()) {
      v_pt = this->m_stress_history[i].get();
      fout << v_pt->m_fl << '\t';
    }
 
    if (i < this->m_fatigue_history.size()) {
      v_pt = this->m_fatigue_history[i].get();
      fout << v_pt->m_fl << '\t';
    }
//manifestation
    if (i < this->m_max_alarm_length_timeline.size()) {
      v_pt = this->m_max_alarm_length_timeline[i].get();
      fout << v_pt->m_int << '\t';
    }
 
    if (i < this->m_cognitive_resouse_use_history.size()) {
      v_pt = this->m_cognitive_resouse_use_history[i].get();
      fout << v_pt->m_fl << '\t';
    }
 
    if (i < this->m_cognitive_time_cost_multiplier_history.size()) {
      v_pt = this->m_cognitive_time_cost_multiplier_history[i].get();
      fout << v_pt->m_fl << '\t';
    }
 
    if (i < this->m_routine_monitor_interval_multiplier_history.size()) {
      v_pt = this->m_routine_monitor_interval_multiplier_history[i].get();
      fout << v_pt->m_fl << '\t';
    }
 
    if (i < this->m_attention_span_history.size()) {
      v_pt = this->m_attention_span_history[i].get();
      fout << v_pt->m_fl << '\t';
    }
 
    if (i < this->m_memory_span_history.size()) {
      v_pt = this->m_memory_span_history[i].get();
      fout << v_pt->m_fl << '\t';
    }
 
    if (i < this->m_decay_time_history.size()) {
      v_pt = this->m_decay_time_history[i].get();
      fout << v_pt->m_fl << '\t';
    }
 
    fout << '\n';
    i++;
  }
 
  fout.close();
}
 
float ReasonMachine::GetAParameterValueImediately(string CP_name) {
  SystemDisplay *_system_display;
  DisplayParameterValue *_parameter_value;
  DisplayParameterValueRate *_parameter_trend;
  DisplayHeatStructure *_heat_structure;
  DisplayType display_type;
 
  /*MRParameterUnit * M_P_pt;
    M_P_pt = (MRParameterUnit *)(this->m_MR->FindMRUnitByID(MR_name));
    if(M_P_pt == NULL || M_P_pt->m_ID_Type != 201)
    {this->ErrorMessage("could not find a MRParameterUnit of " + MR_name); return 0;}
    CP_name = M_P_pt->m_parameter_indicator_ID;
    */
  float perceived_value = 0;
  _system_display = g_sim.Indicator.indicators.getDisplayFromMap(CP_name);
  if (_system_display != 0) {
    display_type = _system_display->getTypeOfDisplay();
    if (display_type == DisplayType::ParameterValue) {
      _parameter_value = (DisplayParameterValue *) _system_display;
      perceived_value = _parameter_value->getDisplayedParameterValue();
    } else if (display_type == DisplayType::HeatStructure) {
      _heat_structure = (DisplayHeatStructure *) _system_display;
      perceived_value = _heat_structure->getDisplayedParameterValue();
    } else if (display_type == DisplayType::ParameterTrend) {
      _parameter_trend = (DisplayParameterValueRate *) _system_display;
      perceived_value = _parameter_trend->getRateOfChange();
    } else { this->ErrorMessage("Unrecognized parameter type of " + CP_name); }
  } else { this->ErrorMessage("Could not find such a parameter " + CP_name); }
  return perceived_value;
}
 
int ReasonMachine::GetAComponentStateImediately(string CP_name) {
  /*M_C_pt = (MRComponentStateUnit *)(this->m_MR->FindMRUnitByID(MR_name));
    if(M_C_pt == NULL || M_C_pt->m_ID_Type != 202)
    {this->ErrorMessage("could not find a MRComponentStateUnit of " + MR_name); return 0;}
 
    if(M_C_pt->m_CS_type == 0)
    {CP_name = M_C_pt->Component_State_Indicator_ID;}
    else
    {
        CP_name = M_C_pt->Control_Value_Indicator_ID;
    }*/
 
  SystemDisplay *_system_display;
  DisplayType display_type;
  DisplayComponentState *_component_state;
  DisplaySupportSystemState *_support_system_state;
 
  int perceived_state = 0;
  _system_display = g_sim.Indicator.indicators.getDisplayFromMap(CP_name);
  if (_system_display != 0) {
    if (display_type == DisplayType::ComponentState) {
      _component_state = (DisplayComponentState *) _system_display;
      perceived_state = _component_state->getDisplayedComponentOperationalState();
    } else {
      this->ErrorMessage(
          "Unreconginzed type othat than DisplayType::ComponentState or DisplayType::SupportSystemState for " + CP_name);
    }
  } else { this->ErrorMessage("Could not find  a system display for " + CP_name); }
  return perceived_state;
}
 
int ReasonMachine::GetASupportSystemStateImediately(string CP_name) {
 
  SystemDisplay *_system_display;
  DisplayType display_type;
  DisplaySupportSystemState *_support_system_state;
 
  int perceived_state = 0;
  _system_display = g_sim.Indicator.indicators.getDisplayFromMap(CP_name);
  if (_system_display != 0) {
    if (display_type == DisplayType::SupportSystemState) {
      _support_system_state = (DisplaySupportSystemState *) _system_display;
      perceived_state = _support_system_state->getDisplayedSupportSystemOperationalState();
    } else {
      this->ErrorMessage(
          "Unreconginzed type other than DisplayType::SupportSystemState for " + CP_name);
    }
  } else { this->ErrorMessage("Could not find  a system display for " + CP_name); }
  return perceived_state;
}
 
int ReasonMachine::GetAlarmStateImediately(string CP_name) {
  SystemAlarm *_system_alarm;
  int perceived_state = 0;
 
  _system_alarm = g_sim.Indicator.alarms.getAlarmFromMap(CP_name);
  if (_system_alarm != NULL) { perceived_state = _system_alarm->getDisplayedAlarmState(); }
  else { this->ErrorMessage("Could not find a system alarm of " + CP_name); }
 
  return perceived_state;
}
 
void ReasonMachine::CheckWhetherTheThoughtLineHasChanged() {
  string line_ID;
  vector<string>::iterator str_itr;
  bool has_changed = false;
  Investigator *invest_pt = NULL;
  InvestigatorLink *link_pt = NULL;
  if (this->m_RM_Token == rm::WorkOnInvestigator) {
    for (str_itr = this->m_current_thought_line_info->m_thought_line_list.begin();
         str_itr != this->m_current_thought_line_info->m_thought_line_list.end(); str_itr++) {
      if (this->m_working_on_invest_pt->CheckWhetherInAThoughtLine(*str_itr) == false) { has_changed = true; }
    }
  } else if (this->m_RM_Token == rm::WorkOnInvestigatorLink) {
    for (str_itr = this->m_current_thought_line_info->m_thought_line_list.begin();
         str_itr != this->m_current_thought_line_info->m_thought_line_list.end(); str_itr++) {
      if (this->m_working_on_invest_link_pt->CheckWhetherInAThoughtLine(*str_itr) == false) { has_changed = true; }
    }
  }
 
  if (has_changed == true) {
    this->m_current_thought_line_info->m_interval_end = r5pars_.timesno;
    if (this->m_current_investigation_info != nullptr) {
      invest_pt = this->FindInvestigatorByID(this->m_current_investigation_info->m_name);
      if (invest_pt == NULL) {
        link_pt = this->FindInvestigatorLinkByID(this->m_current_investigation_info->m_name);
      }
      if (invest_pt != NULL) {
        if (invest_pt->m_investigation_closed == false) {
          this->m_current_investigation_info->m_interrupted_bl = true;
        }
      }
      if (link_pt != NULL) {
        if (link_pt->m_invest_link_Token < inv_link::ActiveThreshold) {
          this->m_current_investigation_info->m_interrupted_bl = true;
        }
      }
    }
 
    this->m_thought_line_history.push_back(std::move(this->m_current_thought_line_info));
 
    this->m_current_thought_line_info = make_unique<StringTimeIntervalUnit>();
    this->m_current_thought_line_info->m_interval_start = r5pars_.timesno;
    if (this->m_RM_Token == rm::WorkOnInvestigator) {
      if (this->m_working_on_invest_pt->m_root_of_a_thought_line == true) {
        this->m_current_thought_line_info->m_thought_line_list.push_back(this->m_working_on_invest_pt->m_ID);
      }
      for (str_itr = this->m_working_on_invest_pt->m_thoughtline_roots_list.begin();
           str_itr != this->m_working_on_invest_pt->m_thoughtline_roots_list.end(); str_itr++) {
        line_ID = *str_itr;
        this->m_current_thought_line_info->m_thought_line_list.push_back(line_ID);
      }
    } else {
      for (str_itr = this->m_working_on_invest_link_pt->m_thoughtline_roots_list.begin();
           str_itr != this->m_working_on_invest_link_pt->m_thoughtline_roots_list.end(); str_itr++) {
        line_ID = *str_itr;
        this->m_current_thought_line_info->m_thought_line_list.push_back(line_ID);
      }
    }
  }
  return;
}
 
void ReasonMachine::DecayOfForgottenInvestigator() {
  bool remove_it;
  vector<Investigator *>::iterator invest_itr;
  vector<InvestigatorLink *>::iterator link_itr;
  vector<Statement *>::iterator state_itr;
  Investigator *oldest_invest_pt = NULL;
  InvestigatorLink *oldest_link_pt = NULL;
  int i = 0;
  int n_Count = 0;
  int n_max_item;
  string rm_aux_info;
 
  vector<IDElement *> subject_list;
  vector<IDElement *>::iterator subject_itr;
  IDElement *subject_pt;
 
  if (r5pars_.timesno < 852) {
    //here need to clear the statement member link of investigators
    for (auto invest_itr = this->m_investigator_pool.begin(); invest_itr != this->m_investigator_pool.end(); invest_itr++) {
      if ((*invest_itr)->m_Statement_pt != NULL) {
        (*invest_itr)->m_Statement_pt->m_investigator_ID_pt = NULL;
        (*invest_itr)->m_Statement_pt->m_ID_investigator = "";
      }
    }
    this->m_investigator_pool.clear();
    this->m_unresolved_investigator_pool.clear();
  }
 
  for (auto link_itr = this->m_investigator_link_pool.begin(); link_itr != this->m_investigator_link_pool.end();
       link_itr++) {
    if ((*link_itr)->m_invest_link_dormant == true || (*link_itr)->m_invest_link_pause == true
        || (*link_itr)->m_invest_link_Token == inv_link::TransferOut || (*link_itr)->m_forgotten_bl == true) { continue; }
 
    remove_it = false;
    if (r5pars_.timesno - (*link_itr)->m_link_last_activated_time > this->m_decay_time) { remove_it = true; }
 
    if ((*link_itr)->m_SI_ID_pt != NULL) { remove_it = false; }
 
    if (remove_it == true) {
      (*link_itr)->m_forgotten_bl = true;
      //rite aux information
      rm_aux_info = "Item forgotten: ";
      rm_aux_info += (*link_itr)->m_ID;
      this->WriteAuxInfo(rm_aux_info);
    } else {
      n_Count++;
      if (oldest_link_pt == NULL) { oldest_link_pt = link_itr->get(); }
      else if ((*link_itr)->m_link_last_activated_time < oldest_link_pt->m_link_last_activated_time) {
        oldest_link_pt = link_itr->get();
      }
    }
  }
 
  while (i < this->m_unresolved_investigator_pool.size()) {
    invest_itr = this->m_unresolved_investigator_pool.begin();
    invest_itr += i;
 
    remove_it = false;
    //criteria:
    //activation
    //inactive time since the initiation
    if ((*invest_itr)->m_invest_dormant == true
        && (r5pars_.timesno - (*invest_itr)->m_investigation_initiate_time > this->m_decay_time / 2)) {
      remove_it = true;
    }
 
    if ((*invest_itr)->m_invest_dormant == false) {
      if ((*invest_itr)->m_investigator_token == inv::GetCorrespondingKE
          && (r5pars_.timesno - (*invest_itr)->m_last_active_time > this->m_decay_time)) { remove_it = true; }
      else if ((*invest_itr)->m_investigator_token == inv::FindMatchingStatement
          && (r5pars_.timesno - (*invest_itr)->m_last_active_time > this->m_decay_time)) { remove_it = true; }
    }
 
    //is it initiated by a SymptomInvestigator?
    if ((*invest_itr)->m_note.compare("by event schema") == 0) { remove_it = false; }
 
    if ((*invest_itr)->m_invest_pause == true) { remove_it = false; }
 
    if (remove_it == true) {
      if ((*invest_itr)->m_ID == "Investigator_378") { this->PrintMessage(""); }
      //rite aux information
      rm_aux_info = "Item forgotten: ";
      rm_aux_info += (*invest_itr)->m_ID;
      this->WriteAuxInfo(rm_aux_info);
 
      (*invest_itr)->m_investigation_closed = true;
      this->AddItemToDecayedItemList((IDElement *) (*invest_itr));
      this->RemoveInvestigatorFromUnresolvedPool(*invest_itr);
    } else {
      i++;
      if ((*invest_itr)->m_invest_dormant == false && (*invest_itr)->m_invest_pause == false) {
        //n_Count++;
        if ((*invest_itr)->m_Statement_pt != NULL) {
          subject_pt = (*invest_itr)->m_Statement_pt->m_sent_pt->m_subject_pt;
        } else {
          subject_pt = ((KnowledgeElement *) ((*invest_itr)->m_KElement_ID_pt))->m_SentenceUnit_pt->m_subject_pt;
        }
        for (subject_itr = subject_list.begin(); subject_itr != subject_list.end() && subject_pt != NULL;
             subject_itr++) {
          if (subject_pt == *subject_itr) { subject_pt = NULL; }
        }
        if (subject_pt != NULL) {
          subject_list.push_back(subject_pt);
          n_Count++;
        }
        if (oldest_invest_pt == NULL) {
          oldest_invest_pt = *invest_itr;
        } else if ((*invest_itr)->m_last_active_time < oldest_invest_pt->m_last_active_time) {
          oldest_invest_pt = *invest_itr;
        }
      }
    }
  }
 
  if (this->m_problem_solving_style == ProblemSolvingStyle::Vagabond) { n_max_item = 1.8 * this->m_memory_span; }
  else if (this->m_problem_solving_style == ProblemSolvingStyle::HamletB) { n_max_item = 7; }
  else { n_max_item = 7; }
 
  while (n_Count > n_max_item && (oldest_invest_pt != NULL || oldest_link_pt != NULL)) {
    //decay one item
    if (oldest_invest_pt != NULL && oldest_link_pt != NULL) {
      if (oldest_invest_pt->m_last_active_time < oldest_link_pt->m_link_last_activated_time) {
        oldest_invest_pt->m_investigation_closed = true;
        this->AddItemToDecayedItemList((IDElement *) oldest_invest_pt);
        this->RemoveInvestigatorFromUnresolvedPool(oldest_invest_pt);
        //rite aux information
        rm_aux_info = "Item forgotten: ";
        rm_aux_info += oldest_invest_pt->m_ID;
        this->WriteAuxInfo(rm_aux_info);
      } else {
        oldest_link_pt->m_forgotten_bl = true;
        this->AddItemToDecayedItemList((IDElement *) oldest_link_pt);
        //rite aux information
        rm_aux_info = "Item forgotten: ";
        rm_aux_info += oldest_link_pt->m_ID;
        this->WriteAuxInfo(rm_aux_info);
      }
    } else if (oldest_invest_pt != NULL) {
      oldest_invest_pt->m_investigation_closed = true;
      this->AddItemToDecayedItemList((IDElement *) oldest_invest_pt);
      this->RemoveInvestigatorFromUnresolvedPool(oldest_invest_pt);
      //rite aux information
      rm_aux_info = "Item forgotten: ";
      rm_aux_info += oldest_invest_pt->m_ID;
      this->WriteAuxInfo(rm_aux_info);
    } else {
      oldest_link_pt->m_forgotten_bl = true;
      this->AddItemToDecayedItemList((IDElement *) oldest_link_pt);
      //rite aux information
      rm_aux_info = "Item forgotten: ";
      rm_aux_info += oldest_link_pt->m_ID;
      this->WriteAuxInfo(rm_aux_info);
    }
 
    //recalculate
    n_Count = 0;
    subject_list.clear();
    if (oldest_link_pt != NULL) {
      if (oldest_link_pt->m_forgotten_bl == true) {
        oldest_link_pt = NULL;
        for (auto link_itr = this->m_investigator_link_pool.begin(); link_itr != this->m_investigator_link_pool.end();
             link_itr++) {
          if ((*link_itr)->m_invest_link_pause == false && (*link_itr)->m_invest_link_dormant == false
              && (*link_itr)->m_forgotten_bl == false && (*link_itr)->m_invest_link_Token != inv_link::TransferOut) {
            n_Count++;
            if (oldest_link_pt == NULL) { oldest_link_pt = link_itr->get(); }
            else if ((*link_itr)->m_link_last_activated_time < oldest_link_pt->m_link_last_activated_time) {
              oldest_link_pt = link_itr->get();
            }
          }
        }
      }
    }
    if (oldest_invest_pt != NULL) {
      if (oldest_invest_pt->m_investigation_closed == true) {
        oldest_invest_pt = NULL;
        for (auto invest_itr = this->m_unresolved_investigator_pool.begin();
             invest_itr != this->m_unresolved_investigator_pool.end(); invest_itr++) {
          if ((*invest_itr)->m_invest_dormant == false && (*invest_itr)->m_invest_pause == false
              && (*invest_itr)->m_investigation_closed == false) {
            if ((*invest_itr)->m_Statement_pt != NULL) {
              subject_pt = (*invest_itr)->m_Statement_pt->m_sent_pt->m_subject_pt;
            } else {
              subject_pt = ((KnowledgeElement *) ((*invest_itr)->m_KElement_ID_pt))->m_SentenceUnit_pt->m_subject_pt;
            }
            for (subject_itr = subject_list.begin(); subject_itr != subject_list.end() && subject_pt != NULL;
                 subject_itr++) {
              if (subject_pt == *subject_itr) { subject_pt = NULL; }
            }
            if (subject_pt != NULL) {
              subject_list.push_back(subject_pt);
              n_Count++;
            }
            if (oldest_invest_pt == NULL) { oldest_invest_pt = *invest_itr; }
            else if ((*invest_itr)->m_last_active_time < oldest_invest_pt->m_last_active_time) {
              oldest_invest_pt = *invest_itr;
            }
          }
        }
      }
    }
 
  }
}
 
int ReasonMachine::FindThePositionInTheInvestigationHistory(string _ID) {
  /*return the reverse position in the investigation history,
    0--no search result
    1--the current investigation item
    n--the last nth investigation item
    */
 
  int count;
  bool found;
  int position = 0;
 
  if (this->m_current_investigation_info != nullptr) {
    if (_ID.compare(this->m_current_investigation_info->m_name) == 0) {
      position = 1;
      return position;
    }
  }
  count = 2;
  found = false;
  for (auto info_ritr = this->m_investigation_history.rbegin();
       info_ritr != this->m_investigation_history.rend() && count < 50 && found == false; info_ritr++) {
    if (_ID.compare((*info_ritr)->m_name) == 0) {
      found = true;
      position = count;
    }
    count++;
  }
  return position;
}
 
int ReasonMachine::FindThePositionInTheThoughtLineHistory(IDElement *_ID_pt) {
  /*return the reverse position in the thoughtline history,
    0--no search result
    1--the current thought line
    n--the last nth thought line
    */
 
  int count;
  bool found;
  int position = 0;
  vector<string>::iterator str_itr;
  Investigator *invest_pt = NULL;
  InvestigatorLink *link_pt = NULL;
  if (_ID_pt->m_ID_Type == 301) {
    invest_pt = (Investigator *) _ID_pt;
  } else if (_ID_pt->m_ID_Type == 302) {
    link_pt = (InvestigatorLink *) _ID_pt;
  } else {
    this->ErrorMessage("Unrecognized Investigation Item Input");
    return 0;
  }
 
  if (this->m_current_thought_line_info != nullptr) {
    for (str_itr = this->m_current_thought_line_info->m_thought_line_list.begin();
         str_itr != this->m_current_thought_line_info->m_thought_line_list.end(); str_itr++) {
      switch (_ID_pt->m_ID_Type) {
        case 301:
          if (invest_pt->CheckWhetherInAThoughtLine(*str_itr) == true) {
            position = 1;
            return position;
          }
          break;
        case 302:
          if (link_pt->CheckWhetherInAThoughtLine(*str_itr) == true) {
            position = 1;
            return position;
          }
          break;
      }
    }
  }
 
  found = false;
  count = 2;
  for (auto info_ritr = this->m_thought_line_history.rbegin();
       info_ritr != this->m_thought_line_history.rend() && found == false && count <= 20; info_ritr++) {
    for (str_itr = (*info_ritr)->m_thought_line_list.begin(); str_itr != (*info_ritr)->m_thought_line_list.end();
         str_itr++) {
      switch (_ID_pt->m_ID_Type) {
        case 301:
          if (invest_pt->CheckWhetherInAThoughtLine(*str_itr) == true) {
            position = count;
            return position;
          }
          break;
        case 302:
          if (link_pt->CheckWhetherInAThoughtLine(*str_itr) == true) {
            position = count;
            return position;
          }
          break;
      }
    }
    count++;
  }
  return position;
}
 
void ReasonMachine::AddBackToUnresolvedInvestigationPool(Investigator *_invest_pt) {
  this->m_unresolved_investigator_pool.push_back(_invest_pt);
  return;
}
 
void ReasonMachine::SaveThoughtLineHistory(string _path) {
  vector<string>::iterator str_itr;
  vector<IDElement *>::iterator link_ID_itr;
  vector<IDElement *>::iterator invest_ID_itr;
  InvestigatorLink *link_pt;
  Investigator *invest_pt;
  Investigator *invest_pt2;
 
  ofstream fout(_path.c_str(), ios::out);
  fout << "starting time" << '\t' << "ending time" << '\t' << "ID List" << '\n';
  for (auto info_itr = this->m_thought_line_history.begin(); info_itr != this->m_thought_line_history.end(); info_itr++) {
    fout << (*info_itr)->m_interval_start << '\t';
    fout << (*info_itr)->m_interval_end << '\t';
    for (str_itr = (*info_itr)->m_thought_line_list.begin(); str_itr != (*info_itr)->m_thought_line_list.end();
         str_itr++) {
      fout << (*str_itr) << " || ";
    }
 
    fout << '\t';
    str_itr = (*info_itr)->m_thought_line_list.begin();
    invest_pt = this->FindInvestigatorByID(*str_itr);
    if (invest_pt != NULL) {
      if (invest_pt->m_KElement_ID_pt != NULL) {
        fout << invest_pt->m_KElement_ID_pt->m_ID << '\t';
        fout << "(" << invest_pt->m_effective_start;
        fout << " , ";
        fout << invest_pt->m_effective_end << ")";
      }
      fout << '\t';
      if (invest_pt->m_explained == 3) { fout << "success"; }
      else if (invest_pt->m_explained == 4) { fout << "fail"; }
      else if (invest_pt->m_explained == 2) { fout << "uncertain"; }
      else if (invest_pt->m_explained == 1) { fout << "unfinish"; }
      fout << '\t';
 
      for (link_ID_itr = invest_pt->m_explanation_link_list.begin();
           link_ID_itr != invest_pt->m_explanation_link_list.end(); link_ID_itr++) {
        link_pt = (InvestigatorLink *) (*link_ID_itr);
        for (invest_ID_itr = link_pt->m_upperstream_ID_list.begin();
             invest_ID_itr != link_pt->m_upperstream_ID_list.end(); invest_ID_itr++) {
          invest_pt2 = (Investigator *) (*invest_ID_itr);
          if (invest_pt2->m_KElement_ID_pt != NULL) { fout << invest_pt2->m_KElement_ID_pt->m_ID; }
          fout << "; ";
        }
      }
    }
    fout << '\t';
    if ((*info_itr)->m_interrupted_bl == true) {
      fout << "Interrupted";
    } else { fout << "Normal transit"; }
    fout << '\n';
  }
  fout.close();
}
 
void ReasonMachine::WriteAuxInfo(string str) {
  ofstream fout("AuxInfo.txt", ios::app);
  fout << "Time: " << r5pars_.timesno << "\t" << str << '\n';
  fout.close();
}
 
bool ReasonMachine::WetherAnInvestigationItemBelongsToTheCurrentThoughtLine(IDElement *_ID_pt) {
  Investigator *invest_pt;
  InvestigatorLink *link_pt;
  bool within_line = false;
  vector<string>::iterator str_itr;
 
  if (this->m_current_thought_line_info == nullptr) { return false; }
//301--Investigator
  //302--InvestigatorLink
  for (str_itr = this->m_current_thought_line_info->m_thought_line_list.begin();
       str_itr != this->m_current_thought_line_info->m_thought_line_list.end() && within_line == false; str_itr++) {
    switch (_ID_pt->m_ID_Type) {
      case 301: invest_pt = (Investigator *) _ID_pt;
        if (invest_pt->CheckWhetherInAThoughtLine(*str_itr) == true) { within_line = true; }
        break;
      case 302: link_pt = (InvestigatorLink *) _ID_pt;
        if (link_pt->CheckWhetherInAThoughtLine(*str_itr) == true) { within_line = true; }
        break;
    }
  }
 
  return within_line;
}
 
void ReasonMachine::CrankASentenceUnitActivationToAGivenValue(SentenceUnit *_sent_pt, float _a) {
  float activation;
  activation = min<float>(_a, 1);
  if (activation < _sent_pt->m_activation) { return; }
  _sent_pt->m_old_activation = _sent_pt->m_activation;
  _sent_pt->m_change_ratio = activation / (_sent_pt->m_activation);
  _sent_pt->m_activation = activation;
  _sent_pt->UpdateTheBaseLineValueAfterAChange(this->m_decay_lamda);
  this->OneRoundActivationSpreadingFromASentence(_sent_pt);
}
 
Statement *ReasonMachine::FoundASimilarStatementInLast10Seconds(Statement *_statement_pt) {
  Statement *found_pt = NULL;
  Statement *state_pt;
 
  bool stop_bl = false;
  for (auto state_ritr = this->m_Statement_list.rbegin();
       state_ritr != this->m_Statement_list.rend() && found_pt == NULL && stop_bl == false; state_ritr++) {
    state_pt = state_ritr->get();
    if (state_pt == _statement_pt) { continue; }
    if (state_pt->m_time_generated < _statement_pt->m_time_range.GetTimeBoundLater() - 10) { stop_bl = true; }
    if (state_pt->m_sent_pt == _statement_pt->m_sent_pt && state_pt->m_state == _statement_pt->m_state) {
      if (state_pt->m_time_range.GetTimeBoundLater() - _statement_pt->m_time_range.GetTimeBoundLater() < 10 &&
          _statement_pt->m_time_range.GetTimeBoundLater() - state_pt->m_time_range.GetTimeBoundLater() < 10) {
        found_pt = state_pt;
      }
    }
  }
  return found_pt;
}
 
bool ReasonMachine::FindAMatchingInvestigatorForAStatement(Statement *_state_pt) {
  bool found = false;
  bool consist_bl;
  Investigator *invest_pt;
  KnowledgeElement *KE_pt;
  float t1 = _state_pt->m_time_range.GetTimeBoundEarlier();
  float t2 = _state_pt->m_time_range.GetTimeBoundLater();
 
  for (auto invest_ritr = this->m_investigator_pool.rbegin();
       invest_ritr != this->m_investigator_pool.rend() && found == false; invest_ritr++) {
    invest_pt = invest_ritr->get();
    if (invest_pt->m_KElement_ID_pt == NULL) { continue; }
    KE_pt = (KnowledgeElement *) invest_pt->m_KElement_ID_pt;
    if (_state_pt->m_sent_pt != KE_pt->m_SentenceUnit_pt) { continue; }
    if (_state_pt->m_state == KE_pt->m_negation) { continue; }
    if ((t1 >= invest_pt->m_effective_start && t1 <= invest_pt->m_effective_end)
        ||
            (t2 >= invest_pt->m_effective_start && t2 <= invest_pt->m_effective_end)) {
      found = true;
      if (invest_pt->m_Statement_pt == NULL) {
        invest_pt->m_Statement_pt = _state_pt;
        this->AddDeltaToCognitiveLoad(0.024); //type 4
        _state_pt->m_investigator_ID_pt = (IDElement *) invest_pt;
        if (invest_pt->m_Happen == 2) {
          invest_pt->m_Happen = 3;
        }
      }
    }
  }
  return found;
}
 
Investigator *ReasonMachine::FindASimilarInvestigatorRecentlyResolved(Investigator *_invest_pt) {
  //50 second
  Investigator *invest_pt;
  Investigator *found_invest_pt = NULL;
  SentenceUnit *sent_pt1;
  SentenceUnit *sent_pt2;
  float time_center;
  if (_invest_pt->m_Statement_pt != NULL) {
    time_center = _invest_pt->m_Statement_pt->m_time_range.GetTimeBoundLater();
    if (time_center == 0) { this->PrintMessage(""); }
    sent_pt1 = _invest_pt->m_Statement_pt->m_sent_pt;
  } else {
    time_center = min(_invest_pt->m_effective_end, _invest_pt->m_investigation_initiate_time);
    sent_pt1 = ((KnowledgeElement *) _invest_pt)->m_SentenceUnit_pt;
  }
 
  for (auto invest_ritr = this->m_resolved_investigator_pool.rbegin();
       invest_ritr != this->m_resolved_investigator_pool.rend() && found_invest_pt == NULL; invest_ritr++) {
    invest_pt = *invest_ritr;
    if (invest_pt->m_KElement_ID_pt == NULL) { continue; }
    sent_pt2 = ((KnowledgeElement *) invest_pt->m_KElement_ID_pt)->m_SentenceUnit_pt;
    if (sent_pt1 != sent_pt2) { continue; }
 
    if (invest_pt->m_Happen_incomplete == true || invest_pt->m_Explain_incomplete == true) { continue; }
 
    if (time_center > invest_pt->m_effective_start - 300 && time_center < invest_pt->m_effective_end + 300) {
      found_invest_pt = invest_pt;
    }
  }
  return found_invest_pt;
}
 
Investigator *ReasonMachine::FindASimilarOngoingInvestigator(Investigator *_invest_pt) {
  //50 second
  Investigator *invest_pt;
  Investigator *found_invest_pt = NULL;
  SentenceUnit *sent_pt1;
  SentenceUnit *sent_pt2;
  float time_center;
  if (_invest_pt->m_Statement_pt != NULL) {
    time_center = _invest_pt->m_Statement_pt->m_time_range.GetTimeBoundLater();
    if (time_center == 0) { this->PrintMessage(""); }
    sent_pt1 = _invest_pt->m_Statement_pt->m_sent_pt;
  } else {
    time_center = min(_invest_pt->m_effective_end, _invest_pt->m_investigation_initiate_time);
    sent_pt1 = ((KnowledgeElement *) _invest_pt)->m_SentenceUnit_pt;
  }
 
  for (auto invest_ritr = this->m_unresolved_investigator_pool.rbegin();
       invest_ritr != this->m_unresolved_investigator_pool.rend() && found_invest_pt == NULL; invest_ritr++) {
    invest_pt = *invest_ritr;
 
    if (invest_pt->m_Statement_pt != NULL) {
      sent_pt2 = invest_pt->m_Statement_pt->m_sent_pt;
      if (_invest_pt->m_Statement_pt != NULL) {
        if (_invest_pt->m_Statement_pt->m_state != invest_pt->m_Statement_pt->m_state) { continue; }
      }
    } else {
      sent_pt2 = ((KnowledgeElement *) invest_pt->m_KElement_ID_pt)->m_SentenceUnit_pt;
    }
    if (sent_pt1 != sent_pt2) { continue; }
 
    if (invest_pt->m_KElement_ID_pt == NULL) {
      if (time_center > invest_pt->m_Statement_pt->m_time_range.GetTimeBoundEarlier() - 150
          && time_center < invest_pt->m_Statement_pt->m_time_range.GetTimeBoundLater()) { found_invest_pt = invest_pt; }
    } else if (time_center > invest_pt->m_effective_start - 150 && time_center < invest_pt->m_effective_end + 150) {
      found_invest_pt = invest_pt;
    }
  }
  return found_invest_pt;
}
 
void ReasonMachine::EraseFromOngoingItemStack(string _ID) {
  vector<string>::iterator str_itr;
 
  int i;
  str_itr = this->m_ongoing_item_stack.begin();
  i = 0;
 
  while (i < this->m_ongoing_item_stack.size()) {
    str_itr = this->m_ongoing_item_stack.begin();
    str_itr += i;
    if (_ID.compare(*str_itr) == 0) {
      this->m_ongoing_item_stack.erase(str_itr);
    } else { i++; }
  }
}
 
void ReasonMachine::AddItemToOngoingItemStack(string _ID) {
  bool added = false;
  vector<string>::iterator str_itr;
 
  str_itr = this->m_ongoing_item_stack.begin();
  while (str_itr != this->m_ongoing_item_stack.end() && added == false) {
    if (_ID.compare(*str_itr) == 0) { added = true; }
    str_itr++;
  }
 
  if (added == false) { this->m_ongoing_item_stack.push_back(_ID); }
}
 
void ReasonMachine::NotDoingAnything() {
  string str;
  str = "Goofy";
  this->WriteAuxInfo(str);
  this->m_consumed_time = this->m_time_length;
  if (this->m_goofy_start_time < 0.0001) { this->m_goofy_start_time = r5pars_.timesno; }
 
  this->ReOpenItemWithActivationLevelAboveAGivenValue(max(0.2,
                                                          exp(-0.04 * (r5pars_.timesno - this->m_goofy_start_time))));
}
 
float ReasonMachine::CheckRemainingTimeForThisStep() {
  float deltaT;
  deltaT = this->m_time_length - this->m_consumed_time;
  deltaT = deltaT / (this->m_cognitive_time_cost_multiplier * this->m_cognitive_time_cost_base_multiplier);
  deltaT += 0.001;
  return deltaT;
}
 
void ReasonMachine::AutoIgnitionOfDecayedInvestigatorInitiatedByActivatingAStatement(Statement *_state_pt) {
  Statement *state_pt;
  vector<Statement *> state_list;
  vector<Statement *>::iterator state_itr;
  vector<Statement *>::iterator state_itr2;
  vector<Statement *>::iterator state_itr3;
  bool exist_bl;
  Investigator *invest_pt;
  SentenceUnit *sent_pt;
 
  state_list.push_back(_state_pt);
  int i = 0;
 
  while (i < state_list.size()) {
    state_itr = state_list.begin();
    state_itr += i;
    state_pt = *state_itr;
    sent_pt = state_pt->m_sent_pt;
    if (sent_pt->m_activation < 1) {
      this->CrankASentenceUnitActivationToAGivenValue(sent_pt, 1.0);
    }
    //first check the investigator associated with this statement
    if (state_pt->m_investigator_ID_pt != 0) {
      invest_pt = (Investigator *) (state_pt->m_investigator_ID_pt);
      if (invest_pt != NULL) {
        if (invest_pt->m_investigation_closed == true
            && invest_pt->m_investigator_token < inv::ActiveThreshold) {// check whether to resume this item
          if ((this->FindASimilarInvestigatorRecentlyResolved(invest_pt) != NULL
              || this->FindASimilarOngoingInvestigator(invest_pt) != NULL)
              && invest_pt->m_active_investigation == false) {//not to resume this item
          } else {
            invest_pt->ReopenThisInvestigator();
          }
        }
      }
    }
    //propagate to the uppstream of this item
    for (state_itr2 = state_pt->m_upperstream_statement_list.begin();
         state_itr2 != state_pt->m_upperstream_statement_list.end(); state_itr2++) {
      exist_bl = false;
      for (state_itr3 = state_list.begin(); exist_bl == false && state_itr3 != state_list.end(); state_itr3++) {
        if ((*state_itr3) == (*state_itr2)) { exist_bl = true; }
      }
      if (exist_bl == false) { state_list.push_back(*state_itr2); }
    }
    //propagate to the downstream of this item
    for (state_itr2 = state_pt->m_downstream_statement_list.begin();
         state_itr2 != state_pt->m_downstream_statement_list.end(); state_itr2++) {
      exist_bl = false;
      for (state_itr3 = state_list.begin(); exist_bl == false && state_itr3 != state_list.end(); state_itr3++) {
        if ((*state_itr3) == (*state_itr2)) { exist_bl = true; }
      }
      if (exist_bl == false) { state_list.push_back(*state_itr2); }
    }
 
    i++;
  }
  state_list.clear();
}
 
void ReasonMachine::RemoveItemFromDecayedItemList(IDElement *_ID_pt) {
  vector<IDElement *>::iterator ID_itr;
  int i;
 
  i = 0;
  while (i < this->m_decayed_item_pt_list.size()) {
    ID_itr = this->m_decayed_item_pt_list.begin();
    ID_itr += i;
    if ((*ID_itr) == _ID_pt) { this->m_decayed_item_pt_list.erase(ID_itr); }
    else { i++; }
  }
 
}
 
void ReasonMachine::AddItemToDecayedItemList(IDElement *_ID_pt) {
  vector<IDElement *>::iterator ID_itr;
  bool exist_bl = false;
 
  for (ID_itr = this->m_decayed_item_pt_list.begin(); ID_itr != this->m_decayed_item_pt_list.end() && exist_bl == false;
       ID_itr++) {
    if ((*ID_itr) == _ID_pt) {
      exist_bl = true;
      break;
    }
  }
 
  if (exist_bl == false) {
    this->m_decayed_item_pt_list.push_back(_ID_pt);
  }
}
 
void ReasonMachine::ReOpenItemWithActivationLevelAboveAGivenValue(float _value) {
  vector<IDElement *>::iterator ID_itr;
  float score;
  Investigator *invest_pt;
  InvestigatorLink *link_pt;
  SentenceUnit *sent_pt;
 
  int i = 0;
  if (r5pars_.timesno > 1740) { i = 0; }
 
  while (i < this->m_decayed_item_pt_list.size()) {
    //three barries:
    //1--activation level
    //2--last active time has to be within 300 second
    //3--not paused, not dormant
    ID_itr = this->m_decayed_item_pt_list.begin();
    ID_itr += i;
    if (i == 23) { i = i; }
 
    if ((*ID_itr)->m_ID_Type == 301) {
      invest_pt = (Investigator *) (*ID_itr);
      if (invest_pt->m_invest_dormant == true || invest_pt->m_invest_pause == true
          || (r5pars_.timesno - invest_pt->m_last_active_time > 300)) {
        i++;
        continue;
      }
 
      sent_pt = invest_pt->GetSemanticSentenceOfThisInvestigator();
      if (sent_pt->m_activation > _value) {
        if (this->FindASimilarInvestigatorRecentlyResolved(invest_pt) == NULL
            && this->FindASimilarOngoingInvestigator(invest_pt) == NULL) {
          invest_pt->ReopenThisInvestigator();
          //this->m_decayed_item_pt_list.erase(ID_itr);
          if (i == this->m_decayed_item_pt_list.size()) { break; }
          continue;
        }
      }
    } else if ((*ID_itr)->m_ID_Type == 302) {
      link_pt = (InvestigatorLink *) (*ID_itr);
      if (link_pt->m_invest_link_dormant == true || link_pt->m_invest_link_pause == true
          || (r5pars_.timesno - link_pt->m_link_last_activated_time > 300)) {
        i++;
        continue;
      }
 
      if (link_pt->GetActivationOfthisLink() > _value) {
        link_pt->m_forgotten_bl = false;
        this->m_decayed_item_pt_list.erase(ID_itr);
        continue;
      }
    }
 
    i++;
  }
 
}
 
void ReasonMachine::AddDeltaToCognitiveLoad(float _delta) {
  _delta *= 0.108;
  this->m_cognitive_load += _delta;
  this->m_cognitive_load = min<float>(this->m_cognitive_load, 1);
}
 
void ReasonMachine::AddDeltaToSystemDynamics(float _delta) {
  _delta *= 0.108;
  this->m_system_dynamic_level += _delta;
}
 
void ReasonMachine::UpdatePSFAtEndOfATimeStep() {
  float value;
  bool confuse_bl;
  float max_confusion = 0;
  int num;
 
  //cogntive load is already updated
 
  //complexity
  if (r5pars_.timesno > 1860) { this->PrintMessage(""); }
  for (auto di_itr = this->m_event_schema_base->m_diagnose_invest_list.begin();
       di_itr != this->m_event_schema_base->m_diagnose_invest_list.end(); di_itr++) {
    if ((*di_itr)->m_terminate_investigation == true) { continue; }
    confuse_bl = false;
    if ((*di_itr)->m_N_setback_list.size() > 0) {
      num = *((*di_itr)->m_N_setback_list.rbegin());
      if (num > 0) {
        { max_confusion = max((*di_itr)->m_confidence, max_confusion); }
      }
    }
  }
 
  this->m_diagnosis_complexity = 0.8 * this->m_system_dynamic_level + 0.2 * max_confusion;
 
  //stress
  this->m_overall_stress = 0.25
      * (this->m_passive_alarm_load->GetAlarmLoadValue() + this->m_time_constraint->getTimeConstrainedPIFValue() / 10
          + this->m_cognitive_load + this->m_diagnosis_complexity);
 
  //fatigue
  this->m_load_stress_integration_of_time += this->m_cognitive_load * pow(1 + this->m_overall_stress, 2);
  this->m_fatigue_level = this->m_initial_fatigue_level + 0.20 * (1 - exp(-0.00008 * r5pars_.timesno))
      + 0.8 * (1 - exp(-0.000054 * this->m_load_stress_integration_of_time));
}
 
void ReasonMachine::UpdateManifestationParameterAtEndOfATimeStep() {
  //alarm stack length
  this->m_max_length_of_alarms_stack = (4 + 3 * this->m_interuptiveness)
      * (1 - 0.5 * this->m_passive_alarm_load->GetAlarmLoadValue() / this->m_interuptiveness)
      * (1 - 0.5 * this->m_time_constraint->getTimeConstrainedPIFValue() / 10) * (1 - 0.5 * this->m_fatigue_level);
 
  //Cognitive Resource Use
  this->m_cognitive_resource_use =
      0.4 * this->m_time_constraint->getTimeConstrainedPIFValue() / 10
          + 0.3 * this->m_passive_alarm_load->GetAlarmLoadValue()
          + 0.2 * this->m_cognitive_load
          + 0.1 * this->m_diagnosis_complexity;
 
  //time cost multiplier
  this->m_cognitive_time_cost_multiplier =
      1 / ((1 + this->m_cognitive_resource_use) * (1 - 0.8 * this->m_fatigue_level));
 
  //routine monitor interval multiplier
  this->m_routine_monitor_interval_multiplier = (1 + this->m_fatigue_level) * this->m_routine_monitor_threshold;
 
  //attention span
  this->m_attention_span = this->m_attention_span_base_value
      / ((1 + this->m_time_constraint->getTimeConstrainedPIFValue() / 10) * (1 + this->m_fatigue_level));
 
  //memory span
  this->m_memory_span = this->m_memory_span_base_value * (1 + this->m_expert_level)
      / ((1 + 0.2 * this->m_time_constraint->getTimeConstrainedPIFValue() / 10) * (1 + this->m_fatigue_level));
 
  //decay time
  this->m_decay_time = this->m_decay_time_base_value
      / ((1 + this->m_fatigue_level) * (1 + this->m_passive_alarm_load->GetAlarmLoadValue()));
 
}
 
void ReasonMachine::AddPSFandManifestationDataSet() {
  unique_ptr<ValueTimeLineUnit> vtu_pt;
 
//PSF
  //time constraint load
  vtu_pt = make_unique<ValueTimeLineUnit>();
  vtu_pt->m_time = r5pars_.timesno;
  vtu_pt->m_fl = this->m_time_constraint->getTimeConstrainedPIFValue() / 10;
  this->m_time_load_history.push_back(std::move(vtu_pt));
 
  //passive load
  vtu_pt = make_unique<ValueTimeLineUnit>();
  vtu_pt->m_time = r5pars_.timesno;
  vtu_pt->m_fl = this->m_passive_alarm_load->m_alarm_load_value;
  this->m_passive_alarm_load->m_passive_alarm_load_timeline.push_back(std::move(vtu_pt));
 
  //fatigue
  vtu_pt = make_unique<ValueTimeLineUnit>();
  vtu_pt->m_time = r5pars_.timesno;
  vtu_pt->m_fl = this->m_fatigue_level;
  this->m_fatigue_history.push_back(std::move(vtu_pt));
 
  //complexity
  vtu_pt = make_unique<ValueTimeLineUnit>();
  vtu_pt->m_time = r5pars_.timesno;
  vtu_pt->m_fl = this->m_diagnosis_complexity;
  this->m_diagnosis_complexity_history.push_back(std::move(vtu_pt));
 
  //cognitive load
  vtu_pt = make_unique<ValueTimeLineUnit>();
  vtu_pt->m_time = r5pars_.timesno;
  vtu_pt->m_fl = this->m_cognitive_load;
  this->m_cognitive_load_history.push_back(std::move(vtu_pt));
 
  //stress
  vtu_pt = make_unique<ValueTimeLineUnit>();
  vtu_pt->m_time = r5pars_.timesno;
  vtu_pt->m_fl = this->m_overall_stress;
  this->m_stress_history.push_back(std::move(vtu_pt));
 
 
//middle variables history
  vtu_pt = make_unique<ValueTimeLineUnit>();
  vtu_pt->m_time = r5pars_.timesno;
  vtu_pt->m_fl = this->m_cognitive_resource_use;
  this->m_cognitive_resouse_use_history.push_back(std::move(vtu_pt));
 
//manifestation variables history
  //max stack length
  vtu_pt = make_unique<ValueTimeLineUnit>();
  vtu_pt->m_time = r5pars_.timesno;
  vtu_pt->m_int = this->m_max_length_of_alarms_stack;
  this->m_max_alarm_length_timeline.push_back(std::move(vtu_pt));
 
  //time consumption multiplier
  vtu_pt = make_unique<ValueTimeLineUnit>();
  vtu_pt->m_time = r5pars_.timesno;
  vtu_pt->m_fl = this->m_cognitive_time_cost_multiplier;
  this->m_cognitive_time_cost_multiplier_history.push_back(std::move(vtu_pt));
 
  //routine monitor
  vtu_pt = make_unique<ValueTimeLineUnit>();
  vtu_pt->m_time = r5pars_.timesno;
  vtu_pt->m_fl = this->m_routine_monitor_interval_multiplier;
  this->m_routine_monitor_interval_multiplier_history.push_back(std::move(vtu_pt));
 
  //attention span
  vtu_pt = make_unique<ValueTimeLineUnit>();
  vtu_pt->m_time = r5pars_.timesno;
  vtu_pt->m_fl = this->m_attention_span;
  this->m_attention_span_history.push_back(std::move(vtu_pt));
 
  //memory span
  vtu_pt = make_unique<ValueTimeLineUnit>();
  vtu_pt->m_time = r5pars_.timesno;
  vtu_pt->m_fl = this->m_memory_span;
  this->m_memory_span_history.push_back(std::move(vtu_pt));
 
  //decay time of investigation items
  vtu_pt = make_unique<ValueTimeLineUnit>();
  vtu_pt->m_time = r5pars_.timesno;
  vtu_pt->m_fl = this->m_decay_time;
  this->m_decay_time_history.push_back(std::move(vtu_pt));
}
 
void ReasonMachine::RandomlyGenerateKnowledgeBug() {
  float fl;
  string str;
 
  for (auto KU_itr = this->m_Knowledge_list.begin(); KU_itr != this->m_Knowledge_list.end(); KU_itr++) {
    fl = ((float) rand() / float(RAND_MAX));
    if (fl > (*KU_itr)->m_knowledge_strength) {
//          (*KU_itr)->m_accessable_bl = false;
      str = "Disabled Knowledge Link: " + (*KU_itr)->m_ID;
      this->WriteAuxInfo(str);
    }
  }
}
 
void ReasonMachine::PrintKnowledgeWeb() {
  /*
    fout <<"\n" << "Time: " << r5pars_.timesno << ":\n" << str << '\n';
    fout.close();
    */
  KnowledgeUnit *KU_pt;
  KnowledgeElement *KE_pt;
 
  string file_name;
  file_name = g_sim.SScheduler.getOutputDirectory();
  file_name += "RMOutPut/";
  file_name += "ODM_Knowledge_Web.txt";
  ofstream fout(file_name.c_str(), ios::out);
  /*vector<SentenceUnit*>::iterator sent_itr;
    fout << "There are " << this->m_Semantic_list.size() + " sentences in total" + '\n';
    for(sent_itr = this->m_Semantic_list.begin(); sent_itr != this->m_Semantic_list.end(); sent_itr++)
    {
        fout << (*sent_itr)->m_ID << '\n';
    }*/
 
  fout << "upstream phenomenon" << '\t'
       << "downstream phenomenon" << '\t'
       << "causal type" << '\t'
       << "inference type" << '\t'
       << "familiarity" << '\t'
       << "strength 1" << '\t'
       << "strength 2" << '\t'
       << "delta T1" << '\t'
       << "delta T2" << '\t'
       << "conditional phenomenon" << '\n';
 
  for (auto KU_itr = this->m_Knowledge_list.begin(); KU_itr != this->m_Knowledge_list.end(); KU_itr++) {
    KU_pt = KU_itr->get();
 
    if (KU_pt->m_Ancestor_pt->m_ID_Type == 401) {
      KE_pt = (KnowledgeElement *) (KU_pt->m_Ancestor_pt);
      fout << KE_pt->m_SentenceUnit_pt->m_ID << '\t';
    } else if (KU_pt->m_Ancestor_pt->m_ID_Type == 402) {
      fout << KU_pt->m_Ancestor_pt->m_ID << '\t';
    }
 
    if (KU_pt->m_Descendant_pt->m_ID_Type == 401) {
      KE_pt = (KnowledgeElement *) (KU_pt->m_Descendant_pt);
      fout << KE_pt->m_SentenceUnit_pt->m_ID << '\t';
    } else if (KU_pt->m_Descendant_pt->m_ID_Type == 402) {
      fout << KU_pt->m_Descendant_pt->m_ID << '\t';
    }
    fout
        << KU_pt->m_causal_type << '\t'
        << KU_pt->m_inference_type << '\t'
        << KU_pt->m_knowledge_strength << '\t'
        << KU_pt->m_forward_retrieve_weight << '\t'
        << KU_pt->m_backward_retrieve_weight << '\t'
        << KU_pt->m_deltaT1 << '\t'
        << KU_pt->m_deltaT2 << '\t';
    if (KU_pt->m_Permission_pt != NULL) {
      if (KU_pt->m_Permission_pt->m_ID_Type == 401) {
        KE_pt = (KnowledgeElement *) (KU_pt->m_Permission_pt);
        fout << KE_pt->m_SentenceUnit_pt->m_ID;
      } else {
        fout << KU_pt->m_Permission_pt->m_ID;
      }
    }
 
    fout << '\n';
  }
  fout.close();
}