MRSupportSystemStateUnit.cpp

Go to the documentation of this file.

#include "MRSupportSystemStateUnit.h"
#include "../Crew/OperatorDM.h"
#include <sstream>
#include "../Global/SimulationContext.h"
using namespace std;
 
 
MRSupportSystemStateUnit::MRSupportSystemStateUnit() {
  this->m_ID_Type = 204;
  this->m_Concept_ID_pt = NULL;
  this->m_recent_state_statement = NULL;
  this->m_recent_action_statement = NULL;
  this->m_concept_ID = "";
  this->Support_System_State_Indicator_ID = "";
  this->m_ID_recent_action_statement = "";
  this->m_ID_recent_state_statement = "";
  //201--MRParameterUnit
  //202--MRComponentStateUnit
  //203--MRAlarmUnit
  //204--MRSupportSystemStateUnit
 
}
MRSupportSystemStateUnit::~MRSupportSystemStateUnit() {
  this->m_history_state.clear();
}
void MRSupportSystemStateUnit::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();
          }
        }
      }
    }
  }
}
void MRSupportSystemStateUnit::BuildConnectionsForThisMRSupportSystemStateUnit(void *_pt) {
  ReasonMachine *RM_pt;
  RM_pt = (ReasonMachine *) _pt;
 
  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 MRSupportSystemStateUnit::CopyMRSupportSystemStateUnitInfoFromAnother(MRSupportSystemStateUnit * _s_pt) {
  this->CopyIDElementToRestartInfo((IDElement*)_s_pt);
  this->m_operator = _s_pt->m_operator;
  this->Support_System_State_Indicator_ID = _s_pt->Support_System_State_Indicator_ID;
 
  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());
  }
  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));
  }
}
void MRSupportSystemStateUnit::AddNewStateForFirstRoundCheck(int _state, int _operator) {
  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->Support_System_State_Indicator_ID;
  prompt += ": ";
  prompt += str;
  this->PrintMessage(prompt);
 
  //check whether this is consistent 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 MRSupportSystemStateUnit::ReadSupportSystemStateIndication(double _timer) {
  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 variable is ""
  operator_pt->ActiveFetchSupportSystemStateInfo(this->Support_System_State_Indicator_ID, _timer);
}
void MRSupportSystemStateUnit::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 == 3023 || _state == 3099)
  {
    state_bl = false;
    str = "OFF";
  }
 
  prompt = "Received new reading of ";
  prompt += this->Support_System_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);
}
MRStateSchema *MRSupportSystemStateUnit::CheckTheFirstSupportSystemStateReadingAfterATime(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;
}
MRStateSchema *MRSupportSystemStateUnit::CheckLastSupportSystemStateReadingBeforeATime(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 *MRSupportSystemStateUnit::CheckSupportSystemStateWithinTimeRange(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;
}
 
void MRSupportSystemStateUnit::PrintMessage(string str)
{
  cout << "Time: " << r5pars_.timesno << ": " << str << '\n';
 
  //test
  ofstream fout("RMI.txt", ios::app);
  fout << "Time: " << r5pars_.timesno << ": " << str << '\n';
  fout.close();
}
 
void MRSupportSystemStateUnit::ErrorMessage(string str)
{
  cout << r5pars_.timesno << "  " << str << " in MRSupportSystemStateUnit.cpp" << '\n';
  ofstream fout("err messages.txt", ios::app);
  fout << r5pars_.timesno << "  " << str << '\n';
  fout.close();
}