MRComponentStateUnit.cpp

Go to the documentation of this file.

// MRComponentState.cpp: implementation of the MRComponentState class.
//
 
#include <string>
#include <sstream>
#include <iostream>
#include <fstream>
 
#include "MRComponentStateUnit.h"
#include "SentenceUnit.h"
#include "../Crew/OperatorDM.h"
#include "../Crew/OperatorAT.h"
#include "ReasonMachine.h"
#include "Statement.h"
#include "../Global/SimulationContext.h"
 
using namespace std;
 
 
 
// Construction/Destruction
 
MRComponentStateUnit::MRComponentStateUnit()
{
    this->m_ID_Type = 202;
    this->m_Concept_ID_pt = NULL;
    this->m_recent_state_statement = NULL;
    this->m_recent_action_statement = NULL;
    this->m_concept_ID = "";
    this->Component_State_Indicator_ID = "";
    this->Control_Value_Indicator_ID = "";
    this->m_change_threshold = 0;
    this->m_ID_recent_action_statement = "";
    this->m_ID_recent_state_statement = "";
 
    //201--MRParameterUnit
    //202--MRComponentStateUnit
    //203--MRAlarmUnit
}
 
MRComponentStateUnit::~MRComponentStateUnit()
{
    this->m_history_state.clear();
    this->m_history_position_value.clear();
}
 
void MRComponentStateUnit::AddNewState(int _state, int _operator, bool _expecting)
{
    string ID_name;
    string prompt, str;
    stringstream conv;
 
 
    if(r5pars_.timesno > 969)
    {this->PrintMessage("check");}
 
    bool state_bl;
    SentenceUnit * found_sent_pt;
    ReasonMachine * RM_pt;
    Investigator * invest_pt;
    Statement * statement_pt;
    bool NewStatement_bl = false;
 
    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
    //convert the key words into 0/1
    if (_state == sim::State::On || _state == sim::State::Open)
    {
        state_bl = true;
        str = "ON";
    }
    else if(_state == sim::State::Off || _state == sim::State::Close)
    {
        state_bl = false;
        str = "OFF";
    }
 
    prompt = "Received new reading of ";
    prompt += this->Component_State_Indicator_ID;
    prompt += ": ";
    prompt += str;
    this->PrintMessage(prompt);
 
    RM_pt->AddDeltaToCognitiveLoad(0.024);
    //check whether this is consistant with what is observed before
    if((this->m_recent_state != NULL) && (this->m_recent_state->m_perceived_state != state_bl))
    {
        //state changed
        NewStatement_bl = true;
        if(state_bl == true)
        {
            //add one statement: "xxx turn_on"
            SentenceUnit turn_on_sent;
            turn_on_sent.m_sentence_type = 1;
            turn_on_sent.m_subject_pt = this->m_Concept_ID_pt;
            turn_on_sent.m_process_pt = RM_pt->m_Concept_Base->getTurnOnPt();
            found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&turn_on_sent);
        }
        else
        {
            //add one statement to say it is turned off
            SentenceUnit turn_off_sent;
            turn_off_sent.m_sentence_type = 1;
            turn_off_sent.m_subject_pt = this->m_Concept_ID_pt;
            turn_off_sent.m_process_pt = RM_pt->m_Concept_Base->getTurnOffPt();
            found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&turn_off_sent);
        }
        if(found_sent_pt != 0)
        {
            auto stmt = make_unique<Statement>();
            stmt->m_factual_type = 1;
            stmt->m_confidence =1;
            stmt->m_sent_pt = found_sent_pt;
            stmt->m_state = true;
            stmt->m_time_range.m_time_after = this->m_recent_state->m_time_perceived;
            stmt->m_time_range.m_time_before = r5pars_.timesno;
            statement_pt = stmt.get();
            RM_pt->AddANewStatement(stmt.release());
            this->m_recent_action_statement = statement_pt;
            RM_pt->AddDeltaToSystemDynamics(0.12);
 
            if(_expecting == true)
            {
                auto *sent_pt = RM_pt->m_working_on_invest_pt->GetSemanticSentenceOfThisInvestigator();
                if(sent_pt->m_sentence_type == statement_pt->m_sent_pt->m_sentence_type)
                {
                    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);
                }
            }
 
            //Add an investigator for this statement
            if(statement_pt->m_investigator_ID_pt == NULL)
            {
                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_state == NULL)
    {
        NewStatement_bl = true;
    }
    else
    {
        NewStatement_bl = false;
        //the state has not changed
        if(this->m_recent_state_statement != NULL)
        {
            this->m_recent_state_statement->RefreshStatementEndTimeToCurrentTime(1);
            RM_pt->ActivationUpdateByRefreshAStatement(this->m_recent_state_statement);
        }
        else
        {}//error message
    }
    if(NewStatement_bl == true)
    {
        if(state_bl == true)
        {
            //add one statement to say "xxx is on"
            SentenceUnit is_on_sent;
            is_on_sent.m_sentence_type = 2;
            is_on_sent.m_subject_pt = this->m_Concept_ID_pt;
            is_on_sent.m_state_pt = RM_pt->m_Concept_Base->getONpt();
            found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&is_on_sent);
        }
        else
        {
            //add one statement to say "xxx is OFF"
            SentenceUnit is_off_sent;
            is_off_sent.m_sentence_type = 2;
            is_off_sent.m_subject_pt = this->m_Concept_ID_pt;
            is_off_sent.m_state_pt = RM_pt->m_Concept_Base->getOFFpt();
            found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&is_off_sent);
        }
        if(found_sent_pt != 0)
        {
            auto stmt = make_unique<Statement>();
            stmt->m_factual_type = 1;
            stmt->m_confidence =1;
            stmt->m_sent_pt = found_sent_pt;
            stmt->m_state = true;
            stmt->m_time_generated = r5pars_.timesno;
            stmt->m_time_range.m_start_time = r5pars_.timesno;
            if(this->m_recent_state)
            {stmt->m_time_range.m_time_after = this->m_recent_state->m_time_perceived;}
            stmt->m_time_range.m_end_time = r5pars_.timesno;
            statement_pt = stmt.get();
            RM_pt->AddANewStatement(stmt.release());
            this->m_recent_state_statement = statement_pt;
            statement_pt->m_tbi_bl = false;
 
            if(_expecting == true)
            {
                auto *sent_pt = RM_pt->m_working_on_invest_pt->GetSemanticSentenceOfThisInvestigator();
                if(sent_pt->m_sentence_type == statement_pt->m_sent_pt->m_sentence_type)
                {
                    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
        {}//warning message/error message
    }
 
    if(this->m_recent_state)
    {
        this->m_history_state.push_back(std::move(this->m_recent_state));
    }
    this->m_recent_state = make_unique<MRStateSchema>();
    this->m_recent_state->m_perceived_state = state_bl;
    this->m_recent_state->m_time_perceived = r5pars_.timesno;
    //To be added, compare the current state with the expectation
 
    this->UpdateTheRelevantInvestigator(_operator);
}
 
void MRComponentStateUnit::AddNewPositionValue(float _position, int _operator, bool _expecting)
{
    SentenceUnit * found_sent_pt;
    ReasonMachine * RM_pt;
    Investigator * invest_pt;
    Statement * statement_pt;
    IDElement * ID_pt;
    bool NewStatement_bl = false;
    bool update_action_bl = false;
 
    string ID_name;
    stringstream conv;
    string prompt;
 
    prompt = "Received new reading of ";
    prompt += this->Control_Value_Indicator_ID;
    prompt += ": ";
    conv.str("");
    conv << _position;
    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 
 
    RM_pt->AddDeltaToCognitiveLoad(0.024);
    if(this->m_recent_position_value != 0)
    {//compare with the last received value
        if(_position - this->m_recent_position_value->m_perceived_value > this->m_change_threshold)
        {
            ID_pt = RM_pt->m_Concept_Base->getOpenBiggerPt();
            NewStatement_bl = true;
        }
        //only use one change threshold
        else if (_position - this->m_recent_position_value->m_perceived_value < 0 - this->m_change_threshold)
        {
            ID_pt = RM_pt->m_Concept_Base->getCloseSmallerPt();
            NewStatement_bl = true;
        }
 
        if(NewStatement_bl == true && this->m_recent_action_statement != NULL)
        {
            if(this->m_recent_action_statement->m_sent_pt->m_process_pt == ID_pt)
            {
                NewStatement_bl = false;
                update_action_bl = true;
            }
        }
        if(update_action_bl == true)
        {
            //only need to update the statement effective time
            
            this->m_recent_action_statement->RefreshStatementEndTimeToCurrentTime(0); //needs to improve with the boundary; like the valve position is 0 for a long while, it should be type 0 instead of type 1
            RM_pt->ActivationUpdateByRefreshAStatement(this->m_recent_action_statement);
        }       
        if(NewStatement_bl == true)
        {
            SentenceUnit sent;
            sent.m_sentence_type = 1;
            sent.m_subject_pt = this->m_Concept_ID_pt;
            sent.m_process_pt = ID_pt;
            found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&sent);
            if(found_sent_pt != 0)
            {
                //new phenomenon, need to add a new statement
                auto stmt = make_unique<Statement>();
                stmt->m_factual_type = 1;
                stmt->m_confidence =1;
                stmt->m_sent_pt = found_sent_pt;
                stmt->m_state = true;
                stmt->m_time_generated = r5pars_.timesno;
                stmt->m_time_range.m_time_before =r5pars_.timesno;
                stmt->m_time_range.m_time_after = this->m_recent_position_value->m_time_perceived;
                statement_pt = stmt.get();
                RM_pt->AddANewStatement(stmt.release());
                this->m_recent_action_statement = statement_pt;
                RM_pt->AddDeltaToSystemDynamics(0.12);
 
                if(_expecting == true)
                {
                    auto *sent_pt = RM_pt->m_working_on_invest_pt->GetSemanticSentenceOfThisInvestigator();
                    if(sent_pt->m_sentence_type == statement_pt->m_sent_pt->m_sentence_type)
                    {
                        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);
                    }
                }
 
                //Add an investigator for this statement
                if(statement_pt->m_investigator_ID_pt == NULL)
                {
                    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;
                    invest_pt = inv.get();
                    RM_pt->AddNewInvestigator(inv.release());
                    invest_pt->m_root_of_a_thought_line = true;
                    //link the statement to the statement pointer
                    statement_pt->m_investigator_ID_pt = (IDElement*)invest_pt;
                }
            }
        }
        this->m_history_position_value.push_back(std::move(this->m_recent_position_value));
    }
    //save the newly received position value
    this->m_recent_position_value = make_unique<MRValueSchema>();
    this->m_recent_position_value->m_perceived_value = _position;
    this->m_recent_position_value->m_time_perceived = r5pars_.timesno;
 
    //update the relevant investigation
    this->UpdateTheRelevantInvestigator(_operator);
}
 
MRValueSchema * MRComponentStateUnit::FoundAPositionReadingWithinTimeRange(float _start, float _end)
{
 
 
    // this function is to find a position reading in the history which is within the required time range
    MRValueSchema * value_schema_pt = NULL;
    bool found = false;
    if(!this->m_recent_position_value)
    {
        return NULL; //question: could use return 0 instead??
    }
    else if(this->m_recent_position_value->m_time_perceived >= _start && this->m_recent_position_value->m_time_perceived <= _end)
    {
        value_schema_pt = this->m_recent_position_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_history_position_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 MRComponentStateUnit::ReadComponentStateIndication(double _timer)
{
    float timer = 0.5;
    Operator * operator_pt;
    switch (this->m_operator)
    {
    case sim::Operator::OAT:
        operator_pt = &g_sim.Action_Taker;
        break;
    case sim::Operator::ODM:
        operator_pt = &g_sim.Decision_Maker;        
        break;
    default:
        break;
        //error message
    }
    //be careful, verify an uninitiated string varible is ""
    if(this->m_CS_type == 0)
    {operator_pt->ActiveFetchComponentStateInfo(this->Component_State_Indicator_ID, _timer); }
    if(this->m_CS_type == 1)
    {operator_pt->ActiveFetchParameterValueInfo(this->Control_Value_Indicator_ID, _timer);}
}
 
MRValueSchema * MRComponentStateUnit::CheckPositionReadingWithinTimeRange(double _start, double _end)
{
    bool found = false;
    MRValueSchema * value_schema_pt = NULL;
    if(this->m_CS_type != 1)
    {
        return NULL;//error message
    }
    if(this->m_recent_position_value == NULL)
    {
        return NULL;
    }
    else
    {
        if(this->m_recent_position_value->m_time_perceived >= _start && this->m_recent_position_value->m_time_perceived <= _end)
        {
            return this->m_recent_position_value.get();
        }
    }
 
    for(auto ritr = this->m_history_position_value.rbegin(); ritr != this->m_history_position_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 MRComponentStateUnit::AddNewPositionValueForFirstRoundCheck(float _position, int _operator)
{
    SentenceUnit * found_sent_pt;
    ReasonMachine * RM_pt;
    Statement * statement_pt;
    IDElement * ID_pt;
    bool NewStatement_bl = false;
    bool update_action_bl = false;
 
    string ID_name;
    stringstream conv;
    string prompt;
 
    prompt = "Received new reading of ";
    prompt += this->Control_Value_Indicator_ID;
    prompt += ": ";
    conv.str("");
    conv << _position;
    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_recent_position_value)
    {//compare with the last received value
        if(_position - this->m_recent_position_value->m_perceived_value > this->m_change_threshold)
        {
            ID_pt = RM_pt->m_Concept_Base->getOpenBiggerPt();
            NewStatement_bl = true;
        }
        //only use one change threshold
        else if (_position - this->m_recent_position_value->m_perceived_value > 0 - this->m_change_threshold)
        {
            ID_pt = RM_pt->m_Concept_Base->getCloseSmallerPt();
            NewStatement_bl = true;
        }
 
        if(NewStatement_bl == true)
        {
            if(this->m_recent_action_statement->m_sent_pt->m_process_pt == ID_pt)
            {
                NewStatement_bl = false;
                update_action_bl = true;
            }
        }
        if(update_action_bl == true)
        {
            //only need to update the statement effective time
            this->m_recent_action_statement->RefreshStatementEndTimeToCurrentTime(0);//needs to improve with the boundary; like the valve position is 0 for a long while, it should be type 0 instead of type 1
            RM_pt->ActivationUpdateByRefreshAStatement(this->m_recent_action_statement);
        }
        if(NewStatement_bl == true)
        {
            SentenceUnit sent;
            sent.m_sentence_type = 1;
            sent.m_subject_pt = this->m_Concept_ID_pt;
            sent.m_process_pt = ID_pt;
            found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&sent);
            if(found_sent_pt != 0)
            {
                //new phenomenon, need to add a new statement
                auto stmt = make_unique<Statement>();
                stmt->m_factual_type = 1;
                stmt->m_confidence =1;
                stmt->m_sent_pt = found_sent_pt;
                stmt->m_state = true;
                stmt->m_time_generated = r5pars_.timesno;
                stmt->m_time_range.m_time_before =r5pars_.timesno;
                stmt->m_time_range.m_time_after = this->m_recent_position_value->m_time_perceived;
                statement_pt = stmt.get();
                RM_pt->AddANewStatement(stmt.release());
                this->m_recent_action_statement = statement_pt;
            }
        }
        this->m_history_position_value.push_back(std::move(this->m_recent_position_value));
    }
    //save the newly received position value
    this->m_recent_position_value = make_unique<MRValueSchema>();
    this->m_recent_position_value->m_perceived_value = _position;
    this->m_recent_position_value->m_time_perceived = r5pars_.timesno;
}
 
 
void MRComponentStateUnit::AddNewStateForFirstRoundCheck(int _state, int _operator)
{
    string ID_name;
    stringstream conv;
    string prompt, str;
 
    bool state_bl;
    SentenceUnit * found_sent_pt;
    ReasonMachine * RM_pt;
    Statement * statement_pt;
    bool NewStatement_bl = false;
 
    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
    //convert the key words into 0/1
    if (_state == sim::State::On || _state == sim::State::Open)
    {
        state_bl = true;
        str = "ON";
    }
    else if(_state == sim::State::Off || _state == sim::State::Close)
    {
        state_bl = false;
        str = "OFF";
    }
 
    prompt = "Received new reading of ";
    prompt += this->Component_State_Indicator_ID;
    prompt += ": ";
    prompt += str;
    this->PrintMessage(prompt);
 
    //check whether this is consistant with what is observed before
    if((this->m_recent_state != NULL) && (this->m_recent_state->m_perceived_state != state_bl))
    {
        //state changed
        NewStatement_bl = true;
        if(state_bl == true)
        {
            //add one statement: "xxx turn_on"
            SentenceUnit turn_on_sent;
            turn_on_sent.m_sentence_type = 1;
            turn_on_sent.m_subject_pt = this->m_Concept_ID_pt;
            turn_on_sent.m_process_pt = RM_pt->m_Concept_Base->getTurnOnPt();
            found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&turn_on_sent);
        }
        else
        {
            //add one statement to say it is turned off
            SentenceUnit turn_off_sent;
            turn_off_sent.m_sentence_type = 1;
            turn_off_sent.m_subject_pt = this->m_Concept_ID_pt;
            turn_off_sent.m_process_pt = RM_pt->m_Concept_Base->getTurnOffPt();
            found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&turn_off_sent);
        }
        if(found_sent_pt != 0)
        {
            auto stmt = make_unique<Statement>();
            stmt->m_factual_type = 1;
            stmt->m_confidence =1;
            stmt->m_sent_pt = found_sent_pt;
            stmt->m_state = true;
            stmt->m_time_range.m_time_after = this->m_recent_state->m_time_perceived;
            stmt->m_time_range.m_time_before = r5pars_.timesno;
            statement_pt = stmt.get();
            RM_pt->AddANewStatement(stmt.release());
            this->m_recent_action_statement = statement_pt;
        }
    }
    else if(this->m_recent_state == NULL)
    {
        NewStatement_bl = true;
    }
    else
    {
        NewStatement_bl = false;
        //the state has not changed
        if(this->m_recent_state_statement != NULL)
        {
            this->m_recent_state_statement->RefreshStatementEndTimeToCurrentTime(0);
            RM_pt->ActivationUpdateByRefreshAStatement(this->m_recent_state_statement);
        }
        else
        {}//error message
    }
    if(NewStatement_bl == true)
    {
        if(state_bl == true)
        {
            //add one statement to say "xxx is on"
            SentenceUnit is_on_sent;
            is_on_sent.m_sentence_type = 2;
            is_on_sent.m_subject_pt = this->m_Concept_ID_pt;
            is_on_sent.m_state_pt = RM_pt->m_Concept_Base->getONpt();
            found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&is_on_sent);
        }
        else
        {
            //add one statement to say "xxx is OFF"
            SentenceUnit is_off_sent;
            is_off_sent.m_sentence_type = 2;
            is_off_sent.m_subject_pt = this->m_Concept_ID_pt;
            is_off_sent.m_state_pt = RM_pt->m_Concept_Base->getOFFpt();
            found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&is_off_sent);
        }
        if(found_sent_pt != 0)
        {
            auto stmt = make_unique<Statement>();
            stmt->m_factual_type = 1;
            stmt->m_confidence =1;
            stmt->m_sent_pt = found_sent_pt;
            stmt->m_state = true;
            stmt->m_time_generated = r5pars_.timesno;
            stmt->m_time_range.m_start_time = r5pars_.timesno;
            if(this->m_recent_state)
            {stmt->m_time_range.m_time_after = this->m_recent_state->m_time_perceived;}
            stmt->m_time_range.m_end_time = r5pars_.timesno;
            statement_pt = stmt.get();
            RM_pt->AddANewStatement(stmt.release());
            this->m_recent_state_statement = statement_pt;
            statement_pt->m_tbi_bl = false;
        }
        else
        {}//warning message/error message
    }
 
    if(this->m_recent_state)
    {
        this->m_history_state.push_back(std::move(this->m_recent_state));
    }
    this->m_recent_state = make_unique<MRStateSchema>();
    this->m_recent_state->m_perceived_state = state_bl;
    this->m_recent_state->m_time_perceived = r5pars_.timesno;   
    //To be added, compare the current state with the expectation
}
 
void MRComponentStateUnit::PrintMessage(string str)
{
    cout << "Time: " << r5pars_.timesno << ": " << str << '\n';
 
    //test
    ofstream fout("RMI.txt", ios::app);
    fout << "Time: " << r5pars_.timesno << ": " << str << '\n';
    fout.close();
}
 
MRStateSchema * MRComponentStateUnit::CheckComponentStateWithinTimeRange(float _start, float _end)
{
    MRStateSchema * found_state_schema_pt = NULL;
    if(this->m_recent_state->m_time_perceived >= _start && this->m_recent_state->m_time_perceived <= _end)
    {
        found_state_schema_pt = this->m_recent_state.get();
        return found_state_schema_pt;
    }
    else if(this->m_recent_state->m_time_perceived > _end)
    {
        for(auto &e : this->m_history_state)
        {
            if(e->m_time_perceived >= _start && e->m_time_perceived <= _end)
            {
                found_state_schema_pt = e.get();
            }
        }
    }
    return found_state_schema_pt;
}
 
MRStateSchema * MRComponentStateUnit::CheckLastComponentStateReadingBeforeATime(float _start)
{
    MRStateSchema * found_state_schema_pt = NULL;
 
    if(this->m_recent_state == NULL)
    {return NULL;}
 
    if(this->m_recent_state->m_time_perceived < _start)
    {
        found_state_schema_pt = this->m_recent_state.get();
        return found_state_schema_pt;
    }
    else
    {
        for(auto ritr = this->m_history_state.rbegin(); ritr != this->m_history_state.rend(); ritr++)
        {
            if((*ritr)->m_time_perceived < _start)
            {
                found_state_schema_pt = ritr->get();
                return found_state_schema_pt;
            }
        }
    }
    return found_state_schema_pt;
}
 
MRStateSchema* MRComponentStateUnit::CheckTheFirstComponentStateReadingAfterATime(float _end)
{
    MRStateSchema * found_state_schema_pt = NULL;
 
    for(auto &e : this->m_history_state)
    {
        if(e->m_time_perceived > _end)
        {
            found_state_schema_pt = e.get();
            return found_state_schema_pt;
        }
    }
 
    if(this->m_recent_state->m_time_perceived > _end)
    {
        found_state_schema_pt = this->m_recent_state.get();
    }
    return found_state_schema_pt;
}
 
 
MRValueSchema* MRComponentStateUnit::FindAPositionReadingConsistantWithASentenceWithinTimeRange(float _start, float _end, SentenceUnit *_sent_pt)
{
    MRValueSchema * found_schema_pt = NULL;
    MRValueSchema * value_schema_pt;
    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;
 
 
    value_schema_pt = this->m_recent_position_value.get();
    if(value_schema_pt != NULL)
    {
        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;
            }
        }
    }
 
    auto VS_ritr = this->m_history_position_value.rbegin();
 
    while(VS_ritr != this->m_history_position_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 MRComponentStateUnit::ErrorMessage(string str)
{
    cout << r5pars_.timesno << "  " << str << " in MRComponentStateUnit.cpp" << '\n';
    ofstream fout("err messages.txt", ios::app);
    fout << r5pars_.timesno << "  " << str << '\n';
    fout.close();
    //r5pars_.terminateall = true;
}
 
MRValueSchema* MRComponentStateUnit::FindAPositionReadingInconsitantWithASentenceWithinTimeRange(float _start, float _end, SentenceUnit *_sent_pt)
{
    MRValueSchema * found_schema_pt = NULL;
    MRValueSchema * value_schema_pt;
    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;
 
 
    value_schema_pt = this->m_recent_position_value.get();
    if(value_schema_pt != NULL)
    {
        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;
            }
        }
    }
 
    auto VS_ritr = this->m_history_position_value.rbegin();
 
    while(VS_ritr != this->m_history_position_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* MRComponentStateUnit::FindTheLastPositionReadingBeforeATime(float _start)
{
    MRValueSchema * found_VS_pt = NULL;
    MRValueSchema * VS_pt = NULL;
 
    if(this->m_recent_position_value)
    {
        if(this->m_recent_position_value->m_time_perceived < _start)
        {
            found_VS_pt = this->m_recent_position_value.get();
            return found_VS_pt;
        }
    }
    else
    {
        return NULL;
    }
 
    for(auto ritr = this->m_history_position_value.rbegin(); ritr != this->m_history_position_value.rend(); ritr++)
    {
        VS_pt = ritr->get();
        if(VS_pt->m_time_perceived < _start)
        {
            found_VS_pt = VS_pt;
            return found_VS_pt;
        }
    }
    return found_VS_pt;
 
}
 
MRValueSchema* MRComponentStateUnit::FindTheFirstPositionReadingAfterATime(float _end)
{
    MRValueSchema * found_VS_pt = NULL;
    MRValueSchema * VS_pt = NULL;
 
    if(this->m_recent_position_value == NULL)
    {
        return NULL;
    }
 
    for(auto &e : this->m_history_position_value)
    {
        VS_pt = e.get();
        if(VS_pt->m_time_perceived > _end)
        {
            found_VS_pt = VS_pt;
            return found_VS_pt;
        }
    }
    
    if(this->m_recent_position_value->m_time_perceived > _end)
    {
        found_VS_pt = this->m_recent_position_value.get();
    }
    return found_VS_pt;
}
 
void MRComponentStateUnit::CopyMRComponentStateInfoFromAnother(MRComponentStateUnit * _s_pt)
{
    this->CopyIDElementToRestartInfo((IDElement*)_s_pt);
    this->m_operator = _s_pt->m_operator;
    this->m_CS_type = _s_pt->m_CS_type;
    this->Component_State_Indicator_ID = _s_pt->Component_State_Indicator_ID;
    this->Control_Value_Indicator_ID = _s_pt->Control_Value_Indicator_ID;
    this->m_change_threshold = _s_pt->m_change_threshold;
 
    if(_s_pt->m_Concept_ID_pt != NULL)
    {this->m_concept_ID = _s_pt->m_Concept_ID_pt->m_ID;}
    else
    {this->m_concept_ID = _s_pt->m_concept_ID;}
 
    //statement
    if(_s_pt->m_recent_action_statement != NULL)
    {this->m_ID_recent_action_statement = _s_pt->m_recent_action_statement->m_ID;}
    else
    {this->m_ID_recent_action_statement = _s_pt->m_ID_recent_action_statement;}
 
    if(_s_pt->m_recent_state_statement != NULL)
    {this->m_ID_recent_state_statement = _s_pt->m_recent_state_statement->m_ID;}
    else
    {this->m_ID_recent_state_statement = _s_pt->m_ID_recent_state_statement;}
 
    //recent reading
    if(_s_pt->m_recent_state)
    {
        this->m_recent_state = make_unique<MRStateSchema>();
        this->m_recent_state->CopyStateSchemaFromAnother(_s_pt->m_recent_state.get());
    }
    if(_s_pt->m_recent_position_value)
    {
        this->m_recent_position_value = make_unique<MRValueSchema>();
        this->m_recent_position_value->CopyMRValueSchemaFromAnother(_s_pt->m_recent_position_value.get());
    }
    for(auto &e : _s_pt->m_history_state)
    {
        auto state_pt = make_unique<MRStateSchema>();
        state_pt->CopyStateSchemaFromAnother(e.get());
        this->m_history_state.push_back(std::move(state_pt));
    }
    for(auto &e : _s_pt->m_history_position_value)
    {
        auto value_pt = make_unique<MRValueSchema>();
        value_pt->CopyMRValueSchemaFromAnother(e.get());
        this->m_history_position_value.push_back(std::move(value_pt));
    }
 
 
}
 
void MRComponentStateUnit::BuildConnectionsForThisMRComponentState(void * _pt)
{
    ReasonMachine * RM_pt;
    RM_pt = (ReasonMachine *)_pt;
/*
    IDElement * m_Concept_ID_pt;
    Statement * m_recent_action_statement;
    Statement * m_recent_state_statement;
 
    string m_concept_ID;
    string m_ID_recent_action_statement;
    string m_ID_recent_state_statement;
*/
    if(this->m_concept_ID.compare("") != 0)
    {
        this->m_Concept_ID_pt = RM_pt->m_Concept_Base->FindConceptByID(this->m_concept_ID);
        if(this->m_Concept_ID_pt == NULL)
        {this->ErrorMessage("could not find the concept " + this->m_concept_ID); return;}
    }
    if(this->m_ID_recent_action_statement.compare("") != 0)
    {
        this->m_recent_action_statement = RM_pt->FindStatementByID(this->m_ID_recent_action_statement);
        if(this->m_recent_action_statement == NULL)
        {this->ErrorMessage("could not find the concept " + this->m_ID_recent_action_statement); return;}
    }
    this->m_ID_recent_action_statement = "";
 
    if(this->m_ID_recent_state_statement.compare("") != 0)
    {
        this->m_recent_state_statement = RM_pt->FindStatementByID(this->m_ID_recent_state_statement);
        if(this->m_recent_state_statement == NULL)
        {this->ErrorMessage("could not find the concept " + this->m_ID_recent_state_statement); return;}
    }
    this->m_ID_recent_state_statement = "";
}
 
void MRComponentStateUnit::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_action_statement != NULL)
    {
        if(this->m_recent_action_statement->m_ID_investigator.compare("") != 0)
        {
            invest_pt = RM_pt->FindInvestigatorByID(this->m_recent_action_statement->m_ID_investigator);
            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)
                    {
                        invest_pt->ReopenThisInvestigator();
                    }
                }
            }
        }
    }
 
    if(this->m_recent_state_statement != NULL)
    {
        if(this->m_recent_state_statement->m_ID_investigator.compare("") != 0)
        {
            invest_pt = RM_pt->FindInvestigatorByID(this->m_recent_state_statement->m_ID_investigator);
            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)
                    {
                        invest_pt->ReopenThisInvestigator();
                    }
                }
            }
        }
    }
}