Investigator.cpp

Go to the documentation of this file.

// Investigator.cpp: implementation of the Investigator class.
//
 
#include <algorithm>
#include <memory>
#include <sstream>
#include <iostream>
#include <fstream>
 
#include "../Global/fmodule.h"
#include "Investigator.h"
#include "DiagnoseInvestigator.h"
#include "ReasonMachine.h"
#include "RMTokens.h"
#include "../Crew/OperatorDM.h"
#include "../Global/SimulationContext.h"
 
using namespace std;
 
 
 
// Construction/Destruction
 
Investigator::Investigator() {
  this->m_Happen_incomplete = false;
  this->m_Explain_incomplete = false;
  this->m_active_investigation = false;
  this->m_probability_update_time = 0;
  this->m_last_active_time = r5pars_.timesno;
  this->m_root_of_a_thought_line = false;
  this->m_investigation_closed = false;
  this->m_ID_Type = 301;
  this->m_timer = 0;
  //301--Investigator
  //302--InvestigatorLink
  this->m_explained = 1; //unknown not yet
  this->m_Happen = 1; //unknown
//  this->m_investiage_status = 3; //idle
  this->m_investigator_token = 0;
  this->m_abort = false;
  this->m_phenomenon_onging = true;
  this->m_invest_pause = false; //if true, that means the operator worked on tracing the upperstream causes
  this->m_invest_dormant = false;
  this->m_read_value_or_rate_bl = 0; //0--read parameter value; 1--rate
  this->m_KElement_ID_pt = NULL;
  this->m_Statement_pt = NULL;
  this->m_possible_statement_pt = NULL;
  this->m_independent_probability = 0;
  this->m_motivation = 0; //0--to verify a knowledge element; 1--to investigate a statement
  this->m_read_requested_bl = 0;
  this->m_effective_start = 0;
  this->m_effective_end = 0;
  this->m_investigation_initiate_time = 0;
  this->m_investigation_cease_time = 0;
  this->m_SI_ID_pt = NULL;
  this->m_has_moved_to_an_upperstream = false;
  this->m_inconsistant_statement = NULL;
  this->m_has_moved_to_link = NULL;
  this->m_interest_from_SymptomInvestigator = 0;
  this->m_last_time_of_refreshing_inference_item = 0;
 
  m_ID_SI = "";
  m_ID_KE = "";
  m_ID_statement = "";
  m_ID_possible_statement = "";
  m_ID_inconsist_statement = "";
  this->m_ID_has_move_to_link = "";
 
}
 
Investigator::~Investigator() {
 
  this->m_investigator_token_history.clear();
  this->m_invest_token_endtime_history.clear();
  this->m_read_indication_list.clear();
  this->m_feedback_list.clear();
  this->m_upperstream_ID_list.clear();
  this->m_downstream_ID_list.clear();
  this->m_explanation_link_list.clear();
  this->m_possible_explanation_link_list.clear();
  this->m_rejected_explanation_list.clear();
 
  this->m_ID_read_indication_list.clear();
  this->m_ID_feedback_list.clear();
  this->m_ID_upperstream_list.clear();
  this->m_ID_downstream_list.clear();
  this->m_ID_explanation_link_list.clear();
  this->m_ID_possible_explanation_link_list.clear();
  this->m_ID_rejected_explanation_list.clear();
}
 
void Investigator::SearchForPossibleCauses3012() {
  bool sucess = false;
  vector<KnowledgeElement *>::iterator KE_itr;
  KnowledgeElement *KE_down_X_pt = NULL;
  KnowledgeElement *KE_upper_X_pt = NULL;
  KnowledgeElement *KE_perm_X_pt = NULL;
  KnowledgeElement *KE_upper_pt = NULL;
  KnowledgeElement *KE_down_pt = NULL;
  KnowledgeElement *KE_perm_pt = NULL;
  KnowledgeElement *KE_pt = NULL;
  KnowledgeElement *KE_buffer_pt = NULL;
  IDElement *label_down_pt = NULL;
  IDElement *label_ID_pt = NULL;
  IDElement *ID_pt;
  IDElement *ID_pt2;
  vector<IDElement *>::iterator label_itr;
  Label *label_group_pt = NULL;
  Label *label_group_down_pt = NULL;
  Label *label_group_upper_pt = NULL;
  Label *label_group_perm_pt = NULL;
  SentenceUnit *sent_pt;
  KnowledgeNode *KN_pt;
  Investigator *invest_pt;
  Investigator *permission_pt;
  InvestigatorLink *invest_link_pt;
  bool inference_direction_reverse_bl;
  double time_start = 0;
  double time_end = 0;
  double time1, time2;
  string ID_name;
  stringstream conv;
  int match_type = 0;
  ReasonMachine *RM_pt;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
  int N_inference = 0;
 
  if (this->m_ID == "Investigator_36") { this->PrintMessage(""); }
 
  if (this->m_upperstream_ID_list.size() != 0) {
    this->ChangeInvestigatorToken(inv::RetrieveNextLink);
    return;
  }
 
  if (this->m_Statement_pt != 0) {//add time range; time_end gets the statement time
    if (this->m_Statement_pt->m_time_range.m_end_time != 0
        && this->m_Statement_pt->m_time_range.m_end_time >= this->m_Statement_pt->m_time_range.m_time_before) {
      time_end = this->m_Statement_pt->m_time_range.m_end_time;
    }
    else if (this->m_Statement_pt->m_time_range.m_time_before != 0) {
      time_end = this->m_Statement_pt->m_time_range.m_time_before;
    }
    else {}//warning message
    if (this->m_Statement_pt->m_time_range.m_start_time != 0
        && this->m_Statement_pt->m_time_range.m_end_time >= this->m_Statement_pt->m_time_range.m_time_before) {
      time_start = this->m_Statement_pt->m_time_range.m_start_time;
    }
    else if (this->m_Statement_pt->m_time_range.m_time_after != 0) {
      time_start = this->m_Statement_pt->m_time_range.m_time_after;
    }
    else {}//warning message
  }
 
  if (this->m_KElement_ID_pt == 0) {
    if (this->m_Statement_pt == 0) { return; }//warning message: void investigator
    this->m_KElement_ID_pt = RM_pt->FindKnowledgeElementByStatement(this->m_Statement_pt);
    if (this->m_KElement_ID_pt
        == NULL) { return; }//message here: could not found a corresponding concept in Knowledge base
    this->m_effective_end = time_end;
    this->m_effective_start = time_start;
  }
 
  if (time_start == 0 && time_end == 0) {
    if (this->m_effective_start == 0 && this->m_effective_end == 0) {}// error message
    else {
      time_start = this->m_effective_start;
      time_end = this->m_effective_end;
    }
  }
  //check point
  if (this->m_ID == "Investigator_26") {
    this->PrintMessage("Check point");
  }
  //
 
  KE_down_X_pt = NULL;
  KE_down_pt = (KnowledgeElement *) (this->m_KElement_ID_pt);
  sent_pt = RM_pt->FindAnIndefiniteSentenceMatchTheInputSentence(KE_down_pt->m_SentenceUnit_pt);
  if (sent_pt != NULL) {
    //assign the KE_down_X_pt
    KE_down_X_pt = RM_pt->FindAKEbySentenceAndNegationSign(sent_pt, KE_down_pt->m_negation);
    if (KE_down_X_pt == NULL) {
      this->ErrorMessage("Could not find a KE for " + sent_pt->m_ID);
      return;
    }
    //assign the label_group_down_pt
    label_group_down_pt = RM_pt->m_IB->CheckWhetherASentenceContainIndefiniteItem(sent_pt);
    if (label_group_down_pt == NULL) {
      this->ErrorMessage("Could not find the corresponding label group for " + sent_pt->m_ID);
      return;
    }
    //assign the label_down_pt
    label_down_pt = KE_down_pt->m_SentenceUnit_pt->GetLabelOfThisSentence();
    label_ID_pt = label_down_pt;
    if (label_down_pt == NULL) {
      this->ErrorMessage("Could not find a label of " + KE_down_pt->m_ID);
      return;
    }
  }
 
  if (this->m_ID == "Investigator_26") { this->PrintMessage("Check"); }
 
  for (auto KU_itr = RM_pt->m_Knowledge_list.begin(); KU_itr != RM_pt->m_Knowledge_list.end(); KU_itr++) {
    if ((*KU_itr)->m_accessable_bl == false) { continue; }
 
    if ((*KU_itr)->m_Descendant_pt->m_ID_Type != 401) { return; }//error message, the KnowledgeUnit format is not right;
 
//-----------------------Search for the upperstream of the inference pathes
    if (this->m_Happen != 3 && this->m_Happen != 4 && (*KU_itr)->m_inference_type != 0) {
      match_type = 0;
      ID_pt = NULL;
      if ((*KU_itr)->m_inference_type == 1 || (*KU_itr)->m_inference_type == 3) {
        //need to compare with the downstream of the KU
        ID_pt = (*KU_itr)->m_Descendant_pt;
        ID_pt2 = (*KU_itr)->m_Ancestor_pt;
        inference_direction_reverse_bl = false;
      } else if ((*KU_itr)->m_inference_type == 2 || (*KU_itr)->m_inference_type == 3) {
        //need to compare witht the upperstream of the KU
        ID_pt = (*KU_itr)->m_Ancestor_pt;
        ID_pt2 = (*KU_itr)->m_Descendant_pt;
        inference_direction_reverse_bl = true;
      } else {
        continue;
      }
 
      if (ID_pt == NULL) {
        this->ErrorMessage("Error!");
        return;
      }
 
      //compare whether it is a match
      if (ID_pt->m_ID_Type == 401) {
        KE_pt = (KnowledgeElement *) ID_pt;
        if (KE_pt == KE_down_pt || KE_pt == KE_down_X_pt) {
          match_type = 1;
        } else {
          match_type = 0;
        }
 
      } else if (ID_pt->m_ID_Type == 402) {
        match_type = 0;
      }
 
      //if it is a match
      if (match_type == 1) {
        N_inference++;
        //add an investigatorLink
        {
        auto invest_link_owned = make_unique<InvestigatorLink>();
        invest_link_pt = invest_link_owned.get();
        invest_link_pt->m_is_causal_path_bl = false;
        invest_link_pt->m_is_inference_path_bl = true;
        invest_link_pt->m_downstream_ID_pt = (IDElement *) this;
        invest_link_pt->m_K_unit_pt = KU_itr->get();
        invest_link_pt->m_operator = this->m_operator;
        RM_pt->AddNewInvestigatorLink(invest_link_owned.release());
        this->m_upperstream_ID_list.push_back(invest_link_pt);
        }
 
        if (ID_pt2->m_ID_Type == 401) {
          KE_buffer_pt = (KnowledgeElement *) ID_pt2;
          //firstly check whether it contains X concept
          label_group_pt = RM_pt->m_IB->CheckWhetherASentenceContainIndefiniteItem(KE_buffer_pt->m_SentenceUnit_pt);
          if (label_group_pt == NULL) {//O-O or O-X
            KE_pt = KE_buffer_pt;
            invest_link_pt->m_link_type = 1;
          } else if (label_group_pt == label_group_down_pt) {//X-X
            invest_link_pt->m_link_type = 1;
            sent_pt = RM_pt->InstantiateAnIndefiniteSentenceWithLabel(KE_buffer_pt->m_SentenceUnit_pt, label_down_pt);
            if (sent_pt == NULL) {
              this->ErrorMessage("Error!");
              return;
            }
            KE_pt = RM_pt->FindAKEbySentenceAndNegationSign(sent_pt, KE_buffer_pt->m_negation);
            if (KE_pt == NULL) {
              this->ErrorMessage("Error!");
              return;
            }
          } else if (label_group_down_pt == NULL) {//X-O
            invest_link_pt->m_link_type = 3;
            for (label_itr = label_group_pt->m_label_option_list.begin();
                 label_itr != label_group_pt->m_label_option_list.end(); label_itr++) {
              sent_pt = RM_pt->InstantiateAnIndefiniteSentenceWithLabel(KE_buffer_pt->m_SentenceUnit_pt, (*label_itr));
              if (sent_pt == NULL) {
                this->ErrorMessage("Error!");
                return;
              }
              KE_pt = RM_pt->FindAKEbySentenceAndNegationSign(sent_pt, KE_buffer_pt->m_negation);
              if (KE_pt == NULL) {
                this->ErrorMessage("Error!");
                return;
              }
              invest_pt = RM_pt->FindAMatchInvestigatorByKnowledgeElement(KE_pt, time1, time2);
              if (invest_pt == NULL) {
                auto invest_owned = make_unique<Investigator>();
                invest_pt = invest_owned.get();
                invest_pt->m_note = "by downstream";
                invest_pt->m_motivation = 0;
                invest_pt->m_KElement_ID_pt = (IDElement *) KE_pt;
                invest_pt->m_investigator_token = inv::FindMatchingStatement;
                invest_pt->m_effective_start = time_start;
                invest_pt->m_effective_end = time_end;
                invest_pt->m_operator = this->m_operator;
                invest_pt->m_invest_dormant = true;
                invest_pt->m_root_of_a_thought_line = false;
                invest_pt->m_active_investigation = true;
                RM_pt->AddNewInvestigator(invest_owned.release());
              }
              //link the permission investigator and the InvestigatorLink
              invest_link_pt->m_upperstream_ID_list.push_back((IDElement *) invest_pt);
              invest_pt->m_downstream_ID_list.push_back((IDElement *) invest_link_pt);
            }
          }
 
          //create new investigator or link to new investigator
          if (invest_link_pt->m_link_type == 1) {
            invest_pt = RM_pt->FindAMatchInvestigatorByKnowledgeElement(KE_pt, time1, time2);
            if (invest_pt == NULL) {
              auto invest_owned = make_unique<Investigator>();
              invest_pt = invest_owned.get();
              invest_pt->m_note = "by downstream";
              invest_pt->m_motivation = 0;
              invest_pt->m_KElement_ID_pt = (IDElement *) KE_pt;
              invest_pt->m_investigator_token = inv::FindMatchingStatement;
              invest_pt->m_effective_start = time_start;
              invest_pt->m_effective_end = time_end;
              invest_pt->m_operator = this->m_operator;
              invest_pt->m_invest_dormant = true;
              invest_pt->m_root_of_a_thought_line = false;
              invest_pt->m_active_investigation = true;
              RM_pt->AddNewInvestigator(invest_owned.release());
            }
            //link the permission investigator and the InvestigatorLink
            invest_link_pt->m_upperstream_ID_list.push_back((IDElement *) invest_pt);
            invest_pt->m_downstream_ID_list.push_back((IDElement *) invest_link_pt);
          }
 
        } else if (ID_pt2->m_ID_Type == 402) {
          KN_pt = (KnowledgeNode *) ID_pt2;
          invest_link_pt->m_link_type = KN_pt->m_Node_Type;
          for (KE_itr = KN_pt->M_KElement_list.begin(); KE_itr != KN_pt->M_KElement_list.end(); KE_itr++) {
            invest_pt = RM_pt->FindAMatchInvestigatorByKnowledgeElement((*KE_itr), time1, time2);
            if (invest_pt == NULL) {
              auto invest_owned = make_unique<Investigator>();
              invest_pt = invest_owned.get();
              invest_pt->m_note = "by downstream";
              invest_pt->m_motivation = 0;
              invest_pt->m_KElement_ID_pt = (IDElement *) (*KE_itr);
              invest_pt->m_investigator_token = inv::FindMatchingStatement;
              invest_pt->m_effective_start = time_start;
              invest_pt->m_effective_end = time_end;
              invest_pt->m_operator = this->m_operator;
              invest_pt->m_invest_dormant = true;
              invest_pt->m_root_of_a_thought_line = false;
              invest_pt->m_active_investigation = true;
              RM_pt->AddNewInvestigator(invest_owned.release());
            }
            //link the permission investigator and the InvestigatorLink
            invest_link_pt->m_upperstream_ID_list.push_back((IDElement *) invest_pt);
            invest_pt->m_downstream_ID_list.push_back((IDElement *) invest_link_pt);
          }
        }
      }// end of if(match_type == 1)
    }
 
 
//---------------------Search for the Causes
 
    //this is strict ID comparison, might need to modify it to make the comparison more flexible
    if ((*KU_itr)->m_causal_type == 0) { continue; }
    if ((*KU_itr)->m_Descendant_pt->m_ID != this->m_KElement_ID_pt->m_ID
        && (*KU_itr)->m_Descendant_pt != (IDElement *) KE_down_X_pt) { continue; }
 
    label_ID_pt = label_down_pt;
    label_group_pt = label_group_down_pt;
    time1 = time_start - (*KU_itr)->m_deltaT2;
    time2 = time_end - (*KU_itr)->m_deltaT1;
 
    //create an InvestigatorLink
    {
    auto invest_link_owned = make_unique<InvestigatorLink>();
    invest_link_pt = invest_link_owned.get();
    invest_link_pt->m_K_unit_pt = KU_itr->get();
    invest_link_pt->m_operator = this->m_operator;
    //links between this investigator and the InvestigatorLink
    this->m_upperstream_ID_list.push_back((IDElement *) invest_link_pt);
    invest_link_pt->m_downstream_ID_pt = (IDElement *) this;
    RM_pt->AddNewInvestigatorLink(invest_link_owned.release());
    }
 
    //Check whether the permission contains an indefinite concept if there is a condition
    label_group_perm_pt = NULL;
    if ((*KU_itr)->m_Permission_pt != NULL) {
      KE_pt = (KnowledgeElement *) ((*KU_itr)->m_Permission_pt);
      label_group_perm_pt = RM_pt->m_IB->CheckWhetherASentenceContainIndefiniteItem(KE_pt->m_SentenceUnit_pt);
      if (label_group_perm_pt != NULL) {
        if (label_group_pt == NULL) {
          this->ErrorMessage(
              "Error: The condition of this KnowledgeUnit has indefinite concept which is not in the downstream item!");
          return;
        } else if (label_group_pt != label_group_perm_pt) {
          this->ErrorMessage("Error: This Knowledge Unit contains more than one indefinite groups!");
          return;
        }
      }
    }
    //Get the KnowledgeElement of the permission if there is one
    if (label_group_perm_pt != NULL) {
      KE_pt = (KnowledgeElement *) ((*KU_itr)->m_Permission_pt);
      sent_pt = RM_pt->InstantiateAnIndefiniteSentenceWithLabel(KE_pt->m_SentenceUnit_pt, label_down_pt);
      KE_perm_pt = RM_pt->FindAKEbySentenceAndNegationSign(sent_pt, KE_pt->m_negation);
      if (KE_perm_pt == NULL) {
        this->ErrorMessage(
            "Could not find a KE for " + sent_pt->m_ID); //should also add the negation infor in the error
        return;
      }
    } else if ((*KU_itr)->m_Permission_pt != NULL) {
      KE_perm_pt = (KnowledgeElement *) ((*KU_itr)->m_Permission_pt);
    }
 
    //build the investigator for the permission
    if ((*KU_itr)->m_Permission_pt != NULL) {
      //search whether there is an investigator match
      //check point
      if (KE_perm_pt->m_ID == "KE_MSI_OFF") {
        this->PrintMessage("check point");
      }
      //
      permission_pt = RM_pt->FindAMatchInvestigatorByKnowledgeElement(KE_perm_pt, time1, time2);
      if (permission_pt == NULL) {
        auto perm_owned = make_unique<Investigator>();
        permission_pt = perm_owned.get();
        permission_pt->m_motivation = 0;
        permission_pt->m_note = "by downstream";
        permission_pt->m_KElement_ID_pt = (IDElement *) KE_perm_pt;
        permission_pt->m_investigator_token = inv::FindMatchingStatement;
        permission_pt->m_effective_start = time1;
        permission_pt->m_effective_end = time2;
        permission_pt->m_operator = this->m_operator;
        permission_pt->m_invest_dormant = true;
        permission_pt->m_root_of_a_thought_line = false;
        permission_pt->m_active_investigation = true;
        RM_pt->AddNewInvestigator(perm_owned.release());
      }
      //link the permission investigator and the InvestigatorLink
      invest_link_pt->m_condition_ID_pt = (IDElement *) permission_pt;
      permission_pt->m_downstream_ID_list.push_back((IDElement *) invest_link_pt);
    }
 
    if ((*KU_itr)->m_Ancestor_pt->m_ID_Type == 401) {//ancestor is a KnowledgeElement
 
      //Check whether the upperstream contains indefinite concept
      KE_pt = (KnowledgeElement *) ((*KU_itr)->m_Ancestor_pt);
      label_group_upper_pt = RM_pt->m_IB->CheckWhetherASentenceContainIndefiniteItem(KE_pt->m_SentenceUnit_pt);
      if (label_group_upper_pt != NULL) {
        if (label_group_down_pt != NULL) {
          if (label_group_down_pt != label_group_upper_pt) {
            if ((*KU_itr)->m_Descendant_pt != this->m_KElement_ID_pt) {
              //this->ErrorMessage("Error: This Knowledge Unit contains more than one indefinite groups!");
              //return;
            }
          }
        }
      }
 
      //Get the KnowledgeElement of the upperstream and build the investigator for the upperstream
      KE_upper_pt = NULL;
      if (label_group_upper_pt != NULL && label_group_down_pt != NULL && label_group_upper_pt == label_group_down_pt) {
        KE_pt = (KnowledgeElement *) ((*KU_itr)->m_Ancestor_pt);
        sent_pt = RM_pt->InstantiateAnIndefiniteSentenceWithLabel(KE_pt->m_SentenceUnit_pt, label_down_pt);
        KE_upper_pt = RM_pt->FindAKEbySentenceAndNegationSign(sent_pt, KE_pt->m_negation);
        if (KE_upper_pt == NULL) {
          this->ErrorMessage(
              "Could not find a KE for" + sent_pt->m_ID); //should also add the negation infor in the error
          return;
        }
      } else if (label_group_upper_pt == NULL) {
        KE_upper_pt = (KnowledgeElement *) ((*KU_itr)->m_Ancestor_pt);
      }
 
      if (KE_upper_pt != NULL) {
        //There is only one upperstream investigator
        invest_link_pt->m_link_type = 1;
        //
        invest_pt = RM_pt->FindAMatchInvestigatorByKnowledgeElement(KE_upper_pt, time1, time2);
        if (invest_pt == NULL) {// if there is no existing investigator, create a new investigator
          auto invest_owned = make_unique<Investigator>();
          invest_pt = invest_owned.get();
          invest_pt->m_note = "by downstream";
          invest_pt->m_motivation = 0;
          invest_pt->m_KElement_ID_pt = (IDElement *) KE_upper_pt;
          invest_pt->m_investigator_token = inv::FindMatchingStatement;
          invest_pt->m_effective_start = time1;
          invest_pt->m_effective_end = time2;
          invest_pt->m_operator = this->m_operator;
          invest_pt->m_invest_dormant = true;
          invest_pt->m_root_of_a_thought_line = false;
          invest_pt->m_active_investigation = true;
          RM_pt->AddNewInvestigator(invest_owned.release());
        }
        //link the upperstream investigator and the InvestigatorLink
        invest_link_pt->m_upperstream_ID_list.push_back((IDElement *) invest_pt);
        invest_pt->m_downstream_ID_list.push_back((IDElement *) invest_link_pt);
      } else if (label_group_upper_pt != NULL && label_group_upper_pt != label_group_down_pt) {
        //There are more than one upperstream investigators
        invest_link_pt->m_link_type = 3;
 
        for (label_itr = label_group_upper_pt->m_label_option_list.begin();
             label_itr != label_group_upper_pt->m_label_option_list.end(); label_itr++) {
          KE_pt = (KnowledgeElement *) ((*KU_itr)->m_Ancestor_pt);
          sent_pt = RM_pt->InstantiateAnIndefiniteSentenceWithLabel(KE_pt->m_SentenceUnit_pt, (*label_itr));
          if (sent_pt == NULL) {
            this->ErrorMessage("Error!");
            return;
          }
          KE_upper_pt = RM_pt->FindAKEbySentenceAndNegationSign(sent_pt, KE_pt->m_negation);
          if (KE_upper_pt == NULL) {
            this->ErrorMessage("Error!");
            return;
          }
          invest_pt = RM_pt->FindAMatchInvestigatorByKnowledgeElement(KE_upper_pt, time1, time2);
          if (invest_pt == NULL) {// if there is no existing investigator, create a new investigator
            auto invest_owned = make_unique<Investigator>();
            invest_pt = invest_owned.get();
            invest_pt->m_note = "by downstream";
            invest_pt->m_motivation = 0;
            invest_pt->m_KElement_ID_pt = (IDElement *) KE_upper_pt;
            invest_pt->m_investigator_token = inv::FindMatchingStatement;
            invest_pt->m_effective_start = time1;
            invest_pt->m_effective_end = time2;
            invest_pt->m_operator = this->m_operator;
            invest_pt->m_invest_dormant = true;
            invest_pt->m_root_of_a_thought_line = false;
            invest_pt->m_active_investigation = true;
            RM_pt->AddNewInvestigator(invest_owned.release());
          }
          //link the upperstream investigator and the InvestigatorLink
          invest_link_pt->m_upperstream_ID_list.push_back((IDElement *) invest_pt);
          invest_pt->m_downstream_ID_list.push_back((IDElement *) invest_link_pt);
        }
      }
    } else if ((*KU_itr)->m_Ancestor_pt->m_ID_Type == 402) {//ancestor is a KnowledgeNode
      KN_pt = (KnowledgeNode *) ((*KU_itr)->m_Ancestor_pt);
      invest_link_pt->m_link_type = KN_pt->m_Node_Type; //2--and gate, 3--or gate
 
      //adding the ancestor investigators
      for (KE_itr = KN_pt->M_KElement_list.begin(); KE_itr != KN_pt->M_KElement_list.end(); KE_itr++) {
        invest_pt = RM_pt->FindAMatchInvestigatorByKnowledgeElement((*KE_itr), time1, time2);
        if (invest_pt == NULL) {// if there is no existing investigator, create a new investigator
          auto invest_owned = make_unique<Investigator>();
          invest_pt = invest_owned.get();
          invest_pt->m_note = "by downstream";
          invest_pt->m_motivation = 0;
          invest_pt->m_KElement_ID_pt = (*KE_itr);
          invest_pt->m_investigator_token = inv::FindMatchingStatement;
          invest_pt->m_effective_start = time1;
          invest_pt->m_effective_end = time2;
          invest_pt->m_operator = this->m_operator;
          invest_pt->m_invest_dormant = true;
          invest_pt->m_root_of_a_thought_line = false;
          invest_pt->m_active_investigation = true;
          RM_pt->AddNewInvestigator(invest_owned.release());
        }
        invest_link_pt->m_upperstream_ID_list.push_back(invest_pt);
        invest_pt->m_downstream_ID_list.push_back((IDElement *) invest_link_pt);
      }
    }
    //update the InvestigatorLink
    if (invest_link_pt->m_upperstream_ID_list.size() == 0) {
      this->ErrorMessage("Error");
    }
    invest_link_pt->CheckThePathStatus3102();
  }//end of the for loop of m_Knowledge_list
  this->ExtendTheThoughtLineToUpperstream();
 
  if (RM_pt->m_problem_solving_style == ProblemSolvingStyle::HamletB) {
    if (this->m_Happen == 1 && N_inference == 0) {
      this->m_Happen = 2;
      this->ChangeInvestigatorToken(inv::ChooseDownstreamLink);
      this->AddTimeConsumptionInInvestigator(0.2);
      //initiate the feedback list
      vector<IDElement *>::iterator ID_itr;
      for (ID_itr = this->m_downstream_ID_list.begin(); ID_itr != this->m_downstream_ID_list.end(); ID_itr++) {
        this->m_feedback_list.push_back(*ID_itr);
      }
      RM_pt->AddToRMFeedbackStack((IDElement *) this);
      return;
    }
  }
  this->ChangeInvestigatorToken(inv::EvaluateNewFeedback);
  this->PrintCausalOrInferenceLink();
  //}
}//end of member function
 
/**********************************************************************\
|Function Name  : GetCorrespondingKE3001                               |
|Input Parameter:                                                      |
|Return Value   :                                                      |
|Load Function  :                                                      |
|Global Variable:                                                      |
|                                                                      |
|Description    : map the statement in this Investigator with a        |
|Knowledge Element in Knowledge Base. This leads to 3012 or 3090       |
\**********************************************************************/
void Investigator::GetCorrespondingKE3001() {
  string str;
  stringstream conv;
 
  string prompt;
  ReasonMachine *RM_pt;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
 
  this->m_motivation = 1;
  if (this->m_Statement_pt == NULL) {
    //break mark
    this->m_abort = true;
    this->m_abort_reason = "void investigator, Investigator::GetCorrespondingKE3001()";
  }
 
  this->m_Happen = 3;
 
  this->m_KElement_ID_pt = (IDElement *) (RM_pt->FindKnowledgeElementByStatement(this->m_Statement_pt));
  if (this->m_KElement_ID_pt != NULL) {
    //output text
    prompt = "\n\n";
    prompt += "found a knowledge element for this investigator: ";
    prompt += this->m_KElement_ID_pt->m_ID;
    prompt += "\n";
    this->m_effective_start = this->m_Statement_pt->m_time_range.GetTimeBoundEarlier();
    this->m_effective_end = this->m_Statement_pt->m_time_range.GetTimeBoundLater();
    this->PrintMessage(prompt);
    this->ChangeInvestigatorToken(inv::SearchPossibleCauses);
    this->AddTimeConsumptionInInvestigator(0.2);
 
  } else {
    this->ChangeInvestigatorToken(inv::NoMatchingKE);
    this->CloseThisInvestigator();
    if (this->m_Happen_incomplete == false
        && this->m_Explain_incomplete == false) { RM_pt->m_resolved_investigator_pool.push_back(this); }
    RM_pt->ChangeRMTokenValue(rm::Prioritize);
    this->AddTimeConsumptionInInvestigator(0.05);
 
    conv.str("");
    conv << r5pars_.timesno;
    str = conv.str();
    str += ": ";
    str += "transfer out to prioritization";
    this->m_note_list.push_back(str);
 
    //output text
    prompt = "\n\n";
    prompt += "could not find a knowledge element corresponding to the statement in this investigator: \n";
    prompt += this->m_Statement_pt->GetThisStatementWords();
    prompt += "\n";
    this->PrintMessage(prompt);
 
  }
}
 
void Investigator::FindAMatchingStatement3002() {//3002
  bool success = false;
  int i, j;
  int type_int;
  bool consistant_bl;
  Statement *statement_found_pt, *statement_new_pt, *statement_match_pt;
  Statement *statement_consistant_pt = NULL;
  Statement *statement_inconsistant_pt = NULL;
  KnowledgeElement *KE_pt;
  KnowledgeElement *KE_down_pt, *KE_upper_pt;
  vector<KnowledgeElement *>::iterator KE_itr;
  vector<Statement *>::iterator statement_itr;
  KnowledgeNode *KN_pt;
  ReasonMachine *RM_pt = nullptr;
  SentenceUnit *sent_origin_pt;
  SentenceUnit *sent_found_pt;
  SentenceUnit *sent_X_pt;
  SentenceUnit *sent_input_pt;
  SentenceUnit *sent_output_pt;
  vector<SentenceUnit *>::iterator sent_itr, sent_input_itr, sent_output_itr;
  vector<SentenceUnit *> input_sent_list;
  vector<SentenceUnit *> output_sent_list;
  vector<SentenceUnit *> comparing_sent_list;
  vector<int>::iterator int_itr;
  vector<int> type_list;
  vector<IDElement *>::iterator label_ID_itr;
  IDElement *label_origin_pt;
  IDElement *ID_pt;
  IDElement *ID_upper_pt, *ID_down_pt;
  ConceptBasicUnit *CB_pt;
  Label *label_group_origin_pt;
  Label *label_group_buffer_pt;
  vector<IDElement *> antonym_list;
  vector<IDElement *>::iterator ID_itr;
  string prompt, err_mes;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
 
  if (this->m_KElement_ID_pt == NULL) {
    //output text
    err_mes = "This is an empty investigator!";
    this->ErrorMessage(err_mes);
    //
 
    this->m_abort = true;
    this->m_abort_reason = "void investigator, Investigator::FindAMatchingStatement3002()";
    this->ChangeInvestigatorToken(inv::NoMatchingKE);
    this->CloseThisInvestigator();
  }
  KE_pt = (KnowledgeElement *) (this->m_KElement_ID_pt);
 
  //caution, the effective start time and the effective end time should not be both zero!
  if (this->m_effective_start == 0 && this->m_effective_end == 0) {
    //error message here, doesn't have a time range
    err_mes = "This investigator doesn't have a time range";
    this->ErrorMessage(err_mes);
  }
 
  if (this->m_ID == "Investigator_155") { this->PrintMessage(""); }
  RM_pt->FindCorrespondingStatementWithinTimeRange(KE_pt->m_SentenceUnit_pt,
                                                   this->m_effective_start,
                                                   this->m_effective_end);
  for (statement_itr = RM_pt->m_temporary_statement_list.begin();
       statement_itr != RM_pt->m_temporary_statement_list.end(); statement_itr++) {
    statement_match_pt = *statement_itr;
    if (statement_match_pt != NULL) {
      //check whether this new statement is consistant with this KE or not
      consistant_bl = this->CheckWhetherTheFoundStatementConsistantWithKE(statement_match_pt);
      if (statement_match_pt->m_sent_pt != KE_pt->m_SentenceUnit_pt
          && statement_match_pt->m_state == false
          && statement_match_pt->m_sent_pt->WhetherItIsBiState() == false) {
        statement_match_pt = NULL;
      }//could not tell
 
      if (statement_match_pt != NULL) {
        if (consistant_bl == true) {
          if (statement_match_pt->m_factual_type == 1 || statement_match_pt->m_factual_type == 2) {
            this->m_Statement_pt = statement_match_pt;
            this->ChangeInvestigatorToken(inv::CompareKEAndStatement);
            RM_pt->AddDeltaToCognitiveLoad(0.024);
            //time consumption
            this->AddTimeConsumptionInInvestigator(0.2);
            return;
          } else {
            statement_consistant_pt = statement_match_pt;
          }
        } else {
          statement_inconsistant_pt = statement_match_pt;
        }
      }
    }
  }
  statement_match_pt = NULL;
  sent_X_pt = NULL;
  label_group_origin_pt = NULL;
  sent_origin_pt = KE_pt->m_SentenceUnit_pt;
  label_origin_pt = sent_origin_pt->GetLabelOfThisSentence();
  if (label_origin_pt != NULL) {
    sent_X_pt = RM_pt->FindAnIndefiniteSentenceMatchTheInputSentence(sent_origin_pt);
    label_group_origin_pt = RM_pt->m_IB->CheckWhetherASentenceContainIndefiniteItem(sent_X_pt);
    if (label_group_origin_pt == NULL) {
      this->ErrorMessage("Error!");
    }
  }
 
  switch (sent_origin_pt->m_sentence_type) {
    case 1: ID_pt = sent_origin_pt->m_process_pt;
      break;
    case 2: ID_pt = sent_origin_pt->m_state_pt;
      break;
    case 3: ID_pt = sent_origin_pt->m_comparison_pt;
      break;
    case 4: ID_pt = sent_origin_pt->m_comparison_pt;
      break;
    case 5: ID_pt = sent_origin_pt->m_attribute_pt;
      break;
    default: break;
  }
  if (ID_pt->m_ID_Type == 001) {
    CB_pt = (ConceptBasicUnit *) ID_pt;
    antonym_list = CB_pt->m_antonym_list;
  }
 
  //Create the list of sentences to be compared against the KnowledgeElement in the knowledge base
  comparing_sent_list.push_back(sent_origin_pt);
  if (sent_X_pt != NULL) {
    comparing_sent_list.push_back(sent_X_pt);
  }
  //add the antonym sentences
  for (ID_itr = antonym_list.begin(); ID_itr != antonym_list.end(); ID_itr++) {
    for (i = 1; i < 3; i++) {
      bool have_buffer = false;
      SentenceUnit sent_buffer;
      if (i == 1) {
        sent_buffer.CopyFromAnotherSentence(sent_origin_pt);
        have_buffer = true;
      } else if (i == 2 && sent_X_pt != NULL) {
        sent_buffer.CopyFromAnotherSentence(sent_X_pt);
        have_buffer = true;
      }
      if (have_buffer) {
        switch (sent_origin_pt->m_sentence_type) {
          case 1: sent_buffer.m_process_pt = (*ID_itr);
            break;
          case 2: sent_buffer.m_state_pt = (*ID_itr);
            break;
          case 3: sent_buffer.m_comparison_pt = (*ID_itr);
            break;
          case 4: sent_buffer.m_comparison_pt = (*ID_itr);
            break;
          case 5: sent_buffer.m_attribute_pt = (*ID_itr);
            break;
        }
        sent_found_pt = RM_pt->CheckExistInSemanticPoolBySentence(&sent_buffer);
        if (sent_found_pt != NULL) {
          comparing_sent_list.push_back(sent_found_pt);
        }
      }
    }// end of for(i=1; i<3; i++)
  }
 
  //Then comparing the sentences in the list with the KnowledgeElement in the KnowledgeUnit
  for (auto KU_itr = RM_pt->m_Knowledge_list.begin(); KU_itr != RM_pt->m_Knowledge_list.end(); KU_itr++) {
    if ((*KU_itr)->m_accessable_bl == false) { continue; }
    ID_down_pt = NULL;
    //a problem with m_inference_type being 3
    if ((*KU_itr)->m_inference_type == 1 || (*KU_itr)->m_inference_type == 3) {
      ID_down_pt = (*KU_itr)->m_Descendant_pt;
      ID_upper_pt = (*KU_itr)->m_Ancestor_pt;
    } else if ((*KU_itr)->m_inference_type == 2 || (*KU_itr)->m_inference_type == 3) {
      ID_down_pt = (*KU_itr)->m_Ancestor_pt;
      ID_upper_pt = (*KU_itr)->m_Descendant_pt;
    } else {
      continue;
    }
    if (ID_down_pt->m_ID_Type == 401) {
      KE_down_pt = (KnowledgeElement *) ID_down_pt;
      for (sent_itr = comparing_sent_list.begin(); sent_itr != comparing_sent_list.end(); sent_itr++) {
        //check if match
        if (KE_down_pt->m_SentenceUnit_pt == (*sent_itr)) {
          //assign the value of the sent_out_pt
          label_group_buffer_pt = RM_pt->m_IB->CheckWhetherASentenceContainIndefiniteItem((*sent_itr));
          if (label_group_buffer_pt != NULL) {
            sent_found_pt = RM_pt->InstantiateAnIndefiniteSentenceWithLabel((*sent_itr), label_origin_pt);
            if (sent_found_pt == NULL) {
              this->ErrorMessage("Error!");
            }
            sent_output_pt = sent_found_pt;
          } else {
            sent_output_pt = *sent_itr;
          }
          //assign the value of the sent_input_pt
          if (ID_upper_pt->m_ID_Type == 401) {
            KE_upper_pt = (KnowledgeElement *) ID_upper_pt;
            if (KE_upper_pt->m_negation == false && KE_down_pt->m_negation == false) { type_int = 1; }
            else if (KE_upper_pt->m_negation == false && KE_down_pt->m_negation == true) { type_int = 2; }
            else if (KE_upper_pt->m_negation == true && KE_down_pt->m_negation == false) { type_int = 3; }
            else if (KE_upper_pt->m_negation == true && KE_down_pt->m_negation == true) { type_int = 4; }
 
            sent_input_pt = NULL;
            label_group_buffer_pt =
                RM_pt->m_IB->CheckWhetherASentenceContainIndefiniteItem(KE_upper_pt->m_SentenceUnit_pt);
            if (label_group_buffer_pt == NULL) {
              sent_input_pt = KE_upper_pt->m_SentenceUnit_pt;
            } else if (label_group_origin_pt != NULL) {
              if (label_group_origin_pt == label_group_buffer_pt) {
                sent_input_pt =
                    RM_pt->InstantiateAnIndefiniteSentenceWithLabel(KE_upper_pt->m_SentenceUnit_pt, label_origin_pt);
                if (sent_input_pt == NULL) { this->ErrorMessage("Error!"); }
              }
 
            }
            if (sent_input_pt != NULL) {
              //add
              if (sent_output_pt == NULL || sent_input_pt == NULL) {
                this->ErrorMessage("Error!");
              }
              input_sent_list.push_back(sent_input_pt);
              output_sent_list.push_back(sent_output_pt);
              type_list.push_back(type_int);
 
            }
            if (label_group_buffer_pt != NULL && label_group_origin_pt == NULL) {
              for (label_ID_itr = label_group_buffer_pt->m_label_option_list.begin();
                   label_ID_itr != label_group_buffer_pt->m_label_option_list.end(); label_ID_itr++) {
                sent_input_pt =
                    RM_pt->InstantiateAnIndefiniteSentenceWithLabel(KE_upper_pt->m_SentenceUnit_pt, (*label_ID_itr));
                if (sent_input_pt == NULL) { this->ErrorMessage("Error!"); }
                //add
                if (sent_output_pt == NULL || sent_input_pt == NULL) {
                  this->ErrorMessage("Error!");
                }
                input_sent_list.push_back(sent_input_pt);
                output_sent_list.push_back(sent_output_pt);
                type_list.push_back(type_int);
              }
            }
          } else if (ID_upper_pt->m_ID_Type == 402) {
            KN_pt = (KnowledgeNode *) ID_upper_pt;
            for (KE_itr = KN_pt->M_KElement_list.begin(); KE_itr != KN_pt->M_KElement_list.end(); KE_itr++) {
              KE_upper_pt = *KE_itr;
              if (KE_upper_pt->m_negation == false && KE_down_pt->m_negation == false) { type_int = 1; }
              else if (KE_upper_pt->m_negation == false && KE_down_pt->m_negation == true) { type_int = 2; }
              else if (KE_upper_pt->m_negation == true && KE_down_pt->m_negation == false) { type_int = 3; }
              else if (KE_upper_pt->m_negation == true && KE_down_pt->m_negation == true) { type_int = 4; }
              sent_input_pt = KE_upper_pt->m_SentenceUnit_pt;
              label_group_buffer_pt = RM_pt->m_IB->CheckWhetherASentenceContainIndefiniteItem(sent_input_pt);
              if (label_group_buffer_pt != NULL) { this->ErrorMessage("Error!"); }
              //add
              if (sent_output_pt == NULL || sent_input_pt == NULL) {
                this->ErrorMessage("Error!");
              }
              input_sent_list.push_back(sent_input_pt);
              output_sent_list.push_back(sent_output_pt);
              type_list.push_back(type_int);
            }
          }
        }//end if match
      }//end comparing_list
    }
  }//end of the KU list
 
  sent_input_itr = input_sent_list.begin();
  sent_output_itr = output_sent_list.begin();
  int_itr = type_list.begin();
  j = 1;
  if (input_sent_list.size() != output_sent_list.size()
      || input_sent_list.size() != type_list.size()) { this->ErrorMessage("Error!"); }
 
  while (sent_input_itr != input_sent_list.end()) {
    RM_pt->FindCorrespondingStatementWithinTimeRange((*sent_input_itr), this->m_effective_start, this->m_effective_end);
    for (statement_itr = RM_pt->m_temporary_statement_list.begin();
         statement_itr != RM_pt->m_temporary_statement_list.end(); statement_itr++) {
      statement_found_pt = (*statement_itr);
      statement_new_pt = NULL;
      if (statement_found_pt != NULL) {
        if (statement_found_pt->m_sent_pt != (*sent_input_itr)) {//antonym
          if (statement_found_pt->m_state == true) {
            auto stmt_owned = make_unique<Statement>();
            statement_new_pt = stmt_owned.get();
            statement_new_pt->m_sent_pt = (*sent_input_itr);
            statement_new_pt->m_state = false;
            statement_new_pt->CopyAuxInfoFromUpperstreamStatement(statement_found_pt);
            if (statement_found_pt->m_factual_type == 1 || statement_found_pt->m_factual_type == 2) {
              statement_new_pt->m_factual_type = 2;
            }
            else { statement_new_pt->m_factual_type = 3; }
            statement_new_pt->m_operator = this->m_operator;
            statement_new_pt->m_time_generated = r5pars_.timesno;
            statement_new_pt->m_tbi_bl = false;
            RM_pt->AddANewStatement(stmt_owned.release());
            //
            statement_new_pt->m_upperstream_statement_list.push_back(statement_found_pt);
            statement_found_pt->m_downstream_statement_list.push_back(statement_new_pt);
          } else if (statement_found_pt->m_sent_pt->WhetherItIsBiState() == true) {
            auto stmt_owned = make_unique<Statement>();
            statement_new_pt = stmt_owned.get();
            statement_new_pt->m_sent_pt = (*sent_input_itr);
            statement_new_pt->m_state = true;
            statement_new_pt->CopyAuxInfoFromUpperstreamStatement(statement_found_pt);
            if (statement_found_pt->m_factual_type == 1 || statement_found_pt->m_factual_type == 2) {
              statement_new_pt->m_factual_type = 2;
            }
            else { statement_new_pt->m_factual_type = 3; }
            statement_new_pt->m_operator = this->m_operator;
            statement_new_pt->m_time_generated = r5pars_.timesno;
            statement_new_pt->m_tbi_bl = false;
            RM_pt->AddANewStatement(stmt_owned.release());
            //
            statement_new_pt->m_upperstream_statement_list.push_back(statement_found_pt);
            statement_found_pt->m_downstream_statement_list.push_back(statement_new_pt);
          } else { statement_new_pt = NULL; }//could not tell
        } else {//the same as the comparing sentence
          statement_new_pt = statement_found_pt;
        }
        //finished give value to the statement_new_pt
 
        if (statement_new_pt != NULL) {
          {
          auto stmt_owned = make_unique<Statement>();
          statement_match_pt = stmt_owned.get();
          if (*sent_output_itr == NULL) {
            this->ErrorMessage("Error!");
          }
          statement_match_pt->m_sent_pt = (*sent_output_itr);
          statement_match_pt->CopyAuxInfoFromUpperstreamStatement(statement_new_pt);
          if (statement_new_pt->m_factual_type == 1 || statement_new_pt->m_factual_type == 2) {
            statement_match_pt->m_factual_type = 2;
          }
          else { statement_match_pt->m_factual_type = 3; }
          statement_match_pt->m_operator = this->m_operator;
          statement_match_pt->m_time_generated = r5pars_.timesno;
          statement_match_pt->m_tbi_bl = false;
          //
          statement_match_pt->m_upperstream_statement_list.push_back(statement_new_pt);
          statement_new_pt->m_downstream_statement_list.push_back(statement_match_pt);
          if ((*int_itr) == 1 || (*int_itr) == 4) {
            statement_match_pt->m_state = statement_new_pt->m_state;
          } else {
            statement_match_pt->m_state = !statement_new_pt->m_state;
          }
          RM_pt->AddANewStatement(stmt_owned.release());
          }
 
          //check whether this new statement is consistant with this KE or not
          consistant_bl = this->CheckWhetherTheFoundStatementConsistantWithKE(statement_match_pt);
          if (consistant_bl == false
              && statement_match_pt->m_sent_pt != KE_pt->m_SentenceUnit_pt
              && statement_match_pt->m_state == false
              && statement_match_pt->m_sent_pt->WhetherItIsBiState() == false) {
            statement_match_pt = NULL;
          }//could not tell
 
          //finished checking the consistancy
          if (statement_match_pt != NULL) {
            this->AddTimeConsumptionInInvestigator(0.2);
            if (consistant_bl == true) {
              if (statement_consistant_pt == NULL) {
                statement_consistant_pt = statement_match_pt;
              } else if (statement_match_pt->m_time_range.GetTimeBoundLater()
                  > statement_consistant_pt->m_time_range.GetTimeBoundLater()) {
                statement_consistant_pt = statement_match_pt;
              }
            } else//consistancy false
            {
              if (statement_inconsistant_pt == NULL) {
                statement_inconsistant_pt = statement_match_pt;
              } else if (statement_match_pt->m_time_range.GetTimeBoundLater()
                  > statement_inconsistant_pt->m_time_range.GetTimeBoundLater()) {
                statement_inconsistant_pt = statement_match_pt;
              }
            }
          }
        }//end of if(statement_new_pt != NULL)
      }//end of if(statement_found_pt != NULL)
    }//end of statement_itr
    j++;
    sent_input_itr++;
    sent_output_itr++;
    int_itr++;
  }
 
  // to be modified
 
  if (statement_consistant_pt != NULL) {//already find a consistant statement
    if (statement_consistant_pt->m_factual_type == 1 || statement_consistant_pt->m_factual_type == 2) {
      this->m_Statement_pt = statement_consistant_pt;
      RM_pt->AddDeltaToCognitiveLoad(0.024);
      this->ChangeInvestigatorToken(inv::CompareKEAndStatement);
    } else {
      this->m_possible_statement_pt = statement_consistant_pt;
      this->ChangeInvestigatorToken(inv::CheckAvailableFromMR);
    }
    //to be added, token stuff
 
  } else if (statement_inconsistant_pt != NULL) {
    this->m_inconsistant_statement = statement_inconsistant_pt;
    this->ChangeInvestigatorToken(inv::CheckAvailableFromMR);
  } else {
    this->ChangeInvestigatorToken(inv::CheckAvailableFromMR);
  }
 
  //time consumption
  this->AddTimeConsumptionInInvestigator(0.2);
  return;
}
 
void Investigator::WhetherItIsAvailablefromMR3003() {//3003
  //lead to 3012 if there is no corresponding indication for verifying the KE
  //lead to 3004 if there isn't enough information but it is possible to get it from new reading
  //lead to 3007 if there is enough informaiton found and a new statement is created
 
  string prompt, err_mes;
  IDElement *ID_pt1 = NULL;
  IDElement *ID_pt2 = NULL;
  MRValueSchema *value_schema_pt = NULL;
  MRValueSchema *value_schema_pt1 = NULL;
  MRValueSchema *value_schema_pt2 = NULL;
  MRStateSchema *state_schema_pt = NULL;
  MRStateSchema *state_schema_pt1 = NULL;
  MRStateSchema *state_schema_pt2 = NULL;
  MRParameterUnit *MR_P_pt = NULL;
  MRComponentStateUnit *MR_C_pt = NULL;
  MRSupportSystemStateUnit *MR_SS_pt = NULL;
  MRAlarmUnit *MR_A_pt = NULL;
  KnowledgeElement *KE_pt = NULL;
  ReasonMachine *RM_pt = NULL;
  Statement *statement_pt = NULL;
  Statement *new_statement_pt = NULL;
  Statement *statement_consistant_pt = NULL;
  Statement *statement_inconsistant_pt = NULL;
  SentenceUnit *sent_pt = NULL;
  SentenceUnit *found_sent_pt = NULL;
  vector<Statement *>::iterator statement_itr;
  bool consistant_bl;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
 
 
  if (this->m_ID == "Investigator_32") { this->PrintMessage("Check!"); }
 
  if (this->m_KElement_ID_pt == NULL) {
    this->m_abort = true;
    this->m_abort_reason = "void investigator, Investigator::FindAMatchingStatement3002()";
    return;
  }
  KE_pt = (KnowledgeElement *) (this->m_KElement_ID_pt);
  ID_pt1 = RM_pt->m_MR->CheckExistenceByConceptStrict(KE_pt->m_SentenceUnit_pt->m_subject_pt);
  if (ID_pt1 == NULL) {//Couldn't find a corresponding MR item for this
    if (this->m_read_requested_bl == 1) {
      this->ErrorMessage("Error!");
    }
    if (this->m_possible_statement_pt != NULL || this->m_inconsistant_statement != NULL) {
      this->ChangeInvestigatorToken(inv::CompareKEAndStatement);
      RM_pt->AddConsumptedDeltaT(0);
    } else {
      this->ChangeInvestigatorToken(inv::SearchPossibleCauses);
      RM_pt->AddConsumptedDeltaT(0);
      return;
    }
  }
 
  if (this->m_Statement_pt != NULL) {
    this->ChangeInvestigatorToken(inv::CompareKEAndStatement);
    return;
  }
 
  statement_consistant_pt = this->m_possible_statement_pt;
  statement_inconsistant_pt = this->m_inconsistant_statement;
 
  if (this->m_read_requested_bl == true && this->m_Statement_pt == NULL) {//With new readings
    //check point
    if (this->m_ID == "Investigator_126") {
      this->PrintMessage("Check point");
    }
    RM_pt->FindCorrespondingStatementWithinTimeRange(KE_pt->m_SentenceUnit_pt,
                                                     this->m_effective_start,
                                                     this->m_effective_end);
    RM_pt->FindCorrespondingStatementWithinTimeRange(KE_pt->m_SentenceUnit_pt,
                                                     this->m_effective_start,
                                                     this->m_effective_end);
    for (statement_itr = RM_pt->m_temporary_statement_list.begin();
         statement_itr != RM_pt->m_temporary_statement_list.end(); statement_itr++) {
      statement_pt = *statement_itr;
      if (statement_pt != NULL) {
        consistant_bl = this->CheckWhetherTheFoundStatementConsistantWithKE(statement_pt);
        if (consistant_bl == false
            && statement_pt->m_sent_pt != KE_pt->m_SentenceUnit_pt
            && statement_pt->m_state == false
            && statement_pt->m_sent_pt->WhetherItIsBiState() == false) { statement_pt = NULL; }
      }
      if (statement_pt != NULL) {
        if (consistant_bl == true) {
          if (statement_consistant_pt == NULL) {
            statement_consistant_pt = statement_pt;
          } else if (statement_pt->m_time_range.GetTimeBoundLater()
              > statement_consistant_pt->m_time_range.GetTimeBoundLater()) {
            statement_consistant_pt = statement_pt;
          }
        } else//consistancy false
        {
          if (statement_inconsistant_pt == NULL) {
            statement_inconsistant_pt = statement_pt;
          } else if (statement_pt->m_time_range.GetTimeBoundLater()
              > statement_inconsistant_pt->m_time_range.GetTimeBoundLater()) {
            statement_inconsistant_pt = statement_pt;
          }
        }
      }
    }
 
 
    //finished checking
    if (statement_consistant_pt != NULL) {//already find a consistant statement
      if (statement_consistant_pt->m_factual_type == 1 || statement_consistant_pt->m_factual_type == 2) {
        this->m_Statement_pt = statement_consistant_pt;
        RM_pt->AddDeltaToCognitiveLoad(0.024);
        this->ChangeInvestigatorToken(inv::CompareKEAndStatement);
        RM_pt->AddConsumptedDeltaT(0);
        return;
      }
    } else if (statement_inconsistant_pt != NULL) {
      this->m_inconsistant_statement = statement_inconsistant_pt;
    }
  }
 
  switch (KE_pt->m_SentenceUnit_pt->m_sentence_type) {
    case 1:
      //
      statement_pt = NULL;
      new_statement_pt = NULL;
 
      if (KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOnPt()
          || KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOffPt()
          || KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getOpenBiggerPt()
          || KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getCloseSmallerPt()
          || KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getIncreasePt()
          || KE_pt->m_SentenceUnit_pt->m_process_pt
              == RM_pt->m_Concept_Base->getDecreasePt()) {//it could be verified from control panel
        if (this->m_read_requested_bl == 0) {//want to request to read from Control Panel
          this->ChangeInvestigatorToken(inv::RequestInfoInit);
          this->AddTimeConsumptionInInvestigator(0.1);
          return;
        } else {
          if (statement_inconsistant_pt == NULL && statement_consistant_pt == NULL
              &&
                  (KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOnPt()
                      || KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOffPt()
                      || KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getOpenBiggerPt()
                      || KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getCloseSmallerPt()
                      || KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getIncreasePt()
                      || KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getDecreasePt())) {
            this->m_Happen = 4;
          }
          this->AddTimeConsumptionInInvestigator(0);
          return;
          //already checked the newly updated action statement
        }
      } else {//the process type isn't anyone of the reserved
        this->ChangeInvestigatorToken(inv::SearchPossibleCauses);
        RM_pt->AddConsumptedDeltaT(0);
        return;
      }
      break;
    case 2:
      //add the situation that there is a gap between two observations
      statement_pt = NULL;
      state_schema_pt = NULL;
      state_schema_pt1 = NULL;
      state_schema_pt2 = NULL;
      if (ID_pt1 != NULL) {
        if (ID_pt1->m_ID_Type == 202) //component state
        {
          MR_C_pt = (MRComponentStateUnit *) ID_pt1;
          //state_schema_pt = MR_C_pt->CheckComponentStateWithinTimeRange(this->m_effective_start, this->m_effective_end);
          //if(state_schema_pt == NULL)
          //{
          state_schema_pt1 = MR_C_pt->CheckTheFirstComponentStateReadingAfterATime(this->m_effective_start);
          state_schema_pt2 = MR_C_pt->CheckLastComponentStateReadingBeforeATime(this->m_effective_end);
          //}
        } else if (ID_pt1->m_ID_Type == 203) // alarms
        {
          MR_A_pt = (MRAlarmUnit *) ID_pt1;
          //state_schema_pt = MR_A_pt->CheckAlarmStateWithinTimeRange(this->m_effective_start, this->m_effective_end);
          //if(state_schema_pt == NULL)
          //{
          state_schema_pt1 = MR_A_pt->CheckFirstAlarmStateAfterATime(this->m_effective_start);
          state_schema_pt2 = MR_A_pt->CheckLastAlarmStateBeforeATime(this->m_effective_end);
          //}
        } else if (ID_pt1->m_ID_Type == 204) // support system state
        {
          MR_SS_pt = (MRSupportSystemStateUnit *) ID_pt1;
          //state_schema_pt = MR_A_pt->CheckAlarmStateWithinTimeRange(this->m_effective_start, this->m_effective_end);
          //if(state_schema_pt == NULL)
          //{
          state_schema_pt1 = MR_SS_pt->CheckTheFirstSupportSystemStateReadingAfterATime(this->m_effective_start);
          state_schema_pt2 = MR_SS_pt->CheckLastSupportSystemStateReadingBeforeATime(this->m_effective_end);
          //}
        } else//error message
        {}
 
        /*if(state_schema_pt != NULL)
            {
                statement_pt = new Statement();
                statement_pt->m_time_range.m_start_time = state_schema_pt->m_time_perceived;
                statement_pt->m_time_range.m_end_time = state_schema_pt->m_perceived_state;
 
            }
            else*/
        if (state_schema_pt1 != NULL && state_schema_pt2 != NULL) {
          this->AddTimeConsumptionInInvestigator(0.3);
          state_schema_pt = state_schema_pt1;
          if (state_schema_pt1->m_perceived_state == state_schema_pt2->m_perceived_state) {
            auto stmt_owned = make_unique<Statement>();
            statement_pt = stmt_owned.get();
            statement_pt->m_time_range.m_start_time = state_schema_pt1->m_time_perceived;
            statement_pt->m_time_range.m_end_time = state_schema_pt2->m_time_perceived;
            statement_pt->m_sent_pt = KE_pt->m_SentenceUnit_pt;
            if (KE_pt->m_SentenceUnit_pt->m_state_pt == RM_pt->m_Concept_Base->getONpt()) {
              statement_pt->m_state = state_schema_pt1->m_perceived_state;
            } else if (KE_pt->m_SentenceUnit_pt->m_state_pt == RM_pt->m_Concept_Base->getOFFpt()) {
              statement_pt->m_state = !state_schema_pt1->m_perceived_state;
            }
            statement_pt->m_confidence = 0.7;
            statement_pt->m_factual_type = 2;
            statement_pt->m_time_range.m_start_time = state_schema_pt1->m_time_perceived;
            statement_pt->m_time_range.m_end_time = state_schema_pt2->m_time_perceived;
            if (statement_pt->m_state == !KE_pt->m_negation) {
              this->m_Statement_pt = statement_pt;
              RM_pt->AddDeltaToCognitiveLoad(0.024);
            } else { this->m_inconsistant_statement = statement_pt; }
            RM_pt->AddANewStatement(stmt_owned.release());
            if (this->m_read_requested_bl == 0) {
              this->ChangeInvestigatorToken(inv::CompareKEAndStatement);
            }
            this->AddTimeConsumptionInInvestigator(0.3);
            return;
          } else {
            //just give up, could not determine from MR and Control Panel
            this->m_Happen = 2;
            this->ChangeInvestigatorToken(inv::CompareKEAndStatement);
            this->AddTimeConsumptionInInvestigator(0);
 
            /*//initiate the feedback list
                    for(ID_itr = this->m_downstream_ID_list.begin();ID_itr != this->m_downstream_ID_list.end(); ID_itr++)
                    {
                        this->m_feedback_list.push_back(*ID_itr);
                    }
                    RM_pt->m_feedback_stack.push_back((IDElement*)this);*/
            return;
          }
        } else if (state_schema_pt1 != NULL && state_schema_pt2 == NULL) {
          //want to request to read from Control Panel
          if (this->m_read_requested_bl == 0) {
            this->ChangeInvestigatorToken(inv::RequestInfoInit);
            this->AddTimeConsumptionInInvestigator(0.1);
            return;
          } else {
            //caution: not sure why to go to 3007?
            //this->ChangeInvestigatorToken(inv::CompareKEAndStatement);
            //this->ErrorMessage("Should have read it already. Error!");
            return;
          }
        } else {
          //just give up, could not determine from MR and Control Panel
          /*this->m_Happen = 2;
                this->ChangeInvestigatorToken(inv::ChooseDownstreamLink);
                this->AddTimeConsumptionInInvestigator(0);
 
                //initiate the feedback list
                for(ID_itr = this->m_downstream_ID_list.begin();ID_itr != this->m_downstream_ID_list.end(); ID_itr++)
                {
                    this->m_feedback_list.push_back(*ID_itr);
                }
                RM_pt->m_feedback_stack.push_back((IDElement*)this);*/
          if (this->m_investigator_token != inv::CompareKEAndStatement) { this->ChangeInvestigatorToken(inv::CompareKEAndStatement); }
          return;
        }
      } else {
        this->ChangeInvestigatorToken(inv::SearchPossibleCauses);
        RM_pt->AddConsumptedDeltaT(0);
        return;
      }
      break;
    case 3:
      //add the situation that there is a gap between two observations
      consistant_bl = false;
      value_schema_pt = NULL;
      value_schema_pt1 = NULL;
      value_schema_pt2 = NULL;
      if (ID_pt1 != NULL) {
        if (ID_pt1->m_ID_Type == 201) {
          MR_P_pt = (MRParameterUnit *) ID_pt1;
          if (KE_pt->m_negation == false) {
            value_schema_pt = MR_P_pt->FindAReadingConsistantWithASentenceWithinTimeRange(this->m_effective_start,
                                                                                          this->m_effective_end,
                                                                                          KE_pt->m_SentenceUnit_pt);
          }
          else {
            value_schema_pt = MR_P_pt->FindAReadingInconsistantWithASentenceWithinTimeRange(this->m_effective_start,
                                                                                            this->m_effective_end,
                                                                                            KE_pt->m_SentenceUnit_pt);
          }
 
          if (value_schema_pt != NULL) { consistant_bl = true; }
          else {//check the inconsistant situation
            if (KE_pt->m_negation == false) {
              value_schema_pt = MR_P_pt->FindAReadingInconsistantWithASentenceWithinTimeRange(this->m_effective_start,
                                                                                              this->m_effective_end,
                                                                                              KE_pt->m_SentenceUnit_pt);
            }
            else {
              value_schema_pt = MR_P_pt->FindAReadingConsistantWithASentenceWithinTimeRange(this->m_effective_start,
                                                                                            this->m_effective_end,
                                                                                            KE_pt->m_SentenceUnit_pt);
            }
 
            if (value_schema_pt != NULL) { consistant_bl = false; }
          }
        } else if (ID_pt1->m_ID_Type == 202) {
          MR_C_pt = (MRComponentStateUnit *) ID_pt1;
          if (KE_pt->m_negation == false) {
            value_schema_pt =
                MR_C_pt->FindAPositionReadingConsistantWithASentenceWithinTimeRange(this->m_effective_start,
                                                                                    this->m_effective_end,
                                                                                    KE_pt->m_SentenceUnit_pt);
          }
          else {
            value_schema_pt =
                MR_C_pt->FindAPositionReadingInconsitantWithASentenceWithinTimeRange(this->m_effective_start,
                                                                                     this->m_effective_end,
                                                                                     KE_pt->m_SentenceUnit_pt);
          }
 
          if (value_schema_pt != NULL) { consistant_bl = true; }
          else {//check the inconsistant situation
            if (KE_pt->m_negation == false) {
              value_schema_pt =
                  MR_C_pt->FindAPositionReadingInconsitantWithASentenceWithinTimeRange(this->m_effective_start,
                                                                                       this->m_effective_end,
                                                                                       KE_pt->m_SentenceUnit_pt);
            }
            else {
              value_schema_pt =
                  MR_C_pt->FindAPositionReadingConsistantWithASentenceWithinTimeRange(this->m_effective_start,
                                                                                      this->m_effective_end,
                                                                                      KE_pt->m_SentenceUnit_pt);
            }
            if (value_schema_pt != NULL) { consistant_bl = false; }
          }
 
          if (value_schema_pt == NULL) {
            value_schema_pt1 = MR_C_pt->FindTheLastPositionReadingBeforeATime(this->m_effective_start);
            value_schema_pt2 = MR_C_pt->FindTheFirstPositionReadingAfterATime(this->m_effective_end);
          }
        } else { this->ErrorMessage("Error!"); }
 
        if (value_schema_pt != NULL && consistant_bl == true) {//find a consistant
          auto stmt_owned = make_unique<Statement>();
          this->m_Statement_pt = stmt_owned.get();
          this->m_Statement_pt->m_sent_pt = KE_pt->m_SentenceUnit_pt;
          this->m_Statement_pt->m_state = !KE_pt->m_negation;
          this->m_Statement_pt->m_time_range.m_start_time = value_schema_pt->m_time_perceived;
          this->m_Statement_pt->m_time_range.m_end_time = value_schema_pt->m_time_perceived;
          this->m_Statement_pt->m_factual_type = 1;
          this->m_Statement_pt->m_confidence = 1;
          this->m_Statement_pt->m_investigator_ID_pt = (IDElement *) this;
          RM_pt->AddANewStatement(stmt_owned.release());
          RM_pt->AddDeltaToCognitiveLoad(0.024);
        } else if (value_schema_pt != NULL && consistant_bl == false) {
          if (this->m_inconsistant_statement != NULL) {
            if (this->m_inconsistant_statement->m_time_range.GetTimeBoundLater() < value_schema_pt->m_time_perceived) {
              value_schema_pt = NULL;
            }
          }
          if (value_schema_pt != NULL) {
            auto stmt_owned = make_unique<Statement>();
            this->m_inconsistant_statement = stmt_owned.get();
            this->m_inconsistant_statement->m_sent_pt = KE_pt->m_SentenceUnit_pt;
            this->m_inconsistant_statement->m_state = KE_pt->m_negation;
            this->m_inconsistant_statement->m_time_range.m_start_time = value_schema_pt->m_time_perceived;
            this->m_inconsistant_statement->m_time_range.m_end_time = value_schema_pt->m_time_perceived;
            this->m_inconsistant_statement->m_factual_type = 1;
            this->m_inconsistant_statement->m_confidence = 1;
            this->m_inconsistant_statement->m_investigator_ID_pt = (IDElement *) this;
            RM_pt->AddANewStatement(stmt_owned.release());
          }
        } else {
          if (value_schema_pt1 != NULL && value_schema_pt2
              != NULL) {//Caution about these codes, if the position is subjective to automatic control, this reasoning is faulted
            this->AddTimeConsumptionInInvestigator(0.2);
            bool is_consistant = false;
            bool is_inconsistant = false;
            if (KE_pt->m_SentenceUnit_pt->m_comparison_pt == RM_pt->m_Concept_Base->getBiggerPt()) {
              if (value_schema_pt1->m_perceived_value - KE_pt->m_SentenceUnit_pt->m_value
                  > KE_pt->m_SentenceUnit_pt->m_delta_value
                  && value_schema_pt2->m_perceived_value - KE_pt->m_SentenceUnit_pt->m_value
                      > KE_pt->m_SentenceUnit_pt->m_delta_value) {
                if (KE_pt->m_negation == false) { is_consistant = true; }
                else { is_inconsistant = true; }
              } else if (!(value_schema_pt1->m_perceived_value - KE_pt->m_SentenceUnit_pt->m_value
                  > KE_pt->m_SentenceUnit_pt->m_delta_value)
                  && !(value_schema_pt2->m_perceived_value - KE_pt->m_SentenceUnit_pt->m_value
                      > KE_pt->m_SentenceUnit_pt->m_delta_value)) {
                if (KE_pt->m_negation == false) { is_inconsistant = true; }
                else { is_consistant = true; }
              }
            } else if (KE_pt->m_SentenceUnit_pt->m_comparison_pt == RM_pt->m_Concept_Base->getEqualPt()) {
              if (value_schema_pt1->m_perceived_value - KE_pt->m_SentenceUnit_pt->m_value
                  < KE_pt->m_SentenceUnit_pt->m_delta_value
                  && KE_pt->m_SentenceUnit_pt->m_value - value_schema_pt1->m_perceived_value
                      < KE_pt->m_SentenceUnit_pt->m_delta_value
                  && value_schema_pt2->m_perceived_value - KE_pt->m_SentenceUnit_pt->m_value
                      < KE_pt->m_SentenceUnit_pt->m_delta_value
                  && KE_pt->m_SentenceUnit_pt->m_value - value_schema_pt2->m_perceived_value
                      < KE_pt->m_SentenceUnit_pt->m_delta_value) {
                if (KE_pt->m_negation == false) { is_consistant = true; }
                else { is_inconsistant = true; }
              } else if (!(value_schema_pt1->m_perceived_value - KE_pt->m_SentenceUnit_pt->m_value
                  < KE_pt->m_SentenceUnit_pt->m_delta_value
                  && KE_pt->m_SentenceUnit_pt->m_value - value_schema_pt1->m_perceived_value
                      < KE_pt->m_SentenceUnit_pt->m_delta_value)
                  && !(value_schema_pt2->m_perceived_value - KE_pt->m_SentenceUnit_pt->m_value
                      < KE_pt->m_SentenceUnit_pt->m_delta_value
                      && KE_pt->m_SentenceUnit_pt->m_value - value_schema_pt2->m_perceived_value
                          < KE_pt->m_SentenceUnit_pt->m_delta_value)) {
                if (KE_pt->m_negation == false) { is_inconsistant = true; }
                else { is_consistant = true; }
              }
 
            } else if (KE_pt->m_SentenceUnit_pt->m_comparison_pt
                == RM_pt->m_Concept_Base->getSmallerPt()) {//if both satisfied or not
              if (-value_schema_pt1->m_perceived_value + KE_pt->m_SentenceUnit_pt->m_value
                  > KE_pt->m_SentenceUnit_pt->m_delta_value
                  && -value_schema_pt2->m_perceived_value + KE_pt->m_SentenceUnit_pt->m_value
                      > KE_pt->m_SentenceUnit_pt->m_delta_value) {
                is_consistant = true;
              } else if (!(-value_schema_pt1->m_perceived_value + KE_pt->m_SentenceUnit_pt->m_value
                  > KE_pt->m_SentenceUnit_pt->m_delta_value)
                  && !(-value_schema_pt2->m_perceived_value + KE_pt->m_SentenceUnit_pt->m_value
                      > KE_pt->m_SentenceUnit_pt->m_delta_value)) {
                is_inconsistant = true;
              }
            }
            //finished comparison
            if (is_consistant) {
              auto stmt_owned = make_unique<Statement>();
              this->m_Statement_pt = stmt_owned.get();
              this->m_Statement_pt->m_sent_pt = KE_pt->m_SentenceUnit_pt;
              this->m_Statement_pt->m_state = !KE_pt->m_negation;
              this->m_Statement_pt->m_time_range.m_start_time = value_schema_pt1->m_time_perceived;
              this->m_Statement_pt->m_time_range.m_end_time = value_schema_pt2->m_time_perceived;
              this->m_Statement_pt->m_factual_type = 1;
              this->m_Statement_pt->m_confidence = 1;
              this->m_Statement_pt->m_investigator_ID_pt = (IDElement *) this;
              RM_pt->AddANewStatement(stmt_owned.release());
              RM_pt->AddDeltaToCognitiveLoad(0.024);
 
              this->ChangeInvestigatorToken(inv::CompareKEAndStatement);
              RM_pt->AddConsumptedDeltaT(0.2);
              return;
            } else if (is_inconsistant) {
              auto stmt_owned = make_unique<Statement>();
              this->m_inconsistant_statement = stmt_owned.get();
              this->m_inconsistant_statement->m_sent_pt = KE_pt->m_SentenceUnit_pt;
              this->m_inconsistant_statement->m_state = KE_pt->m_negation;
              this->m_inconsistant_statement->m_time_range.m_start_time = value_schema_pt1->m_time_perceived;
              this->m_inconsistant_statement->m_time_range.m_end_time = value_schema_pt2->m_time_perceived;
              this->m_inconsistant_statement->m_factual_type = 1;
              this->m_inconsistant_statement->m_confidence = 1;
              this->m_inconsistant_statement->m_investigator_ID_pt = (IDElement *) this;
              RM_pt->AddANewStatement(stmt_owned.release());
 
              this->ChangeInvestigatorToken(inv::CompareKEAndStatement);
              RM_pt->AddConsumptedDeltaT(0.2);
              return;
            }
          }
        }
 
        if (this->m_Statement_pt != NULL) {
          this->ChangeInvestigatorToken(inv::CompareKEAndStatement);
          RM_pt->AddConsumptedDeltaT(0.2);
          return;
        } else {
          if (this->m_read_requested_bl == 0) {
            if (this->m_effective_end >= r5pars_.timesno
                || (value_schema_pt1 != NULL && value_schema_pt2 == NULL)) {
              this->ChangeInvestigatorToken(inv::RequestInfoInit);
              RM_pt->AddConsumptedDeltaT(0.2);
              return;
            } else {
              if (this->m_effective_end < r5pars_.timesno) { this->m_Happen_incomplete = true; }
 
              this->ChangeInvestigatorToken(inv::CompareKEAndStatement);
              RM_pt->AddConsumptedDeltaT(0.2);
              return;
            }
          } else { return; }
        }
        /*
            //  MR_P_pt->CheckReadingWithinTimeRange(this->m_effective_start, this->m_effective_end);
            }
            else if(ID_pt1->m_ID_Type == 202)
            {
                MR_C_pt = (MRComponentStateUnit *)ID_pt1;
                value_schema_pt = MR_C_pt->CheckPositionReadingWithinTimeRange(this->m_effective_start, this->m_effective_end);
            }//To be added
            else
            {
                this->ErrorMessage("Error!");
            }//error message
 
            if(value_schema_pt == NULL)
            {
                //change token value
 
                //output text
                prompt = "There is no available information for this investigator on Mental Representation";
                this->PrintMessage(prompt);
                //
                this->ChangeInvestigatorToken(inv::VerifyFromControlPanel);
                RM_pt->AddConsumptedDeltaT(0.1);
            }
            else
            {
                //add a new statement
                SentenceUnit sent;
                sent.CopyFromAnotherSentence(KE_pt->m_SentenceUnit_pt);
                if( value_schema_pt->m_perceived_value > sent.m_value )
                {
                    sent.m_comparison_pt = RM_pt->m_Concept_Base.getBiggerPt();
                }
                else if(value_schema_pt->m_perceived_value < sent.m_value)
                {
                    sent.m_comparison_pt = RM_pt->m_Concept_Base.getSmallerPt();
                }
                else
                {
                    sent.m_comparison_pt = RM_pt->m_Concept_Base.getEqualPt();
                }
                found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&sent);
                statement_pt = new Statement();
                this->m_Statement_pt = statement_pt;
                statement_pt->m_sent_pt = found_sent_pt;
                if(found_sent_pt == NULL)
                {
                    statement_pt->m_sent_pt = KE_pt->m_SentenceUnit_pt;
                    statement_pt->m_state = false;
                }
                statement_pt->m_investigator_ID_pt = (IDElement *)this;
                statement_pt->m_confidence = 1;
                statement_pt->m_factual_type = 1;
                statement_pt->m_time_range.m_start_time = value_schema_pt->m_time_perceived;
                statement_pt->m_time_range.m_end_time = value_schema_pt->m_time_perceived;
                RM_pt->AddANewStatement(statement_pt);
 
                //change token value
 
                //output text
                prompt = "Found matching information on Mental Representation, and a new statement is inferred: \n";
                prompt += statement_pt->GetThisStatementWords();
                this->PrintMessage(prompt);
                //
 
                this->ChangeInvestigatorToken(inv::CompareKEAndStatement);
                RM_pt->AddConsumptedDeltaT(0.2);
            }*/
      } else {
        //output text
        prompt = "Could not verify this knowledge element from control panel, will dig more root causes. \n";
        this->PrintMessage(prompt);
        //
        this->ChangeInvestigatorToken(inv::SearchPossibleCauses);
        RM_pt->AddConsumptedDeltaT(0);
      }
      break;
    case 4: ID_pt2 = RM_pt->m_MR->CheckExistenceByConceptStrict(KE_pt->m_SentenceUnit_pt->m_object_pt);
      if (ID_pt1 != NULL && ID_pt2 != NULL) {
        //
        if (this->m_read_requested_bl == 0) {
          this->ChangeInvestigatorToken(inv::RequestInfoInit);
          this->AddTimeConsumptionInInvestigator(0.1);
          return;
        }
        //
        if (ID_pt1->m_ID_Type == 201 && ID_pt2->m_ID_Type == 201) {
          MR_P_pt = (MRParameterUnit *) ID_pt1;
          value_schema_pt = MR_P_pt->CheckReadingWithinTimeRange(this->m_effective_start, this->m_effective_end);
 
          MR_P_pt = (MRParameterUnit *) ID_pt2;
          value_schema_pt2 = MR_P_pt->CheckReadingWithinTimeRange(this->m_effective_start, this->m_effective_end);
 
          if (value_schema_pt == NULL || value_schema_pt2 == NULL) {
            //output text
            prompt = "There is no available information for this investigator on Mental Representation";
            this->PrintMessage(prompt);
            //
            //this->ChangeInvestigatorToken(inv::VerifyFromControlPanel);
            this->AddTimeConsumptionInInvestigator(0.2);
          } else {
            //add a new statement
            {
            auto stmt_owned = make_unique<Statement>();
            statement_pt = stmt_owned.get();
            this->m_Statement_pt = statement_pt;
            RM_pt->AddDeltaToCognitiveLoad(0.024);
            statement_pt->m_sent_pt = KE_pt->m_SentenceUnit_pt;
            statement_pt->m_investigator_ID_pt = (IDElement *) this;
            statement_pt->m_confidence = 1;
            statement_pt->m_factual_type = 1;
            statement_pt->m_time_range.m_start_time = value_schema_pt->m_time_perceived;
            statement_pt->m_time_range.m_end_time = value_schema_pt->m_time_perceived;
 
            if (KE_pt->m_SentenceUnit_pt->m_comparison_pt == RM_pt->m_Concept_Base->getBiggerPt()) {
              if (value_schema_pt->m_perceived_value - value_schema_pt2->m_perceived_value
                  > KE_pt->m_SentenceUnit_pt->m_delta_value) {
                statement_pt->m_state = true;
              } else {
                statement_pt->m_state = false;
              }
            } else if (KE_pt->m_SentenceUnit_pt->m_comparison_pt == RM_pt->m_Concept_Base->getSmallerPt()) {
              if (value_schema_pt2->m_perceived_value - value_schema_pt->m_perceived_value
                  > KE_pt->m_SentenceUnit_pt->m_delta_value) {
                statement_pt->m_state = true;
              } else {
                statement_pt->m_state = false;
              }
            } else if (KE_pt->m_SentenceUnit_pt->m_comparison_pt == RM_pt->m_Concept_Base->getEqualPt()) {
              if (value_schema_pt->m_perceived_value - value_schema_pt2->m_perceived_value
                  < KE_pt->m_SentenceUnit_pt->m_delta_value
                  && value_schema_pt2->m_perceived_value - value_schema_pt->m_perceived_value
                      < KE_pt->m_SentenceUnit_pt->m_delta_value) {
                statement_pt->m_state = true;
              } else {
                statement_pt->m_state = false;
              }
            }
            RM_pt->AddANewStatement(stmt_owned.release());
            }
 
            //output text
            prompt = "Found matching information on Mental Representation, and a new statement is inferred: \n";
            prompt += statement_pt->GetThisStatementWords();
            this->PrintMessage(prompt);
            //
 
            //change token value
            //this->ChangeInvestigatorToken(inv::CompareKEAndStatement);
            this->AddTimeConsumptionInInvestigator(0.3);
          }
        } else {
          this->ErrorMessage("valve position comparison is not analyzed here");
        }//error message
        //caution, valve position comparison is not analyzed here
      } else {
        //output text
        prompt = "Could not verify this knowledge element from control panel, will dig more root causes. \n";
        this->PrintMessage(prompt);
        //
 
        this->ChangeInvestigatorToken(inv::SearchPossibleCauses);
        this->AddTimeConsumptionInInvestigator(0);
        return;
      }
      break;
    default:
      //output text
      prompt = "There is no available information for this investigator on Mental Representation";
      this->PrintMessage(prompt);
      //
      this->ChangeInvestigatorToken(inv::VerifyFromControlPanel);
      this->AddTimeConsumptionInInvestigator(0);
      break;
  }
}
 
void Investigator::CompareKEandStatement3007() {//3007
  string err_mes, prompt;
  KnowledgeElement *KE_pt = (KnowledgeElement *) (this->m_KElement_ID_pt);
  ReasonMachine *RM_pt;
  bool consistant_bl;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
 
  //a debugging check point
  if (this->m_ID == "Investigator_32") { this->PrintMessage("Check point!"); }
  //
  if (this->m_Statement_pt != NULL) {
    if ((this->m_Statement_pt->m_time_range.GetTimeBoundEarlier() <= this->m_effective_end
        && this->m_Statement_pt->m_time_range.GetTimeBoundEarlier() >= this->m_effective_start)
        ||
            (this->m_Statement_pt->m_time_range.GetTimeBoundLater() <= this->m_effective_end
                && this->m_Statement_pt->m_time_range.GetTimeBoundLater()
                    >= this->m_effective_start)) {}//satisfy the requirement
    else { this->m_Statement_pt = NULL; }
  }
  //{this->m_Statement_pt = RM_pt->CheckWhetherASentenceIsTrueFromMR(KE_pt->m_SentenceUnit_pt, this->m_effective_start, this->m_effective_end);}
  if (this->m_read_requested_bl == 1) {
    if (this->m_Statement_pt != NULL) {
      if (this->m_Statement_pt->m_sent_pt == KE_pt->m_SentenceUnit_pt
          && this->m_Statement_pt->m_state != KE_pt->m_negation) {}
      else { this->WhetherItIsAvailablefromMR3003(); }
    } else { this->WhetherItIsAvailablefromMR3003(); }
  }
 
  if (this->m_Happen == 1 || this->m_Happen == 2) {
    if (this->m_Statement_pt != NULL) {
      consistant_bl = this->CheckWhetherTheFoundStatementConsistantWithKE(this->m_Statement_pt);
      if (consistant_bl == true) {
        this->m_Happen = 3;
        this->AddTimeConsumptionInInvestigator(0.1);
      } else {
        if (this->m_Statement_pt->m_sent_pt != KE_pt->m_SentenceUnit_pt && this->m_Statement_pt->m_state == false
            && this->m_Statement_pt->m_sent_pt->WhetherItIsBiState() == false) {
          this->m_Happen = 2;
          this->AddTimeConsumptionInInvestigator(0.1);
        } else {
          this->AddTimeConsumptionInInvestigator(0.2);
          this->m_Happen = 4;
        }
        //this->ErrorMessage("Check this situation!");
      }
    } else if (this->m_inconsistant_statement != NULL) {
      consistant_bl = this->CheckWhetherTheFoundStatementConsistantWithKE(this->m_inconsistant_statement);
      if (consistant_bl == false) {
        if (this->m_inconsistant_statement->m_factual_type == 1
            || this->m_inconsistant_statement->m_factual_type == 2) {
          this->AddTimeConsumptionInInvestigator(0.2);
          this->m_Statement_pt = this->m_inconsistant_statement;
          RM_pt->AddDeltaToCognitiveLoad(0.024);
          this->m_Happen = 4;
        } else if (this->m_possible_statement_pt == NULL) {
          this->AddTimeConsumptionInInvestigator(0.1);
          this->m_possible_statement_pt = this->m_inconsistant_statement;
          this->m_Happen = 2;
        }
      } else {
        this->ErrorMessage("Check this situation!");
      }
    } else {
      //    {this->WhetherItIsAvailablefromMR3003();}
      this->m_Happen = 2;
    }
  }
  prompt = "\n\n";
  prompt += "Verification result: ";
  switch (this->m_Happen) {
    case 1: prompt += "Undetermined.";
      break;
    case 2: prompt += "Uncertain, could not tell.";
      break;
    case 3: prompt += "Yes, it happend.";
      break;
    case 4: prompt += "No, it didn't happen.";
      break;
    default: err_mes = "Investigator::m_Happen has an unrecognized value.";
      this->ErrorMessage(err_mes);
  }
 
  prompt += "\n";
  prompt += "KE: ";
  prompt += this->GetKEandTimeRangeWords();
  prompt += "\n";
  prompt += "Statement: ";
  if (this->m_Statement_pt != NULL) {
    prompt += this->m_Statement_pt->GetThisStatementWords();
  } else {
    prompt += "NONE";
  }
  this->PrintMessage(prompt);
 
  this->ChangeInvestigatorToken(inv::ChooseDownstreamLink);
  this->AddTimeConsumptionInInvestigator(0.2);
  //initiate the feedback list
  vector<IDElement *>::iterator ID_itr;
  for (ID_itr = this->m_downstream_ID_list.begin(); ID_itr != this->m_downstream_ID_list.end(); ID_itr++) {
    this->m_feedback_list.push_back(*ID_itr);
  }
  RM_pt->AddToRMFeedbackStack((IDElement *) this);
}
 
void Investigator::OneStepWorkOnThisInvestigator() {
  string str;
  stringstream conv;
 
  string prompt;
  ReasonMachine *RM_pt;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
 
  if (this->m_ID == "Investigator_21") { this->PrintMessage(""); }
  if (this->m_invest_dormant == true) {
    this->m_invest_dormant = false;
    this->m_investigation_initiate_time = r5pars_.timesno;
  }
 
  if (this->m_invest_pause == true) {
    this->m_invest_pause = false;
  }
 
  this->m_last_active_time = r5pars_.timesno;
  if (this->m_investigation_closed == true) {
    if (this->m_investigator_token > inv::ActiveThreshold) {
      if (RM_pt->m_feedback_stack.size() > 0 && this->m_Happen
          == 3) { this->InitiateBackwardPropagationOfConfidence(); }// think about this //no need for the HAMLET_B style
      this->CloseThisInvestigator();
      RM_pt->m_RM_Token = rm::Prioritize;
      return;
    }
    this->m_investigation_closed = false;
    RM_pt->AddBackToUnresolvedInvestigationPool(this);
 
  }
 
  if (this->m_last_time_of_refreshing_inference_item < r5pars_.timesno) {
    if (this->m_Statement_pt
        != NULL) { RM_pt->AutoIgnitionOfDecayedInvestigatorInitiatedByActivatingAStatement(this->m_Statement_pt); }
    this->m_last_time_of_refreshing_inference_item = r5pars_.timesno;
  }
 
  switch (this->m_investigator_token) {
    case inv::GetCorrespondingKE:
      //leads to 3012 or 3090
      this->GetCorrespondingKE3001();
      break;
    case inv::FindMatchingStatement:
      //Use available statements to check the KE
      //leads to 3003 or 3007
      this->FindAMatchingStatement3002();
      break;
    case inv::CheckAvailableFromMR:
      //check Mental Representation
      //leds to 3004 or 3007
      this->WhetherItIsAvailablefromMR3003();
      break;
    case inv::VerifyFromControlPanel: this->WhetherGetInfoFromControlPaneltoVerifyKE3004();
      break;
    case inv::RequestInfoInit: this->RequestInfoFromControlPanelInititaion3005();
      break;
    case inv::RequestInfoRead: this->RequestInfoFromControlPanelReading3006();
      break;
    case inv::CompareKEAndStatement: this->CompareKEandStatement3007();
      break;
    case inv::ChooseDownstreamLink:
      //to be modified
      this->ChoseADownstreamInvestigatorLinkToFeedback3008();
      break;
    case inv::DecideWhetherToClose: this->WhetherToCloseThisInvestigator3009();
      break;
    case inv::SearchPossibleCauses: this->SearchForPossibleCauses3012();
      break;
    case inv::RetrieveNextLink: this->RetrieveTheNextLikelyInvestigatorLink3013();
      break;
    case inv::EvaluateNewFeedback: this->EvaluateAfterGetNewFeedback3014();
      break;
    default: RM_pt->ChangeRMTokenValue(rm::Prioritize);
      prompt = "\n\n";
      prompt = this->TranslateTokenIntoWords(this->m_investigator_token);
      this->PrintMessage(prompt);
      this->CloseThisInvestigator();
      conv.str("");
      conv << r5pars_.timesno;
      str = conv.str();
      str += ": transfer out: to prioritization";
      this->m_note_list.push_back(str);
      //error message
      break;
  }
}
 
void Investigator::WhetherGetInfoFromControlPaneltoVerifyKE3004() {
  //caution: if both the m_effective_start and m_effective_end are 0, consider it has not been initialized yet
//3004
  //1, whether this information is available on the control panel?
  //->the subject of the sentence is on the MR
  //->find a MR, is there a corresponding indicator name?
  string prompt, err_mes;
 
  IDElement *ID_subject_pt;
  IDElement *ID_pt;
  KnowledgeElement *KE_pt;
  ReasonMachine *RM_pt;
  bool on_CP_bl;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
 
  if (this->m_KElement_ID_pt == NULL) {//error message
    err_mes = "This is an empty investigator!";
    this->ErrorMessage(err_mes);
    return;
  }
  KE_pt = (KnowledgeElement *) (this->m_KElement_ID_pt);
  ID_subject_pt = KE_pt->m_SentenceUnit_pt->m_subject_pt;
  ID_pt = RM_pt->m_MR->CheckExistenceByConceptStrict(ID_subject_pt);
  if (ID_pt == NULL) {
    //output text
    prompt = "\n\n";
    prompt = "There is no item on control panel that matches the subject for this knowledge element";
    this->PrintMessage(prompt);
    //
    this->ChangeInvestigatorToken(inv::SearchPossibleCauses);
    this->AddTimeConsumptionInInvestigator(0);
    return;
  }
  on_CP_bl = false;
 
  switch (KE_pt->m_SentenceUnit_pt->m_sentence_type) {
    //Sentence type 1:
    //xxx increase, xxx decrease, xxx stable, xxx turn_on, xxx turn_off, xxx open_bigger, xxx close_smaller
    case 1:
      if (KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getIncreasePt()) { on_CP_bl = true; }
      else if (KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getDecreasePt()) { on_CP_bl = true; }
      else if (KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getStablePt()) { on_CP_bl = true; }
      else if (KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOnPt()) { on_CP_bl = true; }
      else if (KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getTurnOffPt()) { on_CP_bl = true; }
      else if (KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getOpenBiggerPt()) { on_CP_bl = true; }
      else if (KE_pt->m_SentenceUnit_pt->m_process_pt == RM_pt->m_Concept_Base->getCloseSmallerPt()) {
        on_CP_bl = true;
      }
      break;
      //Sentence type 2:
      //xxx is on, xxx is off
    case 2:
      if (KE_pt->m_SentenceUnit_pt->m_state_pt == RM_pt->m_Concept_Base->getONpt()) { on_CP_bl = true; }
      else if (KE_pt->m_SentenceUnit_pt->m_state_pt == RM_pt->m_Concept_Base->getOFFpt()) { on_CP_bl = true; }
      break;
      //Sentence type 3:
      //xxx > value, xxx < value
    case 3: on_CP_bl = true;
      break;
      //Sentence type 4:
      //xxx > yyy, xxx < yyy
    case 4: ID_pt = RM_pt->m_MR->CheckExistenceByConceptStrict(KE_pt->m_SentenceUnit_pt->m_object_pt);
      if (ID_pt != NULL) { on_CP_bl = true; }
      break;
    case 5: break;
 
  }
  if (on_CP_bl == false) {
    //output text
    prompt = "\n\n";
    prompt +=
        "There is no item on control panel that matches the process concept or the object concept for this knowledge element";
    this->PrintMessage(prompt);
    //
    this->ChangeInvestigatorToken(inv::SearchPossibleCauses);
    this->AddTimeConsumptionInInvestigator(0);
    return;
  }
  //2, if fetch new infor from control panel, whether this infor is within the effective time range?
  if (this->m_effective_end
      < r5pars_.timesno) {//already past the time to read the information, this could not be verified any more
    //output text
    prompt = "\n\n";
    prompt += "Already passed the timing to read the information, this could not be verified any more!";
    this->PrintMessage(prompt);
    //
    this->m_Happen_incomplete = true;
    this->m_Happen = 2;
    this->ChangeInvestigatorToken(inv::ChooseDownstreamLink);
    this->AddTimeConsumptionInInvestigator(0);
 
    //initiate the feedback list
    vector<IDElement *>::iterator ID_itr;
    for (ID_itr = this->m_downstream_ID_list.begin(); ID_itr != this->m_downstream_ID_list.end(); ID_itr++) {
      this->m_feedback_list.push_back(*ID_itr);
    }
    RM_pt->AddToRMFeedbackStack((IDElement *) this);
    return;
  } else {
    //output text
    if (this->m_read_requested_bl == 0) {
      prompt = "\n\n";
      prompt += "It could be verified by getting new reading from control panel.";
      this->PrintMessage(prompt);
      //
      this->ChangeInvestigatorToken(inv::RequestInfoInit);
      this->AddTimeConsumptionInInvestigator(0.1);
      return;
    } else {
      this->ChangeInvestigatorToken(inv::CompareKEAndStatement);
      return;
    }
  }
}
 
void Investigator::RequestInfoFromControlPanelInititaion3005() {//3005
  KnowledgeElement *KE_pt;
  ReasonMachine *RM_pt;
  IDElement *ID_pt;
  string prompt, err_mes;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
  bool not_existing_on_CP = false;
 
  KE_pt = (KnowledgeElement *) (this->m_KElement_ID_pt);
 
  switch (KE_pt->m_SentenceUnit_pt->m_sentence_type) {
    case 4: ID_pt = (IDElement *) (RM_pt->m_MR->CheckExistenceByConceptStrict(KE_pt->m_SentenceUnit_pt->m_subject_pt));
      if (ID_pt == NULL) { not_existing_on_CP = true; }
      else {
        this->m_read_indication_list.push_back(ID_pt);
      }
      ID_pt = (IDElement *) (RM_pt->m_MR->CheckExistenceByConceptStrict(KE_pt->m_SentenceUnit_pt->m_object_pt));
      if (ID_pt == NULL) { not_existing_on_CP = true; }
      else {
        this->m_read_indication_list.push_back(ID_pt);
        prompt = "want to read the following indications from control panel: ";
        prompt += KE_pt->m_SentenceUnit_pt->m_subject_pt->m_ID;
        prompt += " , ";
        prompt += KE_pt->m_SentenceUnit_pt->m_object_pt->m_ID;
        this->PrintMessage(prompt);
      }
      break;
    default: ID_pt = (IDElement *) (RM_pt->m_MR->CheckExistenceByConceptStrict(KE_pt->m_SentenceUnit_pt->m_subject_pt));
      if (ID_pt == NULL) { not_existing_on_CP = true; }
      else {
        this->m_read_indication_list.push_back(ID_pt);
        prompt = "want to read the following indications from control panel: ";
        prompt += KE_pt->m_SentenceUnit_pt->m_subject_pt->m_ID;
        this->PrintMessage(prompt);
      }
      break;
  }
  if (not_existing_on_CP == true) {
    prompt = "There is no direct reading from control panel. Try to dig more info from upperstreams.";
    this->PrintMessage(prompt);
    this->ChangeInvestigatorToken(inv::SearchPossibleCauses);
  } else {
    this->ChangeInvestigatorToken(inv::RequestInfoRead);
  }
  this->AddTimeConsumptionInInvestigator(0);
}
 
void Investigator::ChoseADownstreamInvestigatorLinkToFeedback3008() {
  string str;
  stringstream conv;
 
  string err_mes, prompt;
  ReasonMachine *RM_pt;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
 
  if (this->m_ID == "Investigator_87") { this->PrintMessage(""); }
 
  if (this->m_feedback_list.size() == 0) {
    prompt = "\n\n";
    prompt += "Finished feedback process.";
    this->PrintMessage(prompt);
 
    this->ChangeInvestigatorToken(inv::DecideWhetherToClose);
    RM_pt->EraseItemFromFeedbackStack((IDElement *) this);
    //if(RM_pt->m_problem_solving_style == VAGABOND)
    RM_pt->ChangeRMTokenValue(rm::Prioritize);
    return;
  }
  //this is a prioritization process, to be modified.
  prompt = "\n\n";
  prompt += "feedback and move to a downstream investigator";
  this->PrintMessage(prompt);
 
  this->m_invest_pause = true;
  RM_pt->m_working_on_invest_link_pt = (InvestigatorLink *) (*(this->m_feedback_list.rbegin()));
  this->AddTimeConsumptionInInvestigator(0.1);
  this->m_feedback_list.pop_back();
  RM_pt->m_investigation_trace.push_back((IDElement *) this);
  RM_pt->ChangeRMTokenValue(rm::WorkOnInvestigatorLink);    //jump out of this investigator
 
  conv.str("");
  conv << r5pars_.timesno;
  str = conv.str();
  str += ": transfer out: to ";
  str += RM_pt->m_working_on_invest_link_pt->m_ID;
  this->m_note_list.push_back(str);
}
 
void Investigator::WhetherToCloseThisInvestigator3009() {
  string prompt, err_mes;
  ReasonMachine *RM_pt;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
 
  if (this->m_ID == "Investigator_68") { this->PrintMessage(""); }
 
  int next_token_value;
  bool continue_investigation = false;
  prompt = "\n\n";
  switch (this->m_Happen) {
    case 1:
      //error message, should not be 1
      break;
    case 2:
      //can not determine whether it's happened
      if (RM_pt->m_problem_solving_style == ProblemSolvingStyle::HamletB && this->m_upperstream_ID_list.size() > 0) {
        this->AddTimeConsumptionInInvestigator(0.3);
        next_token_value = inv::RetrieveNextLink;
        this->ChangeInvestigatorToken(next_token_value);
      } else {
        prompt += "could not determine whether the KE happened or not, close this investigator.";
        this->PrintMessage(prompt);
        next_token_value = inv::Undetermined;
        this->ChangeInvestigatorToken(next_token_value);
        this->CloseThisInvestigator();
        //this->AddTimeConsumptionInInvestigator(0.1)
        RM_pt->m_undetermined_investigator_pool.push_back(this);
        //could not determine whether the phenomenon specified in the KE happened or not
        //close this investigator;
      }
      break;
    case 3:
      if (this->m_explained == 1) {
        next_token_value = inv::SearchPossibleCauses;
        this->ChangeInvestigatorToken(next_token_value);
      } else if (this->m_explained == 3) {
        continue_investigation = this->WhetherContinueInvestigationAfterFoundExplanation();
        if (continue_investigation == true) {
          this->AddTimeConsumptionInInvestigator(0.3);
          prompt += "continue the investigation eventhough there is one cause found";
          this->PrintMessage(prompt);
          next_token_value = inv::RetrieveNextLink;
          this->ChangeInvestigatorToken(next_token_value);
        } else {
          prompt += "Found the cause and close this investigator";
          this->PrintMessage(prompt);
          next_token_value = inv::CauseFound;
          this->ChangeInvestigatorToken(next_token_value);
          if (this->m_Happen_incomplete == false
              && this->m_Explain_incomplete == false) { RM_pt->m_resolved_investigator_pool.push_back(this); }
          this->CloseThisInvestigator();
          RM_pt->m_success_investigator_pool.push_back(this);
          RM_pt->m_resolved_investigator_pool.push_back(this);
          RM_pt->m_RM_Token = rm::Prioritize;
          this->InitiateBackwardPropagationOfConfidence(); // this is for GARDEN_PATH, VAGABOND, and NEUTRAL, but not for HAMLET
        }
      } else if (this->m_explained == 2) {
        this->AddTimeConsumptionInInvestigator(0.2);
        prompt += "Close this investigator because the cause could not be determined";
        this->PrintMessage(prompt);
        next_token_value = inv::CauseUndetermined;
        this->ChangeInvestigatorToken(next_token_value);
        this->CloseThisInvestigator();
        if (this->m_Happen_incomplete == false
            && this->m_Explain_incomplete == false) { RM_pt->m_resolved_investigator_pool.push_back(this); }
        RM_pt->m_cause_undetermined_investigato_pool.push_back(this);
        RM_pt->m_resolved_investigator_pool.push_back(this);
        RM_pt->m_RM_Token = rm::Prioritize;
      } else if (this->m_explained == 4) {
        this->AddTimeConsumptionInInvestigator(0.4);
        prompt += "close this investigator because the agent failed to expain the statement.";
        this->PrintMessage(prompt);
        next_token_value = inv::FailedToExplain;
        this->ChangeInvestigatorToken(next_token_value);
        this->CloseThisInvestigator();
        RM_pt->m_failed_investigator_pool.push_back(this);
        RM_pt->m_RM_Token = rm::Prioritize;
      }
      break;
    case 4:
      if (this->m_SI_ID_pt == NULL) {
        this->AddTimeConsumptionInInvestigator(0.1);
        prompt += "close this investigator because the KE didn't happen";
        this->PrintMessage(prompt);
        next_token_value = inv::SuccessNotHappened;
        this->ChangeInvestigatorToken(next_token_value);
        this->CloseThisInvestigator();
        RM_pt->m_success_investigator_pool.push_back(this);
        RM_pt->m_RM_Token = rm::Prioritize;
      } else {
        next_token_value = inv::SearchPossibleCauses;
        this->ChangeInvestigatorToken(next_token_value);
      }
      break;
    default:
      //error message;
      this->ChangeInvestigatorToken(next_token_value);
      break;
  }
 
  //jump out of this investigator
  if (RM_pt->m_problem_solving_style == ProblemSolvingStyle::Vagabond) {
    RM_pt->m_investigation_trace.push_back((IDElement *) this);
    RM_pt->ChangeRMTokenValue(rm::Prioritize);
  }
}
 
void Investigator::RetrieveTheNextLikelyInvestigatorLink3013() {//3013
  //to be modified
  //retrieve threshold, PSF slot
  //the current version is very simple, it calculates score for each unfinished investigatorlink
  //and get the one with the highest score
  string str;
  stringstream conv;
 
  string prompt, err_mes;
  SymptomInvestigator *SI_pt;
  ReasonMachine *RM_pt;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
 
  if (this->m_ID == "Investigator_41") { this->PrintMessage("check point!"); }
 
  vector<IDElement *>::iterator ID_itr;
  double highest_score = 0;
  double score;
  bool prior_inference_link = false;
  bool replace_with_new = false;
  InvestigatorLink *invest_link_pt;
  InvestigatorLink *next_invest_link_pt = NULL;
  float delta_T;
 
  if (this->m_timer > 0) {
    delta_T = RM_pt->CheckRemainingTimeForThisStep();
    if (delta_T >= this->m_timer) {
      RM_pt->AddConsumptedDeltaT(this->m_timer);
      this->m_timer = 0;
 
      //
      prompt = "\n\n";
      prompt += "Retrieved one possible cause: ";
      prompt += ((InvestigatorLink *) this->m_has_moved_to_link)->GetASimpleDescriptionOfTheInvestigatorLink();
      this->PrintMessage(prompt);
 
      conv.str("");
      conv << r5pars_.timesno;
      str = conv.str();
      str += "transfer out: to ";
      str += this->m_has_moved_to_link->m_ID;
      this->m_note_list.push_back(str);
 
      RM_pt->m_investigation_trace.push_back((IDElement *) this);
      RM_pt->m_working_on_invest_link_pt = (InvestigatorLink *) (this->m_has_moved_to_link);
 
      if (RM_pt->m_problem_solving_style
          == ProblemSolvingStyle::HamletB) { RM_pt->AddItemToOngoingItemStack(this->m_has_moved_to_link->m_ID); }
      RM_pt->ChangeRMTokenValue(rm::WorkOnInvestigatorLink);
 
      ((InvestigatorLink *) this->m_has_moved_to_link)->m_invest_link_dormant = false;
      ((InvestigatorLink *) this->m_has_moved_to_link)->CrankTheNextLikelyRetrievedInvestigatorActivationToOne();
 
      this->ChangeInvestigatorToken(inv::EvaluateNewFeedback);
      this->m_invest_pause = true;
    } else {
      this->m_timer -= delta_T;
      RM_pt->AddConsumptedDeltaT(delta_T);
    }
    return;
  }
 
  RM_pt->ZeroAllTheInterestFromSymptomInvestigator();
  RM_pt->m_event_schema_base->UpdateTheInterestForInvestigatorOrInvestigatorLink();
  RM_pt->AddDeltaToCognitiveLoad(0.24);
 
  if (this->m_Happen == 1 || this->m_Happen == 2) { prior_inference_link = true; }
 
  if (this->m_SI_ID_pt != NULL) {
    SI_pt = (SymptomInvestigator *) (this->m_SI_ID_pt);
  }
 
  for (ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++) {
    invest_link_pt = (InvestigatorLink *) (*ID_itr);
 
    if ((this->m_SI_ID_pt != NULL && this->m_Happen == 4) || (this->m_SI_ID_pt != NULL
        && this->m_downstream_ID_list.size() > 0)) {//it is forced to invesigate why a symptom not happen.
      if (SI_pt->CheckAKnowledgeUnitInTheList(invest_link_pt->m_K_unit_pt) != NULL) {
        invest_link_pt->m_SI_ID_pt = this->m_SI_ID_pt;
        this->m_has_moved_to_an_upperstream = true;
        if (invest_link_pt->m_path_status == 1) {
          next_invest_link_pt = invest_link_pt;
          next_invest_link_pt->m_SI_ID_pt = this->m_SI_ID_pt;
          next_invest_link_pt->m_invest_link_dormant = false;
          highest_score = invest_link_pt->CalculateBackwardRetrievalScore();
          break;
        }
      }
    }
 
    //this is the normal investigation path
    if (invest_link_pt->m_path_status == 1) {
      replace_with_new = false;
      score = invest_link_pt->CalculateBackwardRetrievalScore();
      cout << '\n' << "retrieval score" << score;
      if (next_invest_link_pt == NULL) {
        replace_with_new = true;
      } else if ((invest_link_pt->m_is_inference_path_bl == next_invest_link_pt->m_is_inference_path_bl
          && prior_inference_link == true)
          || (invest_link_pt->m_is_causal_path_bl == next_invest_link_pt->m_is_causal_path_bl
              && prior_inference_link == false)) {
        if (score > highest_score) { replace_with_new = true; }
      } else {//one is causal link and one is inference link; prioritize inference link or causal link as required
        if (prior_inference_link == true && invest_link_pt->m_is_inference_path_bl == true
            && next_invest_link_pt->m_is_inference_path_bl == false) { replace_with_new = true; }
 
        if (prior_inference_link == false && invest_link_pt->m_is_causal_path_bl == true
            && next_invest_link_pt->m_is_causal_path_bl == false) { replace_with_new = true; }
      }
 
      if (replace_with_new == true) {
        highest_score = score;
        next_invest_link_pt = invest_link_pt;
      }
 
      /*if(score > highest_score)
            {
                highest_score = score;
                next_invest_link_pt = invest_link_pt;
            }*/
    }
  }
  if (next_invest_link_pt == NULL) {//each possible explanation has already been explored
    //transfer to evaluation part: 3014
    prompt = "\n\n";
    prompt += "Every possible cause has already been investigated.";
    //
    this->PrintMessage(prompt);
    this->ChangeInvestigatorToken(inv::EvaluateNewFeedback);
    //time consumption
    this->AddTimeConsumptionInInvestigator(0.1);
  } else {
    this->m_timer = min<float>(pow(1 / highest_score, 0.2), 5);
    this->m_has_moved_to_link = (IDElement *) next_invest_link_pt;
  }
}
 
//DEL void Investigator::WhetherContinueThisInvestigation3016()
//DEL {//There is at least one explanation available
//DEL   //PSF slot
//DEL   //to be added
//DEL
//DEL }
 
void Investigator::ChoseADownstreamInvestigatorLinkToFeedback3018() {//to be added
 
}
 
void Investigator::WhetherToCloseThisInvestigator3019() {//to be added
 
}
 
void Investigator::UpdateEffectiveEndTimeRangeFromStatement(double _endTime, bool _ongoing) {//to be added
  //this is one action that might propagate to other investigatorlinks/investigators without changing token value
  this->m_effective_end = _endTime;
  this->m_phenomenon_onging = _ongoing;
  this->UpdateEffectiveEndTimeRangeToUpperstream(_endTime, _ongoing);
}
 
void Investigator::UpdateEffectiveEndTimeRangeFromDownstream(double _endTime, bool _ongoing) {
  this->m_effective_end = _endTime;
  this->m_phenomenon_onging = _ongoing;
  this->UpdateEffectiveEndTimeRangeToUpperstream(_endTime, _ongoing);
}
 
void Investigator::UpdateEffectiveEndTimeRangeToUpperstream(double _endTime, bool _ongoing) {
  Investigator *invest_pt;
  InvestigatorLink *invest_link_pt;
  double time_end_update;
  vector<IDElement *>::iterator ID_itr;
  vector<IDElement *>::iterator ID_itr2;
  //to be modified, need to calculate the endtime using the input and the knowledge
  if (this->m_upperstream_ID_list.size() == 0) {
    return;
  }
  for (ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++) {
    invest_link_pt = (InvestigatorLink *) (*ID_itr);
    time_end_update = _endTime - invest_link_pt->m_K_unit_pt->m_deltaT1;
    if (invest_link_pt->m_condition_ID_pt != NULL) {
      invest_pt = (Investigator *) (invest_link_pt->m_condition_ID_pt);
      invest_pt->UpdateEffectiveEndTimeRangeFromDownstream(time_end_update, _ongoing);
      /*if(_ongoing = true && invest_pt->m_investigator_token == inv::ChooseDownstreamLink)
            {
                //active this investigator again
                invest_pt->m_investigator_token = inv::RequestInfoInit;
            }*/
    }
    if (r5pars_.timesno > 2640) { this->PrintMessage(""); }
    for (ID_itr2 = invest_link_pt->m_upperstream_ID_list.begin();
         ID_itr2 != invest_link_pt->m_upperstream_ID_list.end(); ID_itr2++) {
      invest_pt = (Investigator *) (*ID_itr2);
      invest_pt->UpdateEffectiveEndTimeRangeFromDownstream(time_end_update, _ongoing);
    }
  }
}
 
void Investigator::RequestInfoFromControlPanelReading3006() {//3006
 
  MRParameterUnit *MR_P_pt;
  MRComponentStateUnit *MR_C_pt;
  MRSupportSystemStateUnit *MR_SS_pt;
  MRAlarmUnit *MR_A_pt;
 
  string prompt, err_mes;
  ReasonMachine *RM_pt;
  IDElement *ID_pt;
  int operator_branch_num = 0;
 
  if (this->m_operator == sim::Operator::ODM) {
    RM_pt = g_sim.Decision_Maker.m_RM.get();
    operator_branch_num = g_sim.Branch_center.getNumOfODMBranch();
  } else if (this->m_operator == sim::Operator::OAT) {
    RM_pt = g_sim.Action_Taker.m_RM.get();
    operator_branch_num = g_sim.Branch_center.getNumOfOATBranch();
  } else {}//add error message
 
  if (operator_branch_num > 0) {
    RM_pt->WaitOneStepThereIsOneOrMoreOperatorBranches();
    return;
  }
 
  //RM_pt->m_reading_indication_ID_pt = NULL;
  if (RM_pt->m_reading_indication_ID_pt != NULL) {
    //to be modified, add time consumption
    //the operator is stilling reading the indication
    RM_pt->m_consumed_time = RM_pt->m_time_length;
  } else
    //the operator finished the last indication reading
  {
    if (this->m_read_indication_list.size() == 0) {
      this->m_read_requested_bl = 1;
      //if(this->m_Statement_pt != NULL)
      //{//output txt
      prompt = "finished reading relevant indications";
      this->PrintMessage(prompt);
 
      //to be modified
      this->ChangeInvestigatorToken(inv::CompareKEAndStatement);
      this->AddTimeConsumptionInInvestigator(0);
      return;
      //}
      /*else
            {
                prompt = "Compare the new reading with the KE";
                this->PrintMessage(prompt);
                this->ChangeInvestigatorToken(inv::CheckAvailableFromMR);
                return;
            }*/
 
    }        //need to verify the vector::rbegin()
    else {
      ID_pt = *(this->m_read_indication_list.rbegin());
      RM_pt->m_reading_indication_ID_pt = ID_pt;
      //output text
      prompt = "send request to read: ";
      if (r5pars_.timesno > 2128) { this->PrintMessage(""); }
      switch (ID_pt->m_ID_Type) {
        case 201: MR_P_pt = (MRParameterUnit *) ID_pt;
          if (this->m_read_value_or_rate_bl == 0
              && MR_P_pt->FoundAValueReadingWithinTimeRange(max<double>(this->m_effective_start, r5pars_.timesno - 5),
                                                            this->m_effective_end) != NULL) {
            this->m_read_indication_list.pop_back();
            RM_pt->m_reading_indication_ID_pt = NULL;
            break;
          }
          if (this->m_read_value_or_rate_bl == 0) {//read parameter firstly
            MR_P_pt->ReadParameterValue(1);
            this->m_read_value_or_rate_bl = 1;
            prompt += MR_P_pt->m_parameter_indicator_ID;
          } else {//read rate secondly
            if (MR_P_pt->m_parameter_rate_indicator_ID.compare("NONE") != 0) { MR_P_pt->ReadParameterRate(1); }
            else { RM_pt->m_reading_indication_ID_pt = NULL; }
            this->m_read_value_or_rate_bl = 0;
            prompt += MR_P_pt->m_parameter_rate_indicator_ID;
            this->m_read_indication_list.pop_back();
          }
          break;
        case 202: MR_C_pt = (MRComponentStateUnit *) ID_pt;
          MR_C_pt->ReadComponentStateIndication(1);
          if (MR_C_pt->m_CS_type == 0) { prompt += MR_C_pt->Component_State_Indicator_ID; }
          else { prompt += MR_C_pt->Control_Value_Indicator_ID; }
          this->m_read_indication_list.pop_back();
          break;
        case 203: MR_A_pt = (MRAlarmUnit *) ID_pt;
          MR_A_pt->ReadAlarmIndication(1);
          prompt += MR_A_pt->m_alarm_indicator_name;
          this->m_read_indication_list.pop_back();
          break;
        case 204: MR_SS_pt = (MRSupportSystemStateUnit *) ID_pt;
          MR_SS_pt->ReadSupportSystemStateIndication(1);
          prompt += MR_SS_pt->Support_System_State_Indicator_ID;
          this->m_read_indication_list.pop_back();
          break;
        default:
          //error message
          break;
      }
      this->PrintMessage(prompt);
      this->AddTimeConsumptionInInvestigator(2);
    }
  }
}
 
void Investigator::CloseThisInvestigator() {
  this->m_investigation_closed = true;
  ReasonMachine *RM_pt;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
  if (this->m_ID == "Investigator_378") { this->PrintMessage(""); }
  bool finished = false;
  this->m_investigation_cease_time = r5pars_.timesno;
  if (this->m_investigator_token > inv::ActiveThreshold && RM_pt->m_problem_solving_style == ProblemSolvingStyle::HamletB) {
    RM_pt->EraseFromOngoingItemStack(this->m_ID);
    this->FinishThePausedConfidencePropagationBeforeCloseInvestigation();
  }
  RM_pt->RemoveInvestigatorFromUnresolvedPool(this);
}
 
double Investigator::GetActivation() {
  double activation;
  KnowledgeElement *KE_pt;
  if (this->m_Statement_pt != NULL) {
    activation = this->m_Statement_pt->m_sent_pt->m_activation;
  } else if (this->m_KElement_ID_pt != NULL) {
    KE_pt = (KnowledgeElement *) (this->m_KElement_ID_pt);
    activation = KE_pt->m_SentenceUnit_pt->m_activation;
  } else {}//error message, this investigator has neither the Statement nor the KnowledgeElement
  return activation;
}
 
void Investigator::EvaluateAfterGetNewFeedback3014() {//3014
  //two options, 1, holistic evaluation; 2, only evaluate the new feedback
  //to be modified, add confidence level to the explanation
  string str;
  stringstream conv;
 
  string prompt, err_mes;
  ReasonMachine *RM_pt;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
 
  if (this->m_ID == "Investigator_1") { this->PrintMessage(""); }
 
  //check point
  if (this->m_KElement_ID_pt->m_ID == "KE_MSLB_true") {
    this->PrintMessage("check point");
  }
  if (this->m_KElement_ID_pt->m_ID == "KE_load_increase") {
    this->PrintMessage("check point");
  }
  if (this->m_investigator_token_history.size() > 12) {
    this->PrintMessage("Check point");
  }
 
  if (this->m_ID == "Investigator_25") {
    this->PrintMessage("Check point");
  }
 
  if (this->m_ID == "Investigator_87" && r5pars_.timesno > 1031) {
    this->PrintMessage("Check point");
  }
  //
 
  bool explained = false;
  bool unexplored_cause_exist = false;
  bool undetermined_cause_exist = false;
  bool need_to_feedback = false;
 
  bool inference_exist = false;
  bool undetermined_inference_exist = false;
  bool unexplored_inference_exist = false;
  bool consistant_bl = false;
 
  int i = 1;
  int Happen_buffer = 1;
  Statement *statement_pt;
  KnowledgeElement *KE_pt;
 
  InvestigatorLink *invest_link_pt;
  vector<IDElement *>::iterator ID_itr;
  prompt = "\n\n Evaluation Process: \n";
 
  //
  if (this->m_ID == "Investigator_630" && r5pars_.timesno > 3196) {
    this->PrintMessage("Check point!");
  }
  //
 
  if (this->m_upperstream_ID_list.size() == 0) {
    this->m_explained = 2;
    RM_pt->AddDeltaToCognitiveLoad(0.024); //type 6
    if (this->m_Happen == 1) {
      this->m_Happen = 2;
      need_to_feedback = true;
      prompt += this->m_KElement_ID_pt->m_ID;
      prompt += " might happen, but could not be determined!";
      this->PrintMessage(prompt);
    } else {
      this->ChangeInvestigatorToken(inv::CauseUndeterminedFeedback);
      this->CloseThisInvestigator();
      RM_pt->m_cause_undetermined_investigato_pool.push_back(this);
      RM_pt->m_resolved_investigator_pool.push_back(this);
      RM_pt->ChangeRMTokenValue(rm::Prioritize);
      RM_pt->m_investigation_trace.push_back((IDElement *) this);
 
      conv.str("");
      conv << r5pars_.timesno;
      str = conv.str();
      str += ": transfer out: to prioritization";
      this->m_note_list.push_back(str);
    }
  } else {
    for (ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++) {
      conv.str("");
      conv << i;
      prompt += "Cause ";
      prompt += conv.str();
 
      invest_link_pt = (InvestigatorLink *) (*ID_itr);
      //check the inference pathes
      if (invest_link_pt->m_is_inference_path_bl == true && (this->m_Happen == 1 || this->m_Happen == 2)) {
        inference_exist = true;
        if (invest_link_pt->m_path_status != 1) {
          if ((invest_link_pt->m_inference_direction_reverse_bl == false
              && (invest_link_pt->m_K_unit_pt->m_inference_type == 1
                  || invest_link_pt->m_K_unit_pt->m_inference_type == 3))
              || (invest_link_pt->m_inference_direction_reverse_bl == true
                  && (invest_link_pt->m_K_unit_pt->m_inference_type == 2
                      || invest_link_pt->m_K_unit_pt->m_inference_type == 3))) {
            switch (invest_link_pt->m_path_status) {
              case 2: undetermined_inference_exist = true;
                break;
              case 3: Happen_buffer = 3;
                break;
            }
          }
        } else {
          unexplored_inference_exist = true;
        }
      }
      //New codes
      if (this->m_Happen == 1 && this->m_Statement_pt != NULL) {
        consistant_bl = this->CheckWhetherTheFoundStatementConsistantWithKE(this->m_Statement_pt);
        if (consistant_bl == true) { Happen_buffer = 3; }
      }
 
      //check the causal path
      if (invest_link_pt->m_is_causal_path_bl == true) {
        prompt += invest_link_pt->GetASimpleDescriptionOfTheInvestigatorLink();
        prompt += " , ";
        switch (invest_link_pt->m_path_status) {
          case 1: prompt += "unexplored; \n";
            unexplored_cause_exist = true;
            break;
          case 2: prompt += "could not determined; \n";
            undetermined_cause_exist = true;
            if (this->CheckExistenceInPossibleExplanationList((IDElement *) invest_link_pt) == NULL) {
              this->m_possible_explanation_link_list.push_back((IDElement *) invest_link_pt);
            }
            break;
          case 3: prompt += "happened; \n";
            explained = true;
            if (this->CheckExistenceInExplanationList((IDElement *) invest_link_pt) == NULL) {
              this->m_explanation_link_list.push_back((IDElement *) invest_link_pt);
            }
            break;
          case 4: prompt += "didn't happen;\n";
            if (this->CheckExistenceInRejectedExplanationList((IDElement *) invest_link_pt) == NULL) {
              this->m_rejected_explanation_list.push_back((IDElement *) invest_link_pt);
            }
            break;
          default:
            //error message
            break;
        }
      }
    }
 
    //forced investigation
    if ((this->m_downstream_ID_list.size() == 0 && this->m_Happen == 4 && this->m_SI_ID_pt != NULL)
        || (this->m_SI_ID_pt != NULL && this->m_downstream_ID_list.size() > 0)) {
      if (this->m_has_moved_to_an_upperstream == true) {//finished the tbi upperstream, then close this investigator
        //caution here: it is possible that the tbi uppersteam is not
        if (this->m_Happen == 1) {
          this->m_Happen = 2;
        }
        if (this->m_Happen == 4) {
          this->m_investigator_token = inv::SuccessNotHappened;
          this->CloseThisInvestigator();
          RM_pt->m_success_investigator_pool.push_back(this);
          RM_pt->ChangeRMTokenValue(rm::Prioritize);
          conv.str("");
          conv << r5pars_.timesno;
          str = conv.str();
          str += ": transfer out: to prioritization";
          this->m_note_list.push_back(str);
          return;
        }
      }
      //else
      //{
      //    this->ChangeInvestigatorToken(inv::RetrieveNextLink);
      //    RM_pt->ChangeRMTokenValue(rm::Prioritize);
      //}
      //return;
    }
 
 
    //finished the iteration of all the upperstreams
    //check inference
    if (this->m_Happen == 1 || this->m_Happen == 2 || Happen_buffer != 1) {
      if (Happen_buffer == 3) {
        this->m_Happen = 3;
        auto stmt_owned = make_unique<Statement>();
        statement_pt = stmt_owned.get();
        KE_pt = (KnowledgeElement *) (this->m_KElement_ID_pt);
        statement_pt->m_sent_pt = KE_pt->m_SentenceUnit_pt;
        statement_pt->m_state = !(KE_pt->m_negation);
        statement_pt->m_time_range.m_time_after = this->m_effective_start;
        statement_pt->m_time_range.m_time_before = this->m_effective_end;
        statement_pt->m_time_generated = r5pars_.timesno;
        statement_pt->m_activation = 1;
        statement_pt->m_factual_type = 2;
        //caution: need to think more about the confidence
        statement_pt->m_confidence = 1;
        statement_pt->m_last_activated_time = r5pars_.timesno;
        this->m_Statement_pt = statement_pt;
        RM_pt->AddDeltaToCognitiveLoad(0.024);
        RM_pt->AddANewStatement(stmt_owned.release());
        need_to_feedback = true;
      } else if (unexplored_inference_exist == false && inference_exist == true) {
        if (undetermined_inference_exist == true) {
          this->m_Happen = 2;
          need_to_feedback = true;
        } else {
          this->m_Happen = 4;
          need_to_feedback = true;
        }
      }
    }
 
    //check causal path
    prompt += "Conclusion: \n";
    if (unexplored_inference_exist == true && (this->m_Happen == 1 || this->m_Happen == 2)) {
      this->ChangeInvestigatorToken(inv::RetrieveNextLink);
      /*RM_pt->ChangeRMTokenValue(rm::Prioritize);
            RM_pt->m_investigation_trace.push_back((IDElement*)this);
            conv.str("");
            conv << r5pars_.timesno;
            str = conv.str();
            str += ": transfer out: to prioritization";
            this->m_note_list.push_back(str);*/
    } else if (explained == true) {
      prompt += "This investigator is explained. \n";
      this->PrintMessage(prompt);
      this->m_explained = 3;
      RM_pt->AddDeltaToCognitiveLoad(0.024); //type 6
      if ((this->m_Happen == 1 || this->m_Happen == 2) && inference_exist == false) {
        this->m_Happen = 3;
        auto stmt_owned = make_unique<Statement>();
        statement_pt = stmt_owned.get();
        KE_pt = (KnowledgeElement *) (this->m_KElement_ID_pt);
        statement_pt->m_sent_pt = KE_pt->m_SentenceUnit_pt;
        statement_pt->m_state = !(KE_pt->m_negation);
        statement_pt->m_time_range.m_time_after = this->m_effective_start;
        statement_pt->m_time_range.m_time_before = this->m_effective_end;
        statement_pt->m_time_generated = r5pars_.timesno;
        statement_pt->m_activation = 1;
        statement_pt->m_factual_type = 3; // it is inferred from a happened upperstream
        //caution: need to think more about the confidence
        statement_pt->m_confidence = 0.7;
        statement_pt->m_last_activated_time = r5pars_.timesno;
        this->m_Statement_pt = statement_pt;
        RM_pt->AddDeltaToCognitiveLoad(0.024);
        RM_pt->AddANewStatement(stmt_owned.release());
        need_to_feedback = true;
        //add feedback to the downstream
      } else {
        this->ChangeInvestigatorToken(inv::DecideWhetherToClose);
      }
    } else if (unexplored_cause_exist == true) {
      if (this->m_Happen != 4) {
        prompt += "This investigator has not been explained yet. \n";
        this->PrintMessage(prompt);
        this->ChangeInvestigatorToken(inv::RetrieveNextLink);
        if (RM_pt->m_problem_solving_style == ProblemSolvingStyle::Vagabond) {
          RM_pt->ChangeRMTokenValue(rm::Prioritize);
          RM_pt->m_investigation_trace.push_back((IDElement *) this);
 
          conv.str("");
          conv << r5pars_.timesno;
          str = conv.str();
          str += ": transfer out: to prioritization";
          this->m_note_list.push_back(str);
        }
      } else {
        this->ChangeInvestigatorToken(inv::DecideWhetherToClose);
      }
    } else if (undetermined_cause_exist == true) {
      prompt += "This investigator has uncertain cause(s)!";
      this->PrintMessage(prompt);
      this->m_explained = 2;
      RM_pt->AddDeltaToCognitiveLoad(0.024); //type 6
      if (this->m_Happen == 1) {
        this->m_Happen = 2;
        need_to_feedback = true;
        //add feedback to the downstream;
      } else {
        this->ChangeInvestigatorToken(inv::CauseUndetermined);
        this->CloseThisInvestigator();
        if (this->m_Happen_incomplete == false
            && this->m_Explain_incomplete == false) { RM_pt->m_resolved_investigator_pool.push_back(this); }
        RM_pt->m_cause_undetermined_investigato_pool.push_back(this);
        RM_pt->ChangeRMTokenValue(rm::Prioritize);
        RM_pt->m_investigation_trace.push_back((IDElement *) this);
 
        conv.str("");
        conv << r5pars_.timesno;
        str = conv.str();
        str += ": transfer out: to prioritization";
        this->m_note_list.push_back(str);
      }
    } else {//at this point, already examined every possible explanation, and all of them failed
      prompt += "This investigator failed to get an explanation. \n";
      this->PrintMessage(prompt);
      this->m_explained = 4;
      RM_pt->AddDeltaToCognitiveLoad(0.024); //type 6
      if (this->m_Happen == 1 && undetermined_inference_exist == false) {
        this->m_Happen = 4;
        need_to_feedback = true;
        //add feedback to the downstream
      } else {
        this->ChangeInvestigatorToken(inv::FailedToExplain); //
        this->CloseThisInvestigator();
        RM_pt->m_failed_investigator_pool.push_back(this);
        RM_pt->ChangeRMTokenValue(rm::Prioritize);
        RM_pt->m_investigation_trace.push_back((IDElement *) this);
 
        conv.str("");
        conv << r5pars_.timesno;
        str = conv.str();
        str += ": transfer out: to prioritization";
        this->m_note_list.push_back(str);
      }
    }
  }
 
  if (need_to_feedback == true) {
    prompt = "The KE is newly verified, needs to feedback to the downstream.";
    this->PrintMessage(prompt);
 
    this->ChangeInvestigatorToken(inv::ChooseDownstreamLink);
    //initiate the feedback list
    vector<IDElement *>::iterator ID_itr;
    for (ID_itr = this->m_downstream_ID_list.begin(); ID_itr != this->m_downstream_ID_list.end(); ID_itr++) {
      this->m_feedback_list.push_back(*ID_itr);
    }
    RM_pt->AddToRMFeedbackStack((IDElement *) this);
    return;
  }
 
  //Add the proababilistic reasoning process
  float p_total = 0;
  float score_total = 0;
  float confidence = 0;
  if (this->m_Happen == 3 && unexplored_cause_exist == false) {
 
    this->InitiateBackwardPropagationOfConfidence(); // All the HAMLET style should go through this
    prompt += "Found the cause and close this investigator";
    this->PrintMessage(prompt);
    this->ChangeInvestigatorToken(inv::CauseFound);
    if (this->m_Happen_incomplete == false
        && this->m_Explain_incomplete == false) { RM_pt->m_resolved_investigator_pool.push_back(this); }
    this->CloseThisInvestigator();
    RM_pt->m_success_investigator_pool.push_back(this);
    RM_pt->ChangeRMTokenValue(rm::Prioritize);
  }
 
  if (this->m_investigator_token == inv::RetrieveNextLink && RM_pt->m_problem_solving_style == ProblemSolvingStyle::HamletB) {
    RM_pt->ChangeRMTokenValue(rm::Prioritize);
  }
  /*
        //caution, the probability here is assigned arbitrarily
        if(this->m_Statement_pt->m_factual_type == 1 || this->m_Statement_pt->m_factual_type == 2)
        {
            if(this->m_explanation_link_list.size() > 0)
            {p_total = 0.1;}
            else
            {p_total = 0.8;}
        }
        else if(this->m_Statement_pt->m_factual_type == 3)
        {
            p_total = 0.1;
        }
        for(ID_itr = this->m_possible_explanation_link_list.begin(); ID_itr != this->m_possible_explanation_link_list.end(); ID_itr++)
        {
            invest_link_pt = (InvestigatorLink*)(*ID_itr);
            score_total += invest_link_pt->m_K_unit_pt->m_backward_retrieve_weight;
        }
        for(ID_itr = this->m_possible_explanation_link_list.begin(); ID_itr != this->m_possible_explanation_link_list.end(); ID_itr++)
        {
            invest_link_pt = (InvestigatorLink*)(*ID_itr);
            confidence = (invest_link_pt->m_K_unit_pt->m_backward_retrieve_weight/score_total)*p_total;
            RM_pt->m_buffer_invest_pt = this;
            invest_link_pt->BackwardPropagateConfidenceLevel(confidence);
            RM_pt->m_buffer_invest_pt = NULL;
        }
        */
 
}
 
bool Investigator::WhetherContinueInvestigationAfterFoundExplanation() {//to be added
  //to be modified
  ReasonMachine *RM_pt;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
 
  bool continue_bl = false;
  bool stop_bl = false;
  bool unexplored_cause_exist = false;
  InvestigatorLink *invest_link_pt;
  vector<IDElement *>::iterator ID_itr;
  double score;
  double highest_score = 0;
  if (this->m_ID == "Investigator_338") { this->PrintMessage(""); }
  for (ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++) {
    invest_link_pt = (InvestigatorLink *) (*ID_itr);
    if (invest_link_pt->m_path_status == 1) {
      unexplored_cause_exist = true;
      score = invest_link_pt->CalculateBackwardRetrievalScore();
      if (score > highest_score) { highest_score = score; }
    }
  }
  //to be modified, add highest_score, current diagnosis confidence into this decision making.
  if (unexplored_cause_exist == false || this->m_explained == 4) {
    stop_bl = true;
    return false;
  }//stop if finishing all
 
  if (this->m_explained == 1 || RM_pt->m_problem_solving_style == ProblemSolvingStyle::Hamlet
      || RM_pt->m_problem_solving_style == ProblemSolvingStyle::HamletB)//continue
  {
    continue_bl = true;
    return true;
  }
 
  if (this->m_explained == 3 && RM_pt->m_problem_solving_style == ProblemSolvingStyle::GardenPath) {
    continue_bl = false;
    return false;
  }
 
  //set up the criteria
  if (highest_score > 0.006) {
    continue_bl = true;
    return true;
  }
  else {
    stop_bl = true;
    return false;
  }
}
 
SentenceUnit *Investigator::GetSemanticSentenceOfThisInvestigator() {
  KnowledgeElement *KE_pt;
  if (this->m_KElement_ID_pt != NULL) {
    KE_pt = (KnowledgeElement *) this->m_KElement_ID_pt;
    return KE_pt->m_SentenceUnit_pt;
  } else if (this->m_Statement_pt != NULL) {
    return this->m_Statement_pt->m_sent_pt;
  } else { return NULL; }//error message
}
 
void Investigator::AddTimeConsumptionInInvestigator(double _delta) {
  ReasonMachine *RM_pt;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
  RM_pt->AddConsumptedDeltaT(_delta);
 
}
 
float Investigator::CalculateFilteredPrioritizingScoreOfInvestigator() {
  //to be added
  float score = 0;
  if (this->m_invest_dormant == true || this->m_invest_pause == true) {
    return 0;
  }
  score = this->CalculatePriorityScoreEvenDormantOrPaused();
  return score;
}
 
float Investigator::CalculatePriorityScoreEvenDormantOrPaused() {
  //to be added
  float s1, s2, s3, score;
  float deltaT;
  if (this->m_ID == "Investigator_308") { this->PrintMessage(""); }
  deltaT = r5pars_.timesno - this->m_investigation_initiate_time;
  s1 = 0.5 * (1 - exp(-deltaT / 300)) + 0.5;
  s2 = this->GetActivation();
  s3 = 0.5 + 0.5 * this->DetermineWhetherItsStillActivePhenomenon();
  score = s1 * s2 * s3;
  if (this->m_explained != 1)//if the explanation is already determined
  {
    score *= 0.5;
  }
  //
  score += 20 * this->m_interest_from_SymptomInvestigator;
  return score;
}
 
float Investigator::DetermineWhetherItsStillActivePhenomenon() {
  //to be modified
  if (this->m_phenomenon_onging == true) {
    return 1;
  } else {
    return 0;
  }
 
}
 
void Investigator::ChangeInvestigatorToken(int _token) {
  string prompt;
  int old_token;
  old_token = this->m_investigator_token;
  this->m_investigator_token_history.push_back(this->m_investigator_token);
  this->m_invest_token_endtime_history.push_back(r5pars_.timesno);
  this->m_investigator_token = _token;
 
  //output text
  prompt = "\n\n";
  prompt += "The investigator token moved from ";
  prompt += this->TranslateTokenIntoWords(old_token);
  prompt += " to ";
  prompt += this->TranslateTokenIntoWords(_token);
  this->PrintMessage(prompt);
}
 
void Investigator::ErrorMessage(string str) {
  cout << r5pars_.timesno << "  " << str << " in Investigator.cpp" << '\n';
  ofstream fout("err messages.txt", ios::app);
  fout << r5pars_.timesno << "  " << str << '\n';
  fout.close();
  //r5pars_.terminateall = true;
}
 
void Investigator::PrintMessage(string str) {
  cout << "Time: " << r5pars_.timesno << ": " << str << '\n';
 
  //test
  ofstream fout("RMI.txt", ios::app);
  fout << "Time: " << r5pars_.timesno << ": " << str << '\n';
  fout.close();
}
 
string Investigator::TranslateTokenIntoWords(int _token) {
  string str;
  stringstream conv;
  switch (_token) {
    case inv::GetCorrespondingKE: str = "GetCorrespondingKE3001";
      break;
    case inv::FindMatchingStatement: str = "FindAMatchingStatement3002";
      break;
    case inv::CheckAvailableFromMR: str = "WhetherItIsAvailablefromMR3003";
      break;
    case inv::VerifyFromControlPanel: str = "WhetherGetInfoFromControlPaneltoVerifyKE3004";
      break;
    case inv::RequestInfoInit: str = "RequestInfoFromControlPanelInititaion3005";
      break;
    case inv::RequestInfoRead: str = "RequestInfoFromControlPanelReading3006";
      break;
    case inv::CompareKEAndStatement: str = "CompareKEandStatement3007";
      break;
    case inv::ChooseDownstreamLink: str = "ChoseADownstreamInvestigatorLinkToFeedback3008";
      break;
    case inv::DecideWhetherToClose: str = "WhetherToCloseThisInvestigator3009";
      break;
    case inv::SearchPossibleCauses: str = "SearchForPossibleCauses3012";
      break;
    case inv::RetrieveNextLink: str = "RetrieveTheNextLikelyInvestigatorLink3013";
      break;
    case inv::EvaluateNewFeedback: str = "EvaluateAfterGetNewFeedback3014";
      break;
    case inv::NoMatchingKE: str = "3090: There is no corresponding knowledge element for this statement";
      break;
    default: conv.str("");
      conv << _token;
      str = conv.str();
      break;
  }
  return str;
}
 
string Investigator::GetASimpleDescriptionOfThisInvestigator() {
  //to be added
  string str;
  if (this->m_Happen == 1) {
    str = "An investigator to verify whether ";
    str += this->m_KElement_ID_pt->m_ID;
    str += " happened or not: ";
    str += this->GetKEandTimeRangeWords();
  } else if (this->m_Happen == 3) {
    if (this->m_motivation == 0) {
      str = "This investigator determined ";
      str += this->m_KElement_ID_pt->m_ID;
      str += " happened.";
    } else {
      str = "An investigator to find the cause of statement: ";
      str += this->m_Statement_pt->GetThisStatementWords();
    }
  } else if (this->m_Happen == 2) {
    str = "This investigator could not determine whether the KE happened or not: ";
    str += this->GetKEandTimeRangeWords();
  } else if (this->m_Happen == 4) {
    str = "This investigator determined the KE didn't happen: ";
    str += this->GetKEandTimeRangeWords();
  } else {
    str = "Error: unrecognized investigator::m_Happen";
  }
  return str;
}
 
string Investigator::GetKEandTimeRangeWords() {
  //to be added
 
  string str;
  stringstream conv;
  str = "Investigation Time Range: (";
  conv.str("");
  conv << this->m_effective_start;
  str += conv.str();
  str += " , ";
  conv.str("");
  conv << this->m_effective_end;
  str += conv.str();
  str += ")";
  return str;
}
 
string Investigator::GetInvestigationKEandTimeRange() {
  string str;
  str = this->m_KElement_ID_pt->m_ID;
  str += ", ";
  str += this->GetKEandTimeRangeWords();
  return str;
 
}
 
IDElement *Investigator::CheckExistenceInExplanationList(IDElement *_ID_pt) {
  IDElement *found_ID_pt = NULL;
  vector<IDElement *>::iterator ID_itr;
  for (ID_itr = this->m_explanation_link_list.begin(); ID_itr != this->m_explanation_link_list.end(); ID_itr++) {
    if ((*ID_itr) == _ID_pt) {
      found_ID_pt = *ID_itr;
    }
  }
  return found_ID_pt;
}
 
IDElement *Investigator::CheckExistenceInPossibleExplanationList(IDElement *_ID_pt) {
  IDElement *found_ID_pt = NULL;
  vector<IDElement *>::iterator ID_itr;
  for (ID_itr = this->m_possible_explanation_link_list.begin(); ID_itr != this->m_possible_explanation_link_list.end();
       ID_itr++) {
    if ((*ID_itr) == _ID_pt) {
      found_ID_pt = *ID_itr;
    }
  }
  return found_ID_pt;
}
 
IDElement *Investigator::CheckExistenceInRejectedExplanationList(IDElement *_ID_pt) {
  IDElement *found_ID_pt = NULL;
  vector<IDElement *>::iterator ID_itr;
  for (ID_itr = this->m_rejected_explanation_list.begin(); ID_itr != this->m_rejected_explanation_list.end();
       ID_itr++) {
    if ((*ID_itr) == _ID_pt) {
      found_ID_pt = *ID_itr;
    }
  }
  return found_ID_pt;
}
 
void Investigator::BackwardPropagateConfidenceLevel(float _p) {
  Statement *new_statement_pt;
  vector<IDElement *>::iterator ID_itr;
  KnowledgeElement *KE_pt;
  InvestigatorLink *invest_link_pt;
  DiagnoseInvestigator *diagnose_invest_pt = NULL;
  EventSchemaUnit *ES_pt = NULL;
  float score_total, confidence;
  bool create_new_statement_bl = false;
  bool need_to_propagate_to_downstream_bl = false;
  float modified_p = _p;
 
  ReasonMachine *RM_pt;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
 
  if (this->m_ID == "Investigator_515") { this->ErrorMessage("check point"); }
 
  if (this->m_Happen != 2) {
    this->ErrorMessage("Error!");
    //  return;
  }
  if (r5pars_.timesno > 1022) { this->PrintMessage(""); }
 
  //caution: think more about the modified_p
  this->m_independent_probability = _p;
  this->m_probability_update_time = r5pars_.timesno;
  //RM_pt->m_event_schema_base->UpdateTheInterestForInvestigatorOrInvestigatorLink();
 
  KE_pt = (KnowledgeElement *) (this->m_KElement_ID_pt);
  if (this->m_possible_statement_pt == NULL && this->m_Statement_pt == NULL) {
    create_new_statement_bl = true;
  } else if (this->m_possible_statement_pt != NULL) {
    //To be added. It should be linked with the Event Schema
    if (this->m_possible_statement_pt->m_sent_pt == KE_pt->m_SentenceUnit_pt
        && this->m_possible_statement_pt->m_state == !KE_pt->m_negation) {//just update the confidence of this statement
      if (this->m_possible_statement_pt->m_diagnose_invest_ID_pt == NULL) {
        this->m_possible_statement_pt->m_confidence =
            this->m_possible_statement_pt->m_confidence + _p - _p * this->m_possible_statement_pt->m_confidence;
        need_to_propagate_to_downstream_bl = true;
      } else {
        diagnose_invest_pt = (DiagnoseInvestigator *) (this->m_possible_statement_pt->m_diagnose_invest_ID_pt);
        RM_pt->m_buffer_used_bl = false;
        RM_pt->m_event_schema_base->UpdateTheInterestForInvestigatorOrInvestigatorLink();
        diagnose_invest_pt->UpdateForOtherEvidenceNotListedInEventSchema((IDElement *) this);
        /*if(RM_pt->m_buffer_used_bl == true)
                {this->m_independent_probability = 0;}*/
        //diagnose_invest_pt->UpdateThisDiagnoseWithAnConfirmedInvestigator(this);
        this->m_possible_statement_pt->m_confidence = diagnose_invest_pt->m_confidence;
        need_to_propagate_to_downstream_bl = true;
      }
    } else {
      create_new_statement_bl = true;
      if (this->m_possible_statement_pt->m_sent_pt == KE_pt->m_SentenceUnit_pt
          && this->m_possible_statement_pt->m_state == KE_pt->m_negation) {
        modified_p = _p * (1 - this->m_possible_statement_pt->m_confidence);
      } else if (this->m_possible_statement_pt->m_sent_pt != KE_pt->m_SentenceUnit_pt
          && this->m_possible_statement_pt->m_state == !KE_pt->m_negation) {
        modified_p = _p * (1 - this->m_possible_statement_pt->m_confidence);
      }
    }
  }
 
 
  //create a new statement if required
  if (create_new_statement_bl == true) {
    //check whether there is a DiagnoseInvestigaor existing for this
    diagnose_invest_pt =
        RM_pt->m_event_schema_base->FindACorrespondingDiagnoseInvestigatorByKE((KnowledgeElement *) (this->m_KElement_ID_pt));
    if (diagnose_invest_pt != NULL) {//there is already a diagnose for this
      this->m_possible_statement_pt = diagnose_invest_pt->m_event_statement_pt;
      if (this->m_SI_ID_pt == NULL) {
        RM_pt->m_buffer_used_bl = false;
        RM_pt->m_event_schema_base->UpdateTheInterestForInvestigatorOrInvestigatorLink();
        diagnose_invest_pt->UpdateForOtherEvidenceNotListedInEventSchema((IDElement *) this);
        /*if(RM_pt->m_buffer_used_bl == true)
                {this->m_independent_probability = 0;}*/
        //diagnose_invest_pt->UpdateThisDiagnoseWithAnConfirmedInvestigator(this);
      }
      need_to_propagate_to_downstream_bl = true;
      create_new_statement_bl = false;
    } else {
      //Add a new statement with a probability
      auto stmt_owned = make_unique<Statement>();
      new_statement_pt = stmt_owned.get();
      new_statement_pt->m_factual_type = 4; // confidence propagated from the downstream
      new_statement_pt->m_sent_pt = KE_pt->m_SentenceUnit_pt;
      new_statement_pt->m_state = !(KE_pt->m_negation);
      new_statement_pt->m_confidence = modified_p;
      new_statement_pt->m_time_range.m_time_after = this->m_effective_start;
      new_statement_pt->m_time_range.m_time_before = this->m_effective_end;
      RM_pt->AddANewStatement(stmt_owned.release());
      this->m_possible_statement_pt = new_statement_pt;
 
      ES_pt =
          RM_pt->m_event_schema_base->FindACorrespondingEventSchemaUnitByKE((KnowledgeElement *) (this->m_KElement_ID_pt));
      if (ES_pt != NULL) {//create a diagnose for this
        auto di_owned = make_unique<DiagnoseInvestigator>();
        diagnose_invest_pt = di_owned.get();
        diagnose_invest_pt->m_event_schema_pt = ES_pt;
        diagnose_invest_pt->m_event_statement_pt = new_statement_pt;
        RM_pt->m_event_schema_base->AddANewDiagnoseInvestigator(di_owned.release());
        RM_pt->m_buffer_used_bl = false;
        diagnose_invest_pt->InitiationOfthisDiagnoseInvestigator(this->m_independent_probability, (IDElement *) this);
        /*if(RM_pt->m_buffer_used_bl == true)
                {this->m_independent_probability = 0;}*/
        //work more on the confidence level during the initiation
      }
      new_statement_pt->m_diagnose_invest_ID_pt = diagnose_invest_pt;
    }
 
 
    //To be added, compare the new generated statement and link it to a diagnose_invest
    //maybe it should be done in the RM
  }
 
  //probability propagate to downstream
  if (need_to_propagate_to_downstream_bl == true) {
    this->ForwardPropagateConfidenceLevel(this->m_possible_statement_pt->m_confidence);
  }
 
  //propagate to upperstream
  bool undetermined_cause = false;
  InvestigatorLink *link_pt;
  if (RM_pt->m_problem_solving_style == ProblemSolvingStyle::HamletB) {//check whether it has finished going through each possible cause
    for (ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++) {
      link_pt = (InvestigatorLink *) (*ID_itr);
      if (link_pt->m_is_causal_path_bl == false) { continue; }
      if (link_pt->m_path_status == 1) {
        undetermined_cause = true;
        break;
      }
    }
 
    if (undetermined_cause == true) {//pause this propagation
      this->m_paused_confidence_passing_list.push_back(_p);
      this->m_pause_confidence_propagation_ID_list.push_back(RM_pt->m_buffer_invest_pt->m_ID);
      return;
    }
  }
  score_total = 0;
  for (ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++) {
    invest_link_pt = (InvestigatorLink *) (*ID_itr);
    if (invest_link_pt->m_is_causal_path_bl == false) { continue; }
    if (invest_link_pt->m_path_status == 2
        || (invest_link_pt->m_path_status == 3 && invest_link_pt->m_is_a_strong_inference == true)) {
      score_total += invest_link_pt->m_K_unit_pt->m_backward_retrieve_weight;
    }
  }
  for (ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++) {
    invest_link_pt = (InvestigatorLink *) (*ID_itr);
    if (invest_link_pt->m_is_causal_path_bl == false) { continue; }
    if (invest_link_pt->m_path_status == 2
        || (invest_link_pt->m_path_status == 3 && invest_link_pt->m_is_a_strong_inference == true)) {
      confidence = (invest_link_pt->m_K_unit_pt->m_backward_retrieve_weight / score_total) * modified_p;
      invest_link_pt->BackwardPropagateConfidenceLevel(confidence);
    }
  }
}
 
void Investigator::ForwardPropagateConfidenceLevel(float _p) {
 
}
 
void Investigator::PrintCausalOrInferenceLink() {
  vector<IDElement *>::iterator ID_link_itr;
  vector<IDElement *>::iterator ID_invest_itr;
  Investigator *invest_pt;
  InvestigatorLink *link_pt;
  string str;
  this->PrintMessage("Downstream:" + this->m_KElement_ID_pt->m_ID);
  for (ID_link_itr = this->m_upperstream_ID_list.begin(); ID_link_itr != this->m_upperstream_ID_list.end();
       ID_link_itr++) {
    str = "";
    link_pt = (InvestigatorLink *) (*ID_link_itr);
    str += "--------";
    if (link_pt->m_K_unit_pt->m_inference_type == 1) {
      str += " A=>B";
    } else if (link_pt->m_K_unit_pt->m_inference_type == 2) {
      str += " A<=B";
    } else if (link_pt->m_K_unit_pt->m_inference_type == 3) {
      str += " A<=>B";
    }
 
    if (link_pt->m_K_unit_pt->m_causal_type != 0) {
      str += "A->B";
    }
    str += "--------";
    this->PrintMessage(str);
    if (link_pt->m_link_type == 2) { str = "AND: "; }
    else if (link_pt->m_link_type == 3) { str = "OR :"; }
    else { str = ""; }
    for (ID_invest_itr = link_pt->m_upperstream_ID_list.begin(); ID_invest_itr != link_pt->m_upperstream_ID_list.end();
         ID_invest_itr++) {
      invest_pt = (Investigator *) (*ID_invest_itr);
      str += "..";
      if (invest_pt->m_KElement_ID_pt != NULL) {
        str += invest_pt->m_KElement_ID_pt->m_ID;
      } else if (invest_pt->m_Statement_pt != NULL) {
        str += invest_pt->m_Statement_pt->m_sent_pt->m_ID;
      }
    }
    this->PrintMessage(str);
  }
 
}
 
bool Investigator::CheckWhetherTheFoundStatementConsistantWithKE(Statement *statement_match_pt) {//the input has to contain the same sentence or the antonym.
  bool consistant_bl = false;
  KnowledgeElement *KE_pt = (KnowledgeElement *) (this->m_KElement_ID_pt);
  if (statement_match_pt->m_sent_pt == KE_pt->m_SentenceUnit_pt) {
    if (statement_match_pt->m_state == !KE_pt->m_negation) {
      consistant_bl = true;
    } else {
      consistant_bl = false;
    }
  } else {//it should be a statement with antonym content
    if (statement_match_pt->m_state == true) {
      if (KE_pt->m_negation == false) {
        consistant_bl = false;
      } else {
        consistant_bl = true;
      }
    } else//m_state false
    {
      if (statement_match_pt->m_sent_pt->WhetherItIsBiState() == true) {//antonym and bi-state
        if (statement_match_pt->m_state == KE_pt->m_negation) {
          consistant_bl = true;
        } else {
          consistant_bl = false;
        }
      } else { consistant_bl = false; }//could not tell, caution!
    }
  }
  return consistant_bl;
}
 
void Investigator::CopyInvestigatorInfoFromAnother(Investigator *_invest_pt) {
  this->m_Happen_incomplete = _invest_pt->m_Happen_incomplete;
  this->m_Explain_incomplete = _invest_pt->m_Explain_incomplete;
  this->m_active_investigation = _invest_pt->m_active_investigation;
  this->CopyIDElementToRestartInfo((IDElement *) _invest_pt);
  this->m_investigation_closed = _invest_pt->m_investigation_closed;
  this->m_root_of_a_thought_line = _invest_pt->m_root_of_a_thought_line;
  /*
 
    bool m_phenomenon_onging;
    bool m_abort;
    int m_operator;
    int m_investigator_token;
    int m_explained;
    //1--unknown yet;
    //2--could not be determined;
    //3--yes, explained;
    //4--No, fail to explain
    int m_Happen;
    //1--unknown
    //2--could not be determined from control panel;
    //3--yes;
    //4--no;
    int m_investiage_status;
    //1, active one;(waiting for checking control panel/or retrieving from memory)
    //2--following;
    //3--idle, wait to be investigated;
    //4--sucess explanation;
    //5--not the cause;
    */
  this->m_last_active_time = _invest_pt->m_last_active_time;
  this->m_has_moved_to_an_upperstream = _invest_pt->m_has_moved_to_an_upperstream;
  this->m_read_requested_bl = _invest_pt->m_read_requested_bl;
  this->m_motivation = _invest_pt->m_motivation;
  this->m_read_value_or_rate_bl = _invest_pt->m_read_value_or_rate_bl;
  this->m_invest_dormant = _invest_pt->m_invest_dormant;
  this->m_invest_pause = _invest_pt->m_invest_pause;
  this->m_phenomenon_onging = _invest_pt->m_phenomenon_onging;
  this->m_abort = _invest_pt->m_abort;
  this->m_operator = _invest_pt->m_operator;
  this->m_investigator_token = _invest_pt->m_investigator_token;
  this->m_explained = _invest_pt->m_explained;
  this->m_Happen = _invest_pt->m_Happen;
  this->m_probability_update_time = _invest_pt->m_probability_update_time;
  this->m_timer = _invest_pt->m_timer;
  this->m_last_time_of_refreshing_inference_item = _invest_pt->m_last_time_of_refreshing_inference_item;
//  this->m_investiage_status = _invest_pt->m_investiage_status;
  /*
    double m_investigation_cease_time;
    double m_investigation_initiate_time;
    double m_effective_end;
    double m_effective_start;
    double m_end;
    float m_independent_probability;
    float m_interest_from_SymptomInvestigator;
    string m_note;
    string m_abort_reason;
    */
  this->m_investigation_cease_time = _invest_pt->m_investigation_cease_time;
  this->m_investigation_initiate_time = _invest_pt->m_investigation_initiate_time;
  this->m_effective_end = _invest_pt->m_effective_end;
  this->m_effective_start = _invest_pt->m_effective_start;
  this->m_independent_probability = _invest_pt->m_independent_probability;
  this->m_interest_from_SymptomInvestigator = _invest_pt->m_interest_from_SymptomInvestigator;
  this->m_note = _invest_pt->m_note;
  this->m_abort_reason = _invest_pt->m_abort_reason;
 
  /*
    IDElement * m_SI_ID_pt;
    IDElement * m_KElement_ID_pt; //The sentence in the KElement is to be investigated
    Statement * m_Statement_pt; //The statement indicates whether the knowledge element happened;
    Statement * m_inconsistant_statement;
    Statement * m_possible_statement_pt;
 
    string m_ID_SI;
    string m_ID_KE;
    string m_ID_statement;
    string m_ID_possible_statement;
    string m_ID_inconsit_statement;
    */
 
  if (_invest_pt->m_has_moved_to_link != NULL) { this->m_ID_has_move_to_link = _invest_pt->m_has_moved_to_link->m_ID; }
  else { this->m_ID_has_move_to_link = _invest_pt->m_ID_has_move_to_link; }
 
  if (_invest_pt->m_SI_ID_pt != NULL) { this->m_ID_SI = _invest_pt->m_SI_ID_pt->m_ID; }
  else { this->m_ID_SI = _invest_pt->m_ID_SI; }
 
  if (_invest_pt->m_KElement_ID_pt != NULL) { this->m_ID_KE = _invest_pt->m_KElement_ID_pt->m_ID; }
  else { this->m_ID_KE = _invest_pt->m_ID_KE; }
 
  if (_invest_pt->m_Statement_pt != NULL) { this->m_ID_statement = _invest_pt->m_Statement_pt->m_ID; }
  else { this->m_ID_statement = _invest_pt->m_ID_statement; }
 
  if (_invest_pt->m_inconsistant_statement != NULL) {
    this->m_ID_inconsist_statement = _invest_pt->m_inconsistant_statement->m_ID;
  }
  else { this->m_ID_inconsist_statement = _invest_pt->m_ID_inconsist_statement; }
 
  if (_invest_pt->m_possible_statement_pt != NULL) {
    this->m_ID_possible_statement = _invest_pt->m_possible_statement_pt->m_ID;
  }
  else { this->m_ID_possible_statement = _invest_pt->m_ID_possible_statement; }
 
 
  //if(this->m_waiting_indication_list.size() != 0)
  //{this->ErrorMessage("this->m_waiting_indication_list.size() != 0");return;}
  /*
    vector<int> m_investigator_token_history;
    vector<float> m_invest_token_endtime_history;
    vector<IDElement *> m_read_indication_list;
    vector<IDElement *> m_feedback_list;
    vector<IDElement *> m_upperstream_ID_list;
    vector<IDElement *> m_downstream_ID_list;
    vector<IDElement *> m_explanation_link_list;
    vector<IDElement *> m_possible_explanation_link_list;
    vector<IDElement *> m_rejected_explanation_list;
    //vector<IDElement *> m_waiting_indication_list;
    */
  if (this->m_investigator_token_history.size() != 0) {
    this->ErrorMessage("this->m_investigator_token_history.size() != 0");
    return;
  }
  if (this->m_invest_token_endtime_history.size() != 0) {
    this->ErrorMessage("this->m_invest_token_endtime_history.size() != 0");
    return;
  }
  if (this->m_read_indication_list.size() != 0) {
    this->ErrorMessage("m_read_indication_list.size() != 0");
    return;
  }
  if (this->m_feedback_list.size() != 0) {
    this->ErrorMessage("m_feedback_list.size() != 0");
    return;
  }
  if (this->m_upperstream_ID_list.size() != 0) {
    this->ErrorMessage("m_upperstream_ID_list.size() != 0");
    return;
  }
  if (this->m_downstream_ID_list.size() != 0) {
    this->ErrorMessage("m_downstream_ID_list.size() != 0");
    return;
  }
  if (this->m_explanation_link_list.size() != 0) {
    this->ErrorMessage("m_explanation_link_list.size() != 0");
    return;
  }
  if (this->m_possible_explanation_link_list.size() != 0) {
    this->ErrorMessage("this->m_possible_explanation_link_list.size() != 0");
    return;
  }
  if (this->m_rejected_explanation_list.size() != 0) {
    this->ErrorMessage("this->m_rejected_explanation_list.size() != 0");
    return;
  }
  if (this->m_thoughtline_roots_list.size() != 0) {
    this->ErrorMessage("this->m_thoughtline_roots_list.size() != 0");
    return;
  }
 
  vector<int>::iterator int_itr;
  int i;
  for (int_itr = _invest_pt->m_investigator_token_history.begin();
       int_itr != _invest_pt->m_investigator_token_history.end(); int_itr++) {
    i = *int_itr;
    this->m_investigator_token_history.push_back(i);
  }
 
  vector<IDElement *>::iterator ID_itr;
  vector<string>::iterator str_itr;
  string ID;
  vector<float>::iterator fl_itr;
  float fl;
  for (fl_itr = _invest_pt->m_paused_confidence_passing_list.begin();
       fl_itr != _invest_pt->m_paused_confidence_passing_list.end(); fl_itr++) {
    fl = *fl_itr;
    this->m_paused_confidence_passing_list.push_back(fl);
  }
  for (fl_itr = _invest_pt->m_invest_token_endtime_history.begin();
       fl_itr != _invest_pt->m_invest_token_endtime_history.end(); fl_itr++) {
    fl = *fl_itr;
    this->m_invest_token_endtime_history.push_back(fl);
  }
 
  for (str_itr = _invest_pt->m_pause_confidence_propagation_ID_list.begin();
       str_itr != _invest_pt->m_pause_confidence_propagation_ID_list.end(); str_itr++) {
    ID = *str_itr;
    this->m_pause_confidence_propagation_ID_list.push_back(ID);
  }
 
  for (str_itr = _invest_pt->m_thoughtline_roots_list.begin(); str_itr != _invest_pt->m_thoughtline_roots_list.end();
       str_itr++) {
    ID = *str_itr;
    this->m_thoughtline_roots_list.push_back(ID);
  }
 
  if (_invest_pt->m_read_indication_list.size() != 0) {
    for (ID_itr = _invest_pt->m_read_indication_list.begin(); ID_itr != _invest_pt->m_read_indication_list.end();
         ID_itr++) {
      ID = (*ID_itr)->m_ID;
      this->m_ID_read_indication_list.push_back(ID);
    }
  } else {
    for (str_itr = _invest_pt->m_ID_read_indication_list.begin();
         str_itr != _invest_pt->m_ID_read_indication_list.end(); str_itr++) {
      ID = *str_itr;
      this->m_ID_read_indication_list.push_back(ID);
    }
  }
 
  //
  if (_invest_pt->m_feedback_list.size() != 0) {
    for (ID_itr = _invest_pt->m_feedback_list.begin(); ID_itr != _invest_pt->m_feedback_list.end(); ID_itr++) {
      ID = (*ID_itr)->m_ID;
      this->m_ID_feedback_list.push_back(ID);
    }
  } else {
    for (str_itr = _invest_pt->m_ID_feedback_list.begin(); str_itr != _invest_pt->m_ID_feedback_list.end(); str_itr++) {
      ID = *str_itr;
      this->m_ID_feedback_list.push_back(ID);
    }
  }
 
  if (_invest_pt->m_upperstream_ID_list.size() != 0) {
    for (ID_itr = _invest_pt->m_upperstream_ID_list.begin(); ID_itr != _invest_pt->m_upperstream_ID_list.end();
         ID_itr++) {
      ID = (*ID_itr)->m_ID;
      this->m_ID_upperstream_list.push_back(ID);
    }
  } else {
    for (str_itr = _invest_pt->m_ID_upperstream_list.begin(); str_itr != _invest_pt->m_ID_upperstream_list.end();
         str_itr++) {
      ID = *str_itr;
      this->m_ID_upperstream_list.push_back(ID);
    }
  }
 
  if (_invest_pt->m_downstream_ID_list.size() != 0) {
    for (ID_itr = _invest_pt->m_downstream_ID_list.begin(); ID_itr != _invest_pt->m_downstream_ID_list.end();
         ID_itr++) {
      ID = (*ID_itr)->m_ID;
      this->m_ID_downstream_list.push_back(ID);
    }
  } else {
    for (str_itr = _invest_pt->m_ID_downstream_list.begin(); str_itr != _invest_pt->m_ID_downstream_list.end();
         str_itr++) {
      ID = *str_itr;
      this->m_ID_downstream_list.push_back(ID);
    }
  }
 
  if (_invest_pt->m_explanation_link_list.size() != 0) {
    for (ID_itr = _invest_pt->m_explanation_link_list.begin(); ID_itr != _invest_pt->m_explanation_link_list.end();
         ID_itr++) {
      ID = (*ID_itr)->m_ID;
      this->m_ID_explanation_link_list.push_back(ID);
    }
  } else {
    for (str_itr = _invest_pt->m_ID_explanation_link_list.begin();
         str_itr != _invest_pt->m_ID_explanation_link_list.end(); str_itr++) {
      ID = *str_itr;
      this->m_ID_explanation_link_list.push_back(ID);
    }
  }
 
  if (_invest_pt->m_possible_explanation_link_list.size() != 0) {
    for (ID_itr = _invest_pt->m_possible_explanation_link_list.begin();
         ID_itr != _invest_pt->m_possible_explanation_link_list.end(); ID_itr++) {
      ID = (*ID_itr)->m_ID;
      this->m_ID_possible_explanation_link_list.push_back(ID);
    }
  } else {
    for (str_itr = _invest_pt->m_ID_possible_explanation_link_list.begin();
         str_itr != _invest_pt->m_ID_possible_explanation_link_list.end(); str_itr++) {
      ID = *str_itr;
      this->m_ID_possible_explanation_link_list.push_back(ID);
    }
  }
 
  if (_invest_pt->m_rejected_explanation_list.size() != 0) {
    for (ID_itr = _invest_pt->m_rejected_explanation_list.begin();
         ID_itr != _invest_pt->m_rejected_explanation_list.end(); ID_itr++) {
      ID = (*ID_itr)->m_ID;
      this->m_ID_rejected_explanation_list.push_back(ID);
    }
  } else {
    for (str_itr = _invest_pt->m_ID_rejected_explanation_list.begin();
         str_itr != _invest_pt->m_ID_rejected_explanation_list.end(); str_itr++) {
      ID = *str_itr;
      this->m_ID_rejected_explanation_list.push_back(ID);
    }
  }
 
  if (this->m_note_list.size() > 0) { this->ErrorMessage("this->m_note_list.size() > 0"); }
 
  if (_invest_pt->m_note_list.size() > 100) { this->PrintMessage(""); }
  for (str_itr = _invest_pt->m_note_list.begin(); str_itr != _invest_pt->m_note_list.end(); str_itr++) {
    this->m_note_list.push_back(*str_itr);
  }
 
}
 
void Investigator::BuildTheConnectionsToThisInvestigator(void *_pt) {
  ReasonMachine *RM_pt;
  RM_pt = (ReasonMachine *) _pt;
  //Statement * m_inconsistant_statement;
  if (this->m_ID_inconsist_statement.compare("") != 0) {
    this->m_inconsistant_statement = RM_pt->FindStatementByID(this->m_ID_inconsist_statement);
    if (this->m_inconsistant_statement == NULL) {
      this->ErrorMessage("this->m_inconsistant_statement == NULL");
      return;
    }
  }
 
  //
  if (this->m_ID_has_move_to_link.compare("") != 0) {
    this->m_has_moved_to_link = RM_pt->FindInvestigatorLinkByID(this->m_ID_has_move_to_link);
    if (this->m_has_moved_to_link == NULL) {
      this->ErrorMessage("this->m_has_moved_to_link == NULL");
      return;
    }
    this->m_ID_has_move_to_link = "";
  }
 
 
  //IDElement * m_SI_ID_pt;
  if (this->m_ID_SI.compare("") != 0) {
    this->m_SI_ID_pt = RM_pt->m_event_schema_base->FindSymtomInvestigatorByID(this->m_ID_SI);
    if (this->m_SI_ID_pt == NULL) {
      this->ErrorMessage("this->m_SI_ID_pt == NULL");
      return;
    }
  }
  //IDElement * m_KElement_ID_pt;
  if (this->m_ID_KE.compare("") != 0) {
    this->m_KElement_ID_pt = RM_pt->FindKnowledgeElementByID(this->m_ID_KE);
    if (this->m_KElement_ID_pt == NULL) {
      this->ErrorMessage("this->m_KElement_ID_pt == NULL");
      return;
    }
 
  }
 
  //Statement * m_Statement_pt;
  if (this->m_ID_statement.compare("") != 0) {
    this->m_Statement_pt = RM_pt->FindStatementByID(this->m_ID_statement);
    if (this->m_Statement_pt == NULL) {
      this->ErrorMessage("this->m_Statement_pt == NULL");
      return;
    }
  }
 
  //Statement * m_possible_statement_pt;
  if (this->m_ID_possible_statement.compare("") != 0) {
    this->m_possible_statement_pt = RM_pt->FindStatementByID(this->m_ID_possible_statement);
    if (this->m_possible_statement_pt == NULL) {
      this->ErrorMessage("this->m_possible_statement_pt == NULL");
      return;
    }
  }
 
  //vector<IDElement *> m_feedback_list;
  vector<string>::iterator str_itr;
  IDElement *ID_pt;
  for (str_itr = this->m_ID_feedback_list.begin(); str_itr != this->m_ID_feedback_list.end(); str_itr++) {
    ID_pt = (IDElement *) (RM_pt->FindInvestigatorLinkByID(*str_itr));
    if (ID_pt == NULL) {
      this->ErrorMessage("could not find " + *str_itr);
      return;
    }
    this->m_feedback_list.push_back(ID_pt);
  }
 
  //vector<IDElement *> m_upperstream_ID_list;
  for (str_itr = this->m_ID_upperstream_list.begin(); str_itr != this->m_ID_upperstream_list.end(); str_itr++) {
    ID_pt = (IDElement *) (RM_pt->FindInvestigatorLinkByID(*str_itr));
    if (ID_pt == NULL) {
      this->ErrorMessage("could not find " + *str_itr);
      return;
    }
    this->m_upperstream_ID_list.push_back(ID_pt);
  }
 
  //vector<IDElement *> m_downstream_ID_list;
  for (str_itr = this->m_ID_downstream_list.begin(); str_itr != this->m_ID_downstream_list.end(); str_itr++) {
    ID_pt = (IDElement *) (RM_pt->FindInvestigatorLinkByID(*str_itr));
    if (ID_pt == NULL) {
      this->ErrorMessage("could not find " + *str_itr);
      return;
    }
    this->m_downstream_ID_list.push_back(ID_pt);
  }
 
  //vector<IDElement *> m_explanation_link_list;
  for (str_itr = this->m_ID_explanation_link_list.begin(); str_itr != this->m_ID_explanation_link_list.end();
       str_itr++) {
    ID_pt = (IDElement *) (RM_pt->FindInvestigatorLinkByID(*str_itr));
    if (ID_pt == NULL) {
      this->ErrorMessage("could not find " + *str_itr);
      return;
    }
    this->m_explanation_link_list.push_back(ID_pt);
  }
 
  //vector<IDElement *> m_possible_explanation_link_list;
  for (str_itr = this->m_ID_possible_explanation_link_list.begin();
       str_itr != this->m_ID_possible_explanation_link_list.end(); str_itr++) {
    ID_pt = (IDElement *) (RM_pt->FindInvestigatorLinkByID(*str_itr));
    if (ID_pt == NULL) {
      this->ErrorMessage("could not find " + *str_itr);
      return;
    }
    this->m_possible_explanation_link_list.push_back(ID_pt);
  }
 
  //vector<IDElement *> m_rejected_explanation_list;
  for (str_itr = this->m_ID_rejected_explanation_list.begin(); str_itr != this->m_ID_rejected_explanation_list.end();
       str_itr++) {
    ID_pt = (IDElement *) (RM_pt->FindInvestigatorLinkByID(*str_itr));
    if (ID_pt == NULL) {
      this->ErrorMessage("could not find " + *str_itr);
      return;
    }
    this->m_rejected_explanation_list.push_back(ID_pt);
  }
 
  //vector<IDElement *> m_read_indication_list;
  for (str_itr = this->m_ID_read_indication_list.begin(); str_itr != this->m_ID_read_indication_list.end(); str_itr++) {
    ID_pt = RM_pt->m_MR->FindMRUnitByID(*str_itr);
    if (ID_pt == NULL) {
      this->ErrorMessage("could not find a MR unit for this indication");
      return;
    }
    this->m_read_indication_list.push_back(ID_pt);
  }
 
}
 
void Investigator::AttachThoughtLineToThisInvestigator(string _line_ID) {
  bool found = false;
  vector<string>::iterator str_itr;
  vector<IDElement *>::iterator ID_itr;
  InvestigatorLink *link_pt;
 
  if (this->m_ID.compare(_line_ID) == 0) { return; } //there is a loop
 
  for (str_itr = this->m_thoughtline_roots_list.begin(); str_itr != this->m_thoughtline_roots_list.end(); str_itr++) {
    if (_line_ID.compare(*str_itr) == 0) { found = true; }
  }
 
  if (found == true) { return; }
 
  //
  if (this->m_ID == "Investigator_23") { this->PrintMessage("check"); }
 
  this->m_thoughtline_roots_list.push_back(_line_ID);
  for (ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++) {
    link_pt = (InvestigatorLink *) (*ID_itr);
    link_pt->AttachThoughtLineToThisLink(_line_ID);
  }
 
}
 
void Investigator::ExtendTheThoughtLineToUpperstream() {
  vector<IDElement *>::iterator ID_itr;
  InvestigatorLink *link_pt;
  vector<string>::iterator str_itr;
 
  if (this->m_root_of_a_thought_line == true) {
    for (ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++) {
      link_pt = (InvestigatorLink *) (*ID_itr);
      link_pt->AttachThoughtLineToThisLink(this->m_ID);
    }
  }
 
  for (str_itr = this->m_thoughtline_roots_list.begin(); str_itr != this->m_thoughtline_roots_list.end(); str_itr++) {
    for (ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++) {
      link_pt = (InvestigatorLink *) (*ID_itr);
      link_pt->AttachThoughtLineToThisLink(*str_itr);
    }
  }
  return;
 
}
 
bool Investigator::CheckWhetherInAThoughtLine(string _line_ID) {
  bool within = false;
  if (this->m_ID.compare(_line_ID) == 0) {
    within = true;
    return within;
  }
 
  vector<string>::iterator str_itr;
  for (str_itr = this->m_thoughtline_roots_list.begin(); str_itr != this->m_thoughtline_roots_list.end(); str_itr++) {
    if (_line_ID.compare(*str_itr) == 0) { within = true; }
  }
  return within;
}
 
float Investigator::GetInitiationTimeOrStatementTimeOrLastActiveTime() {
  float invest_time = this->m_investigation_initiate_time;
  if (this->m_Statement_pt != NULL) {
    invest_time = max<double>(invest_time, this->m_Statement_pt->m_time_generated);
  } else if (this->m_possible_statement_pt != NULL) {
    invest_time = max<double>(invest_time, this->m_possible_statement_pt->m_time_generated);
  }
 
  invest_time = max(invest_time, this->m_last_active_time);
  return invest_time;
}
 
void Investigator::InitiateBackwardPropagationOfConfidence() {
  float p_total = 0;
  float score_total = 0;
  float confidence = 0;
  vector<IDElement *>::iterator ID_itr;
  InvestigatorLink *invest_link_pt;
  string rm_aux_info;
 
  ReasonMachine *RM_pt;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
  if (this->m_ID == "Investigator_3") { this->PrintMessage("Check"); }
 
  if (this->m_Happen != 3) { return; }
  if (this->m_Statement_pt == NULL) { return; }
  else if (this->m_Statement_pt->m_factual_type == 3
      && this->m_Statement_pt->m_confidence < 0.95)//make sure it does propagate from an observed phenomenon
  { return; }
 
  if (this->m_Statement_pt->m_factual_type == 1 || this->m_Statement_pt->m_factual_type == 2
      || this->m_Statement_pt->m_confidence >= 0.95) {
    if (this->m_explanation_link_list.size() > 0) { p_total = 0.2 * pow(0.5, this->m_explanation_link_list.size()); }
    else { p_total = 0.9; }
  }
 
  score_total = 0;
  for (ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++) {
    invest_link_pt = (InvestigatorLink *) (*ID_itr);
    if (invest_link_pt->m_is_causal_path_bl == false) { continue; }
    if (invest_link_pt->m_path_status == 4) { continue; }
    if (invest_link_pt->m_path_status == 2
        || (invest_link_pt->m_path_status == 3 && invest_link_pt->m_is_a_strong_inference == true)) {
      score_total += invest_link_pt->m_K_unit_pt->m_backward_retrieve_weight;
    }
  }
 
  if (score_total == 0) { return; }
 
  rm_aux_info = "Propagating confidence from an observable syptom. Starts from " + this->m_ID;
  RM_pt->WriteAuxInfo(rm_aux_info);
  if (this->m_ID == "Investigator_621") { this->PrintMessage(""); }
 
  for (ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++) {
    invest_link_pt = (InvestigatorLink *) (*ID_itr);
    if (invest_link_pt->m_is_causal_path_bl == false) { continue; }
    if (invest_link_pt->m_path_status == 4) { continue; }
    if (invest_link_pt->m_path_status == 2
        || (invest_link_pt->m_path_status == 3 && invest_link_pt->m_is_a_strong_inference == true)) {
      confidence = (invest_link_pt->m_K_unit_pt->m_backward_retrieve_weight / score_total) * p_total;
      RM_pt->m_buffer_invest_pt = this;
      invest_link_pt->BackwardPropagateConfidenceLevel(confidence);
      RM_pt->m_buffer_invest_pt = NULL;
    }
  }
 
  if (RM_pt->m_problem_solving_style
      != ProblemSolvingStyle::HamletB) { RM_pt->m_event_schema_base->RemoveAllTheCaseAssociatedWithAnInvestigator((IDElement *) this); }
}
 
void Investigator::ReopenThisInvestigator() {
  ReasonMachine *RM_pt;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
  if (this->m_ID == "Investigator_34") { this->PrintMessage(""); }
 
  if (this->m_investigator_token > inv::ActiveThreshold) {
    if (this->m_upperstream_ID_list.size()
        > this->m_ID_possible_explanation_link_list.size() + this->m_rejected_explanation_list.size()
            + this->m_explanation_link_list.size()) {
      this->ChangeInvestigatorToken(inv::RetrieveNextLink);
    } else { this->PrintMessage(""); }
  }
 
  this->m_investigation_closed = false;
  RM_pt->AddBackToUnresolvedInvestigationPool(this);
  RM_pt->RemoveItemFromDecayedItemList((IDElement *) this);
  this->m_last_active_time = r5pars_.timesno;
 
  SentenceUnit *sent_pt;
  sent_pt = this->GetSemanticSentenceOfThisInvestigator();
  if (sent_pt->m_activation < 1) {
    RM_pt->CrankASentenceUnitActivationToAGivenValue(sent_pt, 1.0);
  }
}
 
void Investigator::CrankTheActivationToOne() {
  SentenceUnit *sent_pt;
 
  ReasonMachine *RM_pt;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
 
  sent_pt = this->GetSemanticSentenceOfThisInvestigator();
  if (sent_pt != NULL) {
    RM_pt->CrankASentenceUnitActivationToAGivenValue(sent_pt, 1.0);
  }
}
 
void Investigator::BoostActivationOfThisByActiveDiagnosisInvestigation() {
  InvestigatorLink *link_pt;
  if (this->m_invest_pause == false) {
    this->CrankTheActivationToOne();
  } else {
    link_pt = (InvestigatorLink *) this->m_has_moved_to_link;
    if (link_pt != NULL) { link_pt->BoostActivationOfThisLinkByActiveDiagnosisInvestigation(); }
  }
}
 
void Investigator::BoostAttentionofThisByDiagnosisInvestigation(float _i, bool _vagabond_reset) {
  if (this->m_ID == "Investigator_90") { this->PrintMessage(""); }
  InvestigatorLink *link_pt;
  if (this->m_invest_pause == false) {
    this->m_interest_from_SymptomInvestigator = _i;
    this->m_last_active_time = r5pars_.timesno;
 
    if (this->m_investigation_closed == true && this->m_investigator_token < inv::ActiveThreshold) { this->ReopenThisInvestigator(); }
  } else {
    link_pt = (InvestigatorLink *) this->m_has_moved_to_link;
    if (link_pt != NULL) { link_pt->BoostAttentionOfThisFromDiagnosisInvestigation(_i, _vagabond_reset); }
  }
}
 
void Investigator::MarkMHappenIncompleteTrue() {
//  vector<InvestigatorLink *>::iterator link_itr;
  vector<IDElement *>::iterator ID_itr;
  vector<string>::iterator str_itr;
  Investigator *invest_pt;
  ReasonMachine *RM_pt;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
 
  InvestigatorLink *link_pt;
  this->m_Happen_incomplete = true;
 
  for (ID_itr = this->m_downstream_ID_list.begin(); ID_itr != this->m_downstream_ID_list.end(); ID_itr++) {
    link_pt = (InvestigatorLink *) (*ID_itr);
    link_pt->UpdateMHappenIncomplete();
  }
 
  for (str_itr = this->m_thoughtline_roots_list.begin(); str_itr != this->m_thoughtline_roots_list.end(); str_itr++) {
    invest_pt = RM_pt->FindInvestigatorByID(*str_itr);
    if (invest_pt != NULL) {
      invest_pt->m_Explain_incomplete = true;
    }
  }
}
 
void Investigator::UpdateHappenExplainIncomeplete() {
  vector<IDElement *>::iterator ID_itr;
  InvestigatorLink *link_pt;
  bool mark_happen_change = false;
  bool mark_explain_change = false;
 
  if (this->m_Happen_incomplete == true) { return; }
 
  for (ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++) {
    link_pt = (InvestigatorLink *) (*ID_itr);
    if (link_pt->m_Happen_incomplete == true) {
      if (link_pt->m_is_inference_path_bl == true) { mark_happen_change = true; }
      if (link_pt->m_is_causal_path_bl == true) { mark_explain_change = true; }
    }
  }
 
  if (mark_happen_change == true && this->m_Happen != 3) {
    this->MarkMHappenIncompleteTrue();
  }
 
  if (mark_explain_change == true) {
    this->m_Explain_incomplete = true;
  }
}
 
void Investigator::FinishThePausedConfidencePropagationBeforeCloseInvestigation() {
  float score_total;
  float confidence;
 
  vector<string>::iterator str_itr;
  vector<float>::iterator fl_itr;
  vector<IDElement *>::iterator ID_itr;
  InvestigatorLink *invest_link_pt;
  Investigator *invest_pt;
 
  ReasonMachine *RM_pt;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
 
  if (this->m_pause_confidence_propagation_ID_list.size() != this->m_paused_confidence_passing_list.size()) {
    this->ErrorMessage(
        "this->m_pause_confidence_propagation_ID_list.size() != this->m_paused_confidence_passing_list.size()");
  }
 
  while (this->m_pause_confidence_propagation_ID_list.size() > 0) {
    str_itr = this->m_pause_confidence_propagation_ID_list.begin();
    fl_itr = this->m_paused_confidence_passing_list.begin();
 
    invest_pt = RM_pt->FindInvestigatorByID(*str_itr);
    if (invest_pt == NULL) {
      this->ErrorMessage(
          "unable to find the Investigator for the FinishThePausedConfidencePropagationBeforeCloseInvestigation");
    }
 
    score_total = 0;
    for (ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++) {
      invest_link_pt = (InvestigatorLink *) (*ID_itr);
      if (invest_link_pt->m_is_causal_path_bl == false) { continue; }
      if (invest_link_pt->m_path_status == 2
          || (invest_link_pt->m_path_status == 3 && invest_link_pt->m_is_a_strong_inference == true)) {
        score_total += invest_link_pt->m_K_unit_pt->m_backward_retrieve_weight;
      }
    }
    for (ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++) {
      invest_link_pt = (InvestigatorLink *) (*ID_itr);
      if (invest_link_pt->m_is_causal_path_bl == false) { continue; }
      if (invest_link_pt->m_path_status == 2
          || (invest_link_pt->m_path_status == 3 && invest_link_pt->m_is_a_strong_inference == true)) {
        RM_pt->m_buffer_invest_pt = invest_pt;
        confidence = (invest_link_pt->m_K_unit_pt->m_backward_retrieve_weight / score_total) * (*fl_itr);
        invest_link_pt->BackwardPropagateConfidenceLevel(confidence);
        RM_pt->m_buffer_invest_pt = NULL;
      }
    }
    this->m_pause_confidence_propagation_ID_list.erase(str_itr);
    this->m_paused_confidence_passing_list.erase(fl_itr);
  }
}