RoutineMonitorUnit.cpp

Go to the documentation of this file.

// RoutineMonitorUnit.cpp: implementation of the RoutineMonitorUnit class.
//
 
#include <iostream>
#include <fstream>
 
#include "RoutineMonitorUnit.h"
#include "../Crew/OperatorDM.h"
#include "../Global/SimulationContext.h"
 
 
using namespace std;
 
// Construction/Destruction
 
RoutineMonitorUnit::RoutineMonitorUnit() {
  this->m_relevance = 1;
  this->m_last_update_time = 0;
  this->m_MR_unit_pt = NULL;
  this->m_ID_MR_unit = "";
}
 
RoutineMonitorUnit::~RoutineMonitorUnit() {
 
}
 
void RoutineMonitorUnit::ReadRoutineMonitorUnitInfoFromInputFile(ifstream &fin) {
  string str, ID_str;
  string err_mes;
  float Interval;
 
  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
 
  fin >> str >> ID_str;
  if (str.compare("Concept_Name:") != 0) {
    err_mes = "Concept_Name is missing in Routine_Monitor_List txt file. \n";
    err_mes += "And " + ID_str + " is misplaced";
    this->ErrorMessage(err_mes);
    return;
  }
  this->m_MR_unit_pt = RM_pt->m_MR->CheckExistenceByConceptName(ID_str);
  if (this->m_MR_unit_pt == NULL) {
    err_mes = "Error in the Routine_Monitor_List txt file \n";
    err_mes += "could not find this concept in semantic base: " + ID_str;
    this->ErrorMessage(err_mes);
    return;
  }
 
  fin >> str >> Interval;
  if (str.compare("Monitor_Interval:") != 0) {
    err_mes = "Monitor_Interval of " + ID_str + " is missing in Routine_Monitor_List txt file. \n";
    this->ErrorMessage(err_mes);
    return;
  }
  this->m_desired_monitor_interval = Interval;
}
 
double RoutineMonitorUnit::GetLastUpdateTime() {
  MRParameterUnit *P_pt;
  MRComponentStateUnit *C_pt;
  MRSupportSystemStateUnit *SS_pt;
  MRAlarmUnit *A_pt;
  double update_time;
 
  if (this->m_MR_unit_pt == NULL) { return 0; }//error message
  switch (this->m_MR_unit_pt->m_ID_Type) {
    case 201: P_pt = (MRParameterUnit *) this->m_MR_unit_pt;
      if (P_pt->m_recent_parameter_value != NULL) {
        update_time = P_pt->m_recent_parameter_value->m_time_perceived;
      } else {
        update_time = 0;
      }
      break;
    case 202: C_pt = (MRComponentStateUnit *) this->m_MR_unit_pt;
      if (C_pt->m_CS_type == 0) {
        if (C_pt->m_recent_state != NULL) {
          update_time = C_pt->m_recent_state->m_time_perceived;
        } else {
          update_time = 0;
        }
      } else if (C_pt->m_CS_type == 1) {
        if (C_pt->m_recent_position_value != NULL) {
          update_time = C_pt->m_recent_position_value->m_time_perceived;
        } else {
          update_time = 0;
        }
      } else {}//error message
      break;
    case 203: A_pt = (MRAlarmUnit *) this->m_MR_unit_pt;
      if (A_pt->m_recent_state != NULL) {
        update_time = A_pt->m_recent_state->m_time_perceived;
      } else {
        update_time = 0;
      }
      break;
    case 204: SS_pt = (MRSupportSystemStateUnit *) this->m_MR_unit_pt;
      if (SS_pt->m_recent_state != NULL) {
        update_time = SS_pt->m_recent_state->m_time_perceived;
      } else {
        update_time = 0;
      }
      break;
    default:
      //error message
      break;
  }
  this->m_last_update_time = update_time;
  return this->m_last_update_time;
}
 
void RoutineMonitorUnit::ErrorMessage(string str) {
  cout << r5pars_.timesno << "  " << str << " inRoutineMonitorUnit.cpp" << '\n';
  ofstream fout("err messages.txt", ios::app);
  fout << r5pars_.timesno << "  " << str << '\n';
  fout.close();
  //r5pars_.terminateall = true;
}
 
void RoutineMonitorUnit::CopyRMUinfoFromAnother(RoutineMonitorUnit *_monitor_pt) {
  this->CopyIDElementToRestartInfo((IDElement *) _monitor_pt);
  this->m_desired_monitor_interval = _monitor_pt->m_desired_monitor_interval;
  this->m_last_update_time = _monitor_pt->m_last_update_time;
  this->m_operator = _monitor_pt->m_operator;
  if (_monitor_pt->m_MR_unit_pt != NULL) {
    this->m_ID_MR_unit = _monitor_pt->m_MR_unit_pt->m_ID;
  } else {
    this->m_ID_MR_unit = _monitor_pt->m_ID_MR_unit;
  }
 
}
 
void RoutineMonitorUnit::BuildConnectionsForThisRoutineMonitorUnit(void *_pt) {
  ReasonMachine *RM_pt;
  RM_pt = (ReasonMachine *) _pt;
  //IDElement * m_MR_unit_pt;
  this->m_MR_unit_pt = RM_pt->m_MR->FindMRUnitByID(this->m_ID_MR_unit);
  if (this->m_MR_unit_pt == NULL) {
    this->ErrorMessage("could not find the corresponding MR unit " + this->m_ID_MR_unit);
    return;
  }
}