SupportSystemReliabilityUnit.cpp

Go to the documentation of this file.

#include "SupportSystemReliabilityUnit.h"
#include "../ControlPanel/ControlPanel.h"
#include <boost/serialization/export.hpp>
#include "../Global/SimulationContext.h"
using namespace std;
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
//BOOST_CLASS_EXPORT_IMPLEMENT(SupportSystemReliabilityUnit)
 
 
SupportSystemReliabilityUnit::SupportSystemReliabilityUnit(const string &topNode) : topNode(topNode) {
  correspondingSupportSystemPt = 0;
  initialSupportSystemState = sim::None;
 
//  hclEngine.setBBNSolver(hclEngine.BBN_SMILE);
//  hclEngine.setBDDConstructor(hclEngine.BDD_FORWARD);
//  hclEngine.setOrderingRule(hclEngine.ORDER_NAIVE);
//  hclEngine.addResolver(new HCLFTResolver(SScheduler.getSupportSystemsDirectory()));
//  StringVector branches;
//  hclEngine.addESDNode("END_STATE_F", "", branches);
//  hclEngine.addESDNode("END_STATE_S", "", branches);
//
//  branches.push_back("END_STATE_F");
//  branches.push_back("END_STATE_S");
//  hclEngine.addESDNode("INITIATOR", topNode, branches);
//
//  hclEngine.selectAll("INITIATOR");
//
//  hclEngine.printFTBasicNodes();
//  basicNodes = hclEngine.getFTBasicNodes();
}
 
SupportSystemReliabilityUnit::~SupportSystemReliabilityUnit() {
}
 
void SupportSystemReliabilityUnit::setCorrespondingSupportSystemPt(
    DisplaySupportSystemState *correspondingSupportSystemPt) {
  this->correspondingSupportSystemPt = correspondingSupportSystemPt;
}
 
int SupportSystemReliabilityUnit::getInitialSupportSystemState() const {
  return initialSupportSystemState;
}
 
void SupportSystemReliabilityUnit::setInitialSupportSystemState(int initialSupportSystemState) {
  this->initialSupportSystemState = initialSupportSystemState;
}
 
int SupportSystemReliabilityUnit::checkAndActivateSupportSystemFailure() {
  int current_state;
  int activating_state = sim::None;
  if (this->getStateOfActivation() != sim::State::Done) {
    if (correspondingSupportSystemPt == 0) {
      correspondingSupportSystemPt =
          (DisplaySupportSystemState *) g_sim.Indicator.indicators.getDisplayFromMap(
              this->getDisplayName());
    }
    current_state =
        correspondingSupportSystemPt->getDisplayedSupportSystemOperationalState();
    if (current_state != initialSupportSystemState) {
      activating_state = sim::State::Active;
      this->setStateOfActivation(sim::State::Done);
    }
  } else {
    activating_state = sim::State::Done;
  }
  return activating_state;
}
 
void SupportSystemReliabilityUnit::copySupportSystemUnit(SupportSystemReliabilityUnit &_ssu) {
  this->copyBranchSupportSystemAction(_ssu);
  this->copyStateOfActivation(_ssu);
  initialSupportSystemState = _ssu.getInitialSupportSystemState();
}
 
void SupportSystemReliabilityUnit::saveSupportSystemUnitToFile(ofstream &fout) {
  fout << this->getDisplayName() << " ";
  fout << initialSupportSystemState << '\n';
  this->saveBranchSupportSystemActionToFile(fout);
  this->saveStateOfActivationToFile(fout);
}
 
void SupportSystemReliabilityUnit::retrieveSupportSystemUnitFromFile(ifstream &fin) {
  fin >> initialSupportSystemState;
  this->retrieveBranchSupportSystemActionFromFile(fin);
  this->retrieveStateOfActivationFromFile(fin);
}
#ifdef ENABLE_HCL
const HCLEngine &SupportSystemReliabilityUnit::getHclEngine() const {
  return hclEngine;
}
void SupportSystemReliabilityUnit::setHclEngine(const HCLEngine &hclEngine) {
  SupportSystemReliabilityUnit::hclEngine = hclEngine;
}
#endif
void SupportSystemReliabilityUnit::updateFailureProbability() {
  double pF = 0.0;
#ifdef ENABLE_HCL
  SupportSystemReliabilityUnit::hclEngine.quantify("END_STATE_F", pF);
#endif
  this->setProbability(pF);
}
void SupportSystemReliabilityUnit::updateDisplayState() {
  updateFailureProbability();
  if (correspondingSupportSystemPt) {
    correspondingSupportSystemPt->updateDisplayedSupportSystemOperationalState(getProbability());
  }
}
const string &SupportSystemReliabilityUnit::getTopNode() const {
  return topNode;
}
const vector<string> &SupportSystemReliabilityUnit::getBasicNodes() const {
  return basicNodes;
}
void SupportSystemReliabilityUnit::setBasicNodes(const vector<string> &basicNodes) {
  SupportSystemReliabilityUnit::basicNodes = basicNodes;
}