EventSchemaBase.cpp

Go to the documentation of this file.

// EventSchemaBase.cpp: implementation of the EventSchemaBase class.
//
 
#include <string>
#include <sstream>
#include <iostream>
#include <fstream>
 
#include "EventSchemaBase.h"
#include "InstantiationBase.h"
#include "RMTokens.h"
#include "../Crew/OperatorDM.h"
#include "../Crew/OperatorAT.h"
#include "ReasonMachine.h"
#include "KnowledgeUnit.h"
#include "Label.h"
#include "../Procedure/Procedures.h"
#include "../Branch/BranchProbability.h"
#include "../Global/SimulationContext.h"
using namespace std;
 
 
// Construction/Destruction
 
EventSchemaBase::EventSchemaBase()
{
    this->m_ID_Type = 500;
    this->m_timing = 0;
    this->m_timed_DI = NULL;
    this->m_diagnose_claim_threshold = 0.85;
    this->m_active_investigation_threshold = 0;
    this->m_ID_timed_DI = "";
}
 
EventSchemaBase::~EventSchemaBase()
{
    this->m_event_schema_list.clear();
    this->m_diagnose_invest_list.clear();
 
    this->m_ID_interested_invest_link_list.clear();
    this->m_ID_interested_invest_list.clear();
    this->m_interested_invest_link_list.clear();
    this->m_interested_invest_list.clear();
    this->m_debug_info.clear();
}
 
void EventSchemaBase::ReadEventSchemaBaseFromInputFile()
{
    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 
 
    string dir_path, str, str_ID, err_mes;
    ifstream fin;
    int n_event, n_symptom, n_KU, i, j, k;
    EventSchemaUnit * schema_pt;
    EventSymptomUnit * symptom_pt;
    KnowledgeUnit * KU_pt;
    map<string, ProcedureStep *>::iterator procedure_map_itr;
 
 
    //initialize some variables
    if(RM_pt->m_problem_solving_style != ProblemSolvingStyle::Hamlet && RM_pt->m_problem_solving_style != ProblemSolvingStyle::HamletB)
    this->m_active_investigation_threshold = 0.05;
 
    //get the file directory
    if (this->m_operator == sim::Operator::ODM)
    {   
        dir_path = g_sim.SScheduler.getODMDirectory();
    }
    else if(this->m_operator == sim::Operator::OAT)
    {
        dir_path = g_sim.SScheduler.getOATDirectory();
    }
    dir_path += "RM//";
    dir_path += "KB_ODM_Event_Schema_Base.txt";
 
    fin.open(dir_path.c_str(), ios::in);
    if(!fin.is_open()){
        err_mes = "can not find file: " + dir_path;
        this->ErrorMessage(err_mes);
        return; //has to return and close this program if there is an error
    }
    else
    {
        fin >> str >> n_event;
        if(str.compare("No_of_Event_Schemas:") != 0)
        {
            err_mes = str + " is incorrectly in the position of Number_of_Instantiation_Label_Groups:";
            this->ErrorMessage(err_mes);
            return;
        }
 
        fin >> str >> this->m_diagnose_claim_threshold;
        if(str.compare("Diagnose_Claim_Threshold:") != 0)
        {
            err_mes = str + " is incorrectly in the position of Diagnose_Claim_Threshold:";
            this->ErrorMessage(err_mes);
            return;
        }
 
        string ID_name;
        stringstream conv;
 
        for(i=0; i < n_event; i++)
        {
            auto schema_owned = std::make_unique<EventSchemaUnit>();
            schema_pt = schema_owned.get();
            this->m_event_schema_list.push_back(std::move(schema_owned));
 
            conv.str(""); // clean the conv
            conv << this->m_event_schema_list.size();
            ID_name = "Event_Schema_" + conv.str();
            schema_pt->m_ID = ID_name;
 
            schema_pt->m_diagnose_claim_threshold = this->m_diagnose_claim_threshold;
 
            fin >> str >> str_ID;
            if(str.compare("Event_KE_ID:") != 0)
            {
                err_mes = str + " is incorrectly in the position of Event_KE_ID:";
                this->ErrorMessage(err_mes);
                return;
            }
            schema_pt->m_event_KE_pt = RM_pt->FindKnowledgeElementByID(str_ID);
            if(schema_pt->m_event_KE_pt == NULL)
            {
                this->ErrorMessage("Could not find the KE" + str_ID +" for a schema");
                return;
            }
 
            fin >> str  >> n_symptom;
            if(str.compare("No_of_Symptoms:") != 0)
            {
                err_mes = str + " is incorrectly in the position of No_of_Symptoms:";
                this->ErrorMessage(err_mes);
                return;
            }
 
            for(j = 0; j < n_symptom; j++)
            {
                auto symptom_owned = std::make_unique<EventSymptomUnit>();
                symptom_pt = symptom_owned.get();
                schema_pt->m_symptom_list.push_back(std::move(symptom_owned));
                ID_name = schema_pt->m_ID + "_symptom_" ;
                conv.str("");
                conv << schema_pt->m_symptom_list.size();
                ID_name += conv.str();
                symptom_pt->m_ID = ID_name;
 
                fin >> str >> str_ID;
                if(str.compare("Symptom_KE_ID:") != 0)
                {
                    err_mes = str + " is incorrectly in the position of Symptom_KE_ID:";
                    this->ErrorMessage(err_mes);
                    return;
                }
                symptom_pt->m_symptom_KE_pt = RM_pt->FindKnowledgeElementByID(str_ID);
                if(symptom_pt->m_symptom_KE_pt == NULL)
                {
                    this->ErrorMessage("Could not find the KE" + str_ID +" for a symptom");
                    return;
                }
 
                fin >> str >> n_KU;
                if(str.compare("No_of_causal_chains:") != 0)
                {
                    err_mes = str + " is incorrectly in the position of No_of_causal_chains:";
                    this->ErrorMessage(err_mes);
                    return;
                }
 
                for(k = 0; k < n_KU; k++)
                {
 
                    KU_pt = NULL;
                    fin >> str >> str_ID;
                    if(str.compare("KU_ID:") != 0)
                    {
                        err_mes = str + " is incorrectly in the position of KU_ID:";
                        this->ErrorMessage(err_mes);
                        return;
                    }
                    KU_pt = RM_pt->FindKnowledgeUnitByID(str_ID);
                    if(KU_pt == NULL)
                    {
                        this->ErrorMessage("Could not find the KU" + str_ID +" for a symptom");
                        return;
                    }
                    symptom_pt->m_KU_list.push_back(KU_pt);
                }
                
            }
 
            fin >> str >> schema_pt->m_procedure_name;
            if(str.compare("Response_Procedure_Name:") != 0)
            {
                err_mes = str + " is incorrectly in the position of Response_Procedure_Name:";
                this->ErrorMessage(err_mes);
                return;
            }
 
            fin >> str >> schema_pt->m_procedure_step_name;
            if(str.compare("Response_Procedure_Step:") != 0)
            {
                err_mes = str + " is incorrectly in the position of Response_Procedure_Step:";
                this->ErrorMessage(err_mes);
                return;
            }
            if(schema_pt->m_procedure_step_name.compare("NONE") == 0 || schema_pt->m_procedure_step_name.compare("NONE") == 0)
            {
                schema_pt->m_procedure_step_pt = NULL;
            }
            else 
            {
                procedure_map_itr = g_sim.All_procedure.procedure_map.find(schema_pt->m_procedure_name + schema_pt->m_procedure_step_name);
                if(procedure_map_itr != g_sim.All_procedure.procedure_map.end())
                {
                    schema_pt->m_procedure_step_pt = procedure_map_itr->second;
                }
                else
                {
                    this->ErrorMessage("Could not find this procedure step: " + schema_pt->m_procedure_name + schema_pt->m_procedure_step_name);
                    return;
                }
            }
        }
 
    }
}
 
void EventSchemaBase::ErrorMessage(string str)
{
    cout << r5pars_.timesno << "  " << str << " in EventSchemaBase.cpp" << '\n';
    ofstream fout("err messages.txt", ios::app);
    fout << r5pars_.timesno << "  " << str << '\n';
    fout.close();
}
 
void EventSchemaBase::AddANewDiagnoseInvestigator(DiagnoseInvestigator *_diagnose_invest_pt)
{
    stringstream conv;
    string str_ID;
    string str;
    
    this->m_diagnose_invest_list.push_back(std::unique_ptr<DiagnoseInvestigator>(_diagnose_invest_pt));
    str_ID = "Diagnose_Investigator_";
    conv.str("");
    conv << this->m_diagnose_invest_list.size();
    str_ID += conv.str();
    _diagnose_invest_pt->m_ID = str_ID;
    _diagnose_invest_pt->m_operator = this->m_operator;
    _diagnose_invest_pt->m_ES_base_ID_pt = (IDElement *)this;
 
    conv.str("");
    conv << r5pars_.timesno;
    str = conv.str() + ", a DiagnoseInvestigator is added: " + _diagnose_invest_pt->m_event_statement_pt->m_ID;
 
}
 
DiagnoseInvestigator * EventSchemaBase::FindACorrespondingDiagnoseInvestigatorByKE(KnowledgeElement *_KE_pt)
{
    DiagnoseInvestigator * found_DI_pt = NULL;
 
    for(auto &e : this->m_diagnose_invest_list)
    {
        if(e->m_event_KE_pt == _KE_pt)
        {
            found_DI_pt = e.get();
        }
    }
    return found_DI_pt;
}
 
EventSchemaUnit * EventSchemaBase::FindACorrespondingEventSchemaUnitByKE(KnowledgeElement *_KE_pt)
{
    EventSchemaUnit * found_ES_pt = NULL;
    Label *label_group_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 
 
    for(auto &e : this->m_event_schema_list)
    {
        if(found_ES_pt != NULL) break;
        //caution here: the input _KE_pt should be instantiated. It can not have any indefinite concept.
        if(e->m_event_KE_pt->m_negation != _KE_pt->m_negation)
        {continue;}
 
        label_group_pt = RM_pt->m_IB->CheckWhetherASentenceContainIndefiniteItem(e->m_event_KE_pt->m_SentenceUnit_pt);
        if(label_group_pt != NULL)
        {
            if(RM_pt->FindAnIndefiniteSentenceMatchTheInputSentence(_KE_pt->m_SentenceUnit_pt) == e->m_event_KE_pt->m_SentenceUnit_pt)
            {
                found_ES_pt = e.get();
            }
        }
        else
        {
            if(e->m_event_KE_pt == _KE_pt)
            {
                found_ES_pt = e.get();
            }
        }
    }
    return found_ES_pt;
}
 
void EventSchemaBase::LinkNewInvestigatorToDiagnoseInvestigatorIfNecessary(Investigator *_invest_pt)
{
    bool new_SI_case_bl;
    SymptomCase * case_pt;
 
    for(auto &DI_e : this->m_diagnose_invest_list)
    {
        for(auto &SI_e : DI_e->m_symptom_invest_list)
        {
            new_SI_case_bl = false;
 
            if(_invest_pt->m_motivation == 0)
            {
                if(_invest_pt->m_KElement_ID_pt == (IDElement*)SI_e->m_symptom_KE_pt)
                {
                    new_SI_case_bl = true;
                }
            }
            else if(_invest_pt->m_motivation == 1)
            {
                if(_invest_pt->m_Statement_pt->m_sent_pt == SI_e->m_symptom_KE_pt->m_SentenceUnit_pt
                    && _invest_pt->m_Statement_pt->m_state == !SI_e->m_symptom_KE_pt->m_negation)
                {
                    new_SI_case_bl = true;
                }
            }
            else
            {this->ErrorMessage("error!");}
 
            //add a new SymptomCase if required
            if(new_SI_case_bl == true)
            {
                auto case_owned = std::make_unique<SymptomCase>();
                case_owned->m_invest_pt = _invest_pt;
                case_owned->m_finished_bl = false;
                SI_e->m_candidate_case_list.push_back(std::move(case_owned));
            }
        }
    }
 
}
 
void EventSchemaBase::TrackTheOngoingInvestigation()
{
    for(auto &e : this->m_diagnose_invest_list)
    {
        e->DITrackTheOngoingInvestigation();
    }
}
 
void EventSchemaBase::UpdateTheInterestForInvestigatorOrInvestigatorLink()
{
    this->TrackTheOngoingInvestigation();
 
}
 
bool EventSchemaBase::GenerateANewInvestigatorOrNot()
{
    Investigator * invest_pt;
    //vector<SymptomInvestigator *>::iterator SI_itr;
    float highest_score = 0;
    float score;
    bool ongoing_bl = false;
    bool generated_bl = false;
    SymptomInvestigator * ongoing_SI_pt = NULL;
    SymptomCase * case_pt = NULL;
    string str;
    stringstream conv;
 
    ReasonMachine * RM_pt;
    if (this->m_operator == sim::Operator::ODM)
    {RM_pt = g_sim.Decision_Maker.m_RM.get();}
    else if (this->m_operator == sim::Operator::OAT)
    {RM_pt = g_sim.Action_Taker.m_RM.get();}
    else
    {}//add error message 
    
    if(r5pars_.timesno > 2002)
    {this->PrintMessage("");}
    
    //check point
//  if(r5pars_.timesno > 900)
//  {
//      this->ErrorMessage("Check point!");
//  }
    //
//       ----ongoing----pick a SI--(time delay)--generate investigator--
 
    bool create_bl;
 
    if(this->m_timed_DI != NULL)
    {
        create_bl = true;
        if(this->m_timed_DI->m_tbi_SI->m_candidate_case_list.size() > 0)
        {
            for(auto &case_e : this->m_timed_DI->m_tbi_SI->m_candidate_case_list)
            {
                if(this->m_timed_DI->m_tbi_SI->m_need_to_invest_opposite_bl == false && case_e->m_invest_pt->m_KElement_ID_pt == (IDElement *)(this->m_timed_DI->m_tbi_SI->m_symptom_KE_pt))
                {create_bl = false;}
            }
        }
        if(this->m_timing < r5pars_.timesno && create_bl == true)
        {               
                    //create a new investigator
                    invest_pt = new Investigator();
                    invest_pt->m_note = "by event schema";
                    invest_pt->m_motivation = 0;
                    invest_pt->m_effective_start = r5pars_.timesno - 10;            
                    invest_pt->m_effective_end = r5pars_.timesno + 100;
                    
                    if(this->m_timed_DI->m_tbi_SI->m_need_to_invest_opposite_bl == true && this->m_timed_DI->m_tbi_SI->m_opposite_KE_pt != NULL && this->m_timed_DI->m_tbi_SI->m_can_not_explain_opposite_bl == false)
                    {
                        invest_pt->m_KElement_ID_pt = this->m_timed_DI->m_tbi_SI->m_opposite_KE_pt;
                        invest_pt->m_investigator_token = inv::SearchPossibleCauses;
                        invest_pt->m_Happen = 3;
                        /*
                        case_pt = new SymptomCase();
                        case_pt->m_invest_pt = invest_pt;
                        case_pt->m_invest_opposite_bl = true;
                        this->m_timed_DI->m_tbi_SI->m_candidate_case_list.push_back(case_pt);
                        */
                    }
                    else
                    {
                        invest_pt->m_KElement_ID_pt = (IDElement *)this->m_timed_DI->m_tbi_SI->m_symptom_KE_pt;
                        invest_pt->m_investigator_token = inv::FindMatchingStatement;
                        invest_pt->m_Happen = 1;
                    }
                    invest_pt->m_invest_dormant = false;
                    invest_pt->m_interest_from_SymptomInvestigator = this->m_timed_DI->m_tbi_SI->m_attention_level;
                    invest_pt->m_operator = this->m_operator;
                    if(this->m_timed_DI->m_tbi_SI->m_rejected_case_list.size() > 0 && this->m_timed_DI->m_tbi_SI->m_need_to_invest_opposite_bl == false)
                    {invest_pt->m_SI_ID_pt = (IDElement *)this->m_timed_DI->m_tbi_SI;}
                    invest_pt->m_root_of_a_thought_line = true;
                    invest_pt->m_active_investigation = true;
                    RM_pt->AddNewInvestigator(invest_pt);
                    //activate the relevant sentence
                    invest_pt->CrankTheActivationToOne();
                    generated_bl = true;
 
                    //create a new SymptomCase for this
                    //case_pt = new SymptomCase();
                    //case_pt->m_invest_pt = invest_pt;
                    //case_pt->m_finished_bl = false;
                    //this->m_timed_DI->m_tbi_SI->m_candidate_case_list.push_back(case_pt);
                    //
                    cout << this->m_timed_DI->m_tbi_SI->m_candidate_case_list.size();
                    //              conv.str("");
                    conv << r5pars_.timesno;
                    str = "Created " + invest_pt->m_ID + " for " + this->m_timed_DI->m_tbi_SI->m_symptom_KE_pt->m_ID + " at time: ";
                    str += conv.str();
                    this->m_debug_info.push_back(str);                          
                    if(invest_pt->m_ID == "Investigator_308")
                    {this->PrintMessage("");}
            //clear the m_timed_DI
            this->m_timed_DI->m_tbi_SI = NULL;
            this->m_timed_DI = NULL;
            this->m_timing = 0;
            return generated_bl;
        }
        
        if(create_bl == false)
        {
            this->m_timed_DI->m_tbi_SI = NULL;
            this->m_timed_DI = NULL;
            this->m_timing = 0; 
        }
        else
        {return generated_bl;}
    }
 
    //search and initiate for generating the next one to be investigated
    highest_score = 0;
    for(auto &DI_e : this->m_diagnose_invest_list)
    {
        if(ongoing_bl) break;
        DI_e->SearchForTheToBeInvestigatedSI();
        if(DI_e->m_ongoing_SI != NULL)
        {
            if(DI_e->m_ongoing_SI->m_confirmed_case_list.size() == 0 || DI_e->m_ongoing_SI->m_independent_symptom_probability < 0.02)
            {
                ongoing_bl = true;
                ongoing_SI_pt = DI_e->m_ongoing_SI;
                break;
            }
        }
        else if(DI_e->m_tbi_SI != NULL)
        {
            score = DI_e->m_confidence;
            //if(DI_e->m_tbi_SI->m_rejected_case_list.size() > 0 || DI_e->m_tbi_SI->m_confirmed_case_list.size() > 0)
            //{score *= 0.5;}
            //score *= 1 - exp(-0.01 * (r5pars_.timesno - DI_e->m_tbi_SI->m_last_case_end_time));
            if(r5pars_.timesno >2046)
            {this->PrintMessage("");}
            //score *= 1 - exp(-0.01 * (r5pars_.timesno - DI_e->m_tbi_SI->m_last_case_end_time));
            if(score > highest_score && DI_e->m_confidence > this->m_active_investigation_threshold && DI_e->m_confidence < 0.92)
            {
                highest_score = score;
                this->m_timed_DI = DI_e.get();
                //caution: adjust the sclae of m_timing to model active investigation and passive investigation
                //this->m_timing = r5pars_.timesno + max(min(200, 80/pow(score,2)), 5);
                //this->m_timing = r5pars_.timesno + 2*(260 * pow(DI_e->m_confidence,2) - 530 * DI_e->m_confidence + 300);
                this->m_timing = r5pars_.timesno + 672.96 * exp(-2.5*DI_e->m_confidence) * 1.5;
            }
        }
    }
 
 
    if(ongoing_bl == true)
    {
        this->m_timed_DI = NULL;
        this->m_timing = 0;
        invest_pt = (* ongoing_SI_pt->m_candidate_case_list.begin())->m_invest_pt;
 
        //
        if(invest_pt->m_ID == "Investigator_229")
        {this->PrintMessage("Check");}
        //
        if(invest_pt->m_invest_dormant == true)
        {invest_pt->m_invest_dormant = false;}
        ongoing_SI_pt->BoostTheActivationOfOngoingInvestigation();
        conv.str("");
        conv << r5pars_.timesno;
        str = conv.str();
        str += ", working on ";
        str += invest_pt->m_ID;
        this->m_debug_info.push_back(str);
        if(r5pars_.timesno > 1433)
        {this->PrintMessage("Check point!");}
        //
    }
    else
    {
        if(this->m_timed_DI != NULL)
        {
            if(r5pars_.timesno > 2590)
            {this->PrintMessage("");}
            conv.str("");
            conv << r5pars_.timesno;
            str = conv.str();
            str += ", Plan to investigate ";
            str += this->m_timed_DI->m_event_KE_pt->m_ID;
            str += " at ";
            conv.str("");
            conv << this->m_timing;
            str += conv.str();
            this->m_debug_info.push_back(str);
        }
    }
    return generated_bl;
}
 
void EventSchemaBase::SaveAllDiagnoseInvestigatorInforToFile(string _path)
{
    vector<float>::iterator confidence_itr, timeline_itr;
    vector<string>::iterator str_itr;
    vector<float>::iterator Integrated_prob_itr;
    vector<float>::iterator coverage_itr;
    vector<int>::iterator N_setback_itr;
    vector<int>::iterator N_disabled_itr;
    vector<int>::iterator N_voided_itr;
    vector<string>::iterator symp_confidence_itr;
    string str;
    //vector<SymptomCase *>::iterator case_itr;
    DiagnoseInvestigator * DI_pt;
    SymptomInvestigator * SI_pt;
    ofstream fout(_path.c_str(), ios::out);
    for(auto &DI_e : this->m_diagnose_invest_list)
    {
        DI_pt = DI_e.get();
        fout << '\n' << "***Accident Diagnosis:" << DI_pt->m_event_KE_pt->m_ID << '\n';
        fout << "Diagnose Confidence: " << DI_pt->m_confidence;
        for(auto &SI_e : DI_pt->m_symptom_invest_list)
        {
            SI_pt = SI_e.get();
            fout << '\n' << "---Symptom: " << SI_pt->m_symptom_KE_pt->m_ID;
            fout << "; Symptom confidence: " << SI_pt->m_independent_symptom_probability;
            fout << "; Status: ";
            if(SI_pt->m_confirmed_case_list.size() > 0)
            {
                fout << "Confirmed by: ";
                auto &last_confirmed = SI_pt->m_confirmed_case_list.back();
                fout << last_confirmed->m_invest_pt->m_ID << " " << last_confirmed->m_confirmed_time;
            }
            else if(SI_pt->m_voided_case_list.size() > 0)
            {
                fout << "Voided by: ";
                auto &last_voided = SI_pt->m_voided_case_list.back();
                fout << last_voided->m_invest_pt->m_ID;
            }
            else if(SI_pt->m_exception_case_list.size() > 0)
            {
                fout << "Exception found: ";
                auto &last_exception = SI_pt->m_exception_case_list.back();
                fout << last_exception->m_invest_pt->m_ID << " " << last_exception->m_exception_time;
            }
            else if(SI_pt->m_rejected_case_list.size() > 0)
            {
                fout << "Rejected by: ";
                auto &last_rejected = SI_pt->m_rejected_case_list.back();
                fout << last_rejected->m_invest_pt->m_ID << " " << last_rejected->m_rejection_time;
            }
            else if(SI_pt->m_candidate_case_list.size() > 0)
            {
                fout << "Unfinished: ";
            }
            else
            {
                fout << "miscellaneous";
            }
            fout << " N_confirmation " << SI_pt->m_confirmed_case_list.size();
            for(auto &ce : SI_pt->m_confirmed_case_list)
            {
                fout << ce->m_invest_pt->m_ID << "||";
            }
            fout << " N_voided " << SI_pt->m_voided_case_list.size();
            for(auto &ce : SI_pt->m_voided_case_list)
            {
                fout << ce->m_invest_pt->m_ID << "||";
            }
 
            fout << " N_exception " << SI_pt->m_exception_case_list.size();
            for(auto &ce : SI_pt->m_exception_case_list)
            {
                fout << ce->m_invest_pt->m_ID << "||";
            }
            fout << " N_rejection " << SI_pt->m_rejected_case_list.size();
            for(auto &ce : SI_pt->m_rejected_case_list)
            {
                fout << ce->m_invest_pt->m_ID << "||";
            }
            fout << " N_inconsist " << SI_pt->m_inconsistant_case_list.size();
            for(auto &ce : SI_pt->m_inconsistant_case_list)
            {
                fout << ce->m_invest_pt->m_ID << "||";
            }
            fout << " N_candidate " << SI_pt->m_candidate_case_list.size();
            for(auto &ce : SI_pt->m_candidate_case_list)
            {
                fout << ce->m_invest_pt->m_ID << "||";
            }
 
        }
        fout << '\n' << "Timeline of the confidence level";
        /*
    vector<float>::iterator Integrated_prob_itr;
    vector<float>::iterator coverage_itr;
    vector<int>::iterator N_setback_itr;
    vector<int>::iterator N_disabled_itr;
    vector<string>::iterator symp_confidence_itr;
    */
        confidence_itr = DI_pt->m_confidence_history.begin();
        timeline_itr = DI_pt->m_confidence_timeline.begin();
        Integrated_prob_itr = DI_pt->m_Integrated_prob_list.begin();
        coverage_itr = DI_pt->m_coverage_list.begin();
        N_setback_itr = DI_pt->m_N_setback_list.begin();
        N_disabled_itr = DI_pt->m_N_disabled_list.begin();
        N_voided_itr = DI_pt->m_N_voided_list.begin();
        symp_confidence_itr = DI_pt->m_symp_confidence_list.begin();
 
        fout << '\n';
        fout << "time" << '\t' << '\t'
            << "confidence" << '\t' << '\t'
            << "Integrated_confidence" << '\t' << '\t'
            << "Coverage" << '\t' << '\t'
            << "N_setback" << '\t' << '\t'
            << "N_blocked" << '\t' << '\t'
            << "N_voided" << '\t' << '\t'
            << "symptom_confidence";
 
        while(confidence_itr != DI_pt->m_confidence_history.end())
        {
            fout << '\n' 
                << *timeline_itr << '\t' << '\t' 
                << *confidence_itr << '\t' << '\t'
                << *Integrated_prob_itr << '\t' << '\t'
                << *coverage_itr << '\t' << '\t'
                << *N_setback_itr << '\t' << '\t'
                << *N_disabled_itr << '\t' << '\t'
                << *N_voided_itr << '\t' << '\t'
                << *symp_confidence_itr  << '\t' << '\t';
 
            confidence_itr++;
            timeline_itr++;
            Integrated_prob_itr++;
            coverage_itr++;
            N_setback_itr++;
            N_disabled_itr++;
            N_voided_itr++;
            symp_confidence_itr++;
        }
        fout << '\n';
        
        if(DI_pt->m_other_evidence_list.size() > 0)
        {
            fout << "Other evidence information: " << '\n';
            for(auto &tvn_e : DI_pt->m_other_evidence_list)
            {
                fout << tvn_e->m_string << '\t'
                     << tvn_e->m_value << '\t'
                     << tvn_e->m_note <<'\t'
                     << tvn_e->m_time << '\n';
            }
        }
    }
 
    for(str_itr = this->m_debug_info.begin(); str_itr != this->m_debug_info.end(); str_itr++)
    {
        str = *str_itr;
        fout << '\n';
        //fout << *str_itr << '\n';
        fout << str ;
 
    }
    
    fout.close();
}
 
 
void EventSchemaBase::AddNewSymptomCaseWithNewInvestigatorIfNecessary(Investigator *_invest_pt)
{
    DiagnoseInvestigator * DI_pt;
    SymptomInvestigator * SI_pt;
    bool match_bl = false;
    bool exist_bl = false;
    bool opposite_bl;
    SymptomCase * case_pt;
 
    for(auto &DI_e : this->m_diagnose_invest_list)
    {
        DI_pt = DI_e.get();
        for(auto &SI_e : DI_pt->m_symptom_invest_list)
        {
            match_bl = false;
            exist_bl = false;
            SI_pt = SI_e.get();
            match_bl = false;
            opposite_bl = false;
            if(_invest_pt->m_KElement_ID_pt != NULL)
            {
                if((IDElement *)SI_pt->m_symptom_KE_pt == _invest_pt->m_KElement_ID_pt)
                {
                    match_bl = true;
                }
                else if((IDElement *)SI_pt->m_opposite_KE_pt == _invest_pt->m_KElement_ID_pt )
                {
                    match_bl = true;
                    opposite_bl = true;
                }
            }
            else if(_invest_pt->m_Statement_pt != NULL)
            {
                if(_invest_pt->m_Statement_pt->m_sent_pt == SI_pt->m_symptom_KE_pt->m_SentenceUnit_pt)
                {
                    if(_invest_pt->m_Statement_pt->m_state == !SI_pt->m_symptom_KE_pt->m_negation)
                    {
                        match_bl = true;
                    }
                }
                else if(SI_pt->m_opposite_KE_pt != NULL)
                {
                 if(_invest_pt->m_Statement_pt->m_sent_pt == SI_pt->m_opposite_KE_pt->m_SentenceUnit_pt
                     && _invest_pt->m_Statement_pt->m_state == !SI_pt->m_opposite_KE_pt->m_negation)
                 {
                     match_bl = true;
                     opposite_bl = true;
                 }
                }
            }
 
            if(match_bl == true)
            {
                for(auto &case_e : SI_pt->m_candidate_case_list)
                {
                    if(case_e->m_invest_pt == _invest_pt)
                    {
                        exist_bl = true;
                    }
                }
                if(exist_bl == false)
                {
                    auto case_owned = std::make_unique<SymptomCase>();
                    case_owned->m_invest_pt = _invest_pt;
                    case_owned->m_finished_bl = false;
                    case_owned->m_invest_opposite_bl = opposite_bl;
                    SI_pt->m_candidate_case_list.push_back(std::move(case_owned));
                }
            }
        }//end of SI_itr
    }//end of DI_itr
}
 
 
 
void EventSchemaBase::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 EventSchemaBase::CrossCheckProcedureUse()
{
    if(this->m_operator != sim::Operator::ODM)
    {return;}
 
    //Concern: if there are more than one accident diagnosises active and they all link to procedures
    //The situation covered by the current codes: only one diagnosis is active and links to a procedure;
    for(auto &e : this->m_diagnose_invest_list)
    {
        if(e->m_procedure_step_pt != NULL && e->m_procedure_entered_bl == false)
        {
            e->CheckforPotentialProcedureBranching();
        }
    }
 
}
 
void EventSchemaBase::ConvertStaticESBinfoToString()
{
    for(auto &e : this->m_event_schema_list)
    {
        e->ConvertESUinfoToString();
    }
}
 
void EventSchemaBase::CopyESBinfoFromAnother(EventSchemaBase * _ESB_pt)
{
/*
    int m_operator;
    float m_diagnose_claim_threshold;
    float m_timing; // this timer is used for generating a new investigator
*/
    this->CopyIDElementToRestartInfo((IDElement*)_ESB_pt);
    this->m_diagnose_claim_threshold = _ESB_pt->m_diagnose_claim_threshold;
    this->m_operator = _ESB_pt->m_operator;
    this->m_timing = _ESB_pt->m_timing;
    this->m_active_investigation_threshold = _ESB_pt->m_active_investigation_threshold;
/*
    DiagnoseInvestigator * m_timed_DI;
    string m_ID_timed_DI;
*/
    if(_ESB_pt->m_timed_DI != NULL)
    {this->m_ID_timed_DI = _ESB_pt->m_timed_DI->m_ID;}
    else
    {this->m_ID_timed_DI = _ESB_pt->m_ID_timed_DI;}
 
    if(this->m_event_schema_list.size() != 0)
    {this->ErrorMessage("this->m_event_schema_list.size() != 0");return;}
    if(this->m_diagnose_invest_list.size() != 0)
    {this->ErrorMessage("this->m_diagnose_invest_list.size() != 0"); return;}
    if(this->m_interested_invest_list.size() != 0)
    {this->ErrorMessage("this->m_interested_invest_list.size() != 0"); return;}
    if(this->m_interested_invest_link_list.size() != 0)
    {this->ErrorMessage("this->m_interested_invest_link_list.size() != 0"); return;}
    if(this->m_debug_info.size() != 0)
    {this->ErrorMessage("this->m_debug_info.size() != 0"); return;}
/*
    vector<EventSchemaUnit *> m_event_schema_list;
    vector<DiagnoseInvestigator *> m_diagnose_invest_list;
    vector<string> m_debug_info;
*/
    for(auto &e : _ESB_pt->m_event_schema_list)
    {
        auto es_pt = std::make_unique<EventSchemaUnit>();
        es_pt->CopyESUInfoWithoutPointerFromAnother(e.get());
        this->m_event_schema_list.push_back(std::move(es_pt));
    }
 
    for(auto &e : _ESB_pt->m_diagnose_invest_list)
    {
        auto di_pt = std::make_unique<DiagnoseInvestigator>();
        di_pt->CopyDiagnoseInvestigatorInfoFromAnother(e.get());
        this->m_diagnose_invest_list.push_back(std::move(di_pt));
    }
 
    vector<string>::iterator str_itr;
    string str;
    for(str_itr = _ESB_pt->m_debug_info.begin(); str_itr != _ESB_pt->m_debug_info.end(); str_itr++)
    {
        str = *str_itr;
        this->m_debug_info.push_back(str);
    }
 
/*  
    vector<Investigator *> m_interested_invest_list;
    vector<InvestigatorLink *> m_interested_invest_link_list;
 
    vector<string> m_ID_interested_invest_list;
    vector<string> m_ID_interested_invest_link_list;
*/
 
    vector<Investigator *>::iterator invest_itr;
    string ID;
    if(_ESB_pt->m_interested_invest_list.size() != 0)
    {
        for(invest_itr = _ESB_pt->m_interested_invest_list.begin(); invest_itr != _ESB_pt->m_interested_invest_list.end(); invest_itr++)
        {
            ID = (*invest_itr)->m_ID;
            this->m_ID_interested_invest_list.push_back(ID);
        }
    }
    else
    {
        for(str_itr = _ESB_pt->m_ID_interested_invest_list.begin(); str_itr != _ESB_pt->m_ID_interested_invest_list.end(); str_itr++)
        {
            ID = *str_itr;
            this->m_ID_interested_invest_list.push_back(ID);
        }
    }
 
    vector<InvestigatorLink *>::iterator link_itr;
    if(_ESB_pt->m_interested_invest_link_list.size() != 0)
    {
        for(link_itr = _ESB_pt->m_interested_invest_link_list.begin(); link_itr != _ESB_pt->m_interested_invest_link_list.end(); link_itr++)
        {
            ID = (*link_itr)->m_ID;
            this->m_ID_interested_invest_link_list.push_back(ID);
        }
    }
    else
    {
        for(str_itr = _ESB_pt->m_ID_interested_invest_link_list.begin(); str_itr != _ESB_pt->m_ID_interested_invest_link_list.end(); str_itr++)
        {
            ID = *str_itr;
            this->m_ID_interested_invest_link_list.push_back(ID);
        }
    }
}
 
DiagnoseInvestigator * EventSchemaBase::FindDiagnoseInvestigatorByID(string _ID)
{
    DiagnoseInvestigator * found_di = NULL;
 
    for(auto &e : this->m_diagnose_invest_list)
    {
        if(found_di != NULL) break;
        if(e->m_ID == _ID)
        {
            found_di = e.get();
        }
    }
    return found_di;
}
 
SymptomInvestigator * EventSchemaBase::FindSymtomInvestigatorByID(string _ID)
{
    SymptomInvestigator * found_SI = NULL;
 
    for(auto &DI_e : this->m_diagnose_invest_list)
    {
        if(found_SI != NULL) break;
        for(auto &SI_e : DI_e->m_symptom_invest_list)
        {
            if(found_SI != NULL) break;
            if(SI_e->m_ID == _ID)
            {found_SI = SI_e.get();}
        }
    }
    return found_SI;
}
 
void EventSchemaBase::BuildTheConnectionsForThisEventSchemaBase(void * _pt)
{
    ReasonMachine * RM_pt;
    RM_pt = (ReasonMachine*)_pt;
/*
    DiagnoseInvestigator * m_timed_DI;
    string m_ID_timed_DI;
*/
    if(this->m_ID_timed_DI.compare("") != 0)
    {
        this->m_timed_DI = this->FindDiagnoseInvestigatorByID(this->m_ID_timed_DI);
        if(this->m_timed_DI == NULL)
        {this->ErrorMessage("this->m_timed_DI == NULL"); return;}
    }
    this->m_ID_timed_DI = "";
/*
    vector<Investigator *> m_interested_invest_list;
    vector<InvestigatorLink *> m_interested_invest_link_list;
 
    vector<string> m_ID_interested_invest_list;
    vector<string> m_ID_interested_invest_link_list;
*/
    Investigator * invest_pt;
    InvestigatorLink * link_pt;
 
    vector<string >::iterator str_itr;
    for(str_itr = this->m_ID_interested_invest_list.begin(); str_itr != this->m_ID_interested_invest_list.end(); str_itr++)
    {
        invest_pt = RM_pt->FindInvestigatorByID(*str_itr);
        if(invest_pt == NULL)
        {this->ErrorMessage("invest_pt == NULL ESB"); return;}
        this->m_interested_invest_list.push_back(invest_pt);
    }
    this->m_ID_interested_invest_list.clear();
 
    for(str_itr = this->m_ID_interested_invest_link_list.begin(); str_itr != this->m_ID_interested_invest_link_list.end(); str_itr++)
    {
        link_pt = RM_pt->FindInvestigatorLinkByID(*str_itr);
        if(link_pt == NULL)
        {this->ErrorMessage("link_pt == NULL ESB"); return;}
        this->m_interested_invest_link_list.push_back(link_pt);
    }
    this->m_ID_interested_invest_link_list.clear();
 
    //vector<unique_ptr<EventSchemaUnit>> m_event_schema_list;
    for(auto &esu_e : this->m_event_schema_list)
    {esu_e->BuildConnectionsForThisESU(_pt);}
 
    //vector<unique_ptr<DiagnoseInvestigator>> m_diagnose_invest_list;
    for(auto &di_e : this->m_diagnose_invest_list)
    {di_e->BuildConnectionsForThisDiagnoseInvestigator(_pt);}
 
}
 
EventSchemaUnit * EventSchemaBase::FindEventSchemaUnitByID(string _ID)
{
    EventSchemaUnit * found_esu = NULL;
    for(auto &e : this->m_event_schema_list)
    {
        if(found_esu != NULL) break;
        if(e->m_ID == _ID)
        {found_esu = e.get();}
    }
    return found_esu;
}
 
EventSymptomUnit * EventSchemaBase::FindEventSymptomUnitByID(string _ID)
{
    EventSymptomUnit * found_symp = NULL;
    for(auto &schema_e : this->m_event_schema_list)
    {
        if(found_symp != NULL) break;
        for(auto &symp_e : schema_e->m_symptom_list)
        {
            if(found_symp != NULL) break;
            if(symp_e->m_ID == _ID)
            {found_symp = symp_e.get();}
        }
    }
    return found_symp;
}
 
void EventSchemaBase::UpdateTheBranchingHistory(void * _pt)
{
    for(auto &e : this->m_diagnose_invest_list)
    {
        e->UpdateDiagnoseInvestigatorBranchingInfo(_pt);
    }
}
 
//DEL void EventSchemaBase::test()
//DEL {
//DEL }
 
//DEL float EventSchemaBase::m_active_investigation_threshold()
//DEL {
//DEL 
//DEL }
 
void EventSchemaBase::RemoveAllTheCaseAssociatedWithAnInvestigator(IDElement * _ID_pt)
{
    Investigator * invest_pt = (Investigator*) _ID_pt;
    SymptomInvestigator * SI_pt;
    SymptomCase * case_pt;
    int i;
 
    if(invest_pt->m_KElement_ID_pt != NULL)
    {
        if(invest_pt->m_KElement_ID_pt->m_ID == "KE_SG_A_level_increase" && r5pars_.timesno > 1868)
        {this->PrintMessage("");}
    }
 
    for(auto &DI_e : this->m_diagnose_invest_list)
    {
        for(auto &SI_e : DI_e->m_symptom_invest_list)
        {
            SI_pt = SI_e.get();
            i = 0;
            while(i < (int)SI_pt->m_candidate_case_list.size())
            {
                case_pt = SI_pt->m_candidate_case_list[i].get();
                if(case_pt->m_invest_pt->m_ID == _ID_pt->m_ID)
                {
                    //this symptom case will be removed into three places:
                    //1--discarded list
                    //2--rejection list
                    //3--vioded list, which means the symptom is observed but there is one or more stronger competing explanation to account for it.
 
                    case_pt->m_finished_bl = true;
                    if(case_pt->m_invest_pt->m_Happen == 4)
                    {
                        case_pt->m_rejection_time = r5pars_.timesno;
                        SI_pt->m_last_case_end_time = r5pars_.timesno;
                        SI_pt->MoveCaseFromCandidateTo(case_pt, SI_pt->m_rejected_case_list);
                    }
                    else if(case_pt->m_invest_pt->m_Happen == 2)
                    {
                        SI_pt->MoveCaseFromCandidateTo(case_pt, SI_pt->m_discarded_case_list);
                    }
                    else if(case_pt->m_invest_pt->m_Happen == 3)
                    {//need to create a list of voided symptom cases
                        if(case_pt->m_invest_pt->m_ID == "Investigator_3")
                        {case_pt = case_pt;}//check point
                        SI_pt->m_last_case_end_time = r5pars_.timesno;
                        //
                        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("");
                        }
                        //
                        SI_pt->MoveCaseFromCandidateTo(case_pt, SI_pt->m_voided_case_list);
                    }
                    else
                    {
                        SI_pt->RemoveADeterminedCaseFromCandiateList(case_pt);
                    }
                }
                else
                {i++;}
            }
        }
    }
}
 
bool EventSchemaBase::WhetherItIsNormalOperating()
{
    bool normal_bl = true;
 
    //if(this->m_operator != sim::Operator::ODM)
    //{return ;}
 
    //Concern: if there are more than one accident diagnosises active and they all link to procedures
    //The situation covered by the current codes: only one diagnosis is active and links to a procedure;
    for(auto &e : this->m_diagnose_invest_list)
    {
        //if(e->m_confidence > 0.2)
        if(e->m_claim_bl == true)
        {normal_bl = false;}
    }
    return normal_bl;
}