InitiatingEventController.cpp

Go to the documentation of this file.

// InitiatingEventController.cpp: implementation of the InitiatingEventController class.
//
 
#include "InitiatingEventController.h"
#include "../Branch/BranchRecord.h"
#include <boost/serialization/export.hpp>
#include "../Global/SimulationContext.h"
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(InitiatingEventController)
using namespace std;
 
 
// Construction/Destruction
 
InitiatingEventController::InitiatingEventController() {
  need_to_check_for_activation = true;
}
 
InitiatingEventController::~InitiatingEventController() {
  this->clearInitiatingEventController();
}
void InitiatingEventController::readInfoFromFile() {
  string file_name, str;
  int n_IE, n_IEFT, n_SSIE;
  file_name = g_sim.SScheduler.getSystemDirectory();
  file_name += "Initiating_Event.txt";
  ifstream fin(file_name.c_str(), ios::in);
  if (!fin.is_open()) {
    cout << "File: " << file_name << " cound not be found" << endl;
    ofstream fout("err messages.txt", ios::app);
    fout << r5pars_.timesno << "  File: " << file_name << " cound not be found\n";
    fout.close();
  }
  fin >> str >> n_IE;
  for (int i = 0; i < n_IE; i++) {
    auto ie_pt = make_unique<InitiatingEventUnit>();
    ie_pt->readInfoFromFile(fin);
    initiating_event.push_back(std::move(ie_pt));
  } /*
  fin >> str >> n_IEFT;
  for (int i = 0; i < n_IEFT; i++) {
    auto ieft_pt = make_unique<InitiatingEventFTUnit>();
    ieft_pt->readInfoFromFile(fin);
    initiating_event_ft.push_back(std::move(ieft_pt));
  }*/
  fin >> str >> n_SSIE;
  for (int i = 0; i < n_SSIE; ++i) {
    auto ssie_pt = make_unique<SupportSystemInitiatingEventUnit>();
    ssie_pt->readInfoFromFile(fin);
    support_system_initiating_event.push_back(std::move(ssie_pt));
  }
 
  fin.close();
}
void InitiatingEventController::checkAndExecuteInitiatingEvent() {
  bool need_for_check = false;
  double probability_of_event;
  int r_value;
  BranchSystemAction *bsa_pt;
  BranchSupportSystemAction *bssa_pt;
  if (need_to_check_for_activation) {
    for (auto& ie_itr : initiating_event) {
      r_value = ie_itr->checkActivationState();
      if (r_value == sim::None) { need_for_check = true; }
      if (r_value == sim::Action::Direct) {//this g_sim.IE is actived at this moment
        // calculate probability of event
        probability_of_event = ie_itr->Failure_Probability.calculateProbability();
        ie_itr->Failure_Probability.setProbability(probability_of_event);
        //
        bsa_pt = new BranchSystemAction();
        bsa_pt->setSenderAndReceiver(sim::Source::Plant, sim::Source::Plant);
        bsa_pt->setTimerAndProbability(0.0, ie_itr->Failure_Probability.getProbability());
        bsa_pt->setDisplayName(ie_itr->getInitiatingEventName());
        bsa_pt->setCorrespondingComponentNameOfControl(ie_itr->getInteractiveControlName());
        bsa_pt->setControlValue(ie_itr->getValueToActOnTheInteractiveControl());
        bsa_pt->setFunctionalState(sim::State::Failed);
        g_sim.Branch_center.addHWReliabilityBranch(bsa_pt);
      }
    }
    for (auto& ieft_itr : initiating_event_ft) {
      r_value = ieft_itr->checkActivationState();
      if (r_value == sim::None) { need_for_check = true; }
      if (r_value == sim::Action::Direct) {//this g_sim.IE is actived at this moment
        // calculate probability of event
        probability_of_event = ieft_itr->Failure_Probability.calculateProbability();
        ieft_itr->Failure_Probability.setProbability(probability_of_event);
        //
        bsa_pt = new BranchSystemAction();
        bsa_pt->setSenderAndReceiver(sim::Branch::FtPlant, sim::Source::Plant);
        bsa_pt->setTimerAndProbability(0.0, ieft_itr->Failure_Probability.getProbability());
        bsa_pt->setDisplayName(ieft_itr->getSystemFTTopNodeName());
        bsa_pt->setCorrespondingComponentNameOfControl(ieft_itr->getSystemFTBasicEventNodeName());
        bsa_pt->setControlValue(ieft_itr->getProbabilityValueToActOnTheSystemFTNode());
        bsa_pt->setFunctionalState(sim::State::Failed);
        g_sim.Branch_center.addHWReliabilityBranch(bsa_pt);
      }
    }
    for (auto& ssie_itr : support_system_initiating_event) {
      r_value = ssie_itr->checkActivationState();
      if (r_value == sim::None) { need_for_check = true; }
      if (r_value == sim::Action::Direct) {//this g_sim.IE is actived at this moment
        // calculate probability of event
        probability_of_event = ssie_itr->Failure_Probability.calculateProbability();
        ssie_itr->Failure_Probability.setProbability(probability_of_event);
        bssa_pt = new BranchSupportSystemAction();
        bssa_pt->setSenderAndReceiver(sim::Source::Plant, sim::Source::Plant);
        bssa_pt->setTimerAndProbability(0.0, ssie_itr->Failure_Probability.getProbability());
        bssa_pt->setDisplayName(ssie_itr->getInitiatingEventName());
        bssa_pt->setCorrespondingComponentNameOfControl(ssie_itr->getSupportSystemBasicEventNodeName());
        bssa_pt->setControlValue(ssie_itr->getProbabilityValueToActOnTheSupportSystemNode());
        bssa_pt->setFunctionalState(sim::State::Failed);
        g_sim.Branch_center.addSSReliabilityBranch(bssa_pt);
      }
    }
    need_to_check_for_activation = need_for_check;
  }
}
void InitiatingEventController::InitiationForSimulation() {
  this->readInfoFromFile();
}
void InitiatingEventController::clearInitiatingEventController() {
  initiating_event.clear();
  initiating_event_ft.clear();
  support_system_initiating_event.clear();
  need_to_check_for_activation = true;
}
void InitiatingEventController::copyInitiatingEventController(InitiatingEventController &_ie) {
  for (auto& src : _ie.initiating_event) {
    auto ieu_pt = make_unique<InitiatingEventUnit>();
    ieu_pt->copyInitiatingEventUnit(*src);
    this->initiating_event.push_back(std::move(ieu_pt));
  }
  for (auto& src : _ie.initiating_event_ft) {
    auto ieftu_pt = make_unique<InitiatingEventFTUnit>();
    ieftu_pt->copyInitiatingEventFTUnit(*src);
    this->initiating_event_ft.push_back(std::move(ieftu_pt));
  }
  for (auto& src : _ie.support_system_initiating_event) {
    auto ssieu_pt = make_unique<SupportSystemInitiatingEventUnit>();
    ssieu_pt->copySupportSystemInitiatingEventUnit(*src);
    this->support_system_initiating_event.push_back(std::move(ssieu_pt));
  }
  this->setNeedToCheckForActivation(_ie.getNeedToCheckForActivation());
}
void InitiatingEventController::setNeedToCheckForActivation(bool log) { need_to_check_for_activation = log; }
bool InitiatingEventController::getNeedToCheckForActivation() { return need_to_check_for_activation; }
void InitiatingEventController::saveInitiatingEventControllerToFile(ofstream &fout) {
  int i_need_to_check_for_activation;
  if (need_to_check_for_activation) {
    i_need_to_check_for_activation = 1;
  } else {
    i_need_to_check_for_activation = 0;
  }
  fout << "InitiatingEventController\n" << i_need_to_check_for_activation << ' ' << initiating_event.size() << ' '
       << initiating_event_ft.size() << ' ' << support_system_initiating_event.size() << '\n';
  for (int i = 0; i < initiating_event.size(); i++) {
    this->initiating_event.at(i)->saveInitiatingEventUnitToFile(fout);
  }
  for (int i = 0; i < initiating_event_ft.size(); i++) {
    this->initiating_event_ft.at(i)->saveInitiatingEventFTUnitToFile(fout);
  }
  for (int i = 0; i < support_system_initiating_event.size(); ++i) {
    this->support_system_initiating_event.at(i)->saveSupportSystemInitiatingEventUnitToFile(fout);
  }
}
void InitiatingEventController::retrieveInitiatingEventControllerFromFile(ifstream &fin) {
  int num1, num2, num3, i_need_to_check_for_activation;
  string str;
  //
  fin >> str;
  if (str != "InitiatingEventController") {
    ofstream fout("err messages.txt", ios::app);
    cout << "InfoChunkMental::retrieveInfoChunkMentalFromFile File retrieval error in previous function" << endl;
    fout << r5pars_.timesno
         << "  InfoChunkMental::retrieveInfoChunkMentalFromFile File retrieval error in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("InitiatingEventController::saveInitiatingEventControllerToFile Prior error");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
 
  fin >> i_need_to_check_for_activation >> num1 >> num2 >> num3;
  if (i_need_to_check_for_activation == 1) {
    need_to_check_for_activation = true;
  } else {
    need_to_check_for_activation = false;
  }
  for (int i = 0; i < num1; i++) {
    auto initiating_event_pt = make_unique<InitiatingEventUnit>();
    initiating_event_pt->retrieveInitiatingEventUnitFromFile(fin);
    initiating_event.push_back(std::move(initiating_event_pt));
  }
  for (int i = 0; i < num2; i++) {
    auto initiating_event_ft_pt = make_unique<InitiatingEventFTUnit>();
    initiating_event_ft_pt->retrieveInitiatingEventFTUnitFromFile(fin);
    initiating_event_ft.push_back(std::move(initiating_event_ft_pt));
  }
  for (int i = 0; i < num3; i++) {
    auto support_system_initiating_event_pt = make_unique<SupportSystemInitiatingEventUnit>();
    support_system_initiating_event_pt->retrieveSupportSystemInitiatingEventUnitFromFile(fin);
    support_system_initiating_event.push_back(std::move(support_system_initiating_event_pt));
  }
}