SymptomInvestigator.cpp

Go to the documentation of this file.

// SymptomInvestigator.cpp: implementation of the SymptomInvestigator class.
//
 
#include <memory>
#include "SymptomInvestigator.h"
#include "ReasonMachine.h"
#include "../Crew/OperatorDM.h"
#include "../Crew/OperatorAT.h"
#include "Label.h"
#include "SentenceUnit.h"
#include "InvestigatorLink.h"
#include "KnowledgeUnit.h"
#include "KnowledgeElement.h"
#include "../Global/SimulationContext.h"
using namespace std;
 
 
// Construction/Destruction
 
SymptomInvestigator::SymptomInvestigator()
{
    this->m_event_symptom_pt = NULL;
    this->m_symptom_KE_pt = NULL;
    this->m_ID_Type = 501;
    this->m_independent_symptom_probability = 0;
    this->m_label_ID_pt = NULL;
    this->m_last_case_end_time = 0;
    this->m_DI_ID_pt = NULL;
    this->m_ID_DI = "";
    this->m_ID_lable = "";
    this->m_ID_esu = "";
    this->m_ID_KE = "";
    this->m_opposite_KE_ID = "";
    this->m_need_to_invest_opposite_bl = false;
    this->m_can_not_explain_opposite_bl = false;
    this->m_opposite_KE_pt = NULL;
 
}
 
SymptomInvestigator::~SymptomInvestigator()
{
    this->m_ongoing_invest_list.clear();
    this->m_ongoing_invest_link_list.clear();
    this->m_ID_ongoing_invest_list.clear();
    this->m_ID_ongoing_invest_link_list.clear();
 
    // unique_ptr vectors auto-delete their elements
}
 
void SymptomInvestigator::InitiationOfthisSymptomInvestigator()
{
    vector<Investigator *>::iterator invest_itr;
    Investigator * invest_pt;
    Label * label_group_pt;
    bool  need_inst_bl = false;
    SentenceUnit * sent_pt;
    SymptomCase * case_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
    {this->ErrorMessage("Error!");}//add error message 
 
    //Firstly assign value to the m_symptom_KE_pt
    if(this->m_event_symptom_pt == NULL)
    {this->ErrorMessage("Error!");}//add error message
 
    if(this->m_label_ID_pt == NULL)
    {
        //caution here, even though the schema doesn't contain indefinite concept, the event_symptom might contain one
        this->m_symptom_KE_pt = this->m_event_symptom_pt->m_symptom_KE_pt;
    }
    else
    {
        //caution: there is one situation not included in the current codes. The sentence contains one different indefinite concept or more than one indefinite concept
        //These codes only consider that the sentence contains the same indefinite concept consistant with the event schema
        label_group_pt = RM_pt->m_IB->CheckWhetherASentenceContainIndefiniteItem(this->m_event_symptom_pt->m_symptom_KE_pt->m_SentenceUnit_pt);
        if(label_group_pt != NULL)
        {
            if(RM_pt->m_IB->FindLabelGroupByLabelID(this->m_label_ID_pt) == label_group_pt)
            {
                need_inst_bl = true;
            }
            else
            {
                this->ErrorMessage("The codes is not ready for this situation yet!");
            }
        }
 
        if(need_inst_bl == true)
        {
            sent_pt = RM_pt->InstantiateAnIndefiniteSentenceWithLabel(this->m_event_symptom_pt->m_symptom_KE_pt->m_SentenceUnit_pt, this->m_label_ID_pt);
            if(sent_pt == NULL)
            {this->ErrorMessage("Error!");}
            this->m_symptom_KE_pt = RM_pt->FindAKEbySentenceAndNegationSign(sent_pt, this->m_event_symptom_pt->m_symptom_KE_pt->m_negation);
            if(this->m_symptom_KE_pt == NULL)
            {this->ErrorMessage("Error!");}
        }
        else
        {
            this->m_symptom_KE_pt = this->m_event_symptom_pt->m_symptom_KE_pt;
        }
    }
 
    //
    bool new_case_bl;
    for(auto &invest_e : RM_pt->m_investigator_pool)
    {
        new_case_bl = false;
        invest_pt = invest_e.get();
        if(invest_pt->m_KElement_ID_pt == (IDElement *)(this->m_symptom_KE_pt))
        {
            //caution: all the symptoms have to be observable
            if(invest_pt->m_Happen == 3)
            {
                new_case_bl = true;
            }
        }
        else if(invest_pt->m_KElement_ID_pt == NULL)
        {
            if(invest_pt->m_Statement_pt != NULL)
            {
                if(this->m_symptom_KE_pt->m_SentenceUnit_pt == invest_pt->m_Statement_pt->m_sent_pt)
                {new_case_bl = true;}
            }
        }
        if(new_case_bl == true)
        {
            auto case_owned = make_unique<SymptomCase>();
            case_pt = case_owned.get();
            case_pt->m_finished_bl =false;
            case_pt->m_invest_pt = invest_pt;
            this->m_candidate_case_list.push_back(std::move(case_owned));
            this->TrackOneInvestigationCase(case_pt);
        }
    }
 
 
}
 
void SymptomInvestigator::ErrorMessage(string str)
{
    cout << r5pars_.timesno << "  " << str << " in SymptomInvestigator.cpp" << '\n';
    ofstream fout("err messages.txt", ios::app);
    fout << r5pars_.timesno << "  " << str << '\n';
    fout.close();
    //r5pars_.terminateall = true;
}
 
void SymptomInvestigator::InitiallyCompareAnInvestigationTraceWithThePrototype(SymptomCase * _case_pt)
{
    Investigator * invest_pt;
    Investigator * unfinished_invest_pt = NULL;
    Investigator * problem_invest_pt = NULL;
    Investigator * problem_permission_invest_pt = NULL;
    KnowledgeUnit * KU_stuck_pt = NULL;
    bool consistant_bl = true;
    bool finished_bl = true;
    bool jump_out_bl = false;
    bool found_bl;
    //vector<InvestigatorLink *>::iterator invest_link_itr;
    vector<IDElement *>::iterator link_ID_itr;
    vector<KnowledgeUnit *>::iterator KU_itr;
    InvestigatorLink * invest_link_pt;
    InvestigatorLink * unfinished_invest_link_pt = NULL;
    
    invest_pt = _case_pt->m_invest_pt;  
    for(KU_itr = this->m_event_symptom_pt->m_KU_list.begin(); KU_itr != this->m_event_symptom_pt->m_KU_list.end() && jump_out_bl == false; KU_itr++)
    {
        if(invest_pt->m_Happen == 4)
        {
            problem_invest_pt = invest_pt;
            jump_out_bl = true; //caution here, maybe need to investigate more?
            continue;
        }
        
        
        if(invest_pt->m_investigator_token < 3013)
        {
            unfinished_invest_pt = invest_pt;
            jump_out_bl = true;
            continue;
        }
                
        //find an InvestigatorLink that matches the path specified in the prototype
        found_bl = false;
        for(link_ID_itr = invest_pt->m_upperstream_ID_list.begin(); link_ID_itr != invest_pt->m_upperstream_ID_list.end() && found_bl == false; link_ID_itr++)
        {
            invest_link_pt = (InvestigatorLink*)(*link_ID_itr);
            if(invest_link_pt->m_K_unit_pt == (*KU_itr))
            {
                found_bl = true;                
            }
        }
        if(found_bl == false)
        {this->ErrorMessage("Error!");}
        //Examine this path
        if(invest_link_pt->m_invest_link_dormant == true)
        {
            unfinished_invest_link_pt = invest_link_pt;
            jump_out_bl = true;
            continue;
        }
 
        if(invest_link_pt->m_path_status == 4)
        {
            jump_out_bl = true;
            KU_stuck_pt = (*KU_itr);
 
            if(invest_link_pt->m_condition_ID_pt != NULL)
            {
                invest_pt = (Investigator*)(invest_link_pt->m_condition_ID_pt);
                {
                    if(invest_pt->m_Happen == 4)
                    {
                        problem_permission_invest_pt = invest_pt;
                        jump_out_bl = true;
                    }
                }
            }                       
        }
        invest_pt = NULL;
        if(invest_link_pt->m_upperstream_ID_list.size() > 1)
        {this->ErrorMessage("This situation is beyond the current codes!");}
        else
        {
            invest_pt = (Investigator *)(*(invest_link_pt->m_upperstream_ID_list.begin()));
        }
        if(invest_pt->m_Happen == 4)
        {
            jump_out_bl = true;
            KU_stuck_pt = (*KU_itr);
            problem_invest_pt = invest_pt;
        }
    }
 
    //attach information to the _case_pt
    _case_pt->m_problem_invest_pt = problem_invest_pt;
    _case_pt->m_stuck_KU_pt = KU_stuck_pt;
    _case_pt->m_problem_permission_invest_pt = problem_permission_invest_pt;
 
    if(jump_out_bl == true)
    {       
        _case_pt->m_finished_bl = false;
    }
    else
    {
        
        _case_pt->m_consistant_bl = true;
        _case_pt->m_finished_bl = true;
        _case_pt->m_confirmed_time = r5pars_.timesno;
        this->m_last_case_end_time = r5pars_.timesno;
        //check point
                if(this->m_symptom_KE_pt->m_ID == "KE_air_ejector_radiation_>_10")
                {
                    this->ErrorMessage("check point");
                }
        this->MoveCaseFromCandidateTo(_case_pt, this->m_confirmed_case_list);
        _case_pt->m_path_confidence = _case_pt->m_invest_pt->m_independent_probability;
        _case_pt->m_invest_pt->m_independent_probability = 0;
        this->m_independent_symptom_probability = _case_pt->m_invest_pt->m_independent_probability;
    }
    
    if(problem_invest_pt != NULL)
    {
        
        _case_pt->m_consistant_bl = false;
        _case_pt->m_finished_bl = true;
        this->m_last_case_end_time = r5pars_.timesno;
        this->MoveCaseFromCandidateTo(_case_pt, this->m_inconsistant_case_list);
    }
 
    if(problem_permission_invest_pt != NULL)
    {
 
        _case_pt->m_consistant_bl = false;
        _case_pt->m_finished_bl = true;
        this->m_last_case_end_time = r5pars_.timesno;
        if(_case_pt->m_invest_pt->m_Happen == 4)
        {
            _case_pt->m_exception_time = r5pars_.timesno;
        }
        this->MoveCaseFromCandidateTo(_case_pt, this->m_exception_case_list);
    }
 
    if(unfinished_invest_pt != NULL && unfinished_invest_link_pt != NULL)
    {
        _case_pt->m_finished_bl = false;
    }
}
 
SymptomCase * SymptomInvestigator::FindASymptomCaseByInvestigator(Investigator *_invest_pt)
{
    for(auto &e : this->m_candidate_case_list)
    {
        if(e->m_invest_pt == _invest_pt)
        {
            return e.get();
        }
    }
    return NULL;
}
 
 
void SymptomInvestigator::SITrackTheOngoingInvestigation()
{
    SymptomCase * case_pt;
    std::size_t i = 0;
    //
    if (this->m_symptom_KE_pt->m_ID == "KE_SG_C_pres_decrease")
    {
        this->PrintMessage("check");
    }
    //
    this->m_ongoing_invest_link_list.clear();
    this->m_ongoing_invest_list.clear();
    i = 0;
    //check point
    if(r5pars_.timesno > 900)
    {
        i = 0;
    }
    //
    while(i < this->m_candidate_case_list.size())
    {
        case_pt = this->m_candidate_case_list[i].get();
        if(case_pt->m_finished_bl == false)
        {
            this->TrackOneInvestigationCase(case_pt);
            if(case_pt->m_unfinished_invest_pt != NULL)
            {
                this->m_ongoing_invest_list.push_back(case_pt->m_unfinished_invest_pt);
            }
 
            if(case_pt->m_unfinished_invest_link_pt != NULL)
            {
                this->m_ongoing_invest_link_list.push_back(case_pt->m_unfinished_invest_link_pt);
            }
        }
        else
        {
            this->ErrorMessage("Error!");
        }
        if(case_pt->m_finished_bl == false)
        {
            i++;
        }       
    }
}
 
void SymptomInvestigator::TrackOneInvestigationCase(SymptomCase *_case_pt)
{
    Investigator * invest_pt;
    Investigator * new_invest_pt;
    Investigator * root_invest_pt = NULL;
    Investigator * Happen_invest_pt = NULL;
    vector<KnowledgeUnit *>::reverse_iterator KU_ritr;
    DiagnoseInvestigator * DI_pt;
 
    Investigator * invest_buffer_pt;
    Investigator * unfinished_invest_pt = NULL;
    Investigator * problem_invest_pt = NULL;
    Investigator * problem_permission_invest_pt = NULL;
    KnowledgeUnit * KU_stuck_pt = NULL;
    KnowledgeElement * KE_buffer_pt;
    bool consistant_bl = true;
    bool finished_bl = true;
    bool jump_out_bl = false;
    bool discard_bl = false;
    bool found_bl = false;
    bool match_bl = false;
    int int_buffer;
    //vector<InvestigatorLink *>::iterator invest_link_itr;
    vector<IDElement *>::iterator link_ID_itr;
    vector<IDElement *>::iterator invest_ID_itr;
    vector<KnowledgeUnit *>::iterator KU_itr;
    InvestigatorLink * invest_link_pt;
    InvestigatorLink * unfinished_invest_link_pt = NULL;
 
    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
    {this->ErrorMessage("Error!");}//add error message 
 
    if(RM_pt->m_buffer_invest_pt == NULL)
    {match_bl = true;}
 
    invest_pt = _case_pt->m_invest_pt;
 
    if(invest_pt->m_KElement_ID_pt != NULL)
    {
        if(invest_pt->m_KElement_ID_pt->m_ID == "KE_PRZ_level_decrease" && r5pars_.timesno > 1900 && invest_pt->m_Happen ==4 )
        {
            this->PrintMessage("Check point!");
        }
    }
 
    if(invest_pt->m_ID == "Investigator_535")
    {this->PrintMessage("");}
 
    //add the codes for the investigation of the trend opposite to expectation
    if(_case_pt->m_invest_opposite_bl == true)
    {
        switch (invest_pt->m_Happen)
        {
        case 1:
            if(invest_pt->m_investigation_closed == true)
            {
                invest_pt->ReopenThisInvestigator();
            }
            _case_pt->m_unfinished_invest_pt = invest_pt;
            //continue;
            break;
        case 2:
            //discard, check whether it is available on the control panel
            _case_pt->m_finished_bl = true;
            _case_pt->m_rejection_time = r5pars_.timesno;
            this->m_last_case_end_time = r5pars_.timesno;
            this->MoveCaseFromCandidateTo(_case_pt, this->m_discarded_case_list);
            break;
        case 3:
            if(invest_pt->m_explained == 3 || invest_pt->m_explained == 2)
            {//it explained the opposite trend. move this investigator to the exception list
                _case_pt->m_finished_bl = true;
                _case_pt->m_exception_time = r5pars_.timesno;
                this->m_last_case_end_time = r5pars_.timesno;
                this->MoveCaseFromCandidateTo(_case_pt, this->m_exception_case_list);
            }
            else if(invest_pt->m_explained == 4)
            {
                _case_pt->m_finished_bl = true;
                _case_pt->m_rejection_time = r5pars_.timesno;
                this->m_last_case_end_time = r5pars_.timesno;
                this->MoveCaseFromCandidateTo(_case_pt, this->m_rejected_case_list);
                this->m_can_not_explain_opposite_bl = true;
            }
            else if(invest_pt->m_explained == 1)
            {
                if(invest_pt->m_investigation_closed == true)
                {
                    invest_pt->ReopenThisInvestigator();
                }
                _case_pt->m_unfinished_invest_pt = invest_pt;
            }
            break;
        case 4:
            //remove the need of investigating the opposite trend becasue it's no more there.
            _case_pt->m_finished_bl = true;
            _case_pt->m_rejection_time = r5pars_.timesno;
            this->m_last_case_end_time = r5pars_.timesno;
            this->MoveCaseFromCandidateTo(_case_pt, this->m_discarded_case_list);
            this->m_can_not_explain_opposite_bl = true;
            break;
        }
 
        return;
    }
    //
 
    for(KU_itr = this->m_event_symptom_pt->m_KU_list.begin(); KU_itr != this->m_event_symptom_pt->m_KU_list.end() && jump_out_bl == false; KU_itr++)
    {
        if(invest_pt == _case_pt->m_invest_pt)
        {
            if(invest_pt->m_Happen == 2)
            {
                jump_out_bl = true;
                discard_bl = true;
                break;
            }
        }
        if(invest_pt == RM_pt->m_buffer_invest_pt)
        {match_bl = true;}
 
        if(invest_pt->m_Happen == 4)
        {// Not happen
            problem_invest_pt = invest_pt;
            if(invest_pt->m_SI_ID_pt == NULL)
            {
                jump_out_bl = true;
                continue;
            }
        }       
        
        if((invest_pt->m_explained == 1 && invest_pt->m_investigator_token != 3014 && invest_pt->m_investigator_token < 3029) || invest_pt->m_Happen == 1)
        {//Have not investigated yet
            if(invest_pt->m_invest_pause == false)
            {//ongoing
                unfinished_invest_pt = invest_pt;
                jump_out_bl = true;
                continue;
            }
            else if(invest_pt->m_investigator_token == 3008)
            {//feedback to downstream
                unfinished_invest_pt = invest_pt;
                jump_out_bl = true;
                continue;
            }
            else
            {
                for(link_ID_itr = invest_pt->m_upperstream_ID_list.begin(); link_ID_itr != invest_pt->m_upperstream_ID_list.end(); link_ID_itr++)
                {//forced investigation situation
                    invest_link_pt = (InvestigatorLink*)(*link_ID_itr);
                    if(invest_link_pt->m_path_status == 1 && invest_link_pt->m_is_inference_path_bl == true)
                    {
                        invest_link_pt->m_invest_link_dormant = false;
                        invest_link_pt->m_SI_ID_pt = (IDElement*)this;
                        unfinished_invest_link_pt = invest_link_pt;
                        jump_out_bl = true;
                        break;
                    }
                }
            }
        }
 
        if(jump_out_bl == true)
        {break;}
                
        //find an InvestigatorLink that matches the path specified in the prototype
        found_bl = false;
        for(link_ID_itr = invest_pt->m_upperstream_ID_list.begin(); link_ID_itr != invest_pt->m_upperstream_ID_list.end() && found_bl == false; link_ID_itr++)
        {
            invest_link_pt = (InvestigatorLink*)(*link_ID_itr);
            if(invest_link_pt->m_K_unit_pt == (*KU_itr))
            {
                found_bl = true;
                break;
            }
        }
 
        if(found_bl == false)
        {this->ErrorMessage("Error!");}
        //link_ID_itr = invest_pt->m_upperstream_ID_list.begin();
        invest_link_pt = (InvestigatorLink*)(*link_ID_itr);
        //Examine this path
        if(invest_link_pt->m_path_status == 1 && invest_link_pt->m_invest_link_dormant == false)
        {
            int_buffer = invest_link_pt->m_invest_link_Token;
            invest_link_pt->CheckThePathStatus3102();
            if(invest_link_pt->m_invest_link_Token == 3101 && int_buffer == 3102)
            {invest_link_pt->m_invest_link_Token = int_buffer;}
        }
        if(invest_link_pt->m_invest_link_dormant == true || invest_link_pt->m_path_status == 1)
        {
            if(invest_link_pt->m_invest_link_dormant == true)
            {unfinished_invest_pt = invest_pt;}
            else
            {unfinished_invest_link_pt = invest_link_pt;}
            //unfinished_invest_pt = invest_pt;
            //think about this, need to modify, only activate this link when the DI is conscious to the operator 
            //unfinished_invest_link_pt->m_invest_link_dormant = false;
            jump_out_bl = true;
            break;//continue;
        }
 
        if(invest_link_pt->m_path_status == 4)
        {           
            KU_stuck_pt = (*KU_itr);
            //if(invest_link_pt->m_SI_ID_pt == NULL)
            //{
            //  jump_out_bl = true;
            //}
            if(invest_link_pt->m_condition_ID_pt != NULL)
            {
                invest_pt = (Investigator*)(invest_link_pt->m_condition_ID_pt);
                {
                    if(invest_pt->m_Happen == 4)
                    {
                        problem_permission_invest_pt = invest_pt;
                        if(invest_pt->m_SI_ID_pt == NULL)
                        {
                            jump_out_bl = true;
                        }
                    }
                }
            }                       
        }
        //the situation that m_path_status == 2 is not included here
        invest_pt = NULL;
        if(invest_link_pt->m_upperstream_ID_list.size() > 1)
        {
            if(this->m_label_ID_pt == NULL)
            {
                this->ErrorMessage("This situation is beyond the current codes!");
            }
            else
            {
                for(invest_ID_itr = invest_link_pt->m_upperstream_ID_list.begin(); invest_ID_itr != invest_link_pt->m_upperstream_ID_list.end() && invest_pt == NULL; invest_ID_itr++)
                {
                    invest_buffer_pt = (Investigator *)(*invest_ID_itr);
                    KE_buffer_pt = (KnowledgeElement *)(invest_buffer_pt->m_KElement_ID_pt);
                    if(KE_buffer_pt->m_SentenceUnit_pt->GetLabelOfThisSentence() == this->m_label_ID_pt)
                    {
                        invest_pt = invest_buffer_pt;
                    }                   
                }
                if(invest_pt == NULL)
                {
                    this->ErrorMessage("Error!");
                }
            }
        }
        else
        {
            invest_pt = (Investigator *)(*(invest_link_pt->m_upperstream_ID_list.begin()));
        }
        if(invest_pt->m_Happen == 4)
        {
            KU_stuck_pt = (*KU_itr);
            problem_invest_pt = invest_pt;
            if(invest_pt->m_SI_ID_pt == NULL)
            {
                jump_out_bl = true;
            }
        }
    }
    //unfinished Investigator and InvestigatorLink are marked
    //this mark will be used in function 3013 and 3101 for retrieving prob calculation
    //this is also used for 0030 prioritization process.
 
    //attach information to the _case_pt
    _case_pt->m_problem_invest_pt = problem_invest_pt;
    _case_pt->m_stuck_KU_pt = KU_stuck_pt;
    _case_pt->m_problem_permission_invest_pt = problem_permission_invest_pt;
    
    if(unfinished_invest_pt != NULL)
    {
        if(unfinished_invest_pt->m_investigation_closed == true )
        {
            //if(unfinished_invest_pt->m_SI_ID_pt == (IDElement *)this)
            if(unfinished_invest_pt->m_SI_ID_pt != NULL)
            {
                unfinished_invest_pt->ReopenThisInvestigator();
                _case_pt->m_unfinished_invest_pt = unfinished_invest_pt;
            }
            else
            {
                jump_out_bl = true;
                discard_bl = true;
            }
        }
        
    }
    else
    {_case_pt->m_unfinished_invest_pt = NULL;}
    _case_pt->m_unfinished_invest_link_pt = unfinished_invest_link_pt;
 
    if(jump_out_bl == true)
    {       
        if(discard_bl == true)
        {
            _case_pt->m_finished_bl = true;
            _case_pt->m_rejection_time = r5pars_.timesno;
            this->m_last_case_end_time = r5pars_.timesno;
            // Determine target list, then move from candidate in one operation
            vector<unique_ptr<SymptomCase>> *move_target = &this->m_discarded_case_list;
            if(_case_pt->m_invest_pt->m_Happen == 3 && unfinished_invest_pt != NULL)
            {
                if(unfinished_invest_pt->m_investigator_token > 3029 && ((DiagnoseInvestigator*)(this->m_DI_ID_pt))->m_confidence > 0.2)
                {
                    if(_case_pt->m_invest_pt->m_ID == "Investigator_3")
                    {_case_pt = _case_pt;}//check point
                    move_target = &this->m_voided_case_list;
                    if(_case_pt->m_invest_pt == NULL)
                        {
                            this->PrintMessage("");
                        }
                        else if(_case_pt->m_ID_invest == "Investigator_278" || _case_pt->m_invest_pt->m_ID == "Investigator_278")
                        {
                            this->PrintMessage("");
                        }
                }
            }
            this->MoveCaseFromCandidateTo(_case_pt, *move_target);
 
            //generate a new one??
            //create a new investigator
            if(this->m_rejected_case_list.size() == 0)
            {return;}
            {
            auto invest_owned = make_unique<Investigator>();
            new_invest_pt = invest_owned.get();
            new_invest_pt->m_note = "by event schema";
            new_invest_pt->m_motivation = 0;
            new_invest_pt->m_effective_start = r5pars_.timesno;
            new_invest_pt->m_effective_end = r5pars_.timesno + 60;
            new_invest_pt->m_KElement_ID_pt = this->m_symptom_KE_pt;
            new_invest_pt->m_invest_dormant = false;
            new_invest_pt->m_investigator_token = 3002;
            new_invest_pt->m_Happen = 1;
            new_invest_pt->m_interest_from_SymptomInvestigator = this->m_attention_level;
            new_invest_pt->m_operator = this->m_operator;
            new_invest_pt->m_SI_ID_pt = (IDElement *)this;
            new_invest_pt->m_root_of_a_thought_line = true;
            new_invest_pt->m_active_investigation = true;
            RM_pt->AddNewInvestigator(invest_owned.release());
            }
 
            return;
        }
 
        _case_pt->m_finished_bl = false;
        if(_case_pt->m_invest_pt->m_Happen == 4 && _case_pt->m_invest_pt->m_SI_ID_pt == NULL )
        {
            _case_pt->m_finished_bl = true;
            _case_pt->m_rejection_time = r5pars_.timesno;
            this->m_last_case_end_time = r5pars_.timesno;
            this->MoveCaseFromCandidateTo(_case_pt, this->m_rejected_case_list);
 
            if(_case_pt->m_invest_pt->m_Statement_pt != NULL && _case_pt->m_invest_pt->m_KElement_ID_pt != NULL)
            {
                if(_case_pt->m_invest_pt->m_KElement_ID_pt->m_ID == this->m_symptom_KE_pt->m_ID)
                {
                    if(_case_pt->m_invest_pt->m_Statement_pt->m_state != this->m_symptom_KE_pt->m_negation)
                    {
                        this->m_need_to_invest_opposite_bl = true;
                        this->m_opposite_KE_pt = RM_pt->FindAKEbySentenceAndNegationSign(problem_invest_pt->m_Statement_pt->m_sent_pt, false);
                        if(this->m_opposite_KE_pt == NULL)
                        {this->ErrorMessage("this->m_opposite_KE_pt == NULL");}
                        else
                        {this->m_opposite_KE_ID = this->m_opposite_KE_pt->m_ID;}
                    }
                }
            }
        }
        else if(problem_permission_invest_pt != NULL)
        {
            _case_pt->m_finished_bl = true;
            _case_pt->m_exception_time = r5pars_.timesno;
            this->m_last_case_end_time = r5pars_.timesno;
            if(_case_pt->m_invest_pt->m_Happen == 4)
            {
                _case_pt->m_exception_time = r5pars_.timesno;
            }
            this->MoveCaseFromCandidateTo(_case_pt, this->m_exception_case_list);
        }
    }
    else
    {
        if(problem_permission_invest_pt != NULL)
        {
            
            _case_pt->m_consistant_bl = false;
            _case_pt->m_finished_bl = true;
            this->m_last_case_end_time = r5pars_.timesno;
            if(_case_pt->m_invest_pt->m_Happen == 4)
            {
                _case_pt->m_exception_time = r5pars_.timesno;
                this->MoveCaseFromCandidateTo(_case_pt, this->m_exception_case_list);
            }
            else
            {
                this->MoveCaseFromCandidateTo(_case_pt, this->m_discarded_case_list);
            }
        }
        else if(problem_invest_pt != NULL)
        {
            _case_pt->m_consistant_bl = false;
            _case_pt->m_finished_bl = true;
            if(_case_pt->m_invest_pt->m_Happen == 4)
            {
                _case_pt->m_rejection_time = r5pars_.timesno;
                this->m_last_case_end_time = r5pars_.timesno;
                this->MoveCaseFromCandidateTo(_case_pt, this->m_rejected_case_list);
                if(_case_pt->m_invest_pt->m_SI_ID_pt != NULL)
                {
                    ((DiagnoseInvestigator*)(this->m_DI_ID_pt))->m_n_hard_setback++;
                    if(((DiagnoseInvestigator*)(this->m_DI_ID_pt))->m_n_hard_setback >= 1 )
                    {((DiagnoseInvestigator*)(this->m_DI_ID_pt))->m_terminate_investigation = true;}
                }
            }
            else
            {
                this->m_last_case_end_time = r5pars_.timesno;
                this->MoveCaseFromCandidateTo(_case_pt, this->m_inconsistant_case_list);
            }
 
            if(problem_invest_pt->m_Happen == 4 && problem_invest_pt->m_Statement_pt != NULL)
            {
                if(problem_invest_pt->m_Statement_pt->m_state == true)
                {
                    this->m_need_to_invest_opposite_bl = true;
                    this->m_opposite_KE_pt = RM_pt->FindAKEbySentenceAndNegationSign(problem_invest_pt->m_Statement_pt->m_sent_pt, false);
                    if(this->m_opposite_KE_pt == NULL)
                    {this->ErrorMessage("this->m_opposite_KE_pt == NULL");}
                    else
                    {this->m_opposite_KE_ID = this->m_opposite_KE_pt->m_ID;}
                }
            }
            
        }
        else if(invest_pt->m_independent_probability != 0)
        {
            if(match_bl == true)
            {
                if(invest_pt->m_probability_update_time - r5pars_.timesno < 0.0001 && invest_pt->m_probability_update_time - r5pars_.timesno > -0.0001)
                {
                    //aux information
                    rm_aux_info = "Confirming evidence: " + _case_pt->m_invest_pt->m_ID;
                    RM_pt->WriteAuxInfo(rm_aux_info);
                    //
 
                    RM_pt->m_buffer_used_bl = true;
                    _case_pt->m_path_confidence = invest_pt->m_independent_probability;
                    if(RM_pt->m_buffer_invest_pt == NULL)
                    {invest_pt->m_independent_probability = 0;}
                    _case_pt->m_consistant_bl = true;
                    _case_pt->m_finished_bl = true;
                    _case_pt->m_confirmed_time = r5pars_.timesno;
                    this->m_last_case_end_time = r5pars_.timesno;
                    this->MoveCaseFromCandidateTo(_case_pt, this->m_confirmed_case_list);
                    if(this->m_independent_symptom_probability < _case_pt->m_path_confidence)
                    {this->m_independent_symptom_probability = _case_pt->m_path_confidence;}    
                    
                    this->m_need_to_invest_opposite_bl = false;
                    this->m_opposite_KE_ID = "";
                    this->m_opposite_KE_pt = NULL;
                }
            }
        } 
        else
        {
            _case_pt->m_finished_bl = false;
            if(invest_pt->m_Happen == 1)
            {
                _case_pt->m_unfinished_invest_pt = invest_pt;
                return;
            }
            //the links between the symptom and the root cause have been iterated. Waiting for examing the alternative causes
            //start from the root cause invest
            root_invest_pt = invest_pt;
            //check whether it is the root invest
            if(root_invest_pt == NULL)
            {return;}
            DI_pt = (DiagnoseInvestigator*)(this->m_DI_ID_pt);
 
            if(root_invest_pt->m_KElement_ID_pt != DI_pt->m_event_KE_pt && root_invest_pt->m_KElement_ID_pt->m_ID != DI_pt->m_event_KE_pt->m_ID)
            {this->ErrorMessage("Check this place!"); return;}
            //Find the last Investigator which was confirmed Happened
 
            Happen_invest_pt = _case_pt->m_invest_pt;
            invest_pt = invest_pt = _case_pt->m_invest_pt;
            for(KU_itr = this->m_event_symptom_pt->m_KU_list.begin(); KU_itr != this->m_event_symptom_pt->m_KU_list.end(); KU_itr++)
            {
                if(invest_pt->m_Happen == 3)
                {Happen_invest_pt = invest_pt;}
                //find a link
                found_bl = false;
                for(link_ID_itr = invest_pt->m_upperstream_ID_list.begin(); link_ID_itr != invest_pt->m_upperstream_ID_list.end(); link_ID_itr++)
                {
                    invest_link_pt = (InvestigatorLink*)(*link_ID_itr);
                    if(invest_link_pt->m_K_unit_pt == *KU_itr)
                    {
                        found_bl = true;
                        break;
                    }
                }
                if(found_bl == false)
                {this->ErrorMessage("Check this situation!"); return;}
 
                if(invest_link_pt->m_upperstream_ID_list.size() > 1)
                {
                    if(this->m_label_ID_pt == NULL)
                    {this->ErrorMessage("This situation is beyond the current codes!"); return;}
                    else
                    {
                        invest_pt = NULL;
                        for(invest_ID_itr = invest_link_pt->m_upperstream_ID_list.begin(); invest_ID_itr != invest_link_pt->m_upperstream_ID_list.end() && invest_pt == NULL; invest_ID_itr++)
                        {
                            invest_buffer_pt = (Investigator *)(*invest_ID_itr);
                            KE_buffer_pt = (KnowledgeElement *)(invest_buffer_pt->m_KElement_ID_pt);
                            if(KE_buffer_pt->m_SentenceUnit_pt->GetLabelOfThisSentence() == this->m_label_ID_pt)
                            {invest_pt = invest_buffer_pt;}                 
                        }
                        if(invest_pt == NULL)
                        {this->ErrorMessage("Error!"); return;}
                    }
                }
                else
                {invest_pt = (Investigator *)(*(invest_link_pt->m_upperstream_ID_list.begin()));}
            }
    
            
            //iterate from the Happened invest, find an unfinished invest or unfinished invest_link
            if(Happen_invest_pt == NULL)
            {this->ErrorMessage("Check this situation!"); return;}
            jump_out_bl = false;
            invest_pt = Happen_invest_pt;
            while(unfinished_invest_pt == NULL  && unfinished_invest_link_pt == NULL && jump_out_bl == false)
            {
                //iteration start with invest_pt, chek the invest_pt first
                //invest_pt should not be dormant
                if(invest_pt->m_invest_pause == false && (invest_pt->m_Happen == 1 || invest_pt->m_Happen == 3))
                {unfinished_invest_pt = invest_pt; break;}
 
                //Go find an upperstream investigatorLink
                found_bl = false;
                for(link_ID_itr = invest_pt->m_upperstream_ID_list.begin(); link_ID_itr != invest_pt->m_upperstream_ID_list.end(); link_ID_itr++)
                {
                    invest_link_pt = (InvestigatorLink*)(*link_ID_itr);
                    if(invest_link_pt->m_invest_link_dormant == true)
                    {continue;}
                    if(invest_link_pt->m_path_status != 1)
                    {continue;}
                    if(invest_link_pt->m_invest_link_pause == false)
                    {unfinished_invest_link_pt = invest_link_pt; break;}
                    else
                    {found_bl = true; break;}
                }
                if(unfinished_invest_link_pt != NULL)
                {break;}
 
                if(found_bl == false)
                {this->ErrorMessage("Check this situation!"); return;}
 
                //Go find an upperstream investigator
                found_bl = false;
                
                if(invest_link_pt->m_condition_ID_pt != NULL)
                {
                    invest_pt = (Investigator*)(invest_link_pt->m_condition_ID_pt);
                    if(invest_pt->m_invest_dormant == false && invest_pt->m_Happen == 1)
                    {
                        if(invest_pt->m_invest_pause == false)
                        {unfinished_invest_pt = invest_pt;break;}
                        else
                        {found_bl = true; break;}
                    }
                }
                invest_ID_itr = invest_link_pt->m_upperstream_ID_list.begin();
                while(invest_ID_itr != invest_link_pt->m_upperstream_ID_list.end() && found_bl == false)                    
                {
                    invest_pt = (Investigator*)(*invest_ID_itr);
                    if(invest_pt->m_invest_dormant == true)
                    {invest_ID_itr ++;continue;}
                    if(invest_pt->m_Happen != 1)
                    {invest_ID_itr ++;continue;}
                    if(invest_pt->m_invest_pause == false)
                    {unfinished_invest_pt = invest_pt;break;}
                    else
                    {found_bl = true; break;}
                    invest_ID_itr ++;
                }
 
                if(unfinished_invest_pt != NULL)
                {break;}
                if(found_bl == false)
                {this->ErrorMessage("Check this situation!"); return;}
 
                if(invest_pt->m_invest_pause == false && (invest_pt->m_Happen == 1 || invest_pt->m_Happen == 3))
                {unfinished_invest_pt = invest_pt; break;}
            }
            _case_pt->m_unfinished_invest_pt = unfinished_invest_pt;
            _case_pt->m_unfinished_invest_link_pt = unfinished_invest_link_pt;
        }
    }
}
 
void SymptomInvestigator::RemoveADeterminedCaseFromCandiateList(SymptomCase *_case_pt)
{
 
    if(_case_pt->m_invest_pt->m_ID == "Investigator_322")
    {this->PrintMessage("");}
 
    for(auto it = this->m_candidate_case_list.begin(); it != this->m_candidate_case_list.end(); ++it)
    {
        if(it->get() == _case_pt)
        {
            this->m_candidate_case_list.erase(it);
            return;
        }
    }
}
 
void SymptomInvestigator::MoveCaseFromCandidateTo(SymptomCase *_case_pt, vector<unique_ptr<SymptomCase>> &_target)
{
    for(auto it = this->m_candidate_case_list.begin(); it != this->m_candidate_case_list.end(); ++it)
    {
        if(it->get() == _case_pt)
        {
            _target.push_back(std::move(*it));
            this->m_candidate_case_list.erase(it);
            return;
        }
    }
}
 
float SymptomInvestigator::GetTheLastRejectionTime()
{
    float rejection_time = 0;
    for(auto &e : this->m_rejected_case_list)
    {
        if(e->m_rejection_time > rejection_time)
        {
            rejection_time = e->m_rejection_time;
        }
    }
    return rejection_time;
}
 
KnowledgeUnit * SymptomInvestigator::CheckAKnowledgeUnitInTheList(KnowledgeUnit *_KU_pt)
{
    vector<KnowledgeUnit *>::iterator KU_itr;
    KnowledgeUnit * found_KU_pt = NULL;
 
    for(KU_itr = this->m_event_symptom_pt->m_KU_list.begin(); KU_itr != this->m_event_symptom_pt->m_KU_list.end() && found_KU_pt == NULL; KU_itr++)
    {
        if((*KU_itr) == _KU_pt)
        {
            found_KU_pt = (*KU_itr);
        }
    }
    return found_KU_pt;
}
 
float SymptomInvestigator::GetLastConfirmationTime()
{
    float confirm_time = 0;
    SymptomCase * case_pt = NULL;
    if(this->m_confirmed_case_list.size() == 0)
    {
        this->ErrorMessage("Error!");
    }
    case_pt = this->m_confirmed_case_list.rbegin()->get();
    confirm_time = case_pt->m_confirmed_time;
    return confirm_time;
}
 
void SymptomInvestigator::PrintMessage(string str)
{
    // << "\n";
    //cout << "Time: " << r5pars_.timesno << ":\n" << str << '\n';
    cout << ":\n" << str << '\n';
 
    //test
    ofstream fout("RMI.txt", ios::app);
    fout <<"\n" << "Time: " << r5pars_.timesno << ":\n" << str << '\n';
    fout.close();
}
 
 
void SymptomInvestigator::CopySymptomInvestigatorInfoFromAnother(SymptomInvestigator * _si_pt)
{
    this->CopyIDElementToRestartInfo((IDElement*)_si_pt);
/*
    int m_operator;
    float m_independent_symptom_probability;    
    float m_attention_level;
    float m_last_case_end_time;
*/
    this->m_operator = _si_pt->m_operator;
    this->m_independent_symptom_probability = _si_pt->m_independent_symptom_probability;
    this->m_attention_level = _si_pt->m_attention_level;
    this->m_last_case_end_time = _si_pt->m_last_case_end_time;
    this->m_need_to_invest_opposite_bl = _si_pt->m_need_to_invest_opposite_bl;
    this->m_can_not_explain_opposite_bl = _si_pt->m_can_not_explain_opposite_bl;
/*
    IDElement * m_label_ID_pt;
    EventSymptomUnit * m_event_symptom_pt;
    KnowledgeElement * m_symptom_KE_pt;
 
    string m_ID_lable;
    string m_ID_esu;
    string m_ID_KE;
*/
 
    if(_si_pt->m_opposite_KE_pt != NULL)
    {this->m_opposite_KE_ID = _si_pt->m_opposite_KE_pt->m_ID;}
    else
    {this->m_opposite_KE_ID = _si_pt->m_opposite_KE_ID;}
 
    if(_si_pt->m_DI_ID_pt != NULL)
    {this->m_ID_DI = _si_pt->m_DI_ID_pt->m_ID;}
    else
    {this->m_ID_DI = _si_pt->m_ID_DI;}
 
    if(_si_pt->m_label_ID_pt != NULL)
    {this->m_ID_lable = _si_pt->m_label_ID_pt->m_ID;}
    else
    {this->m_ID_lable = _si_pt->m_ID_lable;}
 
    if(_si_pt->m_event_symptom_pt != NULL)
    {this->m_ID_esu = _si_pt->m_event_symptom_pt->m_ID;}
    else
    {this->m_ID_esu = _si_pt->m_ID_esu;}
 
    if(_si_pt->m_symptom_KE_pt != NULL)
    {this->m_ID_KE = _si_pt->m_symptom_KE_pt->m_ID;}
    else
    {this->m_ID_KE = _si_pt->m_ID_KE;}
 
    if(this->m_ongoing_invest_list.size() != 0)
    {this->ErrorMessage("this->m_ongoing_invest_list.size() != 0");return;}
    if(this->m_ongoing_invest_link_list.size() != 0)
    {this->ErrorMessage("this->m_ongoing_invest_link_list.size() != 0");return;}
/*
    vector<Investigator *> m_ongoing_invest_list;
    vector<InvestigatorLink *> m_ongoing_invest_link_list;
 
    vector<string> m_ID_ongoing_invest_list;
    vector<string> m_ID_ongoing_invest_link_list;
*/
    vector<string>::iterator str_itr;
    string ID;
    vector<Investigator *>::iterator invest_itr;
    if(_si_pt->m_ongoing_invest_list.size() != 0)
    {
        for(invest_itr = _si_pt->m_ongoing_invest_list.begin(); invest_itr != _si_pt->m_ongoing_invest_list.end(); invest_itr++)
        {
            ID = (*invest_itr)->m_ID;
            this->m_ID_ongoing_invest_list.push_back(ID);
        }
    }
    else
    {
        for(str_itr = _si_pt->m_ID_ongoing_invest_list.begin(); str_itr != _si_pt->m_ID_ongoing_invest_list.end(); str_itr++)
        {
            ID = *str_itr;
            this->m_ID_ongoing_invest_list.push_back(ID);
        }
    }
 
    vector<InvestigatorLink *>::iterator link_itr;
    if(_si_pt->m_ongoing_invest_link_list.size() != 0)
    {
        for(link_itr = _si_pt->m_ongoing_invest_link_list.begin(); link_itr != _si_pt->m_ongoing_invest_link_list.end(); link_itr++)
        {
            ID = (*link_itr)->m_ID;
            this->m_ID_ongoing_invest_link_list.push_back(ID);
        }
    }
    else
    {
        for(str_itr = _si_pt->m_ID_ongoing_invest_link_list.begin(); str_itr != _si_pt->m_ID_ongoing_invest_link_list.end(); str_itr++)
        {
            ID = *str_itr;
            this->m_ID_ongoing_invest_link_list.push_back(ID);
        }
    }
/*
    vector<SymptomCase *> m_candidate_case_list; //contain all the symptom cases
    vector<SymptomCase *> m_confirmed_case_list; //there is a possible path from the event to the symptom
    vector<SymptomCase *> m_rejected_case_list; //the symptom doesn't happen at all
    vector<SymptomCase *> m_inconsistant_case_list;//the symptom happen, but path is blocked in the middel
    vector<SymptomCase *> m_exception_case_list;//One or more permission KE is not satisfied and block the path
    vector<SymptomCase *> m_partial_consistant_case_list;//The path is partially satisfied from the event, but not reached to the symptom
*/
    for(auto &e : _si_pt->m_discarded_case_list)
    {
        auto sc_pt = make_unique<SymptomCase>();
        sc_pt->CopySymptomCaseInfoFromAnother(e.get());
        this->m_discarded_case_list.push_back(std::move(sc_pt));
    }
 
    for(auto &e : _si_pt->m_voided_case_list)
    {
        auto sc_pt = make_unique<SymptomCase>();
        sc_pt->CopySymptomCaseInfoFromAnother(e.get());
        this->m_voided_case_list.push_back(std::move(sc_pt));
    }
 
    for(auto &e : _si_pt->m_candidate_case_list)
    {
        auto sc_pt = make_unique<SymptomCase>();
        sc_pt->CopySymptomCaseInfoFromAnother(e.get());
        this->m_candidate_case_list.push_back(std::move(sc_pt));
    }
    for(auto &e : _si_pt->m_confirmed_case_list)
    {
        auto sc_pt = make_unique<SymptomCase>();
        sc_pt->CopySymptomCaseInfoFromAnother(e.get());
        this->m_confirmed_case_list.push_back(std::move(sc_pt));
    }
    for(auto &e : _si_pt->m_rejected_case_list)
    {
        auto sc_pt = make_unique<SymptomCase>();
        sc_pt->CopySymptomCaseInfoFromAnother(e.get());
        this->m_rejected_case_list.push_back(std::move(sc_pt));
    }
    for(auto &e : _si_pt->m_inconsistant_case_list)
    {
        auto sc_pt = make_unique<SymptomCase>();
        sc_pt->CopySymptomCaseInfoFromAnother(e.get());
        this->m_inconsistant_case_list.push_back(std::move(sc_pt));
    }
    for(auto &e : _si_pt->m_exception_case_list)
    {
        auto sc_pt = make_unique<SymptomCase>();
        sc_pt->CopySymptomCaseInfoFromAnother(e.get());
        this->m_exception_case_list.push_back(std::move(sc_pt));
    }
    for(auto &e : _si_pt->m_partial_consistant_case_list)
    {
        auto sc_pt = make_unique<SymptomCase>();
        sc_pt->CopySymptomCaseInfoFromAnother(e.get());
        this->m_partial_consistant_case_list.push_back(std::move(sc_pt));
    }
 
}
 
void SymptomInvestigator::BuildConnectionsForThisSymptomInvestigator(void * _pt)
{
    ReasonMachine * RM_pt;
    RM_pt = (ReasonMachine *)_pt;
    //
    this->m_DI_ID_pt = RM_pt->m_event_schema_base->FindDiagnoseInvestigatorByID(this->m_ID_DI);
    if(this->m_DI_ID_pt == NULL)
    {this->ErrorMessage("this->m_label_ID_pt == NULL"); return;}
 
    //IDElement * m_label_ID_pt;
    if(this->m_ID_lable.compare("") != 0)
    {
        this->m_label_ID_pt = RM_pt->m_Concept_Base->FindConceptByID(this->m_ID_lable);
        if(this->m_label_ID_pt == NULL)
        {this->ErrorMessage("this->m_label_ID_pt == NULL"); return;}
    }
 
    //KnowledgeElement * m_symptom_KE_pt;
    if(this->m_ID_KE.compare("") != 0)
    {
        this->m_symptom_KE_pt = RM_pt->FindKnowledgeElementByID(this->m_ID_KE);
        if(this->m_symptom_KE_pt == NULL)
        {this->ErrorMessage("could not find the symptom KE" + this->m_ID_KE); return;}
    }
 
    if(this->m_opposite_KE_ID.compare("") != 0)
    {
        this->m_opposite_KE_pt = RM_pt->FindKnowledgeElementByID(this->m_opposite_KE_ID);
        if(this->m_opposite_KE_pt == NULL)
        {this->ErrorMessage("could not find the symptom KE" + this->m_opposite_KE_ID); return;}
    }
 
    //EventSymptomUnit * m_event_symptom_pt;
    if(this->m_ID_esu.compare("") != 0)
    {
        this->m_event_symptom_pt = RM_pt->m_event_schema_base->FindEventSymptomUnitByID(this->m_ID_esu);
        if(this->m_event_symptom_pt == NULL)
        {this->ErrorMessage("could not find this EventSymptomUnit" + this->m_ID_esu); return;}
    }
 
    Investigator * invest_pt;
    InvestigatorLink * link_pt;
    vector<string>::iterator str_itr;
    for(str_itr = this->m_ID_ongoing_invest_list.begin(); str_itr != this->m_ID_ongoing_invest_list.end(); str_itr++)
    {
        invest_pt = RM_pt->FindInvestigatorByID(*str_itr);
        if(invest_pt == NULL)
        {this->ErrorMessage("could not find this investigator " + *str_itr); return;}
        this->m_ongoing_invest_list.push_back(invest_pt);
    }
    this->m_ID_ongoing_invest_list.clear();
 
    for(str_itr = this->m_ID_ongoing_invest_link_list.begin(); str_itr != this->m_ID_ongoing_invest_link_list.end(); str_itr++)
    {
        link_pt = RM_pt->FindInvestigatorLinkByID(*str_itr);
        if(link_pt == NULL)
        {this->ErrorMessage("could not find this InvestigatorLink " + *str_itr); return;}
        this->m_ongoing_invest_link_list.push_back(link_pt);
    }
    this->m_ID_ongoing_invest_link_list.clear();
    
/*
    vector<SymptomCase *> m_candidate_case_list; //contain all the symptom cases
    vector<SymptomCase *> m_confirmed_case_list; //there is a possible path from the event to the symptom
    vector<SymptomCase *> m_rejected_case_list; //the symptom doesn't happen at all
    vector<SymptomCase *> m_inconsistant_case_list;//the symptom happen, but path is blocked in the middel
    vector<SymptomCase *> m_exception_case_list;//One or more permission KE is not satisfied and block the path
    vector<SymptomCase *> m_partial_consistant_case_list;//The path is partially satisfied from the event, but not reached to the symptom
 
*/
    for(auto &e : this->m_candidate_case_list)
    {e->BuildConnectionsForThisSymptomCase(_pt);}
 
    for(auto &e : this->m_confirmed_case_list)
    {e->BuildConnectionsForThisSymptomCase(_pt);}
 
    for(auto &e : this->m_rejected_case_list)
    {e->BuildConnectionsForThisSymptomCase(_pt);}
 
    for(auto &e : this->m_inconsistant_case_list)
    {e->BuildConnectionsForThisSymptomCase(_pt);}
 
    for(auto &e : this->m_exception_case_list)
    {e->BuildConnectionsForThisSymptomCase(_pt);}
 
    for(auto &e : this->m_partial_consistant_case_list)
    {e->BuildConnectionsForThisSymptomCase(_pt);}
 
    for(auto &e : this->m_discarded_case_list)
    {e->BuildConnectionsForThisSymptomCase(_pt);}
 
    for(auto &e : this->m_voided_case_list)
    {e->BuildConnectionsForThisSymptomCase(_pt);}
 
}
 
void SymptomInvestigator::BoostTheActivationOfOngoingInvestigation()
{
    vector<Investigator *>::iterator invest_itr;
    vector<InvestigatorLink *>::iterator link_itr;
 
    for(invest_itr = this->m_ongoing_invest_list.begin(); invest_itr != this->m_ongoing_invest_list.end(); invest_itr++)
    {
        (*invest_itr)->BoostActivationOfThisByActiveDiagnosisInvestigation();
    }
 
    for(link_itr = this->m_ongoing_invest_link_list.begin(); link_itr != this->m_ongoing_invest_link_list.end(); link_itr++)
    {
        (*link_itr)->BoostActivationOfThisLinkByActiveDiagnosisInvestigation();
    }
}