DiagnoseInvestigator.cpp

Go to the documentation of this file.

// DiagnoseInvestigator.cpp: implementation of the DiagnoseInvestigator class.
//
 
#include "DiagnoseInvestigator.h"
#include "Investigator.h"
#include "EventSchemaBase.h"
#include "ReasonMachine.h"
#include "../Crew/OperatorDM.h"
#include "../Crew/OperatorAT.h"
#include "../Branch/BranchProcedureStep.h"
#include "../Crew/DecisionProcedureStep.h"
#include "../Branch/BranchRecord.h"
#include "../Procedure/Procedures.h"
#include "../Global/fmodule.h"
#include <memory>
#include <vector>
#include "../Global/SimulationContext.h"
using namespace std;
 
 
// Construction/Destruction
 
DiagnoseInvestigator::DiagnoseInvestigator()
{
    this->m_ID_Type = 502;
    this->m_coverage_coefficient = 0.6;
    this->m_confidence_from_others = 0;
    this->m_event_schema_pt = NULL;
    this->m_ES_base_ID_pt = NULL;
    this->m_confidence = 0;
    this->m_tbi_SI = NULL;
    this->m_ongoing_SI = NULL;
    this->m_event_statement_pt = NULL;
    this->m_label_ID_pt = NULL;
    this->m_claim_bl = false; //whether the operator has claimed that this accident happened
    this->m_terminate_investigation = false;
    this->m_n_hard_setback = 0;
    this->m_procedure_entered_bl = 0; //whether the corresponding procedure has been enterred
    this->m_branching1_prob = 0.5;
    this->m_branching_2_1_prob = 0.1;
    this->m_branching_2_2_prob = 0.5;
    this->m_branching_3_1_prob = 0.4;
    this->m_branching_3_2_prob = 0.4;
    this->m_contain_transfer_point_to_associate_procedure_bl = false;
    this->m_wm_i = 0;
    this->m_wm_type = 0;
    this->m_wm_procedure_step_pt = NULL;
    this->m_procedure_step_pt = NULL;
    this->m_event_KE_pt = NULL;
    this->m_claim_time = 0;
    
    this->m_wm_procedure_name  = "NONE";
    this->m_wm_procedure_step_name = "NONE";
    this->m_procedure_name = "NONE";
    this->m_procedure_step_name = "NONE";
    this->m_ID_tbi_SI = "";
    this->m_ID_ongoing_SI = "";
    this->m_ID_label = "";
    this->m_ID_es = "";
    this->m_ID_KE = "";
    this->m_ID_statement = "";
}
 
DiagnoseInvestigator::~DiagnoseInvestigator()
{
    this->m_wm_i_list.clear();
    this->m_wm_type_list.clear();
    this->m_confidence_history.clear();
    this->m_confidence_timeline.clear();
 
    this->m_symptom_invest_list.clear();
}
 
void DiagnoseInvestigator::InitiationOfthisDiagnoseInvestigator(float _p, IDElement * _ID_pt)
{
    Investigator * invest_pt = (Investigator*)_ID_pt;
 
    //ES_base_pt = (EventSchemaBase *)(this->m_ES_base_ID_pt);
 
    ReasonMachine * RM_pt;
    if (this->m_operator == sim::Operator::ODM)
    {RM_pt = g_sim.Decision_Maker.m_RM.get();}
    else if (this->m_operator == sim::Operator::OAT)
    {RM_pt = g_sim.Action_Taker.m_RM.get();}
    else
    {}//add error message 
 
    //Error Check first
    if(this->m_event_schema_pt == NULL || this->m_event_statement_pt == NULL)
    {
        this->ErrorMessage("Error in DiagnoseInvestigator!");
        return;
    }
 
    if(this->m_event_statement_pt->m_state == false || this->m_event_schema_pt->m_event_KE_pt->m_negation == true)
    {
        this->ErrorMessage("Error in DiagnoseInvestigator!");
        return;
    }
    //
    this->m_procedure_step_pt = this->m_event_schema_pt->m_procedure_step_pt;
    this->m_diagnose_claim_threshold = this->m_event_schema_pt->m_diagnose_claim_threshold;
    if(this->m_procedure_step_pt != NULL)
    {
        this->m_procedure_name = this->m_procedure_step_pt->getCurrentProcedureName();
        this->m_procedure_step_name = this->m_procedure_step_pt->getCurrentStepName();
    }
 
    //record the instantiation label
    this->m_label_ID_pt = this->m_event_statement_pt->m_sent_pt->GetLabelOfThisSentence();
    
    //Assign the m_event_KE_pt
    if(this->m_event_statement_pt->m_sent_pt == this->m_event_schema_pt->m_event_KE_pt->m_SentenceUnit_pt)
    {
        this->m_event_KE_pt = this->m_event_schema_pt->m_event_KE_pt;
    }
    else
    {       
        if(this->m_label_ID_pt == NULL)
        {this->ErrorMessage("Error!");}
 
        //Find a KE for this DiagnoseInvestigator
        this->m_event_KE_pt = RM_pt->FindAKEbySentenceAndNegationSign(this->m_event_statement_pt->m_sent_pt, false);
        if(this->m_event_KE_pt == NULL)
        {this->ErrorMessage("Error!");}
    }
 
    stringstream conv;
    string str_ID;
    
    //Initiate the Symptoms
    for(auto &event_symp : this->m_event_schema_pt->m_symptom_list)
    {
        auto symp_invest_owned = make_unique<SymptomInvestigator>();
        auto symp_invest_pt = symp_invest_owned.get();
        this->m_symptom_invest_list.push_back(std::move(symp_invest_owned));
        conv.str("");
        conv << this->m_symptom_invest_list.size();
        str_ID = this->m_ID + "_SI_" + conv.str();
        symp_invest_pt->m_ID = str_ID;
        symp_invest_pt->m_DI_ID_pt  = (IDElement*)this;
        symp_invest_pt->m_event_symptom_pt = event_symp.get();
        symp_invest_pt->m_operator = this->m_operator;
        symp_invest_pt->m_label_ID_pt = this->m_label_ID_pt;
        symp_invest_pt->InitiationOfthisSymptomInvestigator();
    }
 
    this->CalculateTheConfidenceLeveloftheDiagnoseInvestigator();
    if(this->m_confidence_history.size() == 0)
    {
        this->m_confidence_from_others = _p;
        auto tvn_owned = make_unique<TimeValueNoteUnit>();
        tvn_owned->m_time = r5pars_.timesno;
        tvn_owned->m_value = invest_pt->m_independent_probability;
        tvn_owned->m_string = RM_pt->m_buffer_invest_pt->m_KElement_ID_pt->m_ID;
        tvn_owned->m_note = RM_pt->m_buffer_invest_pt->m_ID;
        this->m_other_evidence_list.push_back(std::move(tvn_owned));
        this->CalculateTheConfidenceLeveloftheDiagnoseInvestigator();
        /*
        this->m_confidence_history.push_back(_p);
        this->m_confidence_timeline.push_back(r5pars_.timesno);
        this->m_Integrated_prob_list.push_back(_p);
        this->m_coverage_list.push_back(0);
        this->m_N_setback_list.push_back(0);
        this->m_N_disabled_list.push_back(0);
        this->m_N_voided_list.push_back(0);
        this->m_symp_confidence_list.push_back("Diagnosis investigation initiated");
        */
    }
}
 
void DiagnoseInvestigator::ErrorMessage(string str)
{
    cout << r5pars_.timesno << "  " << str << '\n';
    ofstream fout("err messages.txt", ios::app);
    fout << r5pars_.timesno << "  " << str << '\n';
    fout.close();
    //r5pars_.terminateall = true;
}
 
void DiagnoseInvestigator::UpdateThisDiagnoseWithAnConfirmedInvestigator(Investigator *_invest_pt)
{
    //to be added
    SymptomCase * case_pt;
    bool jump_out_bl;
    int consistance_level;
    Investigator * invest_pt;
    InvestigatorLink * invest_link_pt;
    InvestigatorLink * found_invest_link_pt;
    vector<KnowledgeUnit *>::reverse_iterator KU_ritr;
    vector<IDElement *>::iterator ID_itr;
 
 
    for(auto &SI_up : this->m_symptom_invest_list)
    {
        consistance_level = 0;
        auto SI_pt = SI_up.get();
        invest_pt = _invest_pt;
        jump_out_bl = false;
        for(KU_ritr = SI_pt->m_event_symptom_pt->m_KU_list.rbegin(); KU_ritr != SI_pt->m_event_symptom_pt->m_KU_list.rend() && jump_out_bl == false; KU_ritr++)
        {
            //compare against each symptominvestigator          
            //KnowledgeUnit by KnowledgeUnit
            //The comparison is going forward, from upperstream to downstream
 
            //find a downstream that match
            found_invest_link_pt = NULL;
            for(ID_itr = invest_pt->m_downstream_ID_list.begin(); ID_itr != invest_pt->m_downstream_ID_list.end() && found_invest_link_pt == NULL; ID_itr++)
            {
                invest_link_pt = (InvestigatorLink*)(*ID_itr);
                if(invest_link_pt->m_K_unit_pt == (*KU_ritr))
                {
                    found_invest_link_pt = invest_link_pt;
                }
            }
            if(found_invest_link_pt == NULL)
            {
                jump_out_bl = true;
            }
            else
            {
                invest_pt = (Investigator *)(found_invest_link_pt->m_downstream_ID_pt);
                if(invest_pt->m_Happen != 4)
                {
                    consistance_level++;
                }
                else
                {break;}
            }           
        }
        //finish examining this SymptomInvestigator
        if(consistance_level > 0)
        {
            case_pt = SI_pt->FindASymptomCaseByInvestigator(invest_pt);
            if(case_pt == NULL)
            {
                //then create a case_pt
                case_pt = new SymptomCase();
                case_pt->m_finished_bl = false;
                case_pt->m_invest_pt = invest_pt;
            }
            //update the case_pt information
            if(consistance_level == SI_pt->m_event_symptom_pt->m_KU_list.size())
            {
                case_pt->m_consistant_bl = true;
                case_pt->m_finished_bl = true;
                case_pt->m_path_confidence = _invest_pt->m_independent_probability;
                _invest_pt->m_independent_probability = 0;
                case_pt->m_confirmed_time = r5pars_.timesno;
                SI_pt->RemoveADeterminedCaseFromCandiateList(case_pt);
                SI_pt->m_confirmed_case_list.push_back(unique_ptr<SymptomCase>(case_pt));
                SI_pt->m_last_case_end_time = r5pars_.timesno;
                if(case_pt->m_path_confidence > SI_pt->m_independent_symptom_probability)
                {
                    SI_pt->m_independent_symptom_probability = case_pt->m_path_confidence;
                }
                //check point
                if(SI_pt->m_symptom_KE_pt->m_ID == "KE_air_ejector_radiation_>_10")
                {
                    this->ErrorMessage("check point");
                }
            }
            else
            {
                case_pt->m_consistant_bl = false;
                case_pt->m_finished_bl = true;
                case_pt->m_path_confidence = _invest_pt->m_independent_probability * consistance_level / SI_pt->m_event_symptom_pt->m_KU_list.size();
                _invest_pt->m_independent_probability = 0;
                SI_pt->RemoveADeterminedCaseFromCandiateList(case_pt);
                SI_pt->m_partial_consistant_case_list.push_back(unique_ptr<SymptomCase>(case_pt));
 
            }
            if(case_pt->m_path_confidence > SI_pt->m_independent_symptom_probability)               
            {
                SI_pt->m_independent_symptom_probability = case_pt->m_path_confidence;
            }
        }
    }
 
    //To be added, add algorithm for calculating the confidence level of the DiagnoseInvestigator
    this->CalculateTheConfidenceLeveloftheDiagnoseInvestigator();
}
 
static int compare_floats(const void*a, const void*b)
{
    float* arg1 = (float*)a;
    float* arg2 = (float*)b;
    if(*arg1 < *arg2)
    {return 1;}
    else
    {return -1;}
}
 
void DiagnoseInvestigator::CalculateTheConfidenceLeveloftheDiagnoseInvestigator()
{//this function calculates the DI confidence level and the interest on this DI
    int N_consistant_symptom = 0;
    int N_disabled_symptom = 0;
    int N_setback_symptom = 0;
    int N_unexplored_symptom = 0;
    int N_voided_symptom = 0;
    float maximum_symp_confidence = 0;
    float coverage_fl;
    float Integrated_prob = 1;
    float modulator = 1;
    float other_confidence = 0;
    float new_confidence;
    stringstream conv;
//  vector<Investigator *>::iterator invest_itr;
//  vector<InvestigatorLink *>::iterator invest_link_itr;
//  vector<IDElement*>::iterator ID_itr;
//  Investigator * invest_pt;
//  InvestigatorLink * link_pt;
    int size, i;
    string str_v;
    size = this->m_symptom_invest_list.size();
    vector<float> ConfidenceArray(size);
    vector<float> OtherConfidenceArray(this->m_other_evidence_list.size());
    ReasonMachine * RM_pt;
    if (this->m_operator == sim::Operator::ODM)
    {RM_pt = g_sim.Decision_Maker.m_RM.get();}
    else if (this->m_operator == sim::Operator::OAT)
    {RM_pt = g_sim.Action_Taker.m_RM.get();}
    else
    {}//add error message 
    bool vagabond_reset = false;
 
    if(r5pars_.timesno > 1416)
    {this->ErrorMessage("");}
 
    i = 0;
    for(auto &tvn : this->m_other_evidence_list)
    {
        OtherConfidenceArray[i] = tvn->m_value;
        i++;
    }
    qsort(OtherConfidenceArray.data(), this->m_other_evidence_list.size(), sizeof(float), compare_floats);
 
    if(this->m_other_evidence_list.size() > 0)
    {
        other_confidence = OtherConfidenceArray[0];
        i = 1;
        while(i < this->m_other_evidence_list.size())
        {
            other_confidence = other_confidence + (1 - other_confidence) * OtherConfidenceArray[i] * RM_pt->m_ability_of_integrating_evidence;
            i++;
        }
    }
    this->m_confidence_from_others = other_confidence;
 
    i = 0;
    for(auto &SI : this->m_symptom_invest_list)
    {
        if(SI->m_confirmed_case_list.size() > 0)
        {
            N_consistant_symptom ++;
        }
        else if(SI->m_exception_case_list.size() > 0 )
        {
            N_disabled_symptom ++;
        }
        else if(SI->m_voided_case_list.size() > 0 )
        {
            N_voided_symptom ++;
        }
        else if(SI->m_rejected_case_list.size() > 0 )
        {
            N_setback_symptom ++;
        }
        else// SI->m_inconsistant_case_list is treated as irrelevant;
        {
            N_unexplored_symptom ++;
        }
 
        if(SI->m_independent_symptom_probability > maximum_symp_confidence)
        {
            maximum_symp_confidence = SI->m_independent_symptom_probability;
        }
        ConfidenceArray[i] = SI->m_independent_symptom_probability;
        i++;
    }
    qsort(ConfidenceArray.data(), size, sizeof(float), compare_floats);
    Integrated_prob = 1;
    if(size > 0)
    {Integrated_prob = ConfidenceArray[0];}
    if(size > 1)
    {
        for(i = 1; i < size; i++)
        {
            Integrated_prob = Integrated_prob + (1 - Integrated_prob)*ConfidenceArray[i]*RM_pt->m_ability_of_integrating_evidence;
        }
    }
 
    Integrated_prob = Integrated_prob + (1 - Integrated_prob)*this->m_confidence_from_others * min<float>(RM_pt->m_ability_of_integrating_evidence,0.5);//caution
        
    if(N_disabled_symptom == this->m_event_schema_pt->m_symptom_list.size())
    {
        this->ErrorMessage("Exception! All the symptoms are disabled!");
    }
    if(this->m_event_schema_pt->m_symptom_list.size() - N_disabled_symptom - N_voided_symptom == 0)
    {
        this->ErrorMessage("this->m_event_schema_pt->m_symptom_list.size() - N_disabled_symptom - N_voided_symptom == 0");
    }
    coverage_fl = (float)N_consistant_symptom/(float)(this->m_event_schema_pt->m_symptom_list.size() - N_disabled_symptom - N_voided_symptom);
 
 
    //calculate the confidence level of this DiagnoseInvestigator and the attention level
    new_confidence = Integrated_prob * pow((this->m_coverage_coefficient * coverage_fl + 1 - this->m_coverage_coefficient), 0.7);
    if(RM_pt->m_problem_solving_style == ProblemSolvingStyle::GardenPath)
    {
        new_confidence = pow(new_confidence, (1+0.3*N_setback_symptom));
    }
    else
    {
        new_confidence = pow(new_confidence, (1+N_setback_symptom));
    }
 
 
    if(this->m_confidence != new_confidence)
    {
        if(new_confidence > this->m_confidence && this->m_terminate_investigation == true)
        {this->m_terminate_investigation = false;}
        this->m_confidence = new_confidence;
        this->m_confidence_history.push_back(new_confidence);
        this->m_confidence_timeline.push_back(r5pars_.timesno);
        if(RM_pt->m_event_schema_base->m_timed_DI == this)
        {//clear this and let it to recalculate the timing of next investigation
            RM_pt->m_event_schema_base->m_timed_DI = NULL;
            RM_pt->m_event_schema_base->m_timing = 0;
        }
        else if(RM_pt->m_event_schema_base->m_timed_DI != NULL && RM_pt->m_event_schema_base->m_timed_DI->m_confidence < this->m_confidence)
        {
            RM_pt->m_event_schema_base->m_timed_DI = NULL;
            RM_pt->m_event_schema_base->m_timing = 0;
        }
/*  
    vector<float> m_Integrated_prob_list;
    vector<float> m_coverage_list;
    vector<int> m_N_setback_list;
    vector<int> m_N_disabled_list;
    vector<string> m_symp_confidence_list;
*/
        this->m_Integrated_prob_list.push_back(Integrated_prob);
        this->m_coverage_list.push_back(coverage_fl);
        this->m_N_setback_list.push_back(N_setback_symptom);
        this->m_N_disabled_list.push_back(N_disabled_symptom);
        this->m_N_voided_list.push_back(N_voided_symptom);
        str_v = "";
        for(auto &SI : this->m_symptom_invest_list)
        {
            conv.str("");
            conv << SI->m_independent_symptom_probability;
            str_v += conv.str();
            str_v += "  ";
        }
        conv.str("");
        conv << this->m_confidence_from_others;
        str_v += conv.str();
        this->m_symp_confidence_list.push_back(str_v);
    }
    this->m_attention_level = this->m_confidence * (N_unexplored_symptom + 0.3 * N_setback_symptom + 0.05* N_consistant_symptom)/this->m_event_schema_pt->m_symptom_list.size();
    //need to remove these codes
    if(this->m_attention_level < 0.15)
    {this->m_attention_level = 0.15;}
    //
    //calculate the attention level of each SymptomInvestigator and propagate it to the Corresponding Investigator or InvestigatorLink
    for(auto &SI : this->m_symptom_invest_list)
    {
        //
        if(RM_pt->m_problem_solving_style == ProblemSolvingStyle::Vagabond && this->m_ongoing_SI == SI.get())
        {vagabond_reset = true;}
 
        if(SI->m_confirmed_case_list.size() > 0)
        {
            modulator = 0.1;
            modulator *= 1 - SI->m_independent_symptom_probability;
        }
        else if(SI->m_exception_case_list.size() > 0)
        {modulator = 0.5;}
        else if(SI->m_rejected_case_list.size() > 0)
        {modulator = 0.2;}
        else
        {modulator = 1.0;}
        SI->m_attention_level = this->m_attention_level * modulator*5;
        for(auto &sc : SI->m_candidate_case_list)
        {
            sc->m_invest_pt->BoostAttentionofThisByDiagnosisInvestigation(SI->m_attention_level, vagabond_reset);
        }
        /*
        for(invest_itr = (*SI_itr)->m_ongoing_invest_list.begin(); invest_itr != (*SI_itr)->m_ongoing_invest_list.end(); invest_itr++)
        {
            (*invest_itr)->m_interest_from_SymptomInvestigator = (*SI_itr)->m_attention_level;
            //
            if(vagabond_reset == true)
            {(*invest_itr)->m_last_active_time = r5pars_.timesno;}
 
            if((*invest_itr)->m_invest_pause == true)
            {
                for(ID_itr = (*invest_itr)->m_upperstream_ID_list.begin(); ID_itr != (*invest_itr)->m_upperstream_ID_list.end(); ID_itr++)
                {
                    link_pt = (InvestigatorLink *)(*ID_itr);
                    if(link_pt->m_invest_link_dormant == false)
                    {
                        link_pt->m_interest_from_SymptomInvestigator = (*SI_itr)->m_attention_level;
                    }
                }
            }
        }
        for(invest_link_itr = (*SI_itr)->m_ongoing_invest_link_list.begin(); invest_link_itr != (*SI_itr)->m_ongoing_invest_link_list.end(); invest_link_itr++)
        {
            (*invest_link_itr)->m_interest_from_SymptomInvestigator = (*SI_itr)->m_attention_level;
            
            //
            if(vagabond_reset == true)
            {
                invest_pt = (Investigator*)(*invest_link_itr)->m_downstream_ID_pt;
                invest_pt->m_last_active_time = r5pars_.timesno;
            }
            //if((*invest_link_itr)->m_invest_link_pause == true)
            //{
                for(ID_itr = (*invest_link_itr)->m_upperstream_ID_list.begin(); ID_itr != (*invest_link_itr)->m_upperstream_ID_list.end(); ID_itr++)
                {
                    invest_pt = (Investigator*)(*ID_itr);
                    //if(invest_pt->m_invest_dormant == false)
                    invest_pt->m_interest_from_SymptomInvestigator = (*SI_itr)->m_attention_level;
                    //
                    if(vagabond_reset == true)
                    {invest_pt->m_last_active_time = r5pars_.timesno;}
                }
            //}
        }
        */
    }
    
    if(this->m_confidence > this->m_diagnose_claim_threshold && this->m_claim_bl == 0)
    {
        if(this->m_operator == sim::Operator::ODM)
        {
            if(g_sim.Branch_center.num_of_ODM_branch > 0)
            {return;}
        }
        else if(this->m_operator == sim::Operator::OAT)
        {
            if(g_sim.Branch_center.num_of_OAT_branch > 0)
            {return;}
        }
        this->TriggerBranchingWhenClaimADiagnose();
    }
}
 
void DiagnoseInvestigator::DITrackTheOngoingInvestigation()
{
    for(auto &SI : this->m_symptom_invest_list)
    {
        SI->SITrackTheOngoingInvestigation();
    }
    this->CalculateTheConfidenceLeveloftheDiagnoseInvestigator();
}
 
void DiagnoseInvestigator::UpdateTheInterestLevelOfDI()
{
 
}
 
void DiagnoseInvestigator::SearchForTheToBeInvestigatedSI()
{
    SymptomInvestigator *found_unexplored_SI = NULL;
    SymptomInvestigator *found_rejected_SI = NULL;
    SymptomInvestigator *found_explored_SI = NULL;
    vector<KnowledgeUnit *>::iterator KU_itr;
    float rejection_time = 0;
    float confirmed_time = 0;
    float retrieve_score, retrieve_score2;
    this->m_ongoing_SI = NULL;
    bool exist_bl;
    //check point
    if(r5pars_.timesno > 2644)
    {
        this->ErrorMessage("Check point!");
    }
    if(this->m_terminate_investigation == true)
    {this->m_tbi_SI = NULL; return;}
    for(auto &SI : this->m_symptom_invest_list)
    {
        if(this->m_ongoing_SI != NULL) break;
        exist_bl = false;
        if(SI->m_candidate_case_list.size() > 0)
        {
            if(SI->m_confirmed_case_list.size() == 0 || SI->m_independent_symptom_probability < ((EventSchemaBase *)(this->m_ES_base_ID_pt))->m_active_investigation_threshold)//using the threshold
            {
                for(auto &sc : SI->m_candidate_case_list)
                {
                    if(SI->m_need_to_invest_opposite_bl == true)
                    {
                        if(sc->m_invest_pt->m_KElement_ID_pt == (IDElement *)(SI->m_opposite_KE_pt))
                        {exist_bl = true;}
                    }
                    else if(sc->m_invest_pt->m_KElement_ID_pt == (IDElement *)(SI->m_symptom_KE_pt))
                    {exist_bl = true;}
                }
 
                if(SI->m_voided_case_list.size() > 0 || SI->m_exception_case_list.size() > 0)
                {exist_bl = false;}
 
                if(exist_bl == true)
                {this->m_ongoing_SI = SI.get();return;}
            }
        }
 
        if(SI->m_confirmed_case_list.size() == 0)
        {
            if(SI->m_rejected_case_list.size() > 0 && SI->m_exception_case_list.size() == 0)
            {
                if(found_rejected_SI == NULL)
                {
                    found_rejected_SI = SI.get();
                    rejection_time = SI->m_last_case_end_time;
                }
                else if(rejection_time > SI->m_last_case_end_time)
                {
                    found_rejected_SI = SI.get();
                    rejection_time = SI->m_last_case_end_time;
                }
            }
            else if(SI->m_voided_case_list.size() > 0)
            {}
            else if(SI->m_exception_case_list.size() == 0)
            {
                retrieve_score2 = 1;
                KU_itr = SI->m_event_symptom_pt->m_KU_list.begin();
                while(KU_itr != SI->m_event_symptom_pt->m_KU_list.end())
                {
                    retrieve_score2 *= (*KU_itr)->m_forward_retrieve_weight;
                    KU_itr++;
                }
                if(found_unexplored_SI == NULL)
                {//investigate the unexplored SI from the first to last
                    found_unexplored_SI = SI.get();
                    retrieve_score = retrieve_score2;
                }
                else
                {
                    if(retrieve_score2 > retrieve_score)
                    {
                        found_unexplored_SI = SI.get();
                        retrieve_score = retrieve_score2;
                    }
                }
            }
        }
        else if(SI->m_voided_case_list.size() > 0)//take this option out if there is a voided symptom found
        {}
        else if(SI->m_independent_symptom_probability < 0.09)
        {
            if(found_explored_SI == NULL)
            {
                found_explored_SI = SI.get();
                confirmed_time = SI->m_last_case_end_time;
            }
            else if(confirmed_time > SI->m_last_case_end_time)
            {
                found_explored_SI = SI.get();
                confirmed_time = SI->m_last_case_end_time;
            }
        }
    }
    //
    //unexplored SI is prioritized over rejected SI over confirmed SI
    if(this->m_ongoing_SI == NULL)
    {
        if(found_unexplored_SI != NULL)
        {
            this->m_tbi_SI = found_unexplored_SI;
        }
        else 
        {
            if(found_rejected_SI)
            {
                this->m_tbi_SI = found_rejected_SI;
            }
            else if(found_explored_SI == NULL)
            {
                this->m_tbi_SI = found_explored_SI;
            }
 
            /*if(found_rejected_SI != NULL && found_explored_SI != NULL)
            {
                if(rejection_time < confirmed_time )
                {this->m_tbi_SI = found_rejected_SI;}
                else
                {this->m_tbi_SI = found_explored_SI;}
            }*/
        }
    }
    //check point
    if(this->m_tbi_SI != NULL)
    {
        if(this->m_tbi_SI->m_symptom_KE_pt->m_ID == "KE_SG_A_level_increase")
        {
            this->ErrorMessage("check point");
        }
    }
}
 
 
 
void DiagnoseInvestigator::TriggerBranchingWhenClaimADiagnose()
{
    this->m_claim_bl = 1;
    this->m_claim_time = r5pars_.timesno;
    ProcedureBranchingInfo * branch_info;
 
    BranchProcedureStep * b_procedure_step_pt;
    string current_procedure_name, current_step_name;
 
    if(this->m_procedure_step_pt == NULL)
    {return;}
 
    if(this->m_operator == sim::Operator::ODM)
    {
        current_procedure_name = g_sim.Decision_Maker.memory.perceived_info.getCurrentProcedureName();
        current_step_name = g_sim.Decision_Maker.memory.perceived_info.getCurrentProceduralStepName();
    }
    else if(this->m_operator == sim::Operator::OAT)
    {
        current_procedure_name = g_sim.Action_Taker.memory.perceived_info.getCurrentProcedureName();
        current_step_name = g_sim.Action_Taker.memory.perceived_info.getCurrentProceduralStepName();
    }
    else
    {
        this->ErrorMessage("Unrecognized Operator!");
    }
 
    if(this->m_procedure_entered_bl == true)
    {return;}
 
    //add the second branch-the operator decides to stay in the current procedure
    {
    auto bps_owned = make_unique<BranchProcedureStep>();
    b_procedure_step_pt = bps_owned.get();
    b_procedure_step_pt->setSenderAndReceiver(this->m_operator, this->m_operator);
    b_procedure_step_pt->setTimerAndProbability(1.0, 1 - this->m_branching1_prob);
    b_procedure_step_pt->setProcedureName(current_procedure_name);
    b_procedure_step_pt->setStepName(current_step_name);
    b_procedure_step_pt->setLastProcedureName(current_procedure_name);
    b_procedure_step_pt->setLastStepName(current_step_name);
    b_procedure_step_pt->setStateOfActivation(sim::Source::Bypass);
    b_procedure_step_pt->setTypeOfPauseActivity(sim::Strategy::FollowProcedure);
    g_sim.Branch_center.addProcedureStep(this->m_operator, bps_owned.release());
    //
    auto bi_owned = make_unique<ProcedureBranchingInfo>();
    branch_info = bi_owned.get();
    branch_info->s_current_procedure_name = current_procedure_name;
    branch_info->s_current_step_name = current_step_name;
    branch_info->s_procedure_name = b_procedure_step_pt->getProcedureName();
    branch_info->s_step_name = b_procedure_step_pt->getStepName();
    branch_info->s_branching_type = 1;
    branch_info->s_branching_choice = 1; //choice 2
    branch_info->s_branching_time = r5pars_.timesno;
    this->m_branching_info_list.push_back(std::move(bi_owned));
    }
 
    //add one branch--the operator transfer to the associated procedure step immediately after s/he claims an accident
    {
    auto bps_owned = make_unique<BranchProcedureStep>();
    b_procedure_step_pt = bps_owned.get();
    b_procedure_step_pt->setSenderAndReceiver(this->m_operator, this->m_operator);
    b_procedure_step_pt->setTimerAndProbability(1.0, this->m_branching1_prob);
    b_procedure_step_pt->setProcedureName(this->m_procedure_step_pt->getCurrentProcedureName());
    b_procedure_step_pt->setStepName(this->m_procedure_step_pt->getCurrentStepName());
    b_procedure_step_pt->setLastProcedureName(current_procedure_name);
    b_procedure_step_pt->setLastStepName(current_step_name);
    b_procedure_step_pt->setTypeOfPauseActivity(sim::Strategy::FollowProcedure);
    g_sim.Branch_center.addProcedureStep(this->m_operator, bps_owned.release());
    //
    auto bi_owned = make_unique<ProcedureBranchingInfo>();
    branch_info = bi_owned.get();
    branch_info->s_current_procedure_name = current_procedure_name;
    branch_info->s_current_step_name = current_step_name;
    branch_info->s_procedure_name = b_procedure_step_pt->getProcedureName();
    branch_info->s_step_name = b_procedure_step_pt->getStepName();
    branch_info->s_branching_type = 1;
    branch_info->s_branching_choice = 2; //choice 2
    branch_info->s_branching_time = r5pars_.timesno;
    this->m_branching_info_list.push_back(std::move(bi_owned));
    }
 
}
 
void DiagnoseInvestigator::ReadCurrentProcedureStepInformation()
{
    DecisionProcedureStep * current_procedure_step_pt;
    ProcedureStepUnit * step_unit_pt;
    map<string, ProcedureStep *>::iterator procedure_map_itr;
    vector<unique_ptr<ProcedureStepUnit>>::iterator step_unit_itr;
    ProcedureStepInfo * step_info_pt;
    int i;
 
    if(this->m_procedure_name == "" || this->m_procedure_step_name == "")
    {
        if(this->m_procedure_step_pt == NULL)
        {
            return; // this event is not linked with a procedure at all
        }
        else
        {
            this->m_procedure_name = this->m_procedure_step_pt->getCurrentProcedureName();
            this->m_procedure_step_name = this->m_procedure_step_pt->getCurrentStepName();
        }
    }
 
    this->ClearTheInfomationAboutTheCurrentProcedureStep();
 
    if(this->m_operator == sim::Operator::ODM)
    {
        current_procedure_step_pt = g_sim.Decision_Maker.memory.perceived_info.getCurrentProcedureStepPtr(this->m_operator);
    }
    else
    {
        current_procedure_step_pt = g_sim.Action_Taker.memory.perceived_info.getCurrentProcedureStepPtr(this->m_operator);
    }   
 
    //find the currently working on procedure step
    if(current_procedure_step_pt == 0)
    {
        return; // The operators have not entered a procedure yet.
    }
 
    if(current_procedure_step_pt->getProcedureName().compare(this->m_procedure_step_pt->getCurrentProcedureName()) == 0)
    {
        this->m_procedure_entered_bl = true;
        return;
    }
 
    procedure_map_itr = g_sim.All_procedure.procedure_map.find(current_procedure_step_pt->getProcedureName() + current_procedure_step_pt->getStepName());
    if(procedure_map_itr != g_sim.All_procedure.procedure_map.end())
    {                   
        this->m_wm_procedure_step_pt = procedure_map_itr->second;
    }               
    else                
    {                   
        this->ErrorMessage("Could not find this procedure step: " + current_procedure_step_pt->getProcedureName() + current_procedure_step_pt->getStepName());              
        return;
    }
    
    //firstly check whether this is a transfer point to the associated procedure
    i = 0;
    for(step_unit_itr = this->m_wm_procedure_step_pt->procedure_step_unit.begin(); step_unit_itr != this->m_wm_procedure_step_pt->procedure_step_unit.end(); step_unit_itr++)
    {
        step_unit_pt = step_unit_itr->get();
        if(step_unit_pt->getTypeOfNonResponseAction() == sim::Branch::Procedure)
        {
            step_info_pt = step_unit_pt->non_response_procedure.get();
            if(step_info_pt->getProcedureName().compare(this->m_procedure_name) == 0)//whether add the step name in the comparison?
            {
                this->m_wm_i_list.push_back(i);
                this->m_wm_type_list.push_back(1); //1--non response procedure transfer
            }
        }
        i++;
    }
    if(this->m_wm_procedure_step_pt->getNextProcedureName().compare(this->m_procedure_name) == 0)
    {
        this->m_wm_i_list.push_back(i); // i beyonds the list size, that means it is the next procedure step
        this->m_wm_type_list.push_back(0); //procedure transfer at the end of a procedure step
    }
}
 
void DiagnoseInvestigator::ClearTheInfomationAboutTheCurrentProcedureStep()
{
    this->m_wm_i_list.clear();
    this->m_wm_type_list.clear();
    this->m_wm_procedure_step_pt = NULL;
}
 
void DiagnoseInvestigator::CheckforPotentialProcedureBranching()
{
    string current_procedure_name, current_step_name;
    string name1, name2;
    int current_i;
    vector<int>::iterator i_itr;
    vector<int>::iterator i_type_itr;
    vector<unique_ptr<ProcedureStepUnit>>::iterator ps_unit_itr;
    ProcedureStepUnit *ps_unit_pt = 0;
    bool found_bl = false;
    bool bps_existing = false;
    int state_of_activation;
    //b_procedure_step_itr: declared as auto at point of use below
    BranchProcedureStep * b_procedure_step_pt;
    ProcedureBranchingInfo * branch_info;
    int prior_choice = 0;
 
    if (r5pars_.timesno > 1404)
    {prior_choice = 0;}
 
 
    if(this->m_operator != sim::Operator::ODM)
    {return;}
 
    if(this->m_procedure_entered_bl == true || this->m_procedure_step_pt == NULL)
    {return;}
 
    if(this->m_wm_procedure_step_pt == NULL)
    {
        this->ReadCurrentProcedureStepInformation();
    }
    else
    {
        current_procedure_name = g_sim.Decision_Maker.memory.perceived_info.getCurrentProcedureName();
        current_step_name = g_sim.Decision_Maker.memory.perceived_info.getCurrentProceduralStepName();
        if(current_procedure_name.compare(this->m_wm_procedure_step_pt->getCurrentProcedureName()) != 0 
            || current_step_name.compare(this->m_wm_procedure_step_pt->getCurrentStepName()) != 0)
        {
            this->ReadCurrentProcedureStepInformation();
        }
    }
    if(this->m_wm_procedure_step_pt != NULL)
    {
        current_procedure_name = g_sim.Decision_Maker.memory.perceived_info.getCurrentProcedureName();
        current_step_name = g_sim.Decision_Maker.memory.perceived_info.getCurrentProceduralStepName();
    }
    else
    {return;}
 
    if(this->m_confidence < 0.2 )
    {return;}
 
    this->m_branching_2_1_prob = this->m_confidence;
    this->m_branching_2_2_prob = this->m_confidence;
    this->m_branching_3_1_prob = this->m_confidence;
    this->m_branching_3_2_prob = (1- this->m_confidence)/2;
    //Type 1 branchign: When an accident is claimed, whether or not transfer to the desired procedure immediately
    //
    //Type 2 branching: the current procedure step contains a transfer to the desired procedure
    //                  but the transfer conditions are not satisfied
    //Type 3 branching: the current procedure step transfers to a third procedure
    
    //Find the progress with the current procedure step
    ps_unit_itr = this->m_wm_procedure_step_pt->procedure_step_unit.begin();
    current_i = 0;
    while(ps_unit_itr != this->m_wm_procedure_step_pt->procedure_step_unit.end() && !found_bl)
    {
        state_of_activation = (*ps_unit_itr)->getStateOfActivation();
        if(state_of_activation == sim::None || state_of_activation == sim::State::Active){
            found_bl = true;
            continue;           
        }
        ps_unit_itr++;
        current_i++;
    }
    //if(found_bl == false && current_i > 0)
    //{return;}
    //start to compare the progress with the potential branching points.
    if(this->m_wm_i_list.size() > 0)
    {
        if(current_i <= this->m_wm_i_list[0])
        {
            //check branching type 21, in the current procedure step, it transits before reaching to the key step
            //intercept the procedurestep branches in the Branch_Record
            if(g_sim.Branch_center.ODM_branch.procedure_step.size() > 0)
            {//Match the type 21 branching condition
                prior_choice = this->FindARecentSimilarBranching(21, current_procedure_name, current_step_name);
 
                if(g_sim.Branch_center.ODM_branch.procedure_step.size() == 1)
                {
                    //branch 1: follow the procedure
                    b_procedure_step_pt = g_sim.Branch_center.ODM_branch.procedure_step.begin()->get();
                    if(prior_choice == 0)
                    {b_procedure_step_pt->setTimerAndProbability(1.0, 1 - this->m_branching_2_1_prob);}
                    else if(prior_choice == 1)
                    {b_procedure_step_pt->setTimerAndProbability(1.0, 1);}
                    else if(prior_choice == 2)
                    {
                        g_sim.Branch_center.ODM_branch.procedure_step.clear();
                        if(g_sim.Branch_center.num_of_ODM_branch >0 )
                        {g_sim.Branch_center.num_of_ODM_branch--;}
                    }
 
                    //ProcedureBranchingInfo * branch_info;
                    if(prior_choice != 2)
                    {
                        auto bi_owned = make_unique<ProcedureBranchingInfo>();
                        branch_info = bi_owned.get();
                        branch_info->s_current_procedure_name = current_procedure_name;
                        branch_info->s_current_step_name = current_step_name;
                        branch_info->s_procedure_name = b_procedure_step_pt->getProcedureName();
                        branch_info->s_step_name = b_procedure_step_pt->getStepName();
                        branch_info->s_branching_type = 21;
                        branch_info->s_branching_choice = 1; // choice 1
                        branch_info->s_branching_time = r5pars_.timesno;
                        this->m_branching_info_list.push_back(std::move(bi_owned));
                    }
                    //branch 2: transit to the desired procedure
                    {
                    auto bps_owned = make_unique<BranchProcedureStep>();
                    b_procedure_step_pt = bps_owned.get();
                    b_procedure_step_pt->setSenderAndReceiver(this->m_operator, this->m_operator);
                    b_procedure_step_pt->setProcedureName(this->m_procedure_step_pt->getCurrentProcedureName());
                    b_procedure_step_pt->setStepName(this->m_procedure_step_pt->getCurrentStepName());
                    b_procedure_step_pt->setLastProcedureName(current_procedure_name);
                    b_procedure_step_pt->setLastStepName(current_step_name);
                    b_procedure_step_pt->setTypeOfPauseActivity(sim::Strategy::FollowProcedure);
                    if(prior_choice == 0)
                    {b_procedure_step_pt->setTimerAndProbability(1.0, this->m_branching_2_1_prob);}
                    else if(prior_choice == 2)
                    {b_procedure_step_pt->setTimerAndProbability(1.0, this->m_branching_2_1_prob);}
 
                    if(prior_choice != 1)
                    {g_sim.Branch_center.addProcedureStep(this->m_operator, bps_owned.release());}
                    // else: bps_owned auto-deletes at scope end
                    }
 
                    //ProcedureBranchingInfo * branch_info;
                    if(prior_choice != 1)
                    {
                        auto bi_owned = make_unique<ProcedureBranchingInfo>();
                        branch_info = bi_owned.get();
                        branch_info->s_current_procedure_name = current_procedure_name;
                        branch_info->s_current_step_name = current_step_name;
                        branch_info->s_procedure_name = b_procedure_step_pt->getProcedureName();
                        branch_info->s_step_name = b_procedure_step_pt->getStepName();
                        branch_info->s_branching_type = 21;
                        branch_info->s_branching_choice = 2; //choice 2
                        branch_info->s_branching_time = r5pars_.timesno;
                        this->m_branching_info_list.push_back(std::move(bi_owned));
                    }
                }
                else
                {this->ErrorMessage("Unexpected!");}
            }
        }
        else if(current_i > this->m_wm_i_list[0])
        {
            if(this->m_wm_type_list[0] == 1)
            {//Match the type 22 branching condition, generate branch
                //to be added
                if(g_sim.Branch_center.ODM_branch.procedure_step.size() == 1)
                {bps_existing = true;}
                else
                {bps_existing = false;}
 
                prior_choice = this->FindARecentSimilarBranching(22, current_procedure_name, current_step_name);
 
                if(g_sim.Branch_center.ODM_branch.procedure_step.size() == 0)
                {
                    //add one branch--the operator transfer to the associated procedure step
                    {
                    auto bps_owned = make_unique<BranchProcedureStep>();
                    b_procedure_step_pt = bps_owned.get();
                    b_procedure_step_pt->setSenderAndReceiver(this->m_operator, this->m_operator);
                    b_procedure_step_pt->setProcedureName(this->m_procedure_step_pt->getCurrentProcedureName());
                    b_procedure_step_pt->setStepName(this->m_procedure_step_pt->getCurrentStepName());
                    b_procedure_step_pt->setLastProcedureName(current_procedure_name);
                    b_procedure_step_pt->setLastStepName(current_step_name);
                    b_procedure_step_pt->setTypeOfPauseActivity(sim::Strategy::FollowProcedure);
                    if(prior_choice == 0)
                    {b_procedure_step_pt->setTimerAndProbability(1.0, this->m_branching_2_2_prob);}
                    else if(prior_choice == 1)
                    {b_procedure_step_pt->setTimerAndProbability(1.0, 1);}
                    else if(prior_choice == 2)
                    {} // bps_owned auto-deletes at scope end
                    else
                    {this->ErrorMessage("the prior_choice type could not be recognized"); return;}
                    if(prior_choice != 2)
                    {g_sim.Branch_center.addProcedureStep(this->m_operator, bps_owned.release());}
                    }
 
                    //ProcedureBranchingInfo * branch_info;
                    if(prior_choice != 2)
                    {
                        auto bi_owned = make_unique<ProcedureBranchingInfo>();
                        branch_info = bi_owned.get();
                        branch_info->s_current_procedure_name = current_procedure_name;
                        branch_info->s_current_step_name = current_step_name;
                        branch_info->s_procedure_name = b_procedure_step_pt->getProcedureName();
                        branch_info->s_step_name = b_procedure_step_pt->getStepName();
                        branch_info->s_branching_type = 22;
                        branch_info->s_branching_choice = 1; // choice 1
                        branch_info->s_branching_time = r5pars_.timesno;
                        this->m_branching_info_list.push_back(std::move(bi_owned));
                    }
 
                    //add the second branch-the operator decides to stay in the current procedure
                    {
                    unique_ptr<BranchProcedureStep> bps_owned;
                    if(bps_existing == true)
                    {b_procedure_step_pt = g_sim.Branch_center.ODM_branch.procedure_step.begin()->get();}
                    else
                    {
                        bps_owned = make_unique<BranchProcedureStep>();
                        b_procedure_step_pt = bps_owned.get();
                        b_procedure_step_pt->setSenderAndReceiver(this->m_operator, this->m_operator);
                        b_procedure_step_pt->setProcedureName(current_procedure_name);
                        b_procedure_step_pt->setStepName(current_step_name);
                        b_procedure_step_pt->setLastProcedureName(current_procedure_name);
                        b_procedure_step_pt->setLastStepName(current_step_name);
                        b_procedure_step_pt->setStateOfActivation(sim::Source::Bypass);
                        b_procedure_step_pt->setTypeOfPauseActivity(sim::Strategy::FollowProcedure);
                    }
                    if(prior_choice == 0)
                    {b_procedure_step_pt->setTimerAndProbability(1.0, 1 - this->m_branching_2_2_prob);}
                    else if(prior_choice == 2)
                    {b_procedure_step_pt->setTimerAndProbability(1.0, 1);}
                    else if(prior_choice == 1)
                    {
                        if(bps_existing == true)
                        {
                            g_sim.Branch_center.ODM_branch.procedure_step.erase(g_sim.Branch_center.ODM_branch.procedure_step.begin());
                            if(g_sim.Branch_center.num_of_ODM_branch >0 )
                            {g_sim.Branch_center.num_of_ODM_branch--;}
                        }
                        // else: bps_owned auto-deletes at scope end
                    }
                    else
                    {this->ErrorMessage("the prior_choice could not be recognized");}
                    if(prior_choice != 1 && bps_existing == false)
                    {g_sim.Branch_center.addProcedureStep(this->m_operator, bps_owned.release());}
                    }
 
                    //ProcedureBranchingInfo * branch_info;
                    if(prior_choice != 1)
                    {
                        auto bi_owned = make_unique<ProcedureBranchingInfo>();
                        branch_info = bi_owned.get();
                        branch_info->s_current_procedure_name = current_procedure_name;
                        branch_info->s_current_step_name = current_step_name;
                        branch_info->s_procedure_name = b_procedure_step_pt->getProcedureName();
                        branch_info->s_step_name = b_procedure_step_pt->getStepName();
                        branch_info->s_branching_type = 22;
                        branch_info->s_branching_choice = 2; // choice 2
                        branch_info->s_branching_time = r5pars_.timesno;
                        this->m_branching_info_list.push_back(std::move(bi_owned));
                    }
                }
                else
                {this->ErrorMessage("Unexpected!");}
            }
            //delete the passed key points
            i_itr = this->m_wm_i_list.begin();
            i_type_itr = this->m_wm_type_list.begin();
            this->m_wm_i_list.erase(i_itr);
            this->m_wm_type_list.erase(i_type_itr);
        }
    }
    else
    {
        if(g_sim.Branch_center.ODM_branch.procedure_step.size() == 1)
        {//type 3 branching
            //check whether it transits to a different procedure
            b_procedure_step_pt = g_sim.Branch_center.ODM_branch.procedure_step.begin()->get();
            name1 = b_procedure_step_pt->getLastProcedureName();
            name2 = b_procedure_step_pt->getProcedureName();
            prior_choice = this->FindARecentSimilarBranching(3, current_procedure_name, current_step_name);
            if(name1.compare(name2) != 0)
            {//type 3 branching happending
 
                if(prior_choice == 0)
                {b_procedure_step_pt->setTimerAndProbability(1.0, this->m_branching_3_2_prob);}
                else if(prior_choice == 2)
                {b_procedure_step_pt->setTimerAndProbability(1.0, 1);}
                else if(prior_choice == 1 || prior_choice == 3)
                {
                    g_sim.Branch_center.ODM_branch.procedure_step.clear();
                    if(g_sim.Branch_center.num_of_ODM_branch >0 )
                    {g_sim.Branch_center.num_of_ODM_branch--;}
                }
                else 
                {this->ErrorMessage("the prior_choice could not be recognized"); return;}
 
                //ProcedureBranchingInfo * branch_info;
                if(prior_choice == 0 || prior_choice == 2)
                {
                    auto bi_owned = make_unique<ProcedureBranchingInfo>();
                    branch_info = bi_owned.get();
                    branch_info->s_current_procedure_name = current_procedure_name;
                    branch_info->s_current_step_name = current_step_name;
                    branch_info->s_procedure_name = b_procedure_step_pt->getProcedureName();
                    branch_info->s_step_name = b_procedure_step_pt->getStepName();
                    branch_info->s_branching_type = 3;
                    branch_info->s_branching_choice = 2; // choice 2
                    branch_info->s_branching_time = r5pars_.timesno;
                    this->m_branching_info_list.push_back(std::move(bi_owned));
                }
 
                //add the second branch-the operator decides to transit to the desired procedure
                {
                auto bps_owned = make_unique<BranchProcedureStep>();
                b_procedure_step_pt = bps_owned.get();
                b_procedure_step_pt->setSenderAndReceiver(this->m_operator, this->m_operator);
                b_procedure_step_pt->setProcedureName(this->m_procedure_step_pt->getCurrentProcedureName());
                b_procedure_step_pt->setStepName(this->m_procedure_step_pt->getCurrentStepName());
                b_procedure_step_pt->setLastProcedureName(current_procedure_name);
                b_procedure_step_pt->setLastStepName(current_step_name);
                b_procedure_step_pt->setTypeOfPauseActivity(sim::Strategy::FollowProcedure);
                if(prior_choice == 0)
                {b_procedure_step_pt->setTimerAndProbability(1.0, this->m_branching_3_1_prob);}
                else if(prior_choice == 1)
                {b_procedure_step_pt->setTimerAndProbability(1.0, 1);}
                else if(prior_choice == 2 || prior_choice == 3)
                {} // bps_owned auto-deletes at scope end
                else
                {this->ErrorMessage("the prior choice could not be recognized"); return;}
 
                if(prior_choice == 0 || prior_choice == 1)
                {g_sim.Branch_center.addProcedureStep(this->m_operator, bps_owned.release());}
                }
                //ProcedureBranchingInfo * branch_info;
 
                if(prior_choice == 0 || prior_choice == 1)
                {
                    auto bi_owned = make_unique<ProcedureBranchingInfo>();
                    branch_info = bi_owned.get();
                    branch_info->s_current_procedure_name = current_procedure_name;
                    branch_info->s_current_step_name = current_step_name;
                    branch_info->s_procedure_name = b_procedure_step_pt->getProcedureName();
                    branch_info->s_step_name = b_procedure_step_pt->getStepName();
                    branch_info->s_branching_type = 3;
                    branch_info->s_branching_choice = 1; // choice 1
                    branch_info->s_branching_time = r5pars_.timesno;
                    this->m_branching_info_list.push_back(std::move(bi_owned));
                }
 
                //add the third branch-the operator decides to stay in the current procedure
                {
                auto bps_owned = make_unique<BranchProcedureStep>();
                b_procedure_step_pt = bps_owned.get();
                b_procedure_step_pt->setSenderAndReceiver(this->m_operator, this->m_operator);
                b_procedure_step_pt->setProcedureName(current_procedure_name);
                b_procedure_step_pt->setStepName(current_step_name);
                b_procedure_step_pt->setLastProcedureName(current_procedure_name);
                b_procedure_step_pt->setLastStepName(current_step_name);
                b_procedure_step_pt->setStateOfActivation(sim::Source::Bypass);
                b_procedure_step_pt->setTypeOfPauseActivity(sim::Strategy::FollowProcedure);
                if(prior_choice == 0)
                {b_procedure_step_pt->setTimerAndProbability(1.0, 1 - this->m_branching_3_1_prob - this->m_branching_3_2_prob);}
                else if(prior_choice == 3)
                {b_procedure_step_pt->setTimerAndProbability(1.0, 1);}
                else if(prior_choice == 1 || prior_choice == 2)
                {} // bps_owned auto-deletes at scope end
                else
                {this->ErrorMessage("the prior_choice could not be recognized"); return;}
 
                if(prior_choice == 0 || prior_choice == 3)
                {g_sim.Branch_center.addProcedureStep(this->m_operator, bps_owned.release());}
                }
                //ProcedureBranchingInfo * branch_info;
                if(prior_choice == 0 || prior_choice == 3)
                {
                    auto bi_owned = make_unique<ProcedureBranchingInfo>();
                    branch_info = bi_owned.get();
                    branch_info->s_current_procedure_name = current_procedure_name;
                    branch_info->s_current_step_name = current_step_name;
                    branch_info->s_procedure_name = b_procedure_step_pt->getProcedureName();
                    branch_info->s_step_name = b_procedure_step_pt->getStepName();
                    branch_info->s_branching_type = 3;
                    branch_info->s_branching_choice = 3;
                    branch_info->s_branching_time = r5pars_.timesno;
                    this->m_branching_info_list.push_back(std::move(bi_owned));
                }
            }
        }
        else if(g_sim.Branch_center.ODM_branch.procedure_step.size() > 1)
        {
            this->ErrorMessage("Unexpected!");
        }
        else if((this->m_claim_bl == true) && (r5pars_.timesno - this->m_claim_time > this->m_event_schema_pt->m_max_delay))
        {
            //type 4 branching, transit to the desired procedure after a certain period of time of claiming an accident
            if(g_sim.Branch_center.ODM_branch.procedure_step.size() > 0)
            {           
                    g_sim.Branch_center.ODM_branch.procedure_step.erase(g_sim.Branch_center.ODM_branch.procedure_step.begin());
                if(g_sim.Branch_center.num_of_ODM_branch >0 )
                {g_sim.Branch_center.num_of_ODM_branch--;}
            }
            {
            auto bps_owned = make_unique<BranchProcedureStep>();
            b_procedure_step_pt = bps_owned.get();
            b_procedure_step_pt->setSenderAndReceiver(this->m_operator, this->m_operator);
            b_procedure_step_pt->setTimerAndProbability(1.0, 1.0);
            b_procedure_step_pt->setProcedureName(this->m_procedure_step_pt->getCurrentProcedureName());
            b_procedure_step_pt->setStepName(this->m_procedure_step_pt->getCurrentStepName());
            b_procedure_step_pt->setLastProcedureName(current_procedure_name);
            b_procedure_step_pt->setLastStepName(current_step_name);
            b_procedure_step_pt->setTypeOfPauseActivity(sim::Strategy::FollowProcedure);
            g_sim.Branch_center.addProcedureStep(this->m_operator, bps_owned.release());
 
            auto bi_owned = make_unique<ProcedureBranchingInfo>();
            branch_info = bi_owned.get();
            branch_info->s_current_procedure_name = current_procedure_name;
            branch_info->s_current_step_name = current_step_name;
            branch_info->s_procedure_name = b_procedure_step_pt->getProcedureName();
            branch_info->s_step_name = b_procedure_step_pt->getStepName();
            branch_info->s_branching_type = 4;
            branch_info->s_branching_choice = 0;
            branch_info->s_branching_time = r5pars_.timesno;
            this->m_branching_info_list.push_back(std::move(bi_owned));
            }
        }
    }
    
}
 
void DiagnoseInvestigator::CopyDiagnoseInvestigatorInfoFromAnother(DiagnoseInvestigator * _di_pt)
{
    this->CopyIDElementToRestartInfo((IDElement*)_di_pt);
    this->m_coverage_coefficient = _di_pt->m_coverage_coefficient;
 
    //new add
    this->m_branching_info_list.clear();
 
 
 
    //to be added
/*
    int m_wm_type;
    int m_wm_i;
    int m_operator; 
    bool m_contain_transfer_point_to_associate_procedure_bl;
    bool m_claim_bl;
    bool m_procedure_entered_bl;    
    float m_branching1_prob;
    float m_branching_2_1_prob; //probability of transiting to the desired procedrue
    float m_branching_2_2_prob; //probability of transiting to the desired procedure
    float m_branching_3_1_prob; //probability of transiting to the desired procedure
    float m_branching_3_2_prob; //probability of literally following the procedure guidance 
    float m_diagnose_claim_threshold;   
    float m_claim_time;
    float m_attention_level;
    float m_confidence;
*/
    this->m_wm_type = _di_pt->m_wm_type;
    this->m_wm_i = _di_pt->m_wm_i;
    this->m_operator = _di_pt->m_operator;
    this->m_contain_transfer_point_to_associate_procedure_bl = _di_pt->m_contain_transfer_point_to_associate_procedure_bl;
    this->m_claim_bl = _di_pt->m_claim_bl;
    this->m_procedure_entered_bl = _di_pt->m_procedure_entered_bl;
    this->m_branching1_prob = _di_pt->m_branching1_prob;
    this->m_branching_2_1_prob = _di_pt->m_branching_2_1_prob;
    this->m_branching_2_2_prob = _di_pt->m_branching_2_1_prob;
    this->m_branching_3_1_prob = _di_pt->m_branching_3_1_prob;
    this->m_branching_3_2_prob = _di_pt->m_branching_3_2_prob;
    this->m_diagnose_claim_threshold = _di_pt->m_diagnose_claim_threshold;
    this->m_claim_time = _di_pt->m_claim_time;
    this->m_attention_level = _di_pt->m_attention_level;
    this->m_confidence = _di_pt->m_confidence;
    this->m_confidence_from_others = _di_pt->m_confidence_from_others;
    this->m_n_hard_setback = _di_pt->m_n_hard_setback;
    this->m_terminate_investigation = _di_pt->m_terminate_investigation;
 
//check the size of each vector
    if(this->m_wm_i_list.size() != 0)
    {this->ErrorMessage("this->m_wm_i_list.size() != 0");return;}
    if(this->m_wm_type_list.size() != 0)
    {this->ErrorMessage("this->m_wm_type_list.size() != 0");return;}
    if(this->m_confidence_history.size() != 0)
    {this->ErrorMessage("this->m_confidence_history.size() != 0");return;}
    if(this->m_confidence_timeline.size() != 0)
    {this->ErrorMessage("this->m_confidence_timeline.size() != 0");return;}
/*
    vector<int> m_wm_i_list;
    vector<int> m_wm_type_list; 
    vector<float> m_confidence_history;
    vector<float> m_confidence_timeline;
*/
    vector<int>::iterator int_itr;
    vector<float>::iterator fl_itr;
    int i;
    float fl;
    for(int_itr = _di_pt->m_wm_i_list.begin(); int_itr != _di_pt->m_wm_i_list.end(); int_itr++)
    {
        i = *int_itr;
        this->m_wm_i_list.push_back(i);
    }
    for(int_itr = _di_pt->m_wm_type_list.begin(); int_itr != _di_pt->m_wm_type_list.end(); int_itr++)
    {
        i = *int_itr;
        this->m_wm_type_list.push_back(i);
    }
    for(fl_itr = _di_pt->m_confidence_history.begin(); fl_itr != _di_pt->m_confidence_history.end(); fl_itr++)
    {
        fl = *fl_itr;
        this->m_confidence_history.push_back(fl);
    }
    for(fl_itr = _di_pt->m_confidence_timeline.begin(); fl_itr != _di_pt->m_confidence_timeline.end(); fl_itr++)
    {
        fl = *fl_itr;
        this->m_confidence_timeline.push_back(fl);
    }
    /*
    
    vector<float> m_Integrated_prob_list;
    vector<float> m_coverage_list;
    vector<int> m_N_setback_list;
    vector<int> m_N_disabled_list;
    vector<string> m_symp_confidence_list;
    */
    for(fl_itr = _di_pt->m_Integrated_prob_list.begin(); fl_itr != _di_pt->m_Integrated_prob_list.end(); fl_itr++)
    {
        fl = *fl_itr;
        this->m_Integrated_prob_list.push_back(fl);
    }
 
    for(fl_itr = _di_pt->m_coverage_list.begin(); fl_itr != _di_pt->m_coverage_list.end(); fl_itr++)
    {
        fl = *fl_itr;
        this->m_coverage_list.push_back(fl);
    }
    for(int_itr = _di_pt->m_N_setback_list.begin(); int_itr != _di_pt->m_N_setback_list.end(); int_itr++)
    {
        i = *int_itr;
        this->m_N_setback_list.push_back(i);
    }
    for(int_itr = _di_pt->m_N_disabled_list.begin(); int_itr != _di_pt->m_N_disabled_list.end(); int_itr++)
    {
        i = *int_itr;
        this->m_N_disabled_list.push_back(i);
    }
    for(int_itr = _di_pt->m_N_voided_list.begin(); int_itr != _di_pt->m_N_voided_list.end(); int_itr++)
    {
        i = *int_itr;
        this->m_N_voided_list.push_back(i);
    }
 
    vector<string>::iterator str_itr;
    string str_v;
    for(str_itr = _di_pt->m_symp_confidence_list.begin(); str_itr != _di_pt->m_symp_confidence_list.end(); str_itr++)
    {
        str_v = *str_itr;
        this->m_symp_confidence_list.push_back(str_v);
    }
 
    if(this->m_other_evidence_list.size() > 0)
    {this->ErrorMessage("this->m_other_evidence_list.size() > 0");}
    for(auto &tvn : _di_pt->m_other_evidence_list)
    {
        auto tvn_owned = make_unique<TimeValueNoteUnit>();
        tvn_owned->CopyFromAnotherTimeValueNoteUnit(tvn.get());
        this->m_other_evidence_list.push_back(std::move(tvn_owned));
    }
 
/*
    ProcedureStep* m_wm_procedure_step_pt;
    ProcedureStep * m_procedure_step_pt;
    SymptomInvestigator * m_tbi_SI;
    SymptomInvestigator * m_ongoing_SI; //is ongoing to explore a symptom
    IDElement * m_ES_base_ID_pt;
    IDElement * m_label_ID_pt;
    Statement * m_event_statement_pt;
    KnowledgeElement * m_event_KE_pt;
    EventSchemaUnit * m_event_schema_pt;
 
    string m_procedure_name;
    string m_procedure_step_name;
    string m_ID_tbi_SI;
    string m_ID_ongoing_SI;
    string m_ID_label;
    string m_ID_es;
    string m_ID_KE;
    string m_ID_statement;
*/
    if(_di_pt->m_wm_procedure_step_pt != NULL)
    {
        this->m_wm_procedure_name = _di_pt->m_wm_procedure_step_pt->getCurrentProcedureName();
        this->m_wm_procedure_step_name = _di_pt->m_wm_procedure_step_pt->getCurrentStepName();
    }
    else
    {
        this->m_wm_procedure_name = _di_pt->m_wm_procedure_name;
        this->m_wm_procedure_step_name = _di_pt->m_wm_procedure_step_name;
    }
    
    if(_di_pt->m_procedure_step_pt != NULL)
    {
        this->m_procedure_name = _di_pt->m_procedure_step_pt->getCurrentProcedureName();
        this->m_procedure_step_name = _di_pt->m_procedure_step_pt->getCurrentStepName();
    }
    else
    {
        this->m_procedure_name = _di_pt->m_procedure_name;
        this->m_procedure_step_name = _di_pt->m_procedure_step_name;
    }
 
    {this->m_ID_tbi_SI = _di_pt->m_ID_tbi_SI;}
 
    if(_di_pt->m_tbi_SI != NULL)
    {this->m_ID_tbi_SI = _di_pt->m_tbi_SI->m_ID;}
    else
    {this->m_ID_tbi_SI = _di_pt->m_ID_tbi_SI;}
 
    if(_di_pt->m_ongoing_SI != NULL)
    {this->m_ID_ongoing_SI = _di_pt->m_ongoing_SI->m_ID;}
    else
    {this->m_ID_ongoing_SI = _di_pt->m_ID_ongoing_SI;}
 
    if(_di_pt->m_label_ID_pt != NULL)
    {this->m_ID_label = _di_pt->m_label_ID_pt->m_ID;}
    else
    {this->m_ID_label = _di_pt->m_ID_label;}
 
    if(_di_pt->m_event_schema_pt != NULL)
    {this->m_ID_es = _di_pt->m_event_schema_pt->m_ID;}
    else
    {this->m_ID_es = _di_pt->m_ID_es;}
 
    if(_di_pt->m_event_KE_pt != NULL)
    {this->m_ID_KE = _di_pt->m_event_KE_pt->m_ID;}
    else
    {this->m_ID_KE = _di_pt->m_ID_KE;}
 
    if(_di_pt->m_event_statement_pt != NULL)
    {this->m_ID_statement = _di_pt->m_event_statement_pt->m_ID;}
    else
    {this->m_ID_statement = _di_pt->m_ID_statement;}
 
/*
    vector<SymptomInvestigator *> m_symptom_invest_list;
*/
    for(auto &si : _di_pt->m_symptom_invest_list)
    {
        auto si_owned = make_unique<SymptomInvestigator>();
        si_owned->CopySymptomInvestigatorInfoFromAnother(si.get());
        this->m_symptom_invest_list.push_back(std::move(si_owned));
    }
 
    
    //vector<ProcedureBranchingInfo *> m_branching_info_list;
    //vector<ProcedureBranchingInfo *> m_branching_history_list;
    for(auto &bh : _di_pt->m_branching_history_list)
    {
        auto bi_owned = make_unique<ProcedureBranchingInfo>();
        bi_owned->s_branching_choice = bh->s_branching_choice;
        bi_owned->s_branching_time = bh->s_branching_time;
        bi_owned->s_branching_type = bh->s_branching_type;
        bi_owned->s_current_procedure_name = bh->s_current_procedure_name;
        bi_owned->s_current_step_name = bh->s_current_step_name;
        bi_owned->s_procedure_name = bh->s_procedure_name;
        bi_owned->s_step_name = bh->s_step_name;
        this->m_branching_history_list.push_back(std::move(bi_owned));
    }
    for(auto &bi : _di_pt->m_branching_info_list)
    {
        auto bi_owned = make_unique<ProcedureBranchingInfo>();
        bi_owned->s_branching_choice = bi->s_branching_choice;
        bi_owned->s_branching_time = bi->s_branching_time;
        bi_owned->s_branching_type = bi->s_branching_type;
        bi_owned->s_current_procedure_name = bi->s_current_procedure_name;
        bi_owned->s_current_step_name = bi->s_current_step_name;
        bi_owned->s_procedure_name = bi->s_procedure_name;
        bi_owned->s_step_name = bi->s_step_name;
        this->m_branching_info_list.push_back(std::move(bi_owned));
    }
}
 
void DiagnoseInvestigator::BuildConnectionsForThisDiagnoseInvestigator(void * _pt)
{
    ReasonMachine * RM_pt;
    RM_pt = (ReasonMachine*)_pt;
    map<string, ProcedureStep *>::iterator procedure_map_itr;
 
    //ProcedureStep* m_wm_procedure_step_pt;
    //ProcedureStep * m_procedure_step_pt;
    if(this->m_procedure_name.compare("NONE") != 0 && this->m_procedure_step_name.compare("NONE") != 0)
    {
        procedure_map_itr = g_sim.All_procedure.procedure_map.find(this->m_procedure_name + this->m_procedure_step_name);
        if(procedure_map_itr != g_sim.All_procedure.procedure_map.end())
        {
            this->m_procedure_step_pt = procedure_map_itr->second;
        }
        else
        {
            this->ErrorMessage("Could not find this procedure step: " + this->m_procedure_name + this->m_procedure_step_name);
            return;
        }
    }
 
    if(this->m_wm_procedure_name.compare("NONE") != 0 && this->m_wm_procedure_step_name.compare("NONE") != 0)
    {
        procedure_map_itr = g_sim.All_procedure.procedure_map.find(this->m_wm_procedure_name + this->m_wm_procedure_step_name);
        if(procedure_map_itr != g_sim.All_procedure.procedure_map.end())
        {
            this->m_wm_procedure_step_pt = procedure_map_itr->second;
        }
        else
        {
            this->ErrorMessage("Could not find this procedure step: " + this->m_wm_procedure_name + this->m_wm_procedure_step_name);
            return;
        }
    }
    this->m_wm_procedure_name = "NONE";
    this->m_wm_procedure_step_name = "NONE";
 
    
 
    //SymptomInvestigator * m_tbi_SI;
    if(this->m_ID_tbi_SI.compare("") != 0)
    {
        this->m_tbi_SI = RM_pt->m_event_schema_base->FindSymtomInvestigatorByID(this->m_ID_tbi_SI);
        if(this->m_tbi_SI == NULL)
        {this->ErrorMessage("this->m_tbi_SI == NULL"); return;}
    }
    this->m_ID_tbi_SI = "";
 
    //SymptomInvestigator * m_ongoing_SI;
    if (this->m_ID_ongoing_SI.compare("") != 0)
    {
        this->m_ongoing_SI = RM_pt->m_event_schema_base->FindSymtomInvestigatorByID(this->m_ID_ongoing_SI);
        if( this->m_ongoing_SI == NULL)
        {this->ErrorMessage("this->m_ongoing_SI"); return;}
    }
    this->m_ID_ongoing_SI = "";
 
    //IDElement * m_ES_base_ID_pt;
    this->m_ES_base_ID_pt = (IDElement*)(RM_pt->m_event_schema_base.get());
 
    //IDElement * m_label_ID_pt;
    if(this->m_ID_label.compare("") != 0)
    {
        this->m_label_ID_pt = RM_pt->m_Concept_Base->FindConceptByID(this->m_ID_label);
        if( this->m_label_ID_pt== NULL)
        {this->ErrorMessage("this->m_label_ID_pt == NULL"); return;}
    }
 
    //KnowledgeElement * m_event_KE_pt;
    if(this->m_ID_KE.compare("") != 0)
    {
        this->m_event_KE_pt = RM_pt->FindKnowledgeElementByID(this->m_ID_KE);
        if(this->m_event_KE_pt == NULL)
        {this->ErrorMessage("this->m_event_KE_pt == NULL"); return;}
    }
 
    //Statement * m_event_statement_pt;
    if(this->m_ID_statement.compare("") != 0)
    {
        this->m_event_statement_pt = RM_pt->FindStatementByID(this->m_ID_statement);
        if(this->m_event_statement_pt == NULL)
        {this->ErrorMessage("this->m_event_statement_pt == NULL"); return;}
    }
 
    //EventSchemaUnit * m_event_schema_pt;
    if(this->m_ID_es.compare("") != 0)
    {
        this->m_event_schema_pt = RM_pt->m_event_schema_base->FindEventSchemaUnitByID(this->m_ID_es);
        if(this->m_event_schema_pt == NULL)
        {this->ErrorMessage("this->m_event_schema_pt == NULL"); return;}
    }
        
/*
    vector<SymptomInvestigator *> m_symptom_invest_list;
*/
    for(auto &symp : this->m_symptom_invest_list)
    {
        symp->BuildConnectionsForThisSymptomInvestigator(_pt);
    }
 
}
 
void DiagnoseInvestigator::UpdateDiagnoseInvestigatorBranchingInfo(void * _pt)
{
    bool match_bl;
    BranchProbability * bp_pt;
    BranchProcedureStep * bps_pt;
    string next_procedure_name;
    string next_step_name;
    int type = 0;
    int choice = 0;
 
    bp_pt = (BranchProbability *)_pt;
 
 
    ProcedureBranchingInfo * found_info_pt = NULL;
    size_t found_idx = 0;
 
    if(this->m_branching_info_list.size() == 0)
    {return;}
 
    if(bp_pt->procedure_step.size() == 0)
    {this->ErrorMessage("bp_pt->procedure_step.size() == 0"); return;}
    else if(bp_pt->procedure_step.size() > 1)
    {this->ErrorMessage("bp_pt->procedure_step.size() > 1"); return;}
 
    bps_pt = bp_pt->procedure_step.begin()->get();
    next_procedure_name = bps_pt->getProcedureName();
    next_step_name = bps_pt->getStepName();
 
    for(size_t idx = 0; idx < this->m_branching_info_list.size(); idx++)
    {
        auto &info = this->m_branching_info_list[idx];
        match_bl = false;
 
        if(info->s_procedure_name.compare(next_procedure_name) == 0)
        {
            if(info->s_step_name.compare(next_step_name) == 0)
            {
                match_bl = true;
                found_info_pt = info.get();
                found_idx = idx;
            }
        }
 
        //if(match_bl == false)
        //{delete (*info_itr);}
    }
 
    if(found_info_pt == NULL)
    {this->ErrorMessage("Fail: found_info == NULL"); return;}
 
    type = found_info_pt->s_branching_type;
    choice = found_info_pt->s_branching_choice;
 
    if((type == 1 && choice == 2) || (type == 21 && choice == 2) || (type == 22 && choice == 1) || (type == 3 && choice == 2) || (type == 4))
    {this->TerminateTheCurrentProcedureStep();}
    this->m_branching_history_list.push_back(std::move(this->m_branching_info_list[found_idx]));
    this->m_branching_info_list.clear();
    //clear this->m_branching_info_list
}
 
int DiagnoseInvestigator::FindARecentSimilarBranching(int type, string procedure_name, string step_name)
{
    int choice = 0;
    ProcedureBranchingInfo * found_info_pt = NULL;
 
    for(auto ritr = this->m_branching_history_list.rbegin(); ritr != this->m_branching_history_list.rend() && found_info_pt == NULL; ritr++)
    {
        if((*ritr)->s_branching_type != type)
        {continue;}
        if((*ritr)->s_current_procedure_name.compare(procedure_name) == 0 && (*ritr)->s_step_name.compare(step_name) == 0)
        {
            found_info_pt = ritr->get();
        }
    }
 
    if(found_info_pt != NULL)
    {choice = found_info_pt->s_branching_choice;}
    return choice;
}
 
void DiagnoseInvestigator::TerminateTheCurrentProcedureStep()
{
    DecisionProcedureStep * dps_pt = NULL;
    if(this->m_wm_procedure_step_pt != NULL)
    {this->m_wm_procedure_step_pt->resetStateOfActivation();}
    dps_pt = g_sim.Decision_Maker.memory.perceived_info.getCurrentProcedureStepPtr(this->m_operator);
    if(dps_pt != NULL)
    {dps_pt->setStateOfActivation(sim::State::Done);}
}
 
//DEL float DiagnoseInvestigator::m_coverage_coefficient()
//DEL {
//DEL 
//DEL }
 
void DiagnoseInvestigator::UpdateForOtherEvidenceNotListedInEventSchema(IDElement * _ID_pt)
{
    Investigator * invest_pt = (Investigator *)_ID_pt;
    bool exist_bl = false;
    bool seen_before = 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 
 
    if(invest_pt->m_KElement_ID_pt == NULL)
    {return;}
    if((invest_pt->m_probability_update_time - r5pars_.timesno) > 0.0001 || (invest_pt->m_probability_update_time - r5pars_.timesno) < -0.0001)
    {return;}
    if(invest_pt->m_KElement_ID_pt->m_ID != this->m_event_KE_pt->m_ID )
    {return;}
 
    for(auto &SI : this->m_symptom_invest_list)
    {
        if(exist_bl) break;
        if((IDElement*)(SI->m_symptom_KE_pt) == RM_pt->m_buffer_invest_pt->m_KElement_ID_pt)
        {exist_bl = true;}
    }
 
    if(exist_bl == true)
    {return;}
 
    // Check whether exists in the other info list and update
    bool update_number = false;
 
    for(auto &tvn : this->m_other_evidence_list)
    {
        if(seen_before) break;
        if(tvn->m_string.compare(RM_pt->m_buffer_invest_pt->m_KElement_ID_pt->m_ID) == 0)
        {
            seen_before = true;
            if(invest_pt->m_independent_probability > tvn->m_value)
            {
                tvn->m_time = r5pars_.timesno;
                tvn->m_value = invest_pt->m_independent_probability;
                tvn->m_note = invest_pt->m_ID;
                update_number = true;
            }
        }
    }
 
    if(seen_before == false)
    {
        auto other_evidence_owned = make_unique<TimeValueNoteUnit>();
        other_evidence_owned->m_string = RM_pt->m_buffer_invest_pt->m_KElement_ID_pt->m_ID;
        other_evidence_owned->m_value = invest_pt->m_independent_probability;
        other_evidence_owned->m_note = RM_pt->m_buffer_invest_pt->m_ID;
        other_evidence_owned->m_time = r5pars_.timesno;
        this->m_other_evidence_list.push_back(std::move(other_evidence_owned));
        update_number = true;
    }
 
    if(update_number == true)
    {
        this->CalculateTheConfidenceLeveloftheDiagnoseInvestigator();
        
        //test
        //write aux infor
 
 
        
        //write the codes for first other evidence at initation of DI, done
        // sort, do calculation...done
        //update the confidence, done
        //save the restore information for the m_other_evidence_list, done
        //link this function with the Investigator::backwardpropagateconfidence...., done
 
 
        //work on the resuming of investigation  item
        //
    }
 
}