HWReliabilityModule.cpp

Go to the documentation of this file.

// HWReliabilityModule.cpp: implementation of the HWReliabilityModule class.
//
 
#include "HWReliabilityModule.h"
#include "../Branch/BranchRecord.h"
#include "../Scheduler/Scheduler.h"
#include "../ControlPanel/ControlPanel.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(HWReliabilityModule)
using namespace std;
 
// Construction/Destruction
 
HWReliabilityModule::HWReliabilityModule() {
}
 
HWReliabilityModule::~HWReliabilityModule() {
  this->clearForRestart();
}
void HWReliabilityModule::readInfoFromFile() {
  string file_name, str;
 
//
  file_name = g_sim.SScheduler.getHardwareReliabilityDirectory();
  file_name += "SystemReliability.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();
  }
  this->readSystemReliabilityInfoFromFile(fin);
  this->readSystemOperationReliabilityInfoFromFile(fin);
  this->readSystemReliabilityFTInfoFromFile(fin);
  fin.close();
}
 
void HWReliabilityModule::readSystemReliabilityInfoFromFile(ifstream &fin) {
  int num = 0, i, failed_state, initial_state = 0;
  string str, display_name, control_name;
  double probability, control_value;
  double failure_alpha_parameter, failure_beta_parameter;
  double recovery_alpha_parameter, recovery_beta_parameter;
  bool found_state;
  bool found_value;
  vector<unique_ptr<ControlState>>::iterator cs_itr;
  vector<unique_ptr<ControlValue>>::iterator cv_itr;
  DisplayComponentState *dcs_pt;
  ControlState *ctrl_state_pt;
  ControlValue *ctrl_value_pt;
 
  fin >> str >> num;
  if (fin.fail()) {
    // A count/content mismatch in SystemReliability.txt leaves the stream
    // failed here. No units load past the malformed point, and the condition
    // is reported on stdout and in "err messages.txt".
    std::cout << "WARNING: SystemReliability.txt: malformed or unexpected content where "
              << __func__ << " expected a section header — remaining failure models NOT loaded."
              << std::endl;
    std::ofstream ferr("err messages.txt", std::ios::app);
    ferr << r5pars_.timesno << "  WARNING: SystemReliability.txt malformed in " << __func__ << "\n";
    return;
  }
  for (i = 0; i < num; i++) {
    found_state = false;
    found_value = false;
    auto hwr_pt = make_unique<HWReliabilityUnit>();
    fin >> display_name
        >> control_name
        >> failure_alpha_parameter
        >> failure_beta_parameter
        >> recovery_alpha_parameter
        >> recovery_beta_parameter;
//          >> probability;
    hwr_pt->setDisplayName(display_name);
    hwr_pt->setCorrespondingComponentNameOfControl(control_name);
    hwr_pt->setAlpha_Parameter(failure_alpha_parameter);
    hwr_pt->setBeta_Parameter(failure_beta_parameter);
    //
    probability = hwr_pt->calculateProbability();
    hwr_pt->setProbability(probability);
    //
    dcs_pt = (DisplayComponentState *) g_sim.Indicator.indicators.getDisplayFromMap(display_name);
    //ctrl_pt = (ControlState *) Indicator.controls.getControlFromMap(control_name);
    if (dcs_pt == 0) {
      ofstream fout("err messages.txt", ios::app);
      cout << "HWReliabilityModule::readSystemReliabilityInfoFromFile: could not find display name: " << display_name
           << endl;
      fout << r5pars_.timesno
           << "  HWReliabilityModule::readSystemReliabilityInfoFromFile: could not find display name: "
           << display_name << '\n';
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("HWReliabilityModule::readSystemReliabilityInfoFromFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    }
    /*if(ctrl_pt == 0){
        ofstream fout("err messages.txt", ios::app);
        cout << "HWReliabilityModule::readInfoFromFile: could not find control name: " << control_name << endl;
        fout << r5pars_.timesno << "  HWReliabilityModule::readInfoFromFile: could not find control name: " << control_name << '\n';
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("HWReliabilityModule::readInfoFromFile err.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    } else {
        // set recovery probability parameters for system control
        ctrl_pt->setAlpha_Parameter(recovery_alpha_parameter);
        ctrl_pt->setBeta_Parameter(recovery_beta_parameter);
    }
    */
    initial_state = dcs_pt->getDisplayedComponentOperationalState();
    hwr_pt->setInitialComponentState(initial_state);
    //
    //determine if failed component is a fine adjustment controller or a binary state controller
    //
    // check if control is a binary state controller
    cs_itr = g_sim.Indicator.controls.control_state_array.begin();
    while (cs_itr != g_sim.Indicator.controls.control_state_array.end() && !found_state) {
      if (control_name == (*cs_itr)->getDisplayName()) {
        found_state = true;
      }
      cs_itr++;
    }
    //
    // check if controller is a fine adjustment controller
    cv_itr = g_sim.Indicator.controls.control_value_array.begin();
    while (cv_itr != g_sim.Indicator.controls.control_value_array.end() && !found_state && !found_value) {
      if (control_name == (*cv_itr)->getDisplayName()) {
        found_value = true;
      }
      cv_itr++;
    }
    //
    if (found_state) {
      ctrl_state_pt = (ControlState *) g_sim.Indicator.controls.getControlFromMap(control_name);
      //failed_state = dcs_pt->getDisplayedComponentOperationalStateWhenFail();
      failed_state = ctrl_state_pt->getDisplayedControlStateWhenFail();
      if (failed_state == sim::State::On || failed_state == sim::State::Open) {
        control_value = ctrl_state_pt->getValueForOnOrFullyOpen();
      } else if (failed_state == sim::State::Off || failed_state == sim::State::Close) {
        control_value = ctrl_state_pt->getValueForOffOrFullyClose();
      } else {
        control_value = ctrl_state_pt->getValueForNeutralState();
      }
      ctrl_state_pt->setAlpha_Parameter(recovery_alpha_parameter);
      ctrl_state_pt->setBeta_Parameter(recovery_beta_parameter);
    } else if (found_value) {
      ctrl_value_pt = (ControlValue *) g_sim.Indicator.controls.getControlFromMap(control_name);
      control_value = ctrl_value_pt->getDisplayedControlValueWhenFail();
      ctrl_value_pt->setAlpha_Parameter(recovery_alpha_parameter);
      ctrl_value_pt->setBeta_Parameter(recovery_beta_parameter);
    } else {
      //
      // control not found
      ofstream fout("err messages.txt", ios::app);
      cout << "HWReliabilityModule::readSystemReliabilityInfoFromFile: could not find control name: " << control_name
           << endl;
      fout << r5pars_.timesno
           << "  HWReliabilityModule::readSystemReliabilityInfoFromFile: could not find control name: "
           << control_name << '\n';
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("HWReliabilityModule::readSystemReliabilityInfoFromFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    }
    //
    hwr_pt->setControlValue(control_value);
    hwr_pt->setBothTotalTimeRequiredAndRemainingTime(0.0);
    hwr_pt->setSender(sim::Source::Reliability);
    hwr_pt->setIntendedReceiver(sim::Source::Plant);
    hwr_pt->setCorrespondingComponentPt(dcs_pt);
    component_reliability.push_back(std::move(hwr_pt));
  }
}
void HWReliabilityModule::readSystemOperationReliabilityInfoFromFile(ifstream &fin) {
  //TODO:
  //Check if the component is already defined to fail on demand
  //if yes, add its new properties
  //if no, add all its properties
  int num = 0, i, failed_state, initial_state = 0, numberOfIntervals;
  string str, display_name, control_name;
  double probability, control_value;
  double deltaT, failure_rate, recovery_alpha_parameter, recovery_beta_parameter;
  bool found_state;
  bool found_value;
  vector<unique_ptr<ControlState>>::iterator cs_itr;
  vector<unique_ptr<ControlValue>>::iterator cv_itr;
  DisplayComponentState *dcs_pt;
  ControlState *ctrl_state_pt;
  ControlValue *ctrl_value_pt;
 
  fin >> str >> num;
  if (fin.fail()) {
    // A count/content mismatch in SystemReliability.txt leaves the stream
    // failed here. No units load past the malformed point, and the condition
    // is reported on stdout and in "err messages.txt".
    std::cout << "WARNING: SystemReliability.txt: malformed or unexpected content where "
              << __func__ << " expected a section header — remaining failure models NOT loaded."
              << std::endl;
    std::ofstream ferr("err messages.txt", std::ios::app);
    ferr << r5pars_.timesno << "  WARNING: SystemReliability.txt malformed in " << __func__ << "\n";
    return;
  }
  for (i = 0; i < num; i++) {
    found_state = false;
    found_value = false;
    auto hwr_pt = make_unique<HWReliabilityUnit>();
    fin >> display_name
        >> control_name
        >> failure_rate
        >> deltaT
        >> numberOfIntervals
        >> recovery_alpha_parameter
        >> recovery_beta_parameter;
    hwr_pt->setDisplayName(display_name);
    hwr_pt->setCorrespondingComponentNameOfControl(control_name);
    hwr_pt->setFailureRate(failure_rate);
    hwr_pt->setT_Minimum(deltaT);
    hwr_pt->setNumberOfIntervals(numberOfIntervals);
    //
    probability = hwr_pt->calculateSurvivalProbability(hwr_pt->getT_Minimum());
    hwr_pt->setProbability(1 - probability);
    //
    dcs_pt = (DisplayComponentState *) g_sim.Indicator.indicators.getDisplayFromMap(display_name);
    //ctrl_pt = (ControlState *) Indicator.controls.getControlFromMap(control_name);
    if (dcs_pt == 0) {
      ofstream fout("err messages.txt", ios::app);
      cout << "HWReliabilityModule::readSystemOperationReliabilityInfoFromFile: could not find display name: "
           << display_name << endl;
      fout << r5pars_.timesno
           << "  HWReliabilityModule::readSystemOperationReliabilityInfoFromFile: could not find display name: "
           << display_name << '\n';
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("HWReliabilityModule::readSystemOperationReliabilityInfoFromFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    }
    initial_state = dcs_pt->getDisplayedComponentOperationalState();
    hwr_pt->setInitialComponentState(initial_state);
    //
    //determine if failed component is a fine adjustment controller or a binary state controller
    //
    // check if control is a binary state controller
    cs_itr = g_sim.Indicator.controls.control_state_array.begin();
    while (cs_itr != g_sim.Indicator.controls.control_state_array.end() && !found_state) {
      if (control_name == (*cs_itr)->getDisplayName()) {
        found_state = true;
      }
      cs_itr++;
    }
    //
    // check if controller is a fine adjustment controller
    cv_itr = g_sim.Indicator.controls.control_value_array.begin();
    while (cv_itr != g_sim.Indicator.controls.control_value_array.end() && !found_state && !found_value) {
      if (control_name == (*cv_itr)->getDisplayName()) {
        found_value = true;
      }
      cv_itr++;
    }
    //
    if (found_state) {
      ctrl_state_pt = (ControlState *) g_sim.Indicator.controls.getControlFromMap(control_name);
      failed_state = ctrl_state_pt->getDisplayedControlStateWhenFail();
      if (failed_state == sim::State::On || failed_state == sim::State::Open) {
        control_value = ctrl_state_pt->getValueForOnOrFullyOpen();
      } else if (failed_state == sim::State::Off || failed_state == sim::State::Close) {
        control_value = ctrl_state_pt->getValueForOffOrFullyClose();
      } else {
        control_value = ctrl_state_pt->getValueForNeutralState();
      }
      ctrl_state_pt->setAlpha_Parameter(recovery_alpha_parameter);
      ctrl_state_pt->setBeta_Parameter(recovery_beta_parameter);
    } else if (found_value) {
      ctrl_value_pt = (ControlValue *) g_sim.Indicator.controls.getControlFromMap(control_name);
      control_value = ctrl_value_pt->getDisplayedControlValueWhenFail();
      ctrl_value_pt->setAlpha_Parameter(recovery_alpha_parameter);
      ctrl_value_pt->setBeta_Parameter(recovery_beta_parameter);
    } else {
      //
      // control not found
      ofstream fout("err messages.txt", ios::app);
      cout << "HWReliabilityModule::readSystemOperationReliabilityInfoFromFile: could not find control name: "
           << control_name << endl;
      fout << r5pars_.timesno
           << "  HWReliabilityModule::readSystemOperationReliabilityInfoFromFile: could not find control name: "
           << control_name << '\n';
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("HWReliabilityModule::readSystemOperationReliabilityInfoFromFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    }
    //
    hwr_pt->setControlValue(control_value);
    hwr_pt->setBothTotalTimeRequiredAndRemainingTime(0.0);
    hwr_pt->setSender(sim::Source::Reliability);
    hwr_pt->setIntendedReceiver(sim::Source::Plant);
    hwr_pt->setCorrespondingComponentPt(dcs_pt);
    component_operation_reliability.push_back(std::move(hwr_pt));
  }
}
void HWReliabilityModule::readSystemReliabilityFTInfoFromFile(ifstream &fin) {
  int num = 0, i, failed_state, initial_state = 0;
  string str, display_name, control_name, top_node_name;
  double control_value = 0.0;
  bool found_state;
  bool found_value;
  vector<unique_ptr<ControlState>>::iterator cs_itr;
  vector<unique_ptr<ControlValue>>::iterator cv_itr;
  DisplayComponentState *dcs_pt;
  ControlState *ctrl_state_pt;
  ControlValue *ctrl_value_pt;
 
  fin >> str >> num;
  if (fin.fail()) {
    // A count/content mismatch in SystemReliability.txt leaves the stream
    // failed here. No units load past the malformed point, and the condition
    // is reported on stdout and in "err messages.txt".
    std::cout << "WARNING: SystemReliability.txt: malformed or unexpected content where "
              << __func__ << " expected a section header — remaining failure models NOT loaded."
              << std::endl;
    std::ofstream ferr("err messages.txt", std::ios::app);
    ferr << r5pars_.timesno << "  WARNING: SystemReliability.txt malformed in " << __func__ << "\n";
    return;
  }
  for (i = 0; i < num; i++) {
    found_state = false;
    found_value = false;
    fin >> display_name
        >> control_name
        >> top_node_name;
    auto hwr_pt = make_unique<HWReliabilityFTUnit>(top_node_name);
    hwr_pt->setDisplayName(display_name);
    hwr_pt->setCorrespondingComponentNameOfControl(control_name);
    hwr_pt->updateFailureProbability();
    dcs_pt = (DisplayComponentState *) g_sim.Indicator.indicators.getDisplayFromMap(display_name);
    if (dcs_pt == 0) {
      ofstream fout("err messages.txt", ios::app);
      cout << "HWReliabilityModule::readSystemReliabilityInfoFromFile: could not find display name: " << display_name
           << endl;
      fout << r5pars_.timesno
           << "  HWReliabilityModule::readSystemReliabilityInfoFromFile: could not find display name: "
           << display_name << '\n';
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("HWReliabilityModule::readSystemReliabilityInfoFromFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
      initial_state = 0;
    } else {
      initial_state = dcs_pt->getDisplayedComponentOperationalState();
    }
    hwr_pt->setInitialComponentState(initial_state);
    cs_itr = g_sim.Indicator.controls.control_state_array.begin();
    while (cs_itr != g_sim.Indicator.controls.control_state_array.end() && !found_state) {
      if (control_name == (*cs_itr)->getDisplayName()) {
        found_state = true;
      }
      cs_itr++;
    }
    cv_itr = g_sim.Indicator.controls.control_value_array.begin();
    while (cv_itr != g_sim.Indicator.controls.control_value_array.end() && !found_state && !found_value) {
      if (control_name == (*cv_itr)->getDisplayName()) {
        found_value = true;
      }
      cv_itr++;
    }
    if (found_state) {
      ctrl_state_pt = (ControlState *) g_sim.Indicator.controls.getControlFromMap(control_name);
      failed_state = ctrl_state_pt->getDisplayedControlStateWhenFail();
      if (failed_state == sim::State::On || failed_state == sim::State::Open) {
        control_value = ctrl_state_pt->getValueForOnOrFullyOpen();
      } else if (failed_state == sim::State::Off || failed_state == sim::State::Close) {
        control_value = ctrl_state_pt->getValueForOffOrFullyClose();
      } else {
        control_value = ctrl_state_pt->getValueForNeutralState();
      }
      ctrl_state_pt->setAlpha_Parameter(100000.0);
      ctrl_state_pt->setBeta_Parameter(1.0);
      std::vector<string> nodes = hwr_pt->getBasicNodes();
      for (std::vector<string>::iterator it = nodes.begin(); it != nodes.end(); ++it) {
//        std::cout << "**Basic Event:** " << *it
//                  << std::endl;
      }
//      std::cout << "Created SystemReliabilityFT: " << hwr_pt->getDisplayName()
//                << " with initial probability: " << hwr_pt->getProbability()
//                << " of type: " << ctrl_state_pt->getTypeOfControl()
//                << " with Control State: " << ctrl_state_pt->getDisplayName()
//                << std::endl;
    } else if (found_value) {
      ctrl_value_pt = (ControlValue *) g_sim.Indicator.controls.getControlFromMap(control_name);
      control_value = ctrl_value_pt->getDisplayedControlValueWhenFail();
      ctrl_value_pt->setAlpha_Parameter(100000.0);
      ctrl_value_pt->setBeta_Parameter(1.0);
      std::vector<string> nodes = hwr_pt->getBasicNodes();
      for (std::vector<string>::iterator it = nodes.begin(); it != nodes.end(); ++it) {
//        std::cout << "**Basic Event:** " << *it
//                  << std::endl;
      }
//      std::cout << "Created SystemReliabilityFT: " << hwr_pt->getDisplayName()
//                << " with initial probability: " << hwr_pt->getProbability()
//                << " of type: " << ctrl_value_pt->getTypeOfControl()
//                << " with Control Value: " << ctrl_value_pt->getDisplayName()
//                << std::endl;
    } else {
      ofstream fout("err messages.txt", ios::app);
      cout << "HWReliabilityModule::readSystemReliabilityFTInfoFromFile: could not find control name: " << control_name
           << endl;
      fout << r5pars_.timesno
           << "  HWReliabilityModule::readSystemReliabilityFTInfoFromFile: could not find control name: "
           << control_name << '\n';
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("HWReliabilityModule::readSystemReliabilityFTInfoFromFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    }
    //
    hwr_pt->setControlValue(control_value);
    hwr_pt->setBothTotalTimeRequiredAndRemainingTime(0.0);
    hwr_pt->setSender(sim::Source::Reliability);
    hwr_pt->setIntendedReceiver(sim::Source::Plant);
    hwr_pt->setCorrespondingComponentPt(dcs_pt);
    component_reliability_FT.push_back(std::move(hwr_pt));
  }
}
void HWReliabilityModule::checkAndActiveComponentFailure() {
  bool need_to_check = false;
  int activation_state;
  double probability, waiting_time;
  BranchSystemAction *bsa_success, *bsa_fail;
  if (this->getStateOfActivation() == sim::State::Done) return;
  for (auto& cr : component_reliability) {
    activation_state = cr->checkAndActivateComponentFailure();
    if (activation_state == sim::None) need_to_check = true;
    if (activation_state == sim::State::Active) {
      bsa_fail = new BranchSystemAction();
      bsa_fail->copyBranchSystemAction(*cr);
      bsa_fail->setSenderAndReceiver(sim::Source::Plant, sim::Source::Plant);
      bsa_fail->setFunctionalState(sim::State::Failed);
      bsa_fail->setTimerAndProbability(-1.0, cr->getProbability());
      //
      bsa_success = new BranchSystemAction();
      bsa_success->copyBranchSystemAction(*cr);
      bsa_success->setSenderAndReceiver(sim::Source::Plant, sim::Source::Plant);
      bsa_success->setFunctionalState(sim::State::Succeed);
      bsa_success->setTimerAndProbability(-1.0, 1.0 - bsa_fail->getProbability());
      for (auto& cor : component_operation_reliability) {
        if (cr->getDisplayName() == cor->getDisplayName()) {
          cor->setTimeAtDemand(r5pars_.timesno);
        }
      }
      //
      g_sim.Branch_center.addHWReliabilityBranch(bsa_success, bsa_fail);
    }
  }
  for (auto& crft : component_reliability_FT) {
    activation_state = crft->checkAndActivateComponentFailure();
    if (activation_state == sim::None) need_to_check = true;
    if (activation_state == sim::State::Active) {
      bsa_fail = new BranchSystemAction();
      bsa_fail->copyBranchSystemAction(*crft);
      bsa_fail->setSenderAndReceiver(sim::Source::Plant, sim::Source::Plant);
      bsa_fail->setFunctionalState(sim::State::Failed);
      bsa_fail->setTimerAndProbability(-1.0, crft->getProbability());
      //
      bsa_success = new BranchSystemAction();
      bsa_success->copyBranchSystemAction(*crft);
      bsa_success->setSenderAndReceiver(sim::Source::Plant, sim::Source::Plant);
      bsa_success->setFunctionalState(sim::State::Succeed);
      bsa_success->setTimerAndProbability(-1.0, 1.0 - bsa_fail->getProbability());
      for (auto& cor : component_operation_reliability) {
        if (crft->getDisplayName() == cor->getDisplayName()) {
          cor->setTimeAtDemand(r5pars_.timesno);
        }
      }
      //
      g_sim.Branch_center.addHWReliabilityBranch(bsa_success, bsa_fail);
    }
  }
  for (auto& cor : component_operation_reliability) {
    activation_state = cor->checkAndActivateComponentFailure();
    if (activation_state == sim::None) need_to_check = true;
    // A running-failure unit is "activated" the moment its component state
    // changes, but its interval branches come later. The module keeps
    // checking while an operation unit has run-time failure intervals pending.
    if (cor->getNumberOfIntervalsPassed() <= cor->getNumberOfIntervals()) need_to_check = true;
    waiting_time =
        cor->getTimeAtDemand() + cor->getNumberOfIntervalsPassed() * cor->getT_Minimum();
    if (activation_state == sim::State::Done &&
        r5pars_.timesno > waiting_time &&
        cor->getNumberOfIntervalsPassed() <= cor->getNumberOfIntervals()) {
      probability = cor->calculateSurvivalProbability(
          cor->getNumberOfIntervalsPassed() * cor->getT_Minimum());
      cor->setProbability(1 - probability);
      bsa_fail = new BranchSystemAction();
      bsa_fail->copyBranchSystemAction(*cor);
      bsa_fail->setSenderAndReceiver(sim::Source::Plant, sim::Source::Plant);
      bsa_fail->setFunctionalState(sim::State::Failed);
      bsa_fail->setTimerAndProbability(-1.0, cor->getProbability());
      //
      bsa_success = new BranchSystemAction();
      bsa_success->copyBranchSystemAction(*cor);
      bsa_success->setSenderAndReceiver(sim::Source::Plant, sim::Source::Plant);
      bsa_success->setFunctionalState(sim::State::Succeed);
      bsa_success->setTimerAndProbability(-1.0, 1.0 - bsa_fail->getProbability());
      cor->setNumberOfIntervalsPassed(cor->getNumberOfIntervalsPassed() + 1);
      //
      g_sim.Branch_center.addHWReliabilityBranch(bsa_success, bsa_fail);
    }
  }
  if (!need_to_check) this->setStateOfActivation(sim::State::Done);
}
void HWReliabilityModule::copyHWReliabilityModule(HWReliabilityModule &_hwm) {
  StateOfActivation::copyStateOfActivation(_hwm);
  for (auto& src : _hwm.component_reliability) {
    auto ptr = make_unique<HWReliabilityUnit>();
    ptr->copyHWReliabilityUnit(*src);
    component_reliability.push_back(std::move(ptr));
  }
  for (auto& src : _hwm.component_operation_reliability) {
    auto ptr = make_unique<HWReliabilityUnit>();
    ptr->copyHWReliabilityUnit(*src);
    component_operation_reliability.push_back(std::move(ptr));
  }
  for (auto& src : _hwm.component_reliability_FT) {
    auto ptr = make_unique<HWReliabilityFTUnit>();
    ptr->setDisplayName(src->getTopNode());
    ptr->copyHWReliabilityFTUnit(*src);
    component_reliability_FT.push_back(std::move(ptr));
  }
}
void HWReliabilityModule::clearForRestart() {
  component_reliability.clear();
  component_reliability_FT.clear();
  component_operation_reliability.clear();
  resetStateOfActivation();
}
void HWReliabilityModule::saveHWReliabilityModuleToFile(ofstream &fout) {
  int i, num;
  num = component_reliability.size();
  fout << "HWReliabilityModule\n"
       << num << '\n';
  for (i = 0; i < num; i++) {
    component_reliability.at(i)->saveHWReliabilityUnitToFile(fout);
  }
  num = component_operation_reliability.size();
  fout << "HWOperationReliabilityModule\n"
       << num << '\n';
  for (i = 0; i < num; i++) {
    component_operation_reliability.at(i)->saveHWReliabilityUnitToFile(fout);
  }
  this->saveStateOfActivationToFile(fout);
}
void HWReliabilityModule::retrieveHWReliabilityModuleFromFile(ifstream &fin) {
  int i, num;
  string str;
  fin >> str >> num;
  if (str != "HWReliabilityModule") {
    ofstream fout("err messages.txt", ios::app);
    cout << "HWReliabilityModule::retrieveHWReliabilityModuleFromFile in previous function" << endl;
    fout << r5pars_.timesno
         << "  HWReliabilityModule::retrieveHWReliabilityModuleFromFile errir in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("HWReliabilityModule::retrieveHWReliabilityModuleFromFile Prior err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
  fin >> str >> num;
  if (str != "HWOperationReliabilityModule") {
    ofstream fout("err messages.txt", ios::app);
    cout << "HWReliabilityModule::retrieveHWReliabilityModuleFromFile in previous function" << endl;
    fout << r5pars_.timesno
         << "  HWReliabilityModule::retrieveHWReliabilityModuleFromFile errir in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("HWReliabilityModule::retrieveHWReliabilityModuleFromFile Prior err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
  for (i = 0; i < num; i++) {
    auto ptr = make_unique<HWReliabilityUnit>();
    ptr->retrieveHWReliabilityUnitFromFile(fin);
    component_operation_reliability.push_back(std::move(ptr));
  }
  this->retrieveStateOfActivationFromFile(fin);
}
HWReliabilityFTUnit *HWReliabilityModule::getHWReliabilityFTUnit(const string name) {
  for(auto& p : component_reliability_FT){
    if(p->getTopNode() == name){
      return p.get();
    }
  }
  ofstream fout("err messages.txt", ios::app);
  cout << "HWReliabilityModule::getHWReliabilityFTUnit "
       << name
       << " can not be found." << endl;
  fout << r5pars_.timesno << "  HWReliabilityModule::getHWReliabilityFTUnit "
       << name
       << " can not be found.\n";
  fout.close();
  r5pars_.sim_err = true;
  g_sim.Branch_center.setTempESMessage("HWReliabilityModule::getHWReliabilityFTUnit err.");
  g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  return nullptr;
}