DiagnosisComponentActionUnit.cpp

Go to the documentation of this file.

// DiagnosisComponentActionUnit.cpp: implementation of the DiagnosisComponentActionUnit class.
//
 
#include "DiagnosisComponentActionUnit.h"
#include "../ControlPanel/ControlPanel.h"
#include "../Procedure/ProcedureExpectedSupportSystemStateUnit.h"
#include "../Global/SimulationContext.h"
using namespace std;
 
 
// Construction/Destruction
 
DiagnosisComponentActionUnit::DiagnosisComponentActionUnit() {
  priority = -999;
  action_type = sim::None;
  prerequisite_state = sim::None;
  control_parameter_name = "NONE";
  control_input = 0.0;
  lower_limit = 0.0;
  upper_limit = 0.0;
}
 
DiagnosisComponentActionUnit::~DiagnosisComponentActionUnit() {
  this->clearDiagnosisComponentActionUnit();
}
 
void DiagnosisComponentActionUnit::clearDiagnosisComponentActionUnit() {
  action_prerequisites.clear();
}
 
void DiagnosisComponentActionUnit::setPriority(int n) { priority = n; }
int DiagnosisComponentActionUnit::getPriority() { return priority; }
void DiagnosisComponentActionUnit::setActionType(int n) { action_type = n; }
int DiagnosisComponentActionUnit::getActionType() { return action_type; }
void DiagnosisComponentActionUnit::setPrerequisiteState(int n) { prerequisite_state = n; }
int DiagnosisComponentActionUnit::getPrerequisiteState() { return prerequisite_state; }
void DiagnosisComponentActionUnit::setControlInput(double x) { control_input = x; }
double DiagnosisComponentActionUnit::getControlInput() { return control_input; }
void DiagnosisComponentActionUnit::setLowerLimit(double x) { lower_limit = x; }
double DiagnosisComponentActionUnit::getLowerLimit() { return lower_limit; }
void DiagnosisComponentActionUnit::setUpperLimit(double x) { upper_limit = x; }
double DiagnosisComponentActionUnit::getUpperLimit() { return upper_limit; }
void DiagnosisComponentActionUnit::setControlParameterName(string _str) { control_parameter_name = _str; }
string DiagnosisComponentActionUnit::getControlParameterName() { return control_parameter_name; }
 
void DiagnosisComponentActionUnit::readDiagnosisComponentActionUnitInfoFromFile(ifstream &fin) {
  string str;
  fin >> str;
  this->readInfoFromFile(fin);  // read component name
  fin >> str >> priority;
  fin >> str >> action_type;
  if (action_type == sim::ControlAction::ParameterControl) {
    fin >> str >> control_parameter_name;
  } else {
    fin >> str >> control_input;
  }
  fin >> str >> lower_limit;
  fin >> str >> upper_limit;
  this->readDiagnosisComponentPrerequisiteFromFile(fin);
 
}
 
void DiagnosisComponentActionUnit::readDiagnosisComponentPrerequisiteFromFile(ifstream &fin) {
  string str, str_obj;
  int obj_type, i_temp;
  int num_prereqs;
  ProcedureExpectedAlarmStateUnit *alarm_pt;
  ProcedureExpectedComponentStateUnit *comp_pt;
  ProcedureExpectedSupportSystemStateUnit *ss_pt;
  ProcedureExpectedParameterValueUnit *par_val_pt;
  ProcedureExpectedParameterDifferenceUnit *par_dif_pt;
  ExpectationORUnit *exp_or_pt;
  ExpectedMentalBelief *mp_pt;
  ProcedureExpectORLink *or_pt;
  ExpectationElement *exp_pt;
  //
  fin >> str >> num_prereqs;
  for (i_temp = 0; i_temp < num_prereqs; i_temp++) {
    auto exp_or_upt = make_unique<ExpectationORUnit>();
    exp_or_pt = exp_or_upt.get();
    action_prerequisites.push_back(std::move(exp_or_upt));
    do {
      fin >> str_obj;
      obj_type = this->checkForTypeOfPrerequisite(str_obj);
      if (obj_type == sim::Comm::AlarmState) {
        alarm_pt = new ProcedureExpectedAlarmStateUnit();
        alarm_pt->readInfoFromFileWithoutInfoName(fin);
        alarm_pt->setInfoName(str_obj);
        alarm_pt->setTypeOfExpectation(obj_type);
        exp_pt = (ExpectationElement *) alarm_pt;
        or_pt = (ProcedureExpectORLink *) alarm_pt;
        exp_or_pt->add(exp_pt);
      } else if (obj_type == sim::Comm::ComponentState) {
        comp_pt = new ProcedureExpectedComponentStateUnit();
        comp_pt->readInfoFromFileWithoutInfoName(fin);
        comp_pt->setInfoName(str_obj);
        comp_pt->setTypeOfExpectation(obj_type);
        exp_pt = (ExpectationElement *) comp_pt;
        or_pt = (ProcedureExpectORLink *) comp_pt;
        exp_or_pt->add(exp_pt);
      } else if (obj_type == sim::Comm::SupportSystemState) {
        ss_pt = new ProcedureExpectedSupportSystemStateUnit();
        ss_pt->readInfoFromFileWithoutInfoName(fin);
        ss_pt->setInfoName(str_obj);
        ss_pt->setTypeOfExpectation(obj_type);
        exp_pt = (ExpectationElement *) ss_pt;
        or_pt = (ProcedureExpectORLink *) ss_pt;
        exp_or_pt->add(exp_pt);
      } else if (obj_type == sim::Comm::ParameterValue || obj_type == sim::Comm::ParameterTrend) {
        par_val_pt = new ProcedureExpectedParameterValueUnit();
        par_val_pt->readInfoFromFileWithoutInfoName(fin);
        par_val_pt->setInfoName(str_obj);
        par_val_pt->setTypeOfExpectation(obj_type);
        exp_pt = (ExpectationElement *) par_val_pt;
        or_pt = (ProcedureExpectORLink *) par_val_pt;
        exp_or_pt->add(exp_pt);
      } else if (obj_type == sim::Branch::MentalBelief) {
        mp_pt = new ExpectedMentalBelief();
        mp_pt->readInfoFromFile(fin);
        mp_pt->setTypeOfExpectation(obj_type);
        exp_pt = (ExpectationElement *) mp_pt;
        or_pt = (ProcedureExpectORLink *) mp_pt;
        exp_or_pt->add(exp_pt);
      } else if (obj_type == sim::Comm::ParameterDifference) {
        par_dif_pt = new ProcedureExpectedParameterDifferenceUnit();
        par_dif_pt->readInfoFromFile(fin);
        par_dif_pt->setTypeOfExpectation(obj_type);
        exp_pt = (ExpectationElement *) par_dif_pt;
        or_pt = (ProcedureExpectORLink *) par_dif_pt;
        exp_or_pt->add(exp_pt);
      } else {//parmeter trend and parameter state are not provided currently
        ofstream fout("err messages.txt", ios::app);
        cout << "ProcedureStepUnit::readInfofromFile: expectation body obj_type:" << obj_type << " cannot be recognized"
             << endl;
        fout << r5pars_.timesno << "  ProcedureStepUnit::readInfofromFile: expectation body obj_type:" << obj_type
             << " cannot be recognized\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("ProcedureStepUnit::readInfofromFile err.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
      }
    } while (or_pt->getORLink() == sim::Bool::Yes);
  }
}
 
int DiagnosisComponentActionUnit::checkForTypeOfPrerequisite(string _prereq_name) {
  int n_return;
  DisplayType n_temp;
  string sub_str;
  SystemDisplay *sd_pt;
  map<string, SystemAlarm *>::iterator alarm_map_itr;
  map<string, SystemDisplay *>::iterator display_map_itr;
  map<string, SystemControl *>::iterator control_map_itr;
  n_return = sim::State::Unknown;
  alarm_map_itr = g_sim.Indicator.alarms.alarm_map.find(_prereq_name);
  if (alarm_map_itr != g_sim.Indicator.alarms.alarm_map.end()) {//check whether is an alarm
    n_return = sim::Comm::AlarmState;
    return n_return;
  }
  display_map_itr = g_sim.Indicator.indicators.display_map.find(_prereq_name);
  if (display_map_itr
      != g_sim.Indicator.indicators.display_map.end()) {//check wether is a control panel component stat eor parameter value
    sd_pt = display_map_itr->second;
    n_temp = sd_pt->getTypeOfDisplay();
    if (n_temp == DisplayType::ComponentState) {
      n_return = sim::Comm::ComponentState;
    } else if (n_temp == DisplayType::SupportSystemState) {
      n_return = sim::Comm::SupportSystemState;
    } else if (n_temp == DisplayType::ParameterValue || n_temp == DisplayType::HeatStructure
        || n_temp == DisplayType::ParameterTrend) {
      n_return = sim::Comm::ParameterValue;
    } else {
      ofstream fout("err messages.txt", ios::app);
      cout << "ProcedureStepUnit::checkForTypeOfExpectation obj: " << _prereq_name << " Type of display:" << static_cast<int>(n_temp)
           << " cannot be recognized" << endl;
      fout << r5pars_.timesno << "  DiagnosisComponentActionUnit::checkForTypeOfPrerequisite obj: " << _prereq_name
           << " Type of display:" << static_cast<int>(n_temp) << " cannot be recognized\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("DiagnosisComponentActionUnit::checkForTypeOfPrerequisite err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
    }
    return n_return;
  }
  if (_prereq_name == "Mental_Belief") {
    n_return = sim::Branch::MentalBelief;
  } else if (_prereq_name == "Parameter_Difference") {
    n_return = sim::Comm::ParameterDifference;
  } else {
    ofstream fout("err messages.txt", ios::app);
    cout << "DiagnosisComponentActionUnit::checkForTypeOfExpectation: Obj_name: " << _prereq_name
         << " cannot be recognized" << endl;
    fout << r5pars_.timesno << "  DiagnosisComponentActionUnit::checkForTypeOfPrerequisite: Obj_name: " << _prereq_name
         << " cannot be recognized\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("DiagnosisComponentActionUnit::checkForTypeOfPrerequisite err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
  return n_return;
}
 
bool DiagnosisComponentActionUnit::assessPrerequisites(Operator &_operator, ShortTermMemory &_stm, int _entry) {
  bool found_prereq = false;
  bool branch_generated = false;
  int state_of_activation;
  auto expectationOR_itr = action_prerequisites.begin();
  while (expectationOR_itr != action_prerequisites.end() && !found_prereq) {
    state_of_activation = (*expectationOR_itr)->getStateOfActivation();
    if (state_of_activation == sim::None) {
      found_prereq = true;
      (*expectationOR_itr)->setStateOfActivation(sim::State::Active);
      branch_generated = (*expectationOR_itr)->assessExpectation(_operator, _stm, _entry);
      if (branch_generated) {
        return branch_generated;
      }
    } else if (state_of_activation == sim::State::Active) {
      found_prereq = true;
      branch_generated = (*expectationOR_itr)->assessExpectation(_operator, _stm, _entry);
      if (branch_generated) {
        return branch_generated;
      }
    } else if (state_of_activation == sim::State::Failed) {
      found_prereq = true;
      this->setPrerequisiteState(sim::State::Failed);
    }
 
    expectationOR_itr++;
  }
  if (!found_prereq) {
    this->setPrerequisiteState(sim::State::Succeed);
  }
  return branch_generated;
}
 
void DiagnosisComponentActionUnit::resetComponentActionUnit() {
  this->setPrerequisiteState(sim::None);
  for (auto& prereq : this->action_prerequisites) {
    prereq->setStateOfActivation(sim::None);
    for (auto& exp_or : prereq->expectation_OR) {
      exp_or->setStateOfExpectation(sim::None);
    }
  }
}
 
void DiagnosisComponentActionUnit::copyDiagnosisComponentActionUnit(DiagnosisComponentActionUnit &_dcau) {
  this->copyKBElement(_dcau);
  action_type = _dcau.getActionType();
  control_input = _dcau.getControlInput();
  control_parameter_name = _dcau.getControlParameterName();
  lower_limit = _dcau.getLowerLimit();
  upper_limit = _dcau.getUpperLimit();
  priority = _dcau.getPriority();
  prerequisite_state = _dcau.getPrerequisiteState();
  //
  for (auto& src : _dcau.action_prerequisites) {
    auto prereq_pt = make_unique<ExpectationORUnit>();
    prereq_pt->copyExpectationORUnit(*src);
    this->action_prerequisites.push_back(std::move(prereq_pt));
  }
}
 
void DiagnosisComponentActionUnit::saveDiagnosisComponentActionUnitToFile(ofstream &fout) {
  int num_prereq;
  this->saveKBElementToFile(fout);
  fout << action_type << ' ' << control_input << '\n'
       << control_parameter_name << '\n'
       << lower_limit << ' ' << upper_limit << '\n'
       << priority << ' ' << prerequisite_state
       << '\n';
  //
  num_prereq = this->action_prerequisites.size();
  fout << num_prereq << '\n';
  for (auto& prereq : action_prerequisites) {
    prereq->saveExpectationORUnitToFile(fout);
  }
}
 
void DiagnosisComponentActionUnit::retrieveDiagnosisComponentActionUnitFromFile(ifstream &fin) {
  int i, num_prereq;
  this->retrieveKBElementFromFile(fin);
  fin >> action_type >> control_input
      >> control_parameter_name
      >> lower_limit >> upper_limit
      >> priority >> prerequisite_state;
  //
  fin >> num_prereq;
  for (i = 0; i < num_prereq; i++) {
    auto prereq_ptr = make_unique<ExpectationORUnit>();
    prereq_ptr->retrieveExpectationORUnitFromFile(fin);
    this->action_prerequisites.push_back(std::move(prereq_ptr));
  }
}