MRParameterUnit.cpp

Go to the documentation of this file.

// MRParameterUnit.cpp: implementation of the MRParameterUnit class.
//
 
#include <string>
#include <sstream>
#include <iostream>
#include <fstream>
 
#include "MRParameterUnit.h"
#include "SentenceUnit.h"
#include "../Crew/OperatorDM.h"
#include "../Crew/OperatorAT.h"
#include "ReasonMachine.h"
#include "Statement.h"
#include "Investigator.h"
#include "KnowledgeElement.h"
#include "../Global/SimulationContext.h"
 
using namespace std;
 
 
// Construction/Destruction
 
MRParameterUnit::MRParameterUnit()
{
    this->m_ID_Type = 201;
    this->m_Concept_ID_pt = NULL;
    this->m_recent_trend = NULL;
    this->m_parameter_concept_ID = "";
    this->m_ID_recent_trend = "";
    //201--MRParameterUnit
    //202--MRComponentStateUnit
    //203--MRAlarmUnit
}
 
MRParameterUnit::~MRParameterUnit()
{
    this->m_parameter_history_value.clear();
    this->m_parameter_history_rate.clear();
}
 
void MRParameterUnit::AddNewValue(float NewValue, int _operator, bool _expecting)
{
    string prompt;
    stringstream conv;
    SentenceUnit * found_sent_pt;
    SentenceUnit * sent_pt;
    Investigator * invest_pt;
    ReasonMachine * RM_pt;
    Statement * statement_pt;
    decltype(RM_pt->m_Statement_list)::reverse_iterator state_ritr;
    decltype(RM_pt->m_investigator_pool)::reverse_iterator invest_ritr;
    Statement * new_statement_pt;
    bool NewStatement_bl = false;
    bool new_invest_bl = false;
    bool stop_bl = false;
    KnowledgeElement * KE_pt;
 
    vector<SentenceUnit *> sent_list;
    vector<SentenceUnit *>::iterator sent_itr;
    float value1, value2;
    MRParameterUnit * MP_pt;
    int order = 0;
 
    prompt = "Received new reading of ";
    prompt += this->m_parameter_indicator_ID;
    prompt += ": ";
    conv.str("");
    conv << NewValue;
    prompt += conv.str();
    this->PrintMessage(prompt);
 
    if (_operator == sim::Operator::ODM)
    {RM_pt = g_sim.Decision_Maker.m_RM.get();}
    else if (_operator == sim::Operator::OAT)
    {RM_pt = g_sim.Action_Taker.m_RM.get();}
    else
    {}//add error message 
 
 
    if(this->m_Concept_ID_pt->m_ID == "SG_B_WR_level")
    {this->ErrorMessage("");}
    //Function: 
    //if the new received value is bigger than the last received value--difference bigger than threshold
    //if the last received rate was not "increasing"
    //that means the parameter increased between the two consecutive readings
 
    int trend_int = 0; // 1, increasing trend; 2, decreasing trend; 3, stable trend; 0, not enought info to observe trend   
/*  if(this->m_recent_trend != NULL)
    {
        if(this->m_recent_trend->m_sent_pt->m_ID == "PRZ_level_decrease")
        {this->PrintMessage("");}
    }
    */
    RM_pt->AddDeltaToCognitiveLoad(0.024);
    if(this->m_recent_parameter_value != NULL)
    {
        if((NewValue - this->m_recent_parameter_value->m_perceived_value) > this->m_increase_threshold)
        {       
            trend_int = 1;
        }//end of increase analysis
        else if ((NewValue - this->m_recent_parameter_value->m_perceived_value) < this->m_decrease_threshold)
        {
            trend_int = 2;
        }//end of decrease analysis     
        else
        {
            //if two observations are very close to each other. A small difference between readings is not evidence to show it is stable
            //only when the difference is smaller than the rate * deltaT, it concludes a stable state
            //if the difference is bigger than the rate * deltaT, we believe that "AddNewRate" function might catch this trend. 
            //Or else there is a fuzzy zone that it doesn't give a statement.
            if((NewValue - this->m_recent_parameter_value->m_perceived_value) < this->m_increase_rate_threshold * (r5pars_.timesno - this->m_recent_parameter_value->m_time_perceived)
                &&
               (NewValue - this->m_recent_parameter_value->m_perceived_value) > this->m_decrease_rate_threshold * (r5pars_.timesno - this->m_recent_parameter_value->m_time_perceived))
            {trend_int = 3;}
            
            //if a parameter drops below the indication range, do not generate a stable statement
            //Right now we use 0 as the lower bound for all indication ranges
            //ways to expand in future: a) use specific lower range value for each indication; 2) generate false "stable" indication; 
            if(NewValue < 0.0001)
            {trend_int = 0;}
            trend_int = 0;
        }
 
        switch (trend_int)
        {
        case 0:
            break;
        case 1:
            //increase trend
            if(this->m_recent_trend == NULL)
            {NewStatement_bl = true;}
            else if(this->m_recent_trend->m_sent_pt->m_process_pt != RM_pt->m_Concept_Base->getIncreasePt())
            {NewStatement_bl = true;}
            else if(this->m_recent_trend->m_investigator_ID_pt == NULL)
            {NewStatement_bl = true;}
            if(NewStatement_bl == true)
            {
                new_invest_bl = true;
                SentenceUnit increase_sent;
                increase_sent.m_sentence_type = 1;
                increase_sent.m_subject_pt = this->m_Concept_ID_pt;
                increase_sent.m_process_pt = RM_pt->m_Concept_Base->getIncreasePt();
                found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&increase_sent);
            }
            break;
        case 2:
            //decrease trend
            if(this->m_recent_trend == NULL)
            {NewStatement_bl = true;}
            else if(this->m_recent_trend->m_sent_pt->m_process_pt != RM_pt->m_Concept_Base->getDecreasePt())
            {NewStatement_bl = true;}
            else if(this->m_recent_trend->m_investigator_ID_pt == NULL)
            {NewStatement_bl = true;}
            if(NewStatement_bl == true)
            {
                new_invest_bl = true;
                SentenceUnit decrease_sent;
                decrease_sent.m_sentence_type = 1;
                decrease_sent.m_subject_pt = this->m_Concept_ID_pt;
                decrease_sent.m_process_pt = RM_pt->m_Concept_Base->getDecreasePt();
                found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&decrease_sent);
            }
            break;
        case 3:
            //stable trend
            if(this->m_recent_trend == NULL)
            {NewStatement_bl = true;}
            else if(this->m_recent_trend->m_sent_pt->m_process_pt != RM_pt->m_Concept_Base->getStablePt())
            {NewStatement_bl = true;}
            if(NewStatement_bl == true)
            {
                new_invest_bl = false;
                SentenceUnit stable_sent;
                stable_sent.m_sentence_type = 1;
                stable_sent.m_subject_pt = this->m_Concept_ID_pt;
                stable_sent.m_process_pt = RM_pt->m_Concept_Base->getStablePt();
                found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&stable_sent);
            }
            break;
        default:
            break;
        }
 
        if(found_sent_pt != NULL && NewStatement_bl == true)
        {
            //new phenomenon, need to add a new statement
            auto stmt = make_unique<Statement>();
            stmt->m_sent_pt = found_sent_pt;
            stmt->m_state = true;
            stmt->m_time_range.m_time_before = r5pars_.timesno;
            stmt->m_time_range.m_time_after = this->m_recent_parameter_value->m_time_perceived;
            stmt->m_confidence = 0.9;
            stmt->m_factual_type = 2; //inferred fact
            statement_pt = stmt.get();
            this->m_recent_trend = statement_pt;
            RM_pt->AddANewStatement(stmt.release());
            RM_pt->AddDeltaToSystemDynamics(0.12);
 
            if(_expecting == true)
            {
                sent_pt = RM_pt->m_working_on_invest_pt->GetSemanticSentenceOfThisInvestigator();
                if(statement_pt->m_sent_pt == sent_pt)
                {
                    RM_pt->m_working_on_invest_pt->m_Statement_pt = statement_pt;
                    RM_pt->AddDeltaToCognitiveLoad(0.024);
                    statement_pt->m_investigator_ID_pt = (IDElement*)(RM_pt->m_working_on_invest_pt);
                    new_invest_bl = false;
                }
            }
 
            if(statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getStablePt())
            {
                statement_pt->m_tbi_bl = false;
            }
            else if( new_invest_bl == true)
            {
                //Add an investigator for this statement
                auto inv = make_unique<Investigator>();
                inv->m_note = "by a statement";
                inv->m_motivation = 1;
                inv->m_Happen = 3;
                inv->m_Statement_pt = statement_pt;
                RM_pt->AddDeltaToCognitiveLoad(0.024);
                inv->m_operator = this->m_operator;
                inv->m_root_of_a_thought_line = true;
                invest_pt = inv.get();
                RM_pt->AddNewInvestigator(inv.release());
                //link the statement to the statement pointer
                statement_pt->m_investigator_ID_pt = (IDElement*)invest_pt;
            }
        }
        else if(this->m_recent_trend != NULL)
        {
            this->m_recent_trend->RefreshStatementEndTimeToCurrentTime(0); //need to improve; value only updates the 0 type; while rate updates the 1 type
            //RM_pt->ActivationUpdateByRefreshAStatement(this->m_recent_trend);
            //update the existing statement
        }
        this->m_parameter_history_value.push_back(std::move(this->m_recent_parameter_value));
    }
    //if this is the first reading
    this->m_recent_parameter_value = make_unique<MRValueSchema>();
    this->m_recent_parameter_value->m_time_perceived = r5pars_.timesno;
    this->m_recent_parameter_value->m_perceived_value = NewValue;
    this->UpdateTheRelevantInvestigator(_operator);
 
//***************************************************************
// comparing the perceived value with other parameter or values
//***************************************************************
 
//Interpretation with comparison sentences
    for(auto &sem_e : RM_pt->m_Semantic_list)
    {
        if(sem_e->m_sentence_type == 3 || sem_e->m_sentence_type == 4)
        {
            if(sem_e->m_subject_pt == this->m_Concept_ID_pt || sem_e->m_object_pt == this->m_Concept_ID_pt)
            {
                sent_list.push_back(sem_e.get());
            }
        }
    }
 
 
    if(this->m_Concept_ID_pt->m_ID == "SG_A_WR_level" && r5pars_.timesno > 1150)
    {this->PrintMessage("check");}
 
//Looping
    for(sent_itr = sent_list.begin(); sent_itr != sent_list.end(); sent_itr++)
    {
        new_statement_pt = NULL;
        NewStatement_bl = false;
        value1 = 0;
        value2 = 0;
        order = 1; // 1--A >=< B; 2--B >=< A
 
        sent_pt = *sent_itr;
        switch (sent_pt->m_sentence_type)
        {
        case 3:
            value1 = NewValue;
            value2 = sent_pt->m_value;
            //compare the values
            if(sent_pt->m_comparison_pt == RM_pt->m_Concept_Base->getBiggerPt())
            {
                if(value1 > value2)
                {
                    NewStatement_bl = true;
                }
            }
            else if(sent_pt->m_comparison_pt == RM_pt->m_Concept_Base->getSmallerPt())
            {
                if(value1 < value2)
                {
                    NewStatement_bl = true;
                }
            }
            else
            {break;}
            break;
        case 4:
            //assign one value
            if(sent_pt->m_subject_pt == this->m_Concept_ID_pt)
            {
                value1 = NewValue;
                order = 1;
                MP_pt = (MRParameterUnit *)(RM_pt->m_MR->CheckExistenceByConceptName(sent_pt->m_object_pt->m_ID));
            }
            else if(sent_pt->m_object_pt == this->m_Concept_ID_pt)
            {
                value2 = NewValue;
                order = 2;
                MP_pt = (MRParameterUnit *)(RM_pt->m_MR->CheckExistenceByConceptName(sent_pt->m_subject_pt->m_ID));
            }
            else
            {break;}
 
            //get the other value
            if(MP_pt == NULL)
            {break;}
            if(MP_pt->m_recent_parameter_value == NULL)
            {break;}
            if(MP_pt->m_recent_parameter_value->m_time_perceived < r5pars_.timesno - 8)
            {break;}
 
            if(order == 1)
            {
                value2 = MP_pt->m_recent_parameter_value->m_perceived_value;
            }
            else if(order == 2)
            {
                value1 = MP_pt->m_recent_parameter_value->m_perceived_value;
            }
            else
            {break;}
 
            //compare these two values
            if(sent_pt->m_comparison_pt == RM_pt->m_Concept_Base->getBiggerPt())
            {
                if(value1 > value2 + sent_pt->m_delta_value)
                {
                    NewStatement_bl = true;
                }
            }
            else if(sent_pt->m_comparison_pt == RM_pt->m_Concept_Base->getSmallerPt())
            {
                if(value1 < value2 - sent_pt->m_delta_value)
                {
                    NewStatement_bl = true;
                }
            }
            else if(sent_pt->m_comparison_pt == RM_pt->m_Concept_Base->getEqualPt())
            {
                if(value1 > value2 - sent_pt->m_delta_value && value1 < value2 + sent_pt->m_delta_value)
                {
                    NewStatement_bl = true;
                }
            }
            else
            {break;}
 
            break;
        default:
            break;
        }
 
        //create a new statement if needed
        if(NewStatement_bl == true)
        {
            auto stmt = make_unique<Statement>();
            stmt->m_sent_pt = sent_pt;
            stmt->m_state = true;
            stmt->m_time_generated = r5pars_.timesno;
            stmt->m_time_range.m_start_time = r5pars_.timesno;
            stmt->m_time_range.m_end_time = r5pars_.timesno;
            stmt->m_confidence = 1;
            new_statement_pt = stmt.get();
            RM_pt->AddANewStatement(stmt.release());
            //whether to initiate an investigation item for this statement
 
            new_invest_bl = false;
            invest_pt = NULL;
            statement_pt = NULL;
 
            //search for a recent corresponding statement
            stop_bl = false;
            for(state_ritr = RM_pt->m_Statement_list.rbegin(); state_ritr != RM_pt->m_Statement_list.rend() && statement_pt == NULL && stop_bl == false; state_ritr++)
            {
                if(state_ritr->get() != new_statement_pt)
                {statement_pt = state_ritr->get();}
                else if((*state_ritr)->m_time_range.GetTimeBoundLater() < r5pars_.timesno - 600)
                {stop_bl = true;}
            }
 
            //search for a recent corresponding Investigator
            stop_bl = false;
            for(invest_ritr = RM_pt->m_investigator_pool.rbegin(); invest_ritr != RM_pt->m_investigator_pool.rend() && invest_pt == NULL && stop_bl == false; invest_ritr++)
            {
                if((*invest_ritr)->m_KElement_ID_pt != NULL)
                {
                    KE_pt = (KnowledgeElement*)((*invest_ritr)->m_KElement_ID_pt);
                    if(KE_pt->m_SentenceUnit_pt == sent_pt && KE_pt->m_negation == false)
                    {invest_pt = invest_ritr->get();}
                }
                else if((*invest_ritr)->m_Statement_pt != NULL)
                {
                    if((*invest_ritr)->m_Statement_pt->m_sent_pt == sent_pt)
                    {invest_pt = invest_ritr->get();}
                }
                else if((*invest_ritr)->m_investigation_initiate_time < r5pars_.timesno - 600)
                {stop_bl = true;}
            }
 
            if(invest_pt == NULL)
            {new_invest_bl = true;}
            else
            {
                if(invest_pt->m_Happen == 2 || invest_pt->m_Happen == 4)
                {new_invest_bl = true;}
                else if(invest_pt->m_explained == 4)
                {new_invest_bl = true;}
                else if(invest_pt->m_explained == 3 || invest_pt->m_explained == 2)
                {
                    if(statement_pt == NULL)
                    {new_invest_bl = true;}
                    else if(statement_pt->m_time_range.GetTimeBoundEarlier() < r5pars_.timesno - 300)
                    {new_invest_bl = true;}
                }
            }
 
            if(new_invest_bl == true)
            {
                //initiate a new investigator here
                auto inv = make_unique<Investigator>();
                inv->m_note = "by a statement";
                inv->m_motivation = 1;
                inv->m_Happen = 3;
                inv->m_Statement_pt = new_statement_pt;
                RM_pt->AddDeltaToCognitiveLoad(0.024);
                inv->m_operator = this->m_operator;
                inv->m_root_of_a_thought_line = true;
                invest_pt = inv.get();
                RM_pt->AddNewInvestigator(inv.release());
                //link the statement to the statement pointer
                new_statement_pt->m_investigator_ID_pt = (IDElement*)invest_pt;
            }
        }
    }//end of iteration of the list of sentences sent_pt
 
}
 
void MRParameterUnit::AddNewRate(float NewValue, int _operator, bool _expecting)
{
    SentenceUnit * found_sent_pt;
    SentenceUnit * sent_pt;
    ReasonMachine * RM_pt;
    Investigator * invest_pt;
    Statement * statement_pt;
    bool NewStatement_bl = false;
 
 
 
    string ID_name;
    string prompt;
    stringstream conv;
    prompt = "Received new reading of ";
    prompt += this->m_parameter_rate_indicator_ID;
    prompt += ": ";
    conv.str("");
    conv << NewValue;
    prompt += conv.str();
    this->PrintMessage(prompt);
 
    if (_operator == sim::Operator::ODM)
    {RM_pt = g_sim.Decision_Maker.m_RM.get();}
    else if (_operator == sim::Operator::OAT)
    {RM_pt = g_sim.Action_Taker.m_RM.get();}
    else
    {}//add error message 
 
    if(r5pars_.timesno > 1111)
    {this->PrintMessage("");}
 
    RM_pt->AddDeltaToCognitiveLoad(0.024);
    if(NewValue > this->m_increase_rate_threshold)
    {//parameter increase
        SentenceUnit increase_sent;
        increase_sent.m_sentence_type = 1;
        increase_sent.m_subject_pt = this->m_Concept_ID_pt;
        increase_sent.m_process_pt = RM_pt->m_Concept_Base->getIncreasePt();
        found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&increase_sent);
        if(found_sent_pt != 0 )
        {
            if(this->m_recent_trend == NULL)
            {NewStatement_bl = true;}
            else if(this->m_recent_trend->m_sent_pt->m_process_pt != RM_pt->m_Concept_Base->getIncreasePt())
            {NewStatement_bl = true;}
            else if(this->m_recent_trend->m_investigator_ID_pt == NULL)
            {NewStatement_bl = true;}
        }
    }
    else if(NewValue < this->m_decrease_rate_threshold)
    {//parameter decrease
        SentenceUnit decrease_sent;
        decrease_sent.m_sentence_type = 1;
        decrease_sent.m_subject_pt = this->m_Concept_ID_pt;
        decrease_sent.m_process_pt = RM_pt->m_Concept_Base->getDecreasePt();
        found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&decrease_sent);
        if(found_sent_pt != 0 )
        {
            if(this->m_recent_trend == NULL)
            {NewStatement_bl = true;}
            else if(this->m_recent_trend->m_sent_pt->m_process_pt != RM_pt->m_Concept_Base->getDecreasePt())
            {NewStatement_bl = true;}
            else if(this->m_recent_trend->m_investigator_ID_pt == NULL)
            {NewStatement_bl = true;}
        }
    }
    else
    {//parameter stable
        SentenceUnit stable_sent;
        stable_sent.m_sentence_type = 1;
        stable_sent.m_subject_pt = this->m_Concept_ID_pt;
        stable_sent.m_process_pt = RM_pt->m_Concept_Base->getStablePt();
        found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&stable_sent);
        if(found_sent_pt != 0 )
        {
            if(this->m_recent_trend == NULL)
            {NewStatement_bl = true;}
            else if(this->m_recent_trend->m_sent_pt->m_process_pt != RM_pt->m_Concept_Base->getStablePt())
            {NewStatement_bl = true;}
        }
 
        if(this->m_recent_parameter_value != NULL)
        {
            if(this->m_recent_parameter_value->m_perceived_value < 0.00001)
            {NewStatement_bl = false;}
        }
    }
 
    if(NewStatement_bl == true && found_sent_pt!= NULL)
    {   //new phenomenon, need to add a new statement
 
        auto stmt = make_unique<Statement>();
        stmt->m_sent_pt = found_sent_pt;
        stmt->m_state = true;
        stmt->m_time_range.m_start_time  = r5pars_.timesno;
        stmt->m_time_range.m_end_time = r5pars_.timesno;
        stmt->m_confidence = 1.0;
        stmt->m_factual_type = 1; //observed fact
        statement_pt = stmt.get();
        RM_pt->AddANewStatement(stmt.release());
        this->m_recent_trend = statement_pt;
        RM_pt->AddDeltaToSystemDynamics(0.12);
 
        //feed this back to the investigator
        if(_expecting == true)
        {
            sent_pt = RM_pt->m_working_on_invest_pt->GetSemanticSentenceOfThisInvestigator();
            if(statement_pt->m_sent_pt->m_sentence_type == sent_pt->m_sentence_type)
            {
                if(statement_pt->m_sent_pt == sent_pt)
                {
                    RM_pt->m_working_on_invest_pt->m_Statement_pt = statement_pt;
                    RM_pt->AddDeltaToCognitiveLoad(0.024);
                    statement_pt->m_investigator_ID_pt = (IDElement*)(RM_pt->m_working_on_invest_pt);
                }
                else
                {
                    RM_pt->m_working_on_invest_pt->m_possible_statement_pt = statement_pt;
                }
            }
        }
 
        //if a parameter is stable, no need to investigate this.
        if(statement_pt->m_sent_pt->m_process_pt == RM_pt->m_Concept_Base->getStablePt())
        {
            statement_pt->m_tbi_bl = false;
        }
        else if(statement_pt->m_investigator_ID_pt == NULL)
        {
            //Add an investigator for this statement
            auto inv = make_unique<Investigator>();
            inv->m_note = "by a statement";
            inv->m_motivation = 1;
            inv->m_Statement_pt = statement_pt;
            RM_pt->AddDeltaToCognitiveLoad(0.024);
            inv->m_Happen = 3;
            inv->m_operator = this->m_operator;
            inv->m_root_of_a_thought_line = true;
            invest_pt = inv.get();
            RM_pt->AddNewInvestigator(inv.release());
            //link the statement to the statement pointer
            statement_pt->m_investigator_ID_pt = (IDElement*)invest_pt;
        }
    }
    else if(this->m_recent_trend != NULL)
    {
        this->m_recent_trend->RefreshStatementEndTimeToCurrentTime(1);
        //RM_pt->ActivationUpdateByRefreshAStatement(this->m_recent_trend);
        //update the existing statement
    }
    //save the newly received parameter value
    if(this->m_recent_parameter_rate)
    {this->m_parameter_history_rate.push_back(std::move(this->m_recent_parameter_rate));}
    this->m_recent_parameter_rate = make_unique<MRValueSchema>();
    this->m_recent_parameter_rate->m_time_perceived = r5pars_.timesno;
    this->m_recent_parameter_rate->m_perceived_value = NewValue;
 
    this->UpdateTheRelevantInvestigator(_operator);
}
 
MRValueSchema * MRParameterUnit::FoundAValueReadingWithinTimeRange(float _start, float _end)
{
    // this function is to find a reading in the history which is within the required time range
    MRValueSchema * value_schema_pt = NULL;
    bool found = false;
    if(!this->m_recent_parameter_value)
    {
        return NULL; //question: could use return 0 instead??
    }
    else if(this->m_recent_parameter_value->m_time_perceived >= _start && this->m_recent_parameter_value->m_time_perceived <= _end)
    {
        value_schema_pt = this->m_recent_parameter_value.get();
        found = true;
    }
    else
    {// To be added, the memory decay effect, only the active value could be retrieved from the memory
        for(auto &e : this->m_parameter_history_value)
        {
            if(found) break;
            if(e->m_time_perceived >= _start && e->m_time_perceived <= _end)
            {
                value_schema_pt = e.get();
                found = true;
            }
        }
    }
    return value_schema_pt;
}
 
void MRParameterUnit::ReadParameterIndication(double _timer)
{
    switch (this->m_operator)
    {
    case sim::Operator::OAT:
        if(this->m_parameter_indicator_ID.compare("NONE") != 0)
        {
            g_sim.Action_Taker.ActiveFetchParameterValueInfo(this->m_parameter_indicator_ID, _timer);
        }
        if(this->m_parameter_rate_indicator_ID.compare("NONE") != 0)
        {
            g_sim.Action_Taker.ActiveFetchParameterValueInfo(this->m_parameter_rate_indicator_ID, _timer);
        }
        break;
    case sim::Operator::ODM:
        if(this->m_parameter_indicator_ID.compare("NONE") != 0)
        {
            g_sim.Decision_Maker.ActiveFetchParameterValueInfo(this->m_parameter_indicator_ID, _timer);
        }
/*      if(this->m_parameter_rate_indicator_ID.compare("NONE") != 0)
        {
            g_sim.Decision_Maker.ActiveFetchParameterValueInfo(this->m_parameter_rate_indicator_ID, _timer);
        }
*/      break;
    default:
        break;
        //error message
    }
 
}
 
MRValueSchema * MRParameterUnit::CheckReadingWithinTimeRange(double _start, double _end)
{
    bool found = false;
    MRValueSchema * value_schema_pt = NULL;
    if(this->m_recent_parameter_value == NULL)
    {
        return NULL;
    }
    else
    {
        if(this->m_recent_parameter_value->m_time_perceived >= _start && this->m_recent_parameter_value->m_time_perceived <= _end)
        {
            return this->m_recent_parameter_value.get();
        }
    }
 
    for(auto ritr = this->m_parameter_history_value.rbegin(); ritr != this->m_parameter_history_value.rend() && found == false; ++ritr)
    {
        if((*ritr)->m_time_perceived <= _end)
        {
            if((*ritr)->m_time_perceived >= _start)
            {
                found = true;
                value_schema_pt = ritr->get();
            }
            else
            {
                //need to verify "break" jumps out of the for loop
                break;
            }
        }
    }
    return value_schema_pt;
}
 
void MRParameterUnit::ReadParameterValue(double _timer)
{
    switch (this->m_operator)
    {
    case sim::Operator::OAT:
        if(this->m_parameter_indicator_ID.compare("NONE") != 0)
        {
            g_sim.Action_Taker.ActiveFetchParameterValueInfo(this->m_parameter_indicator_ID, _timer);
        }
        break;
    case sim::Operator::ODM:
        if(this->m_parameter_indicator_ID.compare("NONE") != 0)
        {
            g_sim.Decision_Maker.ActiveFetchParameterValueInfo(this->m_parameter_indicator_ID, _timer);
        }
        break;
    default:
        break;
        //error message
    }
}
 
void MRParameterUnit::ReadParameterRate(double _timer)
{
    switch (this->m_operator)
    {
    case sim::Operator::OAT:
        if(this->m_parameter_rate_indicator_ID.compare("NONE") != 0)
        {
            g_sim.Action_Taker.ActiveFetchParameterValueInfo(this->m_parameter_rate_indicator_ID, _timer);
        }
        break;
    case sim::Operator::ODM:
        if(this->m_parameter_rate_indicator_ID.compare("NONE") != 0)
        {
            g_sim.Decision_Maker.ActiveFetchParameterValueInfo(this->m_parameter_rate_indicator_ID, _timer);
        }
        break;
    default:
        break;
        //error message
    }
}
 
void MRParameterUnit::AddNewValueForFirstRoundCheck(float NewValue, int _operator)
{
    SentenceUnit * found_sent_pt;
    ReasonMachine * RM_pt;
    Statement * statement_pt;
    bool NewStatement_bl = false;
 
    string prompt;
    stringstream conv;
    prompt = "Received new reading of ";
    prompt += this->m_parameter_indicator_ID;
    prompt += ": ";
    conv.str("");
    conv << NewValue;
    prompt += conv.str();
    this->PrintMessage(prompt);
 
    if (_operator == sim::Operator::ODM)
    {RM_pt = g_sim.Decision_Maker.m_RM.get();}
    else if (_operator == sim::Operator::OAT)
    {RM_pt = g_sim.Action_Taker.m_RM.get();}
    else
    {}//add error message 
    //Function: 
    //if the new received value is bigger than the last received value--difference bigger than threshold
    //if the last received rate was not "increasing"
    //that means the parameter increased between the two consecutive readings
    if(this->m_recent_parameter_value != NULL)
    {
        if((NewValue - this->m_recent_parameter_value->m_perceived_value) > this->m_increase_threshold)
        {//increase trend
            if(this->m_recent_trend == NULL)
            {NewStatement_bl = true;}
            else if(this->m_recent_trend->m_sent_pt->m_process_pt != RM_pt->m_Concept_Base->getIncreasePt())
            {NewStatement_bl = true;}
            if(NewStatement_bl == true)
            {
                SentenceUnit increase_sent;
                increase_sent.m_sentence_type = 1;
                increase_sent.m_subject_pt = this->m_Concept_ID_pt;
                increase_sent.m_process_pt = RM_pt->m_Concept_Base->getIncreasePt();
                found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&increase_sent);
            }
        }//end of increase analysis
        else if ((NewValue - this->m_recent_parameter_value->m_perceived_value) < this->m_decrease_threshold)
        {//decrease trend
            if(this->m_recent_trend == NULL)
            {NewStatement_bl = true;}
            else if(this->m_recent_trend->m_sent_pt->m_process_pt != RM_pt->m_Concept_Base->getDecreasePt())
            {NewStatement_bl = true;}
            if(NewStatement_bl == true)
            {
                SentenceUnit decrease_sent;
                decrease_sent.m_sentence_type = 1;
                decrease_sent.m_subject_pt = this->m_Concept_ID_pt;
                decrease_sent.m_process_pt = RM_pt->m_Concept_Base->getDecreasePt();
                found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&decrease_sent);
            }
        }//end of decrease analysis
        else
        {//stable trend
            if(this->m_recent_trend == NULL)
            {NewStatement_bl = true;}
            else if(this->m_recent_trend->m_sent_pt->m_process_pt != RM_pt->m_Concept_Base->getStablePt())
            {NewStatement_bl = true;}
            if(NewStatement_bl == true)
            {
                SentenceUnit stable_sent;
                stable_sent.m_sentence_type = 1;
                stable_sent.m_subject_pt = this->m_Concept_ID_pt;
                stable_sent.m_process_pt = RM_pt->m_Concept_Base->getStablePt();
                found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&stable_sent);
            }
        }
        if(found_sent_pt != NULL && NewStatement_bl == true)
        {
            //new phenomenon, need to add a new statement
            auto stmt = make_unique<Statement>();
            stmt->m_sent_pt = found_sent_pt;
            stmt->m_state = true;
            stmt->m_time_range.m_time_before = r5pars_.timesno;
            stmt->m_time_range.m_time_after = this->m_recent_parameter_value->m_time_perceived;
            stmt->m_confidence = 0.9;
            stmt->m_factual_type = 2; //inferred fact
            statement_pt = stmt.get();
            this->m_recent_trend = statement_pt;
            RM_pt->AddANewStatement(stmt.release());
 
            statement_pt->m_tbi_bl = false;
        }
        else if(this->m_recent_trend != NULL)
        {
            this->m_recent_trend->RefreshStatementEndTimeToCurrentTime(0);
            //RM_pt->ActivationUpdateByRefreshAStatement(this->m_recent_trend);
            //update the existing statement
        }
        this->m_parameter_history_value.push_back(std::move(this->m_recent_parameter_value));
    }
    //if this is the first reading
    this->m_recent_parameter_value = make_unique<MRValueSchema>();
    this->m_recent_parameter_value->m_time_perceived = r5pars_.timesno;
    this->m_recent_parameter_value->m_perceived_value = NewValue;
}
 
void MRParameterUnit::AddNewRateForFirstRoundCheck(float NewValue, int _operator)
{
    SentenceUnit * found_sent_pt;
    ReasonMachine * RM_pt;
    Statement * statement_pt;
    bool NewStatement_bl = false;
 
    string ID_name;
    string prompt;
    stringstream conv;
    prompt = "Received new reading of ";
    prompt += this->m_parameter_rate_indicator_ID;
    prompt += ": ";
    conv.str("");
    conv << NewValue;
    prompt += conv.str();
    this->PrintMessage(prompt);
 
    if (_operator == sim::Operator::ODM)
    {RM_pt = g_sim.Decision_Maker.m_RM.get();}
    else if (_operator == sim::Operator::OAT)
    {RM_pt = g_sim.Action_Taker.m_RM.get();}
    else
    {}//add error message 
 
    if(NewValue > this->m_increase_rate_threshold)
    {//parameter increase
        SentenceUnit increase_sent;
        increase_sent.m_sentence_type = 1;
        increase_sent.m_subject_pt = this->m_Concept_ID_pt;
        increase_sent.m_process_pt = RM_pt->m_Concept_Base->getIncreasePt();
        found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&increase_sent);
        if(found_sent_pt != 0 )
        {
            if(this->m_recent_trend == NULL)
            {NewStatement_bl = true;}
            else if(this->m_recent_trend->m_sent_pt->m_process_pt != RM_pt->m_Concept_Base->getIncreasePt())
            {NewStatement_bl = true;}
        }
    }
    else if(NewValue < this->m_decrease_rate_threshold)
    {//parameter decrease
        SentenceUnit decrease_sent;
        decrease_sent.m_sentence_type = 1;
        decrease_sent.m_subject_pt = this->m_Concept_ID_pt;
        decrease_sent.m_process_pt = RM_pt->m_Concept_Base->getDecreasePt();
        found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&decrease_sent);
        if(found_sent_pt != 0 )
        {
            if(this->m_recent_trend == NULL)
            {NewStatement_bl = true;}
            else if(this->m_recent_trend->m_sent_pt->m_process_pt != RM_pt->m_Concept_Base->getDecreasePt())
            {NewStatement_bl = true;}
        }
    }
    else
    {//parameter stable
        SentenceUnit stable_sent;
        stable_sent.m_sentence_type = 1;
        stable_sent.m_subject_pt = this->m_Concept_ID_pt;
        stable_sent.m_process_pt = RM_pt->m_Concept_Base->getStablePt();
        found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&stable_sent);
        if(found_sent_pt != 0 )
        {
            if(this->m_recent_trend == NULL)
            {NewStatement_bl = true;}
            else if(this->m_recent_trend->m_sent_pt->m_process_pt != RM_pt->m_Concept_Base->getStablePt())
            {NewStatement_bl = true;}
        }
    }
    if(NewStatement_bl == true && found_sent_pt!= NULL)
    {   //new phenomenon, need to add a new statement
 
        auto stmt = make_unique<Statement>();
        stmt->m_sent_pt = found_sent_pt;
        stmt->m_state = true;
        stmt->m_time_range.m_start_time  = r5pars_.timesno;
        stmt->m_time_range.m_end_time  = r5pars_.timesno;
        stmt->m_confidence = 1.0;
        stmt->m_factual_type = 1; //observed fact
        statement_pt = stmt.get();
        RM_pt->AddANewStatement(stmt.release());
        this->m_recent_trend = statement_pt;
    }
    else if(this->m_recent_trend != NULL)
    {
        this->m_recent_trend->RefreshStatementEndTimeToCurrentTime(1);
        //RM_pt->ActivationUpdateByRefreshAStatement(this->m_recent_trend);
        //update the existing statement
    }           
    //save the newly received parameter value
    if(this->m_recent_parameter_rate)
    {this->m_parameter_history_rate.push_back(std::move(this->m_recent_parameter_rate));}
    this->m_recent_parameter_rate = make_unique<MRValueSchema>();
    this->m_recent_parameter_rate->m_time_perceived = r5pars_.timesno;
    this->m_recent_parameter_rate->m_perceived_value = NewValue;
}
 
void MRParameterUnit::PrintMessage(string str)
{
    cout << "Time: " << r5pars_.timesno << ": " << str << '\n';
 
    //test
    ofstream fout("RMI.txt", ios::app);
    fout << "Time: " << r5pars_.timesno << ": " << str << '\n';
    fout.close();
}
 
MRValueSchema * MRParameterUnit::FindAReadingConsistantWithASentenceWithinTimeRange(float _start, float _end, SentenceUnit * _sent_pt)
{
    MRValueSchema * found_schema_pt = NULL;
    MRValueSchema * value_schema_pt;
    decltype(m_parameter_history_value)::reverse_iterator VS_ritr;
    float value, delta;
 
    ReasonMachine * RM_pt;
    if (this->m_operator == sim::Operator::ODM)
    {RM_pt = g_sim.Decision_Maker.m_RM.get();}
    else if (this->m_operator == sim::Operator::OAT)
    {RM_pt = g_sim.Action_Taker.m_RM.get();}
    else
    {}//add error message 
    int comparison_type;
 
    if(_sent_pt->m_sentence_type != 3)
    {
        //error message
        this->ErrorMessage("Error!");
    }
 
    if(_sent_pt->m_comparison_pt == (IDElement *)RM_pt->m_Concept_Base->getBiggerPt())
    {comparison_type = 1;}
    else if(_sent_pt->m_comparison_pt == (IDElement *)RM_pt->m_Concept_Base->getSmallerPt())
    {comparison_type = 2;}
    else if(_sent_pt->m_comparison_pt == (IDElement *)RM_pt->m_Concept_Base->getEqualPt())
    {comparison_type = 3;}
    else
    {
        this->ErrorMessage("Error!");
    }
 
    value = _sent_pt->m_value;
    delta = _sent_pt->m_delta_value;
    
    if(this->m_recent_parameter_value != NULL)
    {
        if(this->m_recent_parameter_value->m_time_perceived >= _start 
            && this->m_recent_parameter_value->m_time_perceived <= _end)
        {
            switch (comparison_type)
            {//1->; 2-<; 3-=;
            case 1:
                if(this->m_recent_parameter_value->m_perceived_value - value > delta)
                {
                    found_schema_pt = this->m_recent_parameter_value.get();
                }
                break;
            case 2:
                if(value - this->m_recent_parameter_value->m_perceived_value > delta)
                {
                    found_schema_pt = this->m_recent_parameter_value.get();
                }
                break;
            case 3:
                if(value - this->m_recent_parameter_value->m_perceived_value < delta 
                    && this->m_recent_parameter_value->m_perceived_value - value < delta)
                {
                    found_schema_pt = this->m_recent_parameter_value.get();
                }
                break;
            default:
                break;
            }
        }
        else
        {
            if(this->m_recent_parameter_value->m_time_perceived < _start)
            {
                return NULL;
            }
        }
    }
 
    VS_ritr = this->m_parameter_history_value.rbegin();
    while(VS_ritr != this->m_parameter_history_value.rend() && found_schema_pt == NULL)
    {
        value_schema_pt = VS_ritr->get();
        if(value_schema_pt->m_time_perceived >= _start 
            && value_schema_pt->m_time_perceived <= _end)
        {
            switch (comparison_type)
            {//1->; 2-<; 3-=;
            case 1:
                if(value_schema_pt->m_perceived_value - value > delta)
                {
                    found_schema_pt = value_schema_pt;
                }
                break;
            case 2:
                if(value - value_schema_pt->m_perceived_value > delta)
                {
                    found_schema_pt = value_schema_pt;
                }
                break;
            case 3:
                if(value - value_schema_pt->m_perceived_value < delta 
                    && value_schema_pt->m_perceived_value - value < delta)
                {
                    found_schema_pt = value_schema_pt;
                }
                break;
            default:
                break;
            }
        }
        else
        {
            if(value_schema_pt->m_time_perceived < _start)
            {
                return NULL;
            }
        }
        VS_ritr++;
    }
    return found_schema_pt;
}
 
MRValueSchema * MRParameterUnit::FindAReadingInconsistantWithASentenceWithinTimeRange(float _start, float _end, SentenceUnit * _sent_pt)
{
    MRValueSchema * found_schema_pt = NULL;
    MRValueSchema * value_schema_pt;
    decltype(m_parameter_history_value)::reverse_iterator VS_ritr;
    float value, delta;
 
    ReasonMachine * RM_pt;
    if (this->m_operator == sim::Operator::ODM)
    {RM_pt = g_sim.Decision_Maker.m_RM.get();}
    else if (this->m_operator == sim::Operator::OAT)
    {RM_pt = g_sim.Action_Taker.m_RM.get();}
    else
    {}//add error message 
    int comparison_type;
 
    if(_sent_pt->m_sentence_type != 3)
    {
        //error message
        this->ErrorMessage("Error!");
    }
 
    if(_sent_pt->m_comparison_pt == (IDElement *)RM_pt->m_Concept_Base->getBiggerPt())
    {comparison_type = 1;}
    else if(_sent_pt->m_comparison_pt == (IDElement *)RM_pt->m_Concept_Base->getSmallerPt())
    {comparison_type = 2;}
    else if(_sent_pt->m_comparison_pt == (IDElement *)RM_pt->m_Concept_Base->getEqualPt())
    {comparison_type = 3;}
    else
    {
        this->ErrorMessage("Error!");
    }
 
    value = _sent_pt->m_value;
    delta = _sent_pt->m_delta_value;
    
    if(this->m_recent_parameter_value != NULL)
    {
        if(this->m_recent_parameter_value->m_time_perceived >= _start 
            && this->m_recent_parameter_value->m_time_perceived <= _end)
        {
            switch (comparison_type)
            {//1->; 2-<; 3-=;
            case 1:
                if(!(this->m_recent_parameter_value->m_perceived_value - value > delta))
                {
                    found_schema_pt = this->m_recent_parameter_value.get();
                }
                break;
            case 2:
                if(!(value - this->m_recent_parameter_value->m_perceived_value > delta))
                {
                    found_schema_pt = this->m_recent_parameter_value.get();
                }
                break;
            case 3:
                if(!(value - this->m_recent_parameter_value->m_perceived_value <= delta 
                    && this->m_recent_parameter_value->m_perceived_value - value <= delta))
                {
                    found_schema_pt = this->m_recent_parameter_value.get();
                }
                break;
            default:
                break;
            }
        }
        else
        {
            if(this->m_recent_parameter_value->m_time_perceived < _start)
            {
                return NULL;
            }
        }
    }
 
    VS_ritr = this->m_parameter_history_value.rbegin();
    while(VS_ritr != this->m_parameter_history_value.rend() && found_schema_pt == NULL)
    {
        value_schema_pt = VS_ritr->get();
        if(value_schema_pt->m_time_perceived >= _start 
            && value_schema_pt->m_time_perceived <= _end)
        {
            switch (comparison_type)
            {//1->; 2-<; 3-=;
            case 1:
                if(!(value_schema_pt->m_perceived_value - value > delta))
                {
                    found_schema_pt = value_schema_pt;
                }
                break;
            case 2:
                if(!(value - value_schema_pt->m_perceived_value > delta))
                {
                    found_schema_pt = value_schema_pt;
                }
                break;
            case 3:
                if(!(value - value_schema_pt->m_perceived_value <= delta 
                    && value_schema_pt->m_perceived_value - value <= delta))
                {
                    found_schema_pt = value_schema_pt;
                }
                break;
            default:
                break;
            }
        }
        else
        {
            if(value_schema_pt->m_time_perceived < _start)
            {
                return NULL;
            }
        }
        VS_ritr++;
    }
    return found_schema_pt;
 
}
 
void MRParameterUnit::ErrorMessage(string str)
{
    cout << r5pars_.timesno << "  " << str << " in MRParameterUnit.cpp" << '\n';
    ofstream fout("err messages.txt", ios::app);
    fout << r5pars_.timesno << "  " << str << '\n';
    fout.close();
    //r5pars_.terminateall = true;
}
 
void MRParameterUnit::CopyMRParameterUnitInforFromAnother(MRParameterUnit * _p_pt)
{
    this->CopyIDElementToRestartInfo((IDElement*)_p_pt);
    this->m_operator = _p_pt->m_operator;
    this->m_decrease_rate_threshold = _p_pt->m_decrease_rate_threshold;
    this->m_increase_rate_threshold = _p_pt->m_increase_rate_threshold;
    this->m_decrease_threshold = _p_pt->m_decrease_threshold;
    this->m_increase_threshold = _p_pt->m_increase_threshold;
 
    this->m_parameter_indicator_ID = _p_pt->m_parameter_indicator_ID;
    this->m_parameter_rate_indicator_ID = _p_pt->m_parameter_rate_indicator_ID;
 
    //
    if(_p_pt->m_Concept_ID_pt != NULL)
    {this->m_parameter_concept_ID = _p_pt->m_Concept_ID_pt->m_ID;}
    else
    {this->m_parameter_concept_ID = _p_pt->m_parameter_concept_ID;}
 
    if(_p_pt->m_recent_trend != NULL)
    {this->m_ID_recent_trend = _p_pt->m_recent_trend->m_ID;}
    else
    {this->m_ID_recent_trend = _p_pt->m_ID_recent_trend;}
 
    if(_p_pt->m_recent_parameter_value)
    {
        this->m_recent_parameter_value = make_unique<MRValueSchema>();
        this->m_recent_parameter_value->CopyMRValueSchemaFromAnother(_p_pt->m_recent_parameter_value.get());
    }
    if(_p_pt->m_recent_parameter_rate)
    {
        this->m_recent_parameter_rate = make_unique<MRValueSchema>();
        this->m_recent_parameter_rate->CopyMRValueSchemaFromAnother(_p_pt->m_recent_parameter_rate.get());
    }
 
    for(auto &e : _p_pt->m_parameter_history_value)
    {
        auto value_pt = make_unique<MRValueSchema>();
        value_pt->CopyMRValueSchemaFromAnother(e.get());
        this->m_parameter_history_value.push_back(std::move(value_pt));
    }
    for(auto &e : _p_pt->m_parameter_history_rate)
    {
        auto value_pt = make_unique<MRValueSchema>();
        value_pt->CopyMRValueSchemaFromAnother(e.get());
        this->m_parameter_history_rate.push_back(std::move(value_pt));
    }
 
}
 
void MRParameterUnit::BuildConnectionsForThisMRParameter(void * _pt)
{
    ReasonMachine * RM_pt;
    RM_pt = (ReasonMachine *)_pt;
/*
    IDElement * m_Concept_ID_pt;
    Statement * m_recent_trend;
 
    string m_parameter_concept_ID;
    string m_ID_recent_trend;
*/
    if(this->m_parameter_concept_ID.compare("") != 0)
    {
        this->m_Concept_ID_pt = RM_pt->m_Concept_Base->FindConceptByID(this->m_parameter_concept_ID);
        if(this->m_Concept_ID_pt == NULL)
        {this->ErrorMessage("could not find the concept " + this->m_parameter_concept_ID); return;}
    }
 
 
    if(this->m_ID_recent_trend.compare("") != 0)
    {
        this->m_recent_trend = RM_pt->FindStatementByID(this->m_ID_recent_trend);
        if(this->m_recent_trend == NULL)
        {this->ErrorMessage("could not find the statement " + this->m_ID_recent_trend); return;}
    }
    this->m_ID_recent_trend = "";
}
 
void MRParameterUnit::UpdateTheRelevantInvestigator(int _operator)
{
 
    ReasonMachine * RM_pt;
    Investigator * invest_pt;
    if (_operator == sim::Operator::ODM)
    {RM_pt = g_sim.Decision_Maker.m_RM.get();}
    else if (_operator == sim::Operator::OAT)
    {RM_pt = g_sim.Action_Taker.m_RM.get();}
    else
    {}//add error message 
    //update the relevant investigation
 
    if(this->m_recent_trend != NULL)
    {
        if(this->m_recent_trend->m_investigator_ID_pt != 0)
        {
            invest_pt = (Investigator *)this->m_recent_trend->m_investigator_ID_pt;
            if(invest_pt != NULL)
            {
                if(invest_pt->m_investigator_token < 3029)
                {
                    invest_pt->m_last_active_time = r5pars_.timesno;
                    if(invest_pt->m_investigation_closed == true)
                    {
                        //if(RM_pt->FindASimilarInvestigatorRecentlyResolved(invest_pt) == NULL && RM_pt->FindASimilarOngoingInvestigator(invest_pt) == NULL)
                        //{
                        invest_pt->ReopenThisInvestigator();
                    }
                }
            }
        }
    }
}