SupportSystemReliabilityModule.cpp

Go to the documentation of this file.

#include "SupportSystemReliabilityModule.h"
#include "../Branch/BranchRecord.h"
#include "../ControlPanel/ControlPanel.h"
#include "../ControlPanel/DisplaySupportSystemState.h"
#include "../Global/TermConversions.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(SupportSystemReliabilityModule)
 
 
SupportSystemReliabilityModule::SupportSystemReliabilityModule() {
}
 
SupportSystemReliabilityModule::~SupportSystemReliabilityModule() {
  this->clearForRestart();
}
 
void SupportSystemReliabilityModule::readInfoFromFile() {
//   TODO: Instead of checking for control state:
//   TODO: 1. saveFTMap()
//   TODO: 2. create control state objects automatically
//   TODO: 3. compute probability
// or
// TODO: get topNodes from ControlPanel.txt
// TODO: for each topNode create new SupportSystemReliabilityUnit(topNode);
// TODO: set probability and other properties
 
 
  const auto&
      support_systems_state_array = g_sim.Indicator.indicators.getSupport_systems_state_array();
 
  for (int j = 0; j < support_systems_state_array.size(); ++j) {
    std::string topNode = support_systems_state_array[j]->getDisplayName();
    auto ssu_pt = make_unique<SupportSystemReliabilityUnit>(topNode);
    ssu_pt->setDisplayName(topNode);
    ssu_pt->updateFailureProbability();
    int initialSupportSystemState = support_systems_state_array[j]->getDisplayedSupportSystemOperationalState();
    ssu_pt->setInitialSupportSystemState(initialSupportSystemState);
    ssu_pt->setBothTotalTimeRequiredAndRemainingTime(0.0);
    ssu_pt->setSender(sim::Source::Reliability);
    ssu_pt->setIntendedReceiver(sim::Source::Plant);
    ssu_pt->setCorrespondingSupportSystemPt(support_systems_state_array[j].get());
    std::vector<string> nodes = ssu_pt->getBasicNodes();
    supportSystemReliabilityUnit.push_back(std::move(ssu_pt));
    for (std::vector<string>::iterator it = nodes.begin(); it != nodes.end(); ++it) {
//      std::cout << "**Basic Event:** " << *it
//                << std::endl;
    }
//    std::cout << "Created SupportSystemReliabilityUnit: " << ssu_pt->getDisplayName()
//              << " with initial probability: " << ssu_pt->getProbability()
//              << " of type: " << support_systems_state_array[j]->getTypeOfDisplay()
//              << " with DisplaySupportSystemState: " << support_systems_state_array[j]->getDisplayName()
//              << std::endl;
  }
}
 
void SupportSystemReliabilityModule::updateSupportSystemDisplayStates() {
  for (auto& unit : supportSystemReliabilityUnit) {
    unit->updateDisplayState();
  }
}
 
void SupportSystemReliabilityModule::checkAndActiveSupportSystemFailure() {
  bool need_to_check = false;
  int activation_state;
  BranchSupportSystemAction *bssa_success, *bssa_fail;
  if (this->getStateOfActivation() == sim::State::Done)
    return;
  for (auto& ssu : supportSystemReliabilityUnit) {
    activation_state = ssu->checkAndActivateSupportSystemFailure();
    if (activation_state == sim::None)
      need_to_check = true;
    if (activation_state == sim::State::Active) {
      bssa_fail = new BranchSupportSystemAction();
      bssa_fail->copyBranchSupportSystemAction(*ssu);
      bssa_fail->setSenderAndReceiver(sim::Source::Plant, sim::Source::Plant);
      bssa_fail->setFunctionalState(sim::State::Failed);
      bssa_fail->setTimerAndProbability(-1.0, ssu->getProbability());
      //
      bssa_success = new BranchSupportSystemAction();
      bssa_success->copyBranchSupportSystemAction(*ssu);
      bssa_success->setSenderAndReceiver(sim::Source::Plant, sim::Source::Plant);
      bssa_success->setFunctionalState(sim::State::Succeed);
      bssa_success->setTimerAndProbability(-1.0, 1.0 - bssa_fail->getProbability());
      //
      g_sim.Branch_center.addSSReliabilityBranch(bssa_success, bssa_fail);
    }
  }
  if (!need_to_check)
    this->setStateOfActivation(sim::State::Done);
}
 
void SupportSystemReliabilityModule::copySupportSystemModule(SupportSystemReliabilityModule &_ssu) {
  StateOfActivation::copyStateOfActivation(_ssu);
  for (auto& src : _ssu.supportSystemReliabilityUnit) {
    auto ptr = make_unique<SupportSystemReliabilityUnit>(src->getTopNode());
    ptr->setDisplayName(src->getTopNode());
    ptr->copySupportSystemUnit(*src);
    supportSystemReliabilityUnit.push_back(std::move(ptr));
  }
}
 
void SupportSystemReliabilityModule::clearForRestart() {
  supportSystemReliabilityUnit.clear();
  resetStateOfActivation();
}
 
void SupportSystemReliabilityModule::saveSupportSystemModuleToFile(ofstream &fout) {
  int i, num;
  num = supportSystemReliabilityUnit.size();
  fout << "SupportSystemReliabilityModule\n" << num << '\n';
  for (i = 0; i < num; i++) {
    supportSystemReliabilityUnit.at(i)->saveSupportSystemUnitToFile(fout);
  }
  this->saveStateOfActivationToFile(fout);
}
 
void SupportSystemReliabilityModule::retrieveSupportSystemModuleFromFile(ifstream &fin) {
  int i, num;
  string str;
  fin >> str >> num;
  if (str != "SupportSystemReliabilityModule") {
    ofstream fout("err messages.txt", ios::app);
    cout
        << "SupportSystemReliabilityModule::retrieveSupportSystemModuleFromFile in previous function"
        << endl;
    fout << r5pars_.timesno
         << "SupportSystemReliabilityModule::retrieveSupportSystemModuleFromFile error in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage(
        "SupportSystemReliabilityModule::retrieveSupportSystemModuleFromFile Prior error.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
  for (i = 0; i < num; i++) {
    fin >> str;
    auto ssu_pt = make_unique<SupportSystemReliabilityUnit>(str);
    ssu_pt->retrieveSupportSystemUnitFromFile(fin);
    supportSystemReliabilityUnit.push_back(std::move(ssu_pt));
  }
  this->retrieveStateOfActivationFromFile(fin);
}
const vector<unique_ptr<SupportSystemReliabilityUnit>> &SupportSystemReliabilityModule::getSupportSystemReliabilityUnit() const {
  return supportSystemReliabilityUnit;
}
SupportSystemReliabilityUnit *SupportSystemReliabilityModule::getSupportSystemReliabilityUnit(const string name) {
  for(auto& p : supportSystemReliabilityUnit){
    if(p->getTopNode() == name){
      return p.get();
    }
  }
  ofstream fout("err messages.txt", ios::app);
  cout << "SupportSystemReliabilityModule::getSupportSystemReliabilityUnit "
       << name
       << " can not be found." << endl;
  fout << r5pars_.timesno << "  SupportSystemReliabilityModule::getSupportSystemReliabilityUnit "
       << name
       << " can not be found.\n";
  fout.close();
  r5pars_.sim_err = true;
  g_sim.Branch_center.setTempESMessage("SupportSystemReliabilityModule::getSupportSystemReliabilityUnit err.");
  g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  return nullptr;
}