RoutineMonitor.cpp

Go to the documentation of this file.

// RoutineMonitor.cpp: implementation of the RoutineMonitor class.
//
 
#include <iostream>
#include <fstream>
 
#include "RoutineMonitor.h"
#include "ReasonMachine.h"
#include "../Crew/OperatorDM.h"
#include "../Global/SimulationContext.h"
 
using namespace std;
 
 
// Construction/Destruction
 
RoutineMonitor::RoutineMonitor() {
  this->m_routine_monitor_Token = 11; //default, the next step is to get a monitor unit;
  this->m_read_value_or_rate = 0; //0--read parameter value; 1--read parameter rate;
  this->m_workon_unit_pt = NULL;
}
 
RoutineMonitor::~RoutineMonitor() {
/*
    vector<RoutineMonitorUnit *> m_monitor_list;
*/
  this->m_monitor_list.clear();
}
 
float RoutineMonitor::GetaMonitorUnit11() {
  //To be modified
  //Based on the relevance and the last time monitored
  RoutineMonitorUnit *unit_pt = NULL;
  float high_score, score;
  double update_time;
  for (auto &e : this->m_monitor_list) {
    update_time = e->GetLastUpdateTime();
    if (update_time == 0) {
      this->m_workon_unit_pt = e.get();
      this->m_routine_monitor_Token = 12;
      return 1;
    }
    score = (r5pars_.timesno - update_time) / e->m_desired_monitor_interval;
    if (unit_pt == NULL) {
      unit_pt = e.get();
      high_score = score;
    } else if (score > high_score) {
      unit_pt = e.get();
      high_score = score;
    }
  }
  //the highest-scoring unit is selected only when its score (elapsed time over desired interval) exceeds 1.0
  if (high_score > 1.0) {
    //
    this->m_workon_unit_pt = unit_pt;
    this->m_routine_monitor_Token = 12;
  }
  return high_score;
}
 
void RoutineMonitor::WorkOnASelectedUnit12() {
  string prompt;
  MRParameterUnit *MR_P_pt;
  MRComponentStateUnit *MR_C_pt;
  MRSupportSystemStateUnit *MR_SS_pt;
  MRAlarmUnit *MR_A_pt;
  ReasonMachine *RM_pt;
  double time_consumption;
  string rm_aux_info;
 
  int operator_branch_num = 0;
  if (this->m_operator == sim::Operator::ODM) {
    RM_pt = g_sim.Decision_Maker.m_RM.get();
    operator_branch_num = g_sim.Branch_center.getNumOfODMBranch();
  } else if (this->m_operator == sim::Operator::OAT) {
    RM_pt = g_sim.Action_Taker.m_RM.get();
    operator_branch_num = g_sim.Branch_center.getNumOfOATBranch();
  } else {}//add error message
 
  if (operator_branch_num > 0) {
    RM_pt->WaitOneStepThereIsOneOrMoreOperatorBranches();
    return;
  }
 
  //To be modified
  //Send the request to get indication reading
  if (this->m_workon_unit_pt->m_MR_unit_pt == NULL) {//error message;
    return;
  }
 
  //To be modified with PSF
  switch (this->m_workon_unit_pt->m_MR_unit_pt->m_ID_Type) {
    case 201: MR_P_pt = (MRParameterUnit *) (this->m_workon_unit_pt->m_MR_unit_pt);
      time_consumption = this->m_time_cost_for_P;
      if (this->m_read_value_or_rate == 0) {
        MR_P_pt->ReadParameterValue(time_consumption);
        this->m_read_value_or_rate = 1;
        prompt = "Send request to read: ";
        prompt += MR_P_pt->m_parameter_indicator_ID;
        this->PrintMessage(prompt);
        //
        rm_aux_info = "Reading requested by routine monitoring: " + MR_P_pt->m_parameter_indicator_ID;
        RM_pt->WriteAuxInfo(rm_aux_info);
      } else {
        MR_P_pt->ReadParameterRate(time_consumption);
        this->m_read_value_or_rate = 0;
        prompt = "Send request to read: ";
        prompt += MR_P_pt->m_parameter_rate_indicator_ID;
        this->PrintMessage(prompt);
        this->m_routine_monitor_Token = 11;
      }
      break;
    case 202: MR_C_pt = (MRComponentStateUnit *) (this->m_workon_unit_pt->m_MR_unit_pt);
      time_consumption = this->m_time_cost_for_C;
      MR_C_pt->ReadComponentStateIndication(time_consumption);
 
      prompt = "Send request to read: ";
      if (MR_C_pt->m_CS_type == 0) {
        prompt += MR_C_pt->Component_State_Indicator_ID;
        rm_aux_info = "Reading requested by routine monitoring: " + MR_C_pt->Component_State_Indicator_ID;
      } else {
        prompt += MR_C_pt->Control_Value_Indicator_ID;
        rm_aux_info = "Reading requested by routine monitoring: " + MR_C_pt->Control_Value_Indicator_ID;
      }
      this->PrintMessage(prompt);
      RM_pt->WriteAuxInfo(rm_aux_info);
 
      //Change the token value
      this->m_routine_monitor_Token = 11;
      break;
    case 203: MR_A_pt = (MRAlarmUnit *) (this->m_workon_unit_pt->m_MR_unit_pt);
      time_consumption = this->m_time_cost_for_A;
      MR_A_pt->ReadAlarmIndication(time_consumption);
 
      prompt = "Send request to read: ";
      prompt += MR_A_pt->m_alarm_indicator_name;
      this->PrintMessage(prompt);
 
      rm_aux_info = "Reading requested by routine monitoring: " + MR_A_pt->m_alarm_indicator_name;
      RM_pt->WriteAuxInfo(rm_aux_info);
 
      //Change the token value
      this->m_routine_monitor_Token = 11;
      break;
    case 204: MR_SS_pt = (MRSupportSystemStateUnit *) (this->m_workon_unit_pt->m_MR_unit_pt);
      time_consumption = this->m_time_cost_for_SS;
      MR_SS_pt->ReadSupportSystemStateIndication(time_consumption);
 
      prompt = "Send request to read: ";
      prompt += MR_SS_pt->Support_System_State_Indicator_ID;
      this->PrintMessage(prompt);
 
      rm_aux_info = "Reading requested by routine monitoring: " + MR_SS_pt->Support_System_State_Indicator_ID;
      RM_pt->WriteAuxInfo(rm_aux_info);
 
      //Change the token value
      this->m_routine_monitor_Token = 11;
      break;
    default:
      //error message, unrecognized indication
      break;
  }
  RM_pt->AddConsumptedDeltaT(time_consumption);
 
}
 
void RoutineMonitor::ReadRoutineMonitorInforFromInputFile() {
  string directory, str, str1, str_ID, file_name;
  ifstream fin;
  int n_Unit, i;
  double v1;
  RoutineMonitorUnit *M_pt;
  string err_mes;
 
  //get the input file directory
  if (this->m_operator == sim::Operator::ODM) {
    file_name = g_sim.SScheduler.getODMDirectory();
    file_name += "RM/";
    file_name += "KB_ODM_Routine_Monitor_List.txt";
  } else if (this->m_operator == sim::Operator::OAT) {
    file_name = g_sim.SScheduler.getOATDirectory();
    file_name += "RM/";
    file_name += "KB_OAT_Routine_Monitor_List.txt";
  } else {}//error message
 
  fin.open(file_name.c_str(), ios::in);
  if (!fin.is_open()) {
    err_mes = "could not open file: " + file_name;
    this->ErrorMessage(err_mes);
    return;
  } else {
    //start to read information from the input file
    fin >> str >> v1;
    if (str.compare("Time_Cost_For_Reading_A_Parameter:") != 0) {
      err_mes = "Time_Cost_For_Reading_A_Parameter is missing in Routine_Monitor_List txt file";
      this->ErrorMessage(err_mes);
      return;
    }
    this->m_time_cost_for_A = v1;
 
    fin >> str >> v1;
    if (str.compare("Time_Cost_For_Reading_A_Component_State:") != 0) {
      err_mes = "Time_Cost_For_Reading_A_Component_State is missing in Routine_Monitor_List txt file";
      this->ErrorMessage(err_mes);
      return;
    }
    this->m_time_cost_for_P = v1;
 
    fin >> str >> v1;
    if (str.compare("Time_Cost_For_Reading_A_Support_System_State:") != 0) {
      err_mes = "Time_Cost_For_Reading_A_Support_System_State is missing in Routine_Monitor_List txt file";
      this->ErrorMessage(err_mes);
      return;
    }
    this->m_time_cost_for_SS = v1;
 
    fin >> str >> v1;
    if (str.compare("Time_Cost_For_Reading_A_Alarm:") != 0) {
      err_mes = "Time_Cost_For_Reading_A_Alarm is missing in Routine_Monitor_List txt file";
      this->ErrorMessage(err_mes);
      return;
    }
    this->m_time_cost_for_C = v1;
 
    fin >> str >> n_Unit;
 
    if (str.compare("Number_of_Monitor_Item") != 0) {
      err_mes = "Number_of_Monitor_Item is missing in Routine_Monitor_List txt file";
      this->ErrorMessage(err_mes);
      return;
    }
    string ID_name;
    stringstream conv;
    for (i = 0; i < n_Unit; i++) {
      conv.str("");
      conv << this->m_monitor_list.size();
      ID_name = "Routine_Monitor_" + conv.str();
      auto M_owned = std::make_unique<RoutineMonitorUnit>();
      M_pt = M_owned.get();
      M_pt->m_ID = ID_name;
      M_pt->m_operator = this->m_operator;
      M_pt->ReadRoutineMonitorUnitInfoFromInputFile(fin);
      this->m_monitor_list.push_back(std::move(M_owned));
    }
    fin.close();
  }
}
 
//DEL void RoutineMonitor::SendMonitorRequestToOneIndication()
//DEL {
//DEL 
//DEL }
 
void RoutineMonitor::ErrorMessage(string str) {
  cout << r5pars_.timesno << "  " << str << " in RoutineMonitor.cpp" << '\n';
  ofstream fout("err messages.txt", ios::app);
  fout << r5pars_.timesno << "  " << str << '\n';
  fout.close();
  //r5pars_.terminateall = true;
}
 
void RoutineMonitor::PrintMessage(string str) {
  cout << "\n";
  cout << "Time: " << r5pars_.timesno << ":\n" << str << '\n';
 
  //test
  ofstream fout("RMI.txt", ios::app);
  fout << "\n" << "Time: " << r5pars_.timesno << ":\n" << str << '\n';
  fout.close();
}
 
void RoutineMonitor::CopyRoutineMonitorInfoFromAnother(RoutineMonitor *_M_pt) {
  this->m_operator = _M_pt->m_operator;
  this->m_routine_monitor_Token = _M_pt->m_routine_monitor_Token;
  this->m_read_value_or_rate = _M_pt->m_read_value_or_rate;
  this->m_time_cost_for_A = _M_pt->m_time_cost_for_A;
  this->m_time_cost_for_C = _M_pt->m_time_cost_for_C;
  this->m_time_cost_for_P = _M_pt->m_time_cost_for_P;
  this->m_time_cost_for_SS = _M_pt->m_time_cost_for_SS;
 
  RoutineMonitorUnit *monitor_pt;
 
  for (auto &e : _M_pt->m_monitor_list) {
    auto monitor_owned = std::make_unique<RoutineMonitorUnit>();
    monitor_pt = monitor_owned.get();
    monitor_pt->CopyRMUinfoFromAnother(e.get());
    this->m_monitor_list.push_back(std::move(monitor_owned));
 
    if (_M_pt->m_workon_unit_pt == e.get()) { this->m_workon_unit_pt = monitor_pt; }
  }
 
}
 
void RoutineMonitor::BuildConnectionsForRoutineMonitor(void *_pt) {
  ReasonMachine *RM_pt;
  RM_pt = (ReasonMachine *) _pt;
  for (auto &e : this->m_monitor_list) {
    e->BuildConnectionsForThisRoutineMonitorUnit(_pt);
  }
}
 
float RoutineMonitor::GetTheLongestIntervalRatio() {
  float highest_score, score;
  double update_time;
 
  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
 
  highest_score = 0;
  for (auto &e : this->m_monitor_list) {
    update_time = e->GetLastUpdateTime();
    score = (r5pars_.timesno - update_time) / e->m_desired_monitor_interval;
    if (score > highest_score) {
      highest_score = score;
    }
  }
 
  highest_score *= 1 / RM_pt->m_routine_monitor_interval_multiplier;
  return highest_score;
}