InvestigatorLink.cpp

Go to the documentation of this file.

// InvestigatorLink.cpp: implementation of the InvestigatorLink class.
//
 
#include <sstream>
#include <iostream>
#include <fstream>
 
#include "InvestigatorLink.h"
#include "Investigator.h"
#include "RMTokens.h"
#include "KnowledgeElement.h"
#include "ReasonMachine.h"
#include "../Crew/OperatorDM.h"
#include "../Crew/OperatorAT.h"
#include "../Global/SimulationContext.h"
 
using namespace std;
 
 
// Construction/Destruction
 
InvestigatorLink::InvestigatorLink()
{
    this->m_Happen_incomplete = false;
    // m_dummy_activation default-constructs to nullptr
    this->m_has_moved_to_invest = NULL;
    this->m_is_a_strong_inference = false;
    this->m_ID_Type = 302;
    //301--Investigator
    //302--InvestigatorLink
    this->m_path_status = 1; // set the default path status as "unknown".
    this->m_invest_link_pause = false;
    this->m_invest_link_Token = inv_link::RetrieveNextInvestigator;
    this->m_invest_link_dormant = true;
    this->m_condition_ID_pt = NULL;
    this->m_downstream_ID_pt = NULL;
    this->m_K_unit_pt = NULL;
    this->m_is_causal_path_bl = true;
    this->m_is_inference_path_bl = false;
    this->m_inference_direction_reverse_bl = false;
    this->m_SI_ID_pt = NULL; 
    this->m_interest_from_SymptomInvestigator = 0;
    this->m_forgotten_bl = false;
    this->m_link_last_activated_time = r5pars_.timesno;
    this->m_has_feedback_to_downstream = false;
 
    this->m_ID_KU = "";
    this->m_ID_downstream = "";
    this->m_ID_condition = "";
    this->m_ID_SI = "";
    this->m_ID_has_moved_to_invest = "";
}
 
InvestigatorLink::~InvestigatorLink()
{
    this->m_invest_link_Token_history.clear();
    this->m_link_token_endtime_history.clear();
 
    this->m_upperstream_ID_list.clear();
    this->m_explanation_ID_list.clear();
    this->m_confirmed_invest_ID_list.clear();
    this->m_rejected_invest_ID_list.clear();
    this->m_possible_invest_ID_list.clear();
 
    this->m_ID_upperstream_list.clear();
    this->m_ID_explanation_list.clear();
    this->m_ID_confirmed_invest_list.clear();
    this->m_ID_rejected_invest_list.clear();
    this->m_ID_possible_invest_list.clear();
}
 
void InvestigatorLink::OneStepWorkOnThisInvestigatorLink()
{
    string str;
    stringstream conv;
 
    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_invest_link_dormant == true)
    {
        this->m_invest_link_dormant = false;
    }
 
    if(this->m_invest_link_pause == true)
    {
        this->m_invest_link_pause = false;
    }
 
    if(this->m_forgotten_bl == true)
    {
        this->m_forgotten_bl = false;
    }
 
    this->m_link_last_activated_time = r5pars_.timesno;
 
    switch (this->m_invest_link_Token)
    {
    case inv_link::RetrieveNextInvestigator:
        this->RetrieveTheNextLikelyInvestigator3101();
        break;
    case inv_link::CheckPathStatus:
        this->CheckThePathStatus3102();
        break;
    case inv_link::FeedbackDetermined:
        this->FeedBackToDownstreamInvestigator310331043105();
        break;
    case inv_link::FeedbackPartial:
        this->FeedBackToDownstreamInvestigator310331043105();
        break;
    case inv_link::FeedbackUndetermined:
        this->FeedBackToDownstreamInvestigator310331043105();
        break;
    case inv_link::TransferOut:
        /*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);*/
        this->TransferOutOfThisInvestigatorLink3110();
        //error message, this InvestigatorLink has already been closed, should not enter this any more
        break;
    default:
        break;
    }
}
 
void InvestigatorLink::RetrieveTheNextLikelyInvestigator3101()
{//to be modified
    //this is a perfect process, the operator would do a complete exam of both the condition and the causes
    Investigator * invest_pt;
    Investigator * next_invest_pt = NULL;
    vector<IDElement *>::iterator ID_itr;
    KnowledgeElement * KE_pt;
    bool want_to_exam_condition_now = false;
    float highest_score = 0;
    float score;
    string prompt, err_mes, str;
    stringstream conv;
 
    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 
 
    //to be modified, the current prioritization is only based on the activation level of each KE sentence
    //also, if there is one cause examed and the condition has not been examed yet, the operator would want to exam the condition first
    prompt = "\n";
    prompt += "Retrieving the next Investigator from the InvestigatorLink:\n";
    RM_pt->ZeroAllTheInterestFromSymptomInvestigator();
    RM_pt->m_event_schema_base->UpdateTheInterestForInvestigatorOrInvestigatorLink();
    //
    //for debug use only
    if(r5pars_.timesno > 134.114)
    {
    //  this->ErrorMessage("pause");
    }
    //
    for(ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr ++)
    {
        invest_pt = (Investigator*)(*ID_itr);
        prompt += invest_pt->GetASimpleDescriptionOfThisInvestigator();
        prompt += "\nRetrieve Score: "; 
        if(invest_pt->m_Happen == 1)
        {
            KE_pt = (KnowledgeElement*)(invest_pt->m_KElement_ID_pt);
            if(KE_pt == NULL)
            {
                this->ErrorMessage("Error!");
            }
            score = KE_pt->m_SentenceUnit_pt->m_activation * (1 + invest_pt->m_interest_from_SymptomInvestigator *2);
            if(next_invest_pt == NULL)
            {
                next_invest_pt = invest_pt;             
                highest_score = score;
            }
            else if(score > highest_score)
            {
                next_invest_pt = invest_pt;             
                highest_score = score;
            }
            conv.str("");
            conv << score;
            prompt += conv.str();
            prompt += "\n";
        }
        else if(invest_pt->m_Happen == 3)
        {
            if(this->m_link_type == 1 || this->m_link_type == 3)
            {
                want_to_exam_condition_now = true;
            }
        }
    }
    
    if(this->m_condition_ID_pt != NULL)
    {
        invest_pt = (Investigator*)(this->m_condition_ID_pt);
        if(invest_pt->m_Happen == 1)
        {
            KE_pt = (KnowledgeElement*)(invest_pt->m_KElement_ID_pt);
            score = KE_pt->m_SentenceUnit_pt->m_activation * (1 + invest_pt->m_interest_from_SymptomInvestigator *2);
            if(want_to_exam_condition_now == true)
            {
                next_invest_pt = invest_pt;
                prompt += "Condition KE needs to be investigated!\n";
                highest_score = score;
            }
            else
            {
                prompt += invest_pt->GetASimpleDescriptionOfThisInvestigator();
                prompt += "\nRetrieve Score: "; 
                if(score > highest_score)
                {
                    next_invest_pt = invest_pt;
                    highest_score = KE_pt->m_SentenceUnit_pt->m_activation;
                }
                conv.str("");
                conv << score;
                prompt += conv.str();
                prompt += "\n";
            }
        }
    }
    this->PrintMessage(prompt);
 
    if(next_invest_pt != NULL)
    {
        //forced inverstigation
        if(this->m_SI_ID_pt != NULL)
        {
            next_invest_pt->m_SI_ID_pt = this->m_SI_ID_pt;
        }
        next_invest_pt->m_invest_dormant = false;
        next_invest_pt->CrankTheActivationToOne();
        //
        prompt = "\n";
        prompt += "The retrieved one: ";
        prompt += next_invest_pt->GetASimpleDescriptionOfThisInvestigator();
        this->PrintMessage(prompt);
        this->ChangeInvestigatorLinkToken(inv_link::CheckPathStatus);
        this->m_invest_link_pause = true;
        this->m_has_moved_to_invest = (IDElement *)next_invest_pt;
        RM_pt->m_investigation_trace.push_back((IDElement*)this);
        RM_pt->m_working_on_invest_pt = next_invest_pt;
        RM_pt->ChangeRMTokenValue(rm::WorkOnInvestigator);
 
        conv.str("");
        conv << r5pars_.timesno;
        str = conv.str();
        str += ": transfer out: to ";
        str += RM_pt->m_working_on_invest_pt->m_ID;
        this->m_note_list.push_back(str);
    }
    else
    {
        this->ChangeInvestigatorLinkToken(inv_link::CheckPathStatus);
    }
}
 
void InvestigatorLink::CheckThePathStatus3102()
{//3102
    //need to go through the logic again to verify it is correct
    //to be modified, the current codes only reflect the OR logic, not and logic
    string prompt, err_mes;
    Investigator * invest_pt;
    vector<IDElement *>::iterator ID_itr;
    if(this->m_path_status == 2 || this->m_path_status == 3 )
    {}//error message, it's already known, should not enter this micro function
    bool status_determined = false;
    bool unknown_cause_exist = false;
    bool all_cause_not_happen = true;
    bool all_cause_happen = true;
    int condition_status = 3;
    int next_status = 1;
    int next_token;
    bool has_a_strong_inference = false;
    bool has_a_determined_cause = false;
 
    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 
    //caution here: Should examine the time range again here?
    //examine the condition first
 
    if(this->m_ID == "InvestigatorLink_60")
    {
        this->PrintMessage("Check");
    }
 
    prompt = "\n\n";
    if(this->m_condition_ID_pt != NULL)
    {
        invest_pt = (Investigator*)(this->m_condition_ID_pt);
        condition_status = invest_pt->m_Happen;
        prompt += "Condition: ";
        prompt += invest_pt->GetASimpleDescriptionOfThisInvestigator();
        prompt += ", ";
    }
 
    if(condition_status == 3 || condition_status == 2)
    {//condition satisfied
        if(this->m_condition_ID_pt != NULL)
        {
            prompt += "happend\n";
        }
        //examine the causes
        for(ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end() && status_determined == false; ID_itr ++)
        {
            invest_pt = (Investigator*)(*ID_itr);
            prompt += "Cause: ";
            prompt += invest_pt->GetASimpleDescriptionOfThisInvestigator();
            prompt += ", ";
            switch (invest_pt->m_Happen)
            {
            case 1://unknown
                prompt += "unknown\n";
                unknown_cause_exist = true;
                all_cause_happen = false;
                all_cause_not_happen = false;
                if(this->m_link_type == 2 || this->m_link_type == 1)
                {//have to know this investigator path in order to determine this path
                    next_status = 1;
                    status_determined = true;
                }
                break;
            case 2://could not determine
                prompt += "could not be determined\n";
                all_cause_happen = false;
                all_cause_not_happen = false;
                if(this->m_link_type == 2 || this->m_link_type ==1)
                {
                    next_status = 2;
                    status_determined = true;
                }
                if(this->CheckExistenceInThePossibleInvestList(*ID_itr) == NULL)
                {this->m_possible_invest_ID_list.push_back(*ID_itr);}
                break;
            case 3://yes, it happens
                prompt += "happened\n";
                all_cause_not_happen = false;
                if(this->m_link_type == 3 || this->m_link_type == 1)
                {
                    next_status = 3;
                    status_determined = true;
                }
 
                if(invest_pt->m_Statement_pt->m_factual_type == 3)
                {has_a_strong_inference = true;}
                else
                {has_a_determined_cause = true;}
 
                if(this->CheckExistenceInTheConfirmedInvestList(*ID_itr) == NULL)
                {this->m_confirmed_invest_ID_list.push_back(*ID_itr);}
                break;
 
            case 4://no, it doesn't go through
                prompt += "did not happen\n";
                all_cause_happen = false;
                if(this->m_link_type == 2 || this->m_link_type ==1)
                {
                    next_status = 4;
                    status_determined = true;
                }
                if(this->CheckExistenceInTheRejectedInvestList(*ID_itr) == NULL)
                {this->m_rejected_invest_ID_list.push_back(*ID_itr);}
                break;
            }
        }
        if(next_status == 1)
        {
            if(all_cause_not_happen == true)
            {
                prompt += "All the causes did not happen\n";
                next_status = 4; 
            }
            else if(unknown_cause_exist == true)
            {
                prompt += "Still more to investigate\n";
                next_status = 1;
            }
            else//some of them could not be determined
            {
                prompt += "One or more causes could not be determined\n";
                next_status = 2;
            }
        }
        
        if(condition_status == 2)
        {
            if(next_status == 1 || next_status == 3)
            {next_status = 2;}
        }
        this->PrintMessage(prompt);
    }
    else if(condition_status == 4)
    {//condition not satisfied
        prompt += "The condition is not satisfied\n";
        next_status = 4; //doesn't go through
    }
    else if(condition_status == 1)
    {//unknown yet
        prompt += "The condition is not known\n";
        next_status = 1; //unknow
    }
 
    if(condition_status == 3 && this->m_link_type == 2 && all_cause_happen == true)
    {
        prompt += "This inference path goes through.\n";
        next_status = 3;
    }
//bool has_a_strong_inference = false;
    //bool has_a_determined_cause = false;
 
    this->m_path_status = next_status;
    if(next_status == 3)
    {
        if(has_a_strong_inference == true)
        {
            if(this->m_link_type ==1)//and gate
            {this->m_is_a_strong_inference = true;}
            else//or gate
            {
                if(has_a_determined_cause == false)
                {this->m_is_a_strong_inference = true;}
            }
        }
    }
    switch (next_status)
    {
    case 1:
        next_token = inv_link::RetrieveNextInvestigator;
        break;
    case 2:
        next_token = inv_link::FeedbackUndetermined;
        break;
    case 3:
        if(unknown_cause_exist == true )
        {next_token = inv_link::RetrieveNextInvestigator;}
        else
        {next_token = inv_link::FeedbackDetermined;}
        break;
    case 4:
        next_token = inv_link::FeedbackPartial;
        break;
    default:
        //error message, should not be here
        break;
    }
    if(this->m_invest_link_dormant == true)
    {
        if(next_token == inv_link::FeedbackDetermined || next_token == inv_link::FeedbackPartial || next_token == inv_link::FeedbackUndetermined)
        {
            this->m_invest_link_dormant = false;
            RM_pt->AddToRMFeedbackStack(this);
        }
    }
    this->ChangeInvestigatorLinkToken(next_token);
    this->AddTimeConsumptionInInvestigatorLink(0.2);
}
 
void InvestigatorLink::FeedBackToDownstreamInvestigator310331043105()
{//3103/3104/3105
    string str;
    stringstream conv;
    vector<IDElement *>::iterator ID_itr;
    Investigator * invest_pt;
 
    //Caution Assumption: Each InvestigatorLink connects only one downstream investigator
    ReasonMachine * RM_pt;
    string prompt;
    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_has_feedback_to_downstream == true)
    {
        if(this->m_confirmed_invest_ID_list.size() != 0)
        {
            ID_itr = this->m_confirmed_invest_ID_list.begin();
            while(ID_itr != this->m_confirmed_invest_ID_list.end())
            {
                invest_pt = (Investigator *)(*ID_itr);
                if(invest_pt->m_investigator_token == inv::GetCorrespondingKE)
                {
                    invest_pt->CrankTheActivationToOne();
                    RM_pt->m_working_on_invest_pt = invest_pt;
                    RM_pt->ChangeRMTokenValue(rm::WorkOnInvestigator);
                    return;
                }
                ID_itr++;
            }
        }
        this->ChangeInvestigatorLinkToken(inv_link::TransferOut);
        return;
    }
    prompt += "Feedback to the downstream investigator";
    this->PrintMessage(prompt);
 
    RM_pt->AddToRMFeedbackStack((IDElement*)this);
    RM_pt->m_working_on_invest_pt = (Investigator*)(this->m_downstream_ID_pt);
    RM_pt->ChangeRMTokenValue(rm::WorkOnInvestigator);
    this->m_has_feedback_to_downstream = true;
 
    conv.str("");
    conv << r5pars_.timesno;
    str = conv.str();
    str += ": transfer out: to ";
    str += RM_pt->m_working_on_invest_pt->m_ID;
    this->m_note_list.push_back(str);
}
 
double InvestigatorLink::CalculateBackwardRetrievalScore()
{//to be modified
    //this is a simple version
    //it finds the highest activation in the condition KE and the causal KE
    //the score is the multiplication of the backward reasoning weight and the highest activation
    double score;
    double highest_activation = 0;
    double activation;
    vector<IDElement*>::iterator ID_itr;
    Investigator * invest_pt;
    
    //check point
    if(this->m_upperstream_ID_list.size() == 0)
    {
        this->ErrorMessage("Error!");
    }
 
 
    if(this->m_condition_ID_pt != NULL)
    {
        invest_pt = (Investigator *)(this->m_condition_ID_pt);
        highest_activation = invest_pt->GetActivation();
    }
 
    for(ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr ++)
    {
        invest_pt = (Investigator *)(*ID_itr);
        activation = invest_pt->GetActivation();
        if(activation > highest_activation)
        {
            highest_activation = activation;
        }
    }
    score = pow((this->m_K_unit_pt->m_backward_retrieve_weight),1.6) * pow(highest_activation,0.4);
    score *= 1 + 2 * this->m_interest_from_SymptomInvestigator;
    if(score == 0)
    {}//error message 
    return score;
}
 
void InvestigatorLink::AddTimeConsumptionInInvestigatorLink(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 InvestigatorLink::CalculateFilteredPrioritizingScoreOfInvestigatorLink()
{
    float score = 0;
    float highest_score = 0;
    vector<IDElement *>::iterator ID_itr;
    Investigator * invest_pt;
 
    if(this->m_ID == "InvestigatorLink_64")
    {
        this->PrintMessage("");
    }
    if(this->m_invest_link_dormant == true || this->m_invest_link_pause == true || this->m_invest_link_Token == inv_link::TransferOut)
    {
        return 0;
    }
    if(this->m_condition_ID_pt != NULL)
    {
        invest_pt = (Investigator*)this->m_condition_ID_pt;
        highest_score = invest_pt->CalculatePriorityScoreEvenDormantOrPaused();
    }
    if(this->m_interest_from_SymptomInvestigator > 0)
    {
        for(ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++)
        {
            invest_pt = (Investigator *)(*ID_itr);
            invest_pt->m_interest_from_SymptomInvestigator = max(this->m_interest_from_SymptomInvestigator, invest_pt->m_interest_from_SymptomInvestigator);
        }
    }
 
    for(ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++)
    {
        invest_pt = (Investigator *)(*ID_itr);
        score = invest_pt->CalculatePriorityScoreEvenDormantOrPaused();
        if(score > highest_score)
        {
            highest_score = score;
        }
    }
    
    return highest_score + 20 * this->m_interest_from_SymptomInvestigator;
}
 
void InvestigatorLink::TransferOutOfThisInvestigatorLink3110()
{
    string str;
    stringstream conv;
 
    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->EraseItemFromFeedbackStack((IDElement *)this);
    if(RM_pt->m_problem_solving_style == ProblemSolvingStyle::HamletB)
    {   
        this->FinishThePausedConfidencePropagationBeforeCloseInvestigatorLink();
        RM_pt->EraseFromOngoingItemStack(this->m_ID);
    }
    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);
 
}
 
void InvestigatorLink::ChangeInvestigatorLinkToken(int _token)
{
    this->m_invest_link_Token_history.push_back(this->m_invest_link_Token);
    this->m_invest_link_Token = _token;
    this->m_link_token_endtime_history.push_back(r5pars_.timesno);
}
 
string InvestigatorLink::GetASimpleDescriptionOfTheInvestigatorLink()
{
    string str;
    Investigator* invest_pt;
    vector<IDElement *>::iterator ID_itr;
 
    str = "InvestigatorLink Information: \n";
    //describe the upperstream
    str += "Upperstream of this inference Path ";
    if(this->m_link_type == 2)
    {
        str += ", OR GATE:\n";  
    }
    else if(this->m_link_type == 3)
    {
        str += ", AND GATE: \n";
    }
    else
    {
        str += ":\n";
    }
    for(ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++)
    {
        invest_pt = (Investigator *)(*ID_itr);
        str += invest_pt->GetASimpleDescriptionOfThisInvestigator();
        str += "\n";
    }
 
    //describe the downstream
    str += "Downstream of this inference path:\n";
    invest_pt = (Investigator*)(this->m_downstream_ID_pt);
    str += invest_pt->GetASimpleDescriptionOfThisInvestigator();
    str += "\n";
 
    //describe the condition
    if(this->m_condition_ID_pt != NULL)
    {
        invest_pt = (Investigator *)(this->m_condition_ID_pt);
        str+= "Condition of this inference path:\n";
        str += invest_pt->GetASimpleDescriptionOfThisInvestigator();
    }
    //to be added
    return str;
}
 
void InvestigatorLink::PrintMessage(string str)
{
    cout << "\n";
    cout << "Time: " << r5pars_.timesno << ":\n" << str << '\n';
 
    //test
    ofstream fout("RMI.txt", ios::app);
    fout <<"\n" << "Time: " << r5pars_.timesno << ":\n" << str << '\n';
    fout.close();
}
 
void InvestigatorLink::ErrorMessage(string str)
{
    cout << r5pars_.timesno << "  " << str << " in InvestigatorLink.cpp" << '\n';
    ofstream fout("err messages.txt", ios::app);
    fout << r5pars_.timesno << "  " << str << '\n';
    fout.close();
    //r5pars_.terminateall = true;
}
 
void InvestigatorLink::BackwardPropagateConfidenceLevel(float _p)
{
    float confidence = 0;
    vector<IDElement *>::iterator ID_itr;
    Investigator * invest_pt;
    int number_of_strong_reference = 0;
    bool unexplored_cause = false;
 
    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
 
    for(ID_itr = this->m_confirmed_invest_ID_list.begin(); ID_itr != this->m_confirmed_invest_ID_list.end(); ID_itr++)
    {
        invest_pt = (Investigator*)(*ID_itr);
        if(invest_pt->m_Happen == 3 && invest_pt->m_Statement_pt->m_factual_type == 3)
        {number_of_strong_reference++;}
    }
 
    if(this->m_path_status != 2)
    {
        if(this->m_path_status != 3 || this->m_is_a_strong_inference == false)
        {this->ErrorMessage("Error!");}
    }
 
    if(this->m_link_type == 1) //only connect to one upperstream investigator
    {
        confidence = _p;
    }
    else if(this->m_link_type == 3) //Or gate
    {
        //confidence = _p/(this->m_possible_invest_ID_list.size()) + number_of_strong_reference;
        confidence = _p;
    }
    else if(this->m_link_type == 2) //And gate
    {
        confidence = _p;
        if(this->m_rejected_invest_ID_list.size() != 0)
        {
            this->ErrorMessage("Error!");
            return;
        }
    }
 
    unexplored_cause = false;
    for(ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++)
    {
        invest_pt = (Investigator*)(*ID_itr);
        if(invest_pt->m_Happen == 1)
        {unexplored_cause = true; break;}
    }
 
    if(unexplored_cause == true)
    {
        this->m_pause_confidence_propagation_ID_list.push_back(RM_pt->m_buffer_invest_pt->m_ID);
        this->m_paused_confidence_passing_list.push_back(_p);
        return;
    }
 
    for(ID_itr = this->m_possible_invest_ID_list.begin(); ID_itr != this->m_possible_invest_ID_list.end(); ID_itr++)
    {
        invest_pt = (Investigator*)(*ID_itr);
        if((*ID_itr) == this->m_condition_ID_pt)
        {
            invest_pt->BackwardPropagateConfidenceLevel(_p);
        }
        else
        {
            invest_pt->BackwardPropagateConfidenceLevel(confidence);
        }
    }
    for(ID_itr = this->m_confirmed_invest_ID_list.begin(); ID_itr != this->m_confirmed_invest_ID_list.end(); ID_itr++)
    {
        invest_pt = (Investigator*)(*ID_itr);
        if(invest_pt->m_Happen == 3 && invest_pt->m_Statement_pt->m_factual_type == 3)
        {invest_pt->BackwardPropagateConfidenceLevel(confidence);}
    }
    
}
 
IDElement * InvestigatorLink::CheckExistenceInTheConfirmedInvestList(IDElement *_ID_pt)
{
    IDElement * found_ID_pt = NULL;
    vector<IDElement *>::iterator ID_itr;
 
    for(ID_itr = this->m_confirmed_invest_ID_list.begin(); ID_itr != this->m_confirmed_invest_ID_list.end() && found_ID_pt == NULL; ID_itr++)
    {
        if((*ID_itr) == _ID_pt)
        {
            found_ID_pt = (*ID_itr);
        }
    }
    return found_ID_pt;
}
 
IDElement * InvestigatorLink::CheckExistenceInThePossibleInvestList(IDElement *_ID_pt)
{
    IDElement * found_ID_pt = NULL;
    vector<IDElement *>::iterator ID_itr;
 
    for(ID_itr = this->m_possible_invest_ID_list.begin(); ID_itr != this->m_possible_invest_ID_list.end() && found_ID_pt == NULL; ID_itr++)
    {
        if((*ID_itr) == _ID_pt)
        {
            found_ID_pt = (*ID_itr);
        }
    }
    return found_ID_pt;
}
 
IDElement * InvestigatorLink::CheckExistenceInTheRejectedInvestList(IDElement *_ID_pt)
{
    IDElement * found_ID_pt = NULL;
    vector<IDElement *>::iterator ID_itr;
 
    for(ID_itr = this->m_rejected_invest_ID_list.begin(); ID_itr != this->m_rejected_invest_ID_list.end() && found_ID_pt == NULL; ID_itr++)
    {
        if((*ID_itr) == _ID_pt)
        {
            found_ID_pt = (*ID_itr);
        }
    }
    return found_ID_pt;
}
 
void InvestigatorLink::CopyInvestigatorLinkInfoFromAnother(InvestigatorLink * _link_pt)
{
    this->CopyIDElementToRestartInfo((IDElement *)_link_pt);
 
    this->m_Happen_incomplete = _link_pt->m_Happen_incomplete;
    if(_link_pt->m_dummy_activation)
    {
        this->m_dummy_activation = make_unique<Activation>();
        this->m_dummy_activation->CopyActivationToRestartInfo(_link_pt->m_dummy_activation.get());
    }
/*  bool m_invest_link_dormant;
    int m_operator;
    int m_invest_link_Token;
    bool m_invest_link_pause;
    bool m_is_inference_path_bl;
    bool m_is_causal_path_bl;   
    float m_interest_from_SymptomInvestigator;
    int m_path_status; //1--unknown; 2--could not be determined; 3--connect through; 4--doesn't go through; 
    int m_link_type; //1--one to one knowledge link; 2--And gate link; 3--Or gate link
*/
    this->m_operator = _link_pt->m_operator;
    this->m_invest_link_dormant = _link_pt->m_invest_link_dormant;
    this->m_invest_link_Token = _link_pt->m_invest_link_Token;
    this->m_invest_link_pause = _link_pt->m_invest_link_pause;
    this->m_is_causal_path_bl = _link_pt->m_is_causal_path_bl;
    this->m_is_inference_path_bl = _link_pt->m_is_inference_path_bl;
    this->m_interest_from_SymptomInvestigator = _link_pt->m_interest_from_SymptomInvestigator;
    this->m_path_status = _link_pt->m_path_status;
    this->m_link_type = _link_pt->m_link_type;
    this->m_is_a_strong_inference = _link_pt->m_is_a_strong_inference;
    this->m_forgotten_bl = _link_pt->m_forgotten_bl;
    this->m_link_last_activated_time = _link_pt->m_link_last_activated_time;
    this->m_has_feedback_to_downstream = _link_pt->m_has_feedback_to_downstream;
/*
    string m_ID_KU;
    string m_ID_downstream;
    string m_ID_condition;
    string m_ID_SI;
*/
    if(_link_pt->m_K_unit_pt != NULL)
    {this->m_ID_KU = _link_pt->m_K_unit_pt->m_ID;}
    else
    {this->m_ID_KU = _link_pt->m_ID_KU;}
 
    if(_link_pt->m_downstream_ID_pt != NULL)
    {this->m_ID_downstream = _link_pt->m_downstream_ID_pt->m_ID;}
    else
    {this->m_ID_downstream = _link_pt->m_ID_downstream;}
 
    if(_link_pt->m_condition_ID_pt != NULL)
    {this->m_ID_condition = _link_pt->m_condition_ID_pt->m_ID;}
    else
    {this->m_ID_condition = _link_pt->m_ID_condition;}
 
    if(_link_pt->m_SI_ID_pt != NULL)
    {this->m_ID_SI = _link_pt->m_SI_ID_pt->m_ID;}
    else
    {this->m_ID_SI = _link_pt->m_ID_SI;}
 
    if(_link_pt->m_has_moved_to_invest != NULL)
    {this->m_ID_has_moved_to_invest = _link_pt->m_has_moved_to_invest->m_ID;}
    else
    {this->m_ID_has_moved_to_invest = _link_pt->m_ID_has_moved_to_invest;}
    
    if(this->m_invest_link_Token_history.size() != 0)
    {this->ErrorMessage("this->m_invest_link_Token_history.size() != 0");return;}
    if(this->m_link_token_endtime_history.size() != 0)
    {this->ErrorMessage("this->m_link_token_endtime_history.size() != 0");return;}
    if(this->m_upperstream_ID_list.size() != 0)
    {this->ErrorMessage("this->m_upperstream_ID_list.size() != 0");return;}
    if(this->m_explanation_ID_list.size() != 0)
    {this->ErrorMessage("this->m_explanation_ID_list.size() != 0");return;}
    if(this->m_confirmed_invest_ID_list.size() != 0)
    {this->ErrorMessage("this->m_confirmed_invest_ID_list.size() != 0");return;}
    if(this->m_rejected_invest_ID_list.size() != 0)
    {this->ErrorMessage("this->m_rejected_invest_ID_list.size() != 0");return;}
    if(this->m_possible_invest_ID_list.size() != 0)
    {this->ErrorMessage("this->m_possible_invest_ID_list.size() != 0");return;}
    if(this->m_thoughtline_roots_list.size() > 0)
    {this->ErrorMessage("this->m_thoughtline_roots_list.size() > 0");}
/*
    vector<int> m_invest_link_Token_history;
    vector<double> m_link_token_endtime_history;
*/
    vector<int>::iterator int_itr;
    int i;
    for(int_itr = _link_pt->m_invest_link_Token_history.begin(); int_itr != _link_pt->m_invest_link_Token_history.end(); int_itr++)
    {
        i = *int_itr;
        this->m_invest_link_Token_history.push_back(i);
    }
 
    vector<float>::iterator fl_itr;
    float fl;
    for(fl_itr = _link_pt->m_link_token_endtime_history.begin(); fl_itr != _link_pt->m_link_token_endtime_history.end(); fl_itr++)
    {
        fl = * fl_itr;
        this->m_link_token_endtime_history.push_back(fl);
    }
 
    for(fl_itr = _link_pt->m_paused_confidence_passing_list.begin(); fl_itr != _link_pt->m_paused_confidence_passing_list.end(); fl_itr++)
    {
        fl = *fl_itr;
        this->m_paused_confidence_passing_list.push_back(fl);
    }
/*
    vector<IDElement *> m_upperstream_ID_list;
    vector<IDElement *> m_explanation_ID_list;
    vector<IDElement *> m_confirmed_invest_ID_list;
    vector<IDElement *> m_rejected_invest_ID_list;
    vector<IDElement *> m_possible_invest_ID_list;
*/
    vector<IDElement *>::iterator ID_itr;
    vector<string>::iterator str_itr;
    string ID;
 
    for(str_itr = _link_pt->m_pause_confidence_propagation_ID_list.begin(); str_itr != _link_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 = _link_pt->m_thoughtline_roots_list.begin(); str_itr != _link_pt->m_thoughtline_roots_list.end(); str_itr++)
    {
        ID = *str_itr;
        this->m_thoughtline_roots_list.push_back(ID);
    }
 
    if(_link_pt->m_upperstream_ID_list.size() != 0)
    {
        for(ID_itr = _link_pt->m_upperstream_ID_list.begin(); ID_itr != _link_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 = _link_pt->m_ID_upperstream_list.begin(); str_itr != _link_pt->m_ID_upperstream_list.end(); str_itr++)
        {
            ID = *str_itr;
            this->m_ID_upperstream_list.push_back(ID);
        }
    }
 
    if(_link_pt->m_explanation_ID_list.size() != 0)
    {
        for(ID_itr = _link_pt->m_explanation_ID_list.begin(); ID_itr != _link_pt->m_explanation_ID_list.end(); ID_itr++)
        {
            ID = (*ID_itr)->m_ID;
            this->m_ID_explanation_list.push_back(ID);
        }
    }
    else
    {
        for(str_itr = _link_pt->m_ID_explanation_list.begin(); str_itr != _link_pt->m_ID_explanation_list.end(); str_itr++)
        {
            ID = *str_itr;
            this->m_ID_explanation_list.push_back(ID);
        }
    }
 
    if(_link_pt->m_confirmed_invest_ID_list.size() != 0)
    {
        for(ID_itr = _link_pt->m_confirmed_invest_ID_list.begin(); ID_itr != _link_pt->m_confirmed_invest_ID_list.end(); ID_itr++)
        {
            ID = (*ID_itr)->m_ID;
            this->m_ID_confirmed_invest_list.push_back(ID);
        }
    }
    else
    {
        for(str_itr = _link_pt->m_ID_confirmed_invest_list.begin(); str_itr != _link_pt->m_ID_confirmed_invest_list.end(); str_itr++)
        {
            ID = *str_itr;
            this->m_ID_confirmed_invest_list.push_back(ID);
        }
    }
 
    if(_link_pt->m_rejected_invest_ID_list.size() != 0)
    {
        for(ID_itr = _link_pt->m_rejected_invest_ID_list.begin(); ID_itr != _link_pt->m_rejected_invest_ID_list.end(); ID_itr++)
        {
            ID = (*ID_itr)->m_ID;
            this->m_ID_rejected_invest_list.push_back(ID);
        }
    }
    else
    {
        for(str_itr = _link_pt->m_ID_rejected_invest_list.begin(); str_itr != _link_pt->m_ID_rejected_invest_list.end(); str_itr++)
        {
            ID = *str_itr;
            this->m_ID_rejected_invest_list.push_back(ID);
        }
    }
 
    if(_link_pt->m_possible_invest_ID_list.size() != 0)
    {
        for(ID_itr = _link_pt->m_possible_invest_ID_list.begin(); ID_itr != _link_pt->m_possible_invest_ID_list.end(); ID_itr++)
        {
            ID = (*ID_itr)->m_ID;
            this->m_ID_possible_invest_list.push_back(ID);
        }
    }
    else
    {
        for(str_itr = _link_pt->m_ID_possible_invest_list.begin(); str_itr != _link_pt->m_ID_possible_invest_list.end(); str_itr++)
        {
            ID = *str_itr;
            this->m_ID_possible_invest_list.push_back(ID);
        }
    }
 
    if(this->m_note_list.size()>0)
    {this->ErrorMessage("this->m_note_list.size()>0");}
    for(str_itr = _link_pt->m_note_list.begin(); str_itr != _link_pt->m_note_list.end(); str_itr++)
    {
        this->m_note_list.push_back(*str_itr);
    }
}
 
void InvestigatorLink::BuildConnectionsToThisInvestigatorLink(void * _pt)
{
    ReasonMachine * RM_pt;
    RM_pt = (ReasonMachine *)_pt;
    
    if(this->m_ID_has_moved_to_invest.compare("") != 0)
    {
        this->m_has_moved_to_invest = RM_pt->FindInvestigatorByID(this->m_ID_has_moved_to_invest);
        if(this->m_has_moved_to_invest == NULL)
        {this->ErrorMessage("this->m_has_moved_to_invest == NULL");return;}
        this->m_ID_has_moved_to_invest = "";
    }
 
    //KnowledgeUnit * m_K_unit_pt;
    if(this->m_ID_KU.compare("") != 0)
    {
        this->m_K_unit_pt = RM_pt->FindKnowledgeUnitByID(this->m_ID_KU);
        if(this->m_K_unit_pt == NULL)
        {this->ErrorMessage("could not find the knowledge " + this->m_ID_KU); return;}
    }
    //IDElement * m_downstream_ID_pt;
    if(this->m_ID_downstream.compare("") != 0)
    {
        this->m_downstream_ID_pt = RM_pt->FindInvestigatorByID(this->m_ID_downstream);
        if(this->m_downstream_ID_pt == NULL)
        {this->ErrorMessage("could not find the downstream investigator" + this->m_ID_downstream); return;}
    }
    //IDElement * m_condition_ID_pt;
    if(this->m_ID_condition.compare("") != 0)
    {
        this->m_condition_ID_pt = RM_pt->FindInvestigatorByID(this->m_ID_condition);
        if(this->m_condition_ID_pt == NULL)
        {this->ErrorMessage("could not find the condition investigator " + this->m_ID_condition); return;}
    }
 
    //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("could not find the SymptomInvestigator " + this->m_ID_SI); return;}
    }
    
 
/*
    vector<IDElement *> m_upperstream_ID_list;
    vector<IDElement *> m_explanation_ID_list;
    vector<IDElement *> m_confirmed_invest_ID_list;
    vector<IDElement *> m_rejected_invest_ID_list;
    vector<IDElement *> m_possible_invest_ID_list;
*/
    vector<string>::iterator str_itr;
    IDElement * 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->FindInvestigatorByID(*str_itr));
        if(ID_pt == NULL)
        {this->ErrorMessage("could not find the investigator " + *str_itr); return;}
        this->m_upperstream_ID_list.push_back(ID_pt);
    }
    //vector<IDElement *> m_explanation_ID_list;
    for(str_itr = this->m_ID_explanation_list.begin(); str_itr != this->m_ID_explanation_list.end(); str_itr++)
    {
        ID_pt = (IDElement *)(RM_pt->FindInvestigatorByID(*str_itr));
        if(ID_pt == NULL)
        {this->ErrorMessage("could not find the investigator " + *str_itr); return;}
        this->m_explanation_ID_list.push_back(ID_pt);
    }
    //vector<IDElement *> m_confirmed_invest_ID_list;
    for(str_itr = this->m_ID_confirmed_invest_list.begin(); str_itr != this->m_ID_confirmed_invest_list.end(); str_itr++)
    {
        ID_pt = (IDElement *)(RM_pt->FindInvestigatorByID(*str_itr));
        if(ID_pt == NULL)
        {this->ErrorMessage("could not find the investigator " + *str_itr); return;}
        this->m_confirmed_invest_ID_list.push_back(ID_pt);
    }
    //vector<IDElement *> m_rejected_invest_ID_list;
    for(str_itr = this->m_ID_rejected_invest_list.begin(); str_itr != this->m_ID_rejected_invest_list.end(); str_itr++)
    {
        ID_pt = (IDElement *)(RM_pt->FindInvestigatorByID(*str_itr));
        if(ID_pt == NULL)
        {this->ErrorMessage("could not find the investigator " + *str_itr); return;}
        this->m_rejected_invest_ID_list.push_back(ID_pt);
    }
    //vector<IDElement *> m_possible_invest_ID_list;
    for(str_itr = this->m_ID_possible_invest_list.begin(); str_itr != this->m_ID_possible_invest_list.end(); str_itr++)
    {
        ID_pt = (IDElement *)(RM_pt->FindInvestigatorByID(*str_itr));
        if(ID_pt == NULL)
        {this->ErrorMessage("could not find the investigator " + *str_itr); return;}
        this->m_possible_invest_ID_list.push_back(ID_pt);
    }
}
 
void InvestigatorLink::AttachThoughtLineToThisLink(string _line_ID)
{
    bool  found = false;
    vector<string>::iterator str_itr;
    vector<IDElement *>::iterator ID_itr;
    Investigator * invest_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;}
 
    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++)
    {
        invest_pt = (Investigator *)(*ID_itr);
        invest_pt->AttachThoughtLineToThisInvestigator(_line_ID);
    }
 
    if(this->m_condition_ID_pt != NULL)
    {
        invest_pt = (Investigator*)(this->m_condition_ID_pt);
        invest_pt->AttachThoughtLineToThisInvestigator(_line_ID);
    }
    return;
}
 
bool InvestigatorLink::CheckWhetherInAThoughtLine(string _line_ID)
{
    bool within = false;
 
    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 InvestigatorLink::GetDownstreamInitiationTimeOrStatementTime()
{
    Investigator * invest_pt;
    invest_pt = (Investigator*)(this->m_downstream_ID_pt);
    return invest_pt->GetInitiationTimeOrStatementTimeOrLastActiveTime();
}
 
void InvestigatorLink::SetAdummyActivation()
{
    this->m_dummy_activation = make_unique<Activation>();
    this->m_dummy_activation->m_activation = 1;
}
 
void InvestigatorLink::CrankTheNextLikelyRetrievedInvestigatorActivationToOne()
{
    Investigator * invest_pt;
    Investigator * next_invest_pt = NULL;
    vector<IDElement *>::iterator ID_itr;
    KnowledgeElement * KE_pt;
    bool want_to_exam_condition_now = false;
    float highest_score = 0;
    float score;
    string prompt, err_mes, str;
    stringstream conv;
 
    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 
 
    for(ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr ++)
    {
        invest_pt = (Investigator*)(*ID_itr);
        if(invest_pt->m_Happen == 1)
        {
            KE_pt = (KnowledgeElement*)(invest_pt->m_KElement_ID_pt);
            if(KE_pt == NULL)
            {
                this->ErrorMessage("Error!");
            }
            score = KE_pt->m_SentenceUnit_pt->m_activation * (1 + invest_pt->m_interest_from_SymptomInvestigator *2);
            if(next_invest_pt == NULL)
            {
                next_invest_pt = invest_pt;             
                highest_score = score;
            }
            else if(score > highest_score)
            {
                next_invest_pt = invest_pt;             
                highest_score = score;
            }
        }
    }
    
    if(this->m_condition_ID_pt != NULL)
    {
        invest_pt = (Investigator*)(this->m_condition_ID_pt);
        if(invest_pt->m_Happen == 1)
        {
            KE_pt = (KnowledgeElement*)(invest_pt->m_KElement_ID_pt);
            score = KE_pt->m_SentenceUnit_pt->m_activation * (1 + invest_pt->m_interest_from_SymptomInvestigator *2);
            if(score > highest_score)
            {
                next_invest_pt = invest_pt;
                highest_score = KE_pt->m_SentenceUnit_pt->m_activation;
            }
        }
    }
 
    if(next_invest_pt != NULL)
    {
        next_invest_pt->CrankTheActivationToOne();
    }
}
 
void InvestigatorLink::BoostActivationOfThisLinkByActiveDiagnosisInvestigation()
{
    Investigator * invest_pt;
    if(this->m_invest_link_pause == false)
    {
        this->CrankTheNextLikelyRetrievedInvestigatorActivationToOne();
 
    }
    else
    {
        invest_pt = (Investigator *)(this->m_has_moved_to_invest);
        if(invest_pt != NULL)
        {invest_pt->BoostActivationOfThisByActiveDiagnosisInvestigation();}
    }
}
 
void InvestigatorLink::BoostAttentionOfThisFromDiagnosisInvestigation(float _i , bool _vagabond_reset)
{
    Investigator * invest_pt;
    if(this->m_invest_link_pause == false)
    {
        this->m_interest_from_SymptomInvestigator = _i;
        this->m_forgotten_bl = false;
    }
    else
    {
        invest_pt = (Investigator *)(this->m_has_moved_to_invest);
        if(invest_pt != NULL)
        {invest_pt->BoostAttentionofThisByDiagnosisInvestigation(_i, _vagabond_reset);}
    }
}
 
void InvestigatorLink::ResetTheLastActivationTimeOfTheNextToBeRetrievedInvestigator()
{
    Investigator * invest_pt;
    Investigator * next_invest_pt = NULL;
    vector<IDElement *>::iterator ID_itr;
    KnowledgeElement * KE_pt;
    bool want_to_exam_condition_now = false;
    float highest_score = 0;
    float score;
    string prompt, err_mes, str;
    stringstream conv;
 
    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 
 
    for(ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr ++)
    {
        invest_pt = (Investigator*)(*ID_itr);
        if(invest_pt->m_Happen == 1)
        {
            KE_pt = (KnowledgeElement*)(invest_pt->m_KElement_ID_pt);
            if(KE_pt == NULL)
            {
                this->ErrorMessage("Error!");
            }
            score = KE_pt->m_SentenceUnit_pt->m_activation * (1 + invest_pt->m_interest_from_SymptomInvestigator *2);
            if(next_invest_pt == NULL)
            {
                next_invest_pt = invest_pt;             
                highest_score = score;
            }
            else if(score > highest_score)
            {
                next_invest_pt = invest_pt;             
                highest_score = score;
            }
        }
    }
    
    if(this->m_condition_ID_pt != NULL)
    {
        invest_pt = (Investigator*)(this->m_condition_ID_pt);
        if(invest_pt->m_Happen == 1)
        {
            KE_pt = (KnowledgeElement*)(invest_pt->m_KElement_ID_pt);
            score = KE_pt->m_SentenceUnit_pt->m_activation * (1 + invest_pt->m_interest_from_SymptomInvestigator *2);
            if(score > highest_score)
            {
                next_invest_pt = invest_pt;
                highest_score = KE_pt->m_SentenceUnit_pt->m_activation;
            }
        }
    }
 
    if(next_invest_pt != NULL)
    {
        next_invest_pt->m_last_active_time = r5pars_.timesno;
    }
}
 
void InvestigatorLink::UpdateMHappenIncomplete()
{
    Investigator * invest_pt;
    vector<IDElement *>::iterator ID_itr;
    bool mark_change = false;
 
    if(this->m_Happen_incomplete == true)
    {return;}
    
    if(this->m_condition_ID_pt != NULL)
    {
        invest_pt = (Investigator *)(this->m_condition_ID_pt);
        if(invest_pt->m_Happen_incomplete == true)
        {mark_change = true;}
    }
 
    for(ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr++)
    {
        invest_pt = (Investigator *)(*ID_itr);
        if(invest_pt->m_Happen_incomplete == true)
        {mark_change = true;}
    }
 
    if(mark_change == true)
    {
        this->MarkMHappenIncompleteTrue();
    }
 
}
 
void InvestigatorLink::MarkMHappenIncompleteTrue()
{
    Investigator * invest_pt;
    this->m_Happen_incomplete = true;
 
    invest_pt = (Investigator*)(this->m_downstream_ID_pt);
    invest_pt->UpdateHappenExplainIncomeplete();
}
 
void InvestigatorLink::FinishThePausedConfidencePropagationBeforeCloseInvestigatorLink()
{
    float confidence, _p;
    vector<IDElement *>::iterator ID_itr;
    Investigator * invest_pt;
    Investigator * buffer_invest_pt;
    int number_of_strong_reference = 0;
    bool unexplored_cause = false;
 
    vector<string>::iterator str_itr;
    vector<float>::iterator fl_itr;
 
    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() == 0)
    {return;}
 
    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()");
    }
 
    for(ID_itr = this->m_confirmed_invest_ID_list.begin(); ID_itr != this->m_confirmed_invest_ID_list.end(); ID_itr++)
    {
        invest_pt = (Investigator*)(*ID_itr);
        if(invest_pt->m_Happen == 3 && invest_pt->m_Statement_pt->m_factual_type == 3)
        {number_of_strong_reference++;}
    }   
 
    while(this->m_paused_confidence_passing_list.size() > 0)
    {
        str_itr = this->m_pause_confidence_propagation_ID_list.begin();
        fl_itr = this->m_paused_confidence_passing_list.begin();
 
        _p = *fl_itr;
        buffer_invest_pt = RM_pt->FindInvestigatorByID(*str_itr);
        if(buffer_invest_pt == NULL)
        {this->ErrorMessage("buffer_invest_pt == NULL");}
 
        if(this->m_link_type == 1) //only connect to one upperstream investigator
        {
            confidence = _p;
        }
        else if(this->m_link_type == 3) //Or gate
        {
            confidence = _p/(this->m_possible_invest_ID_list.size()) + number_of_strong_reference;
        }
        else if(this->m_link_type == 2) //And gate
        {
            confidence = _p;
            if(this->m_rejected_invest_ID_list.size() != 0)
            {
                this->ErrorMessage("Error!");
                return;
            }
        }
        
        for(ID_itr = this->m_possible_invest_ID_list.begin(); ID_itr != this->m_possible_invest_ID_list.end(); ID_itr++)
        {
            RM_pt->m_buffer_invest_pt = buffer_invest_pt;
            invest_pt = (Investigator*)(*ID_itr);
            if((*ID_itr) == this->m_condition_ID_pt)
            {
                invest_pt->BackwardPropagateConfidenceLevel(_p);
            }
            else
            {
                invest_pt->BackwardPropagateConfidenceLevel(confidence);
            }
            RM_pt->m_buffer_invest_pt = NULL;
        }
 
        for(ID_itr = this->m_confirmed_invest_ID_list.begin(); ID_itr != this->m_confirmed_invest_ID_list.end(); ID_itr++)
        {
            RM_pt->m_buffer_invest_pt = buffer_invest_pt;
            invest_pt = (Investigator*)(*ID_itr);
            if(invest_pt->m_Happen == 3 && invest_pt->m_Statement_pt->m_factual_type == 3)
            {invest_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);
    }
}
 
float InvestigatorLink::GetActivationOfthisLink()
{
    double highest_activation = 0;
    double activation;
    vector<IDElement*>::iterator ID_itr;
    Investigator * invest_pt;
    
    //check point
    if(this->m_upperstream_ID_list.size() == 0)
    {
        this->ErrorMessage("Error!");
    }
 
 
    if(this->m_condition_ID_pt != NULL)
    {
        invest_pt = (Investigator *)(this->m_condition_ID_pt);
        highest_activation = invest_pt->GetActivation();
    }
 
    for(ID_itr = this->m_upperstream_ID_list.begin(); ID_itr != this->m_upperstream_ID_list.end(); ID_itr ++)
    {
        invest_pt = (Investigator *)(*ID_itr);
        activation = invest_pt->GetActivation();
        if(activation > highest_activation)
        {
            highest_activation = activation;
        }
    }
    
    return highest_activation;
}