MRAlarmUnit.cpp

Go to the documentation of this file.

// MRAlarmUnit.cpp: implementation of the MRAlarmUnit class.
//
 
#include <string>
#include <sstream>
#include <iostream>
#include <fstream>
 
#include "MRAlarmUnit.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
 
MRAlarmUnit::MRAlarmUnit()
{
    this->m_ID_Type = 203;
    this->m_recent_state_statement = NULL;
    this->m_recent_action_statement = NULL;
    this->m_Concept_pt = NULL;
 
    this->m_Concept_ID = "";
    this->m_ID_recent_state_statement = "";
    this->m_ID_recent_action_statement = "";
    //201--MRParameterUnit
    //202--MRComponentStateUnit
    //203--MRAlarmUnit
}
 
MRAlarmUnit::~MRAlarmUnit()
{
    this->m_history_state_list.clear();
}
 
void MRAlarmUnit::AddNewAlarmState(int _state, int _operator, bool _expecting)
{
    Statement * statement_pt;
    SentenceUnit * sent_pt;
    SentenceUnit * found_sent_pt;
    ReasonMachine * RM_pt;
    string prompt, str;
 
    bool New_Statement_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 
 
    bool state_bl;
    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";
    }
    else {}//error message
 
    
    prompt = "Received new reading of ";
    prompt += this->m_alarm_indicator_name;
    prompt += ": ";
    prompt += str;
    this->PrintMessage(prompt);
 
    RM_pt->AddDeltaToCognitiveLoad(0.024);
    if(this->m_recent_state != NULL)
    {
        if (state_bl != this->m_recent_state->m_perceived_state)
        {
            // there is a change
            New_Statement_bl = true;
            if(state_bl == true)
            {
                //add one statement to say "xxxAlamr turn_on")
                SentenceUnit sent;
                sent.m_sentence_type = 1;
                sent.m_subject_pt = this->m_Concept_pt;
                sent.m_process_pt = RM_pt->m_Concept_Base->getTurnOnPt();
                found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&sent);
            }
            else
            {
                //add one statement to say "xxxAlarm turn_off"
                SentenceUnit sent;
                sent.m_sentence_type = 1;
                sent.m_subject_pt = this->m_Concept_pt;
                sent.m_process_pt = RM_pt->m_Concept_Base->getTurnOffPt();
                found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&sent);
            }
            if(found_sent_pt != 0)
            {
                auto stmt = make_unique<Statement>();
                stmt->m_confidence = 1;
                stmt->m_factual_type = 1;
                stmt->m_sent_pt = found_sent_pt;
                stmt->m_state = true;
                stmt->m_time_generated = r5pars_.timesno;
                if(_expecting == 0)
                {
                    stmt->m_time_range.m_end_time  = r5pars_.timesno;
                    stmt->m_time_range.m_start_time  = r5pars_.timesno;
                }
                else
                {
                    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());
                RM_pt->AddDeltaToSystemDynamics(0.12);
                this->m_recent_action_statement = statement_pt;
 
                if(_expecting == true)
                {
                    auto *check_sent_pt = RM_pt->m_working_on_invest_pt->GetSemanticSentenceOfThisInvestigator();
                    if(check_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);
                    }
                }
 
                //RM_pt->MakeOneStepInferenceFromAStatement(statement_pt);
                /*
                //Add an investigator for this statement
                if(statement_pt->m_investigator_ID_pt == NULL)
                {
                    invest_pt = new Investigator();
                    invest_pt->m_motivation = 1;
                    invest_pt->m_Statement_pt = statement_pt;
                    invest_pt->m_Happen = 3;
                    invest_pt->m_operator = this->m_operator;
                    RM_pt->AddNewInvestigator(invest_pt);
                    //link the statement to the statement pointer
                    statement_pt->m_investigator_ID_pt = (IDElement*)invest_pt;
                }
                */
            }
            else
            {}//warning message
        }
        else
        {
            // it is the same state as received last time
            New_Statement_bl = false;
            this->m_recent_state_statement->RefreshStatementEndTimeToCurrentTime(0);
            RM_pt->ActivationUpdateByRefreshAStatement(this->m_recent_state_statement);
        }
    }
    else
    {
        New_Statement_bl = true;
    }
    if(New_Statement_bl == true)
    {
        if(state_bl == true)
        {
            //add on statement to say "xxxAlarm is on"
            SentenceUnit sent;
            sent.m_sentence_type = 2;
            sent.m_subject_pt = this->m_Concept_pt;
            sent.m_state_pt = RM_pt->m_Concept_Base->getONpt();
            found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&sent);
        }
        else
        {
            //add on statement to say "xxxAlarm is off"
            SentenceUnit sent;
            sent.m_sentence_type = 2;
            sent.m_subject_pt = this->m_Concept_pt;
            sent.m_state_pt = RM_pt->m_Concept_Base->getOFFpt();
            found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&sent);
        }
        if(found_sent_pt != 0)
        {
            auto stmt = make_unique<Statement>();
            stmt->m_confidence = 1;
            stmt->m_factual_type = 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;
            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;
 
            //RM_pt->MakeOneStepInferenceFromAStatement(statement_pt);
        }
        else
        {}//warning
    }
    if(this->m_recent_state)
    {this->m_history_state_list.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;
}
 
void MRAlarmUnit::ReadAlarmIndication(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 ""
    operator_pt->ActiveFetchAlarmStateInfo(this->m_alarm_indicator_name, _timer);
}
 
void MRAlarmUnit::AddNewAlarmStateForFirstRoundCheck(int _state, int _operator)
{
    Statement * statement_pt;
    SentenceUnit * sent_pt;
    SentenceUnit * found_sent_pt;
    ReasonMachine * RM_pt;
    string prompt, str;
 
    bool New_Statement_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 
 
    bool state_bl;
    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";
    }
    else {}//error message
 
    prompt = "Received new reading of ";
    prompt += this->m_alarm_indicator_name;
    prompt += ": ";
    prompt += str;
    this->PrintMessage(prompt);
 
    if(this->m_recent_state != NULL)
    {
        if (state_bl != this->m_recent_state->m_perceived_state)
        {
            // there is a change
            New_Statement_bl = true;
            if(state_bl == true)
            {
                //add one statement to say "xxxAlamr turn_on")
                SentenceUnit sent;
                sent.m_sentence_type = 1;
                sent.m_subject_pt = this->m_Concept_pt;
                sent.m_process_pt = RM_pt->m_Concept_Base->getTurnOnPt();
                found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&sent);
            }
            else
            {
                //add one statement to say "xxxAlarm turn_off"
                SentenceUnit sent;
                sent.m_sentence_type = 1;
                sent.m_subject_pt = this->m_Concept_pt;
                sent.m_process_pt = RM_pt->m_Concept_Base->getTurnOffPt();
                found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&sent);
            }
            if(found_sent_pt != 0)
            {
                auto stmt = make_unique<Statement>();
                stmt->m_confidence = 1;
                stmt->m_factual_type = 1;
                stmt->m_sent_pt = found_sent_pt;
                stmt->m_state = true;
                stmt->m_time_generated = r5pars_.timesno;
                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
            {}//warning message
        }
        else
        {
            // it is the same state as received last time
            New_Statement_bl = false;
            this->m_recent_state_statement->RefreshStatementEndTimeToCurrentTime(0);
            RM_pt->ActivationUpdateByRefreshAStatement(this->m_recent_state_statement);
        }
    }
    else
    {
        New_Statement_bl = true;
    }
    if(New_Statement_bl == true)
    {
        if(state_bl == true)
        {
            //add on statement to say "xxxAlarm is on"
            SentenceUnit sent;
            sent.m_sentence_type = 2;
            sent.m_subject_pt = this->m_Concept_pt;
            sent.m_state_pt = RM_pt->m_Concept_Base->getONpt();
            found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&sent);
        }
        else
        {
            //add on statement to say "xxxAlarm is off"
            SentenceUnit sent;
            sent.m_sentence_type = 2;
            sent.m_subject_pt = this->m_Concept_pt;
            sent.m_state_pt = RM_pt->m_Concept_Base->getOFFpt();
            found_sent_pt = RM_pt->CheckExistInSemanticPoolBySentence(&sent);
        }
        if(found_sent_pt != 0)
        {
            auto stmt = make_unique<Statement>();
            stmt->m_confidence = 1;
            stmt->m_factual_type = 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;
            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
    }
    if(this->m_recent_state)
    {this->m_history_state_list.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;
}
 
void MRAlarmUnit::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* MRAlarmUnit::CheckAlarmStateWithinTimeRange(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_list)
        {
            if(e->m_time_perceived >= _start && e->m_time_perceived <= _end)
            {
                found_state_schema_pt = e.get();
            }
        }
    }
    return found_state_schema_pt;
 
}
 
MRStateSchema* MRAlarmUnit::CheckLastAlarmStateBeforeATime(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_list.rbegin(); ritr != this->m_history_state_list.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* MRAlarmUnit::CheckFirstAlarmStateAfterATime(float _end)
{
    MRStateSchema * found_state_schema_pt = NULL;
 
    for(auto &e : this->m_history_state_list)
    {
        if(e->m_time_perceived > _end)
        {
            found_state_schema_pt = e.get();
            return found_state_schema_pt;
        }
    }
 
    if(this->m_recent_state != NULL)
    {
        if(this->m_recent_state->m_time_perceived > _end)
        {
            found_state_schema_pt = this->m_recent_state.get();
        }
    }
    return found_state_schema_pt;
}
 
void MRAlarmUnit::ConvertStaticInfoToString()
{
    if(this->m_Concept_ID.compare("") != 0)
    {
        if(this->m_Concept_pt != NULL)
        {
            this->m_Concept_ID = this->m_Concept_pt->m_ID;
        }
    }
}
 
void MRAlarmUnit::CopyMRAlarmUnitInfoFromAnother(MRAlarmUnit * _a_pt) 
{
    this->CopyIDElementToRestartInfo((IDElement*) _a_pt);
    this->m_operator = _a_pt->m_operator;
    this->m_alarm_indicator_name = _a_pt->m_alarm_indicator_name;
 
    //
    if(_a_pt->m_Concept_pt != NULL)
    {this->m_Concept_ID = _a_pt->m_Concept_pt->m_ID;}
    else
    {this->m_Concept_ID = _a_pt->m_Concept_ID;}
 
    //
    if(_a_pt->m_recent_action_statement != NULL)
    {this->m_ID_recent_action_statement = _a_pt->m_recent_action_statement->m_ID;}
    else
    {this->m_ID_recent_action_statement = _a_pt->m_ID_recent_action_statement;}
 
    if(_a_pt->m_recent_state_statement != NULL)
    {this->m_ID_recent_state_statement = _a_pt->m_recent_state_statement->m_ID;}
    else
    {this->m_ID_recent_state_statement = _a_pt->m_ID_recent_state_statement;}
 
    //recent state
    if(_a_pt->m_recent_state)
    {
        this->m_recent_state = make_unique<MRStateSchema>();
        this->m_recent_state->CopyStateSchemaFromAnother(_a_pt->m_recent_state.get());
    }
    //history
    if(this->m_history_state_list.size() != 0)
    {
        this->ErrorMessage("this->m_history_state_list.size()");
        return;
    }
    for(auto &e : _a_pt->m_history_state_list)
    {
        auto state_pt = make_unique<MRStateSchema>();
        state_pt->CopyStateSchemaFromAnother(e.get());
        this->m_history_state_list.push_back(std::move(state_pt));
    }
 
}
 
void MRAlarmUnit::ErrorMessage(string str)
{
    cout << r5pars_.timesno << "  " << str << " in MRAlarmUnit.cpp" << '\n';
    ofstream fout("err messages.txt", ios::app);
    fout << r5pars_.timesno << "  " << str << '\n';
    fout.close();
    //r5pars_.terminateall = true;
}
 
void MRAlarmUnit::BuildConnectionsForThisMRAlarmUnit(void * _pt)
{
    ReasonMachine * RM_pt;
    RM_pt = (ReasonMachine *)_pt;
/*
    MRStateSchema * m_recent_state;
    vector<MRStateSchema *> m_history_state_list;
    Statement * m_recent_state_statement;
    Statement * m_recent_action_statement;
    IDElement * m_Concept_pt;
 
    string m_Concept_ID;
    string m_ID_recent_state_statement;
    string m_ID_recent_action_statement;
*/
    if(this->m_Concept_ID.compare("") != 0)
    {
        this->m_Concept_pt = RM_pt->m_Concept_Base->FindConceptByID(this->m_Concept_ID);
        if(this->m_Concept_pt == NULL)
        {this->ErrorMessage("can not find the concept for this MRA " + 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 statement " + 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 statement " + this->m_ID_recent_state_statement ); return;}
    }
    this->m_ID_recent_state_statement = "";
}
 
//DEL void MRAlarmUnit::BuildConnectionsForThisMRAlarm(void *)
//DEL {
//DEL 
//DEL }