BranchRecord.h

Go to the documentation of this file.

#pragma once
 
 
#include <iostream>
#include <typeinfo>
 
#include "BranchCluster.h"
#include "BranchGoal.h"
#include "BranchStrategy.h"
#include "BranchSubGoal.h"
#include "BranchDiagnosis.h"
#include "BranchActionObjective.h"
#include "BranchActionPack.h"
#include "BranchAction.h"
#include "BranchExpectedAlarmState.h"
#include "BranchExpectedComponentState.h"
#include "BranchExpectedParameterTrend.h"
#include "BranchExpectedParameterValue.h"
#include "BranchExpectedParameterDifference.h"
#include "BranchProcedureStep.h"
#include "BranchInfoGatherMode.h"
#include "BranchSystemAction.h"
#include "BranchSystemAlarmState.h"
#include "BranchUnit.h"
#include "BranchEndState.h"
#include "BranchProcedureAtionTime.h"
#include "BranchMentalProcedureActivationTime.h"
#include "BranchProcedureControlValue.h"
#include "BranchExpectedMentalBelief.h"
#include "BranchScannedParameter.h"
#include "BranchSupportSystemAction.h"
#include "BranchSupportSystemActionVector.h"
#include "BranchSystemActionVector.h"
#include "../Global/TermConversions.h"
#include "../Scheduler/AnalysisInfoContainer.h"
#include <boost/serialization/export.hpp>
 
#include <memory>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/unique_ptr.hpp>
 
 
typedef std::vector<std::unique_ptr<BranchSystemAction>> VHWReliabilityUnit;
typedef std::vector<std::unique_ptr<VHWReliabilityUnit>> MHWReliabilityUnit;
typedef std::vector<std::unique_ptr<BranchSupportSystemAction>> VSSReliabilityUnit;
typedef std::vector<std::unique_ptr<VSSReliabilityUnit>> MSSReliabilityUnit;
 
class BranchRecord {
 public:
  BranchRecord();
  virtual ~BranchRecord();
  void addGoal(int, BranchGoal *);
  void addStrategy(int, BranchStrategy *);
  void addSubGoal(int, BranchSubGoal *);
  void addDiagnosis(int, BranchDiagnosis *);
  void addActionObjective(int, BranchActionObjective *);
  void addActionPack(int, BranchActionPack *);
  void addAction(int, BranchAction *);
  void addAlarmState(int, BranchExpectedAlarmState *);
  void addComponentState(int, BranchExpectedComponentState *);
  void addSupportSystemState(int, BranchExpectedSupportSystemState *);
  void addParameterTrend(int, BranchExpectedParameterTrend *);
  void addParameterValue(int, BranchExpectedParameterValue *);
  void addParameterDifference(int, BranchExpectedParameterDifference *);
  void addProcedureStep(int, BranchProcedureStep *);
  void addInstinctiveResponseProcedure(int, BranchProcedureStep *);
  void addInfoGatherMode(int, BranchInfoGatherMode *);
  void addHWReliabilityBranch(BranchSystemAction *, BranchSystemAction *);
  void addHWReliabilityBranch(BranchSystemAction *);
  void addSSReliabilityBranch(BranchSupportSystemAction *, BranchSupportSystemAction *);
  void addSSReliabilityBranch(BranchSupportSystemAction *);
  void addSystemAlarms(BranchSystemAlarmState *);
  void addMentalBelief(int, BranchExpectedMentalBelief *);
  void addScannedParameter(int, BranchScannedParameter *);
  void savePENodeOfABranchClusterToFile(BranchCluster *);
  void saveAESNodeToFile(BranchEndState *);
  void clearBranches();
  void initiationForSimulation();
  void calculateTotalNumberOfBranch();
  void applyBranchProbabilityFloor(double floor);
  int checkAndAddBranchCluster();
  void addCrewContentToExpandedBranch(BranchUnit &, BranchCluster &, int, int, int);
  void addHWContentToExpandedBranch(MHWReliabilityUnit &, BranchCluster &, int, int);
  void addSSContentToExpandedBranch(MSSReliabilityUnit &, BranchCluster &, int, int);
//  void calculateBranchProbability();
  void setIDOfRecentGeneratedBranch(int);
  void setIDOfRecentGeneratedES(int);
  void setIDOfRecentGeneratedBranchCluster(int);
  int getIDOfRecentGeneratedBranch();
  int getIDOfRecentGeneratedES();
  int getIDOfRecentGeneratedBranchCluster();
  void setRecentUnconditionalBranchProbability(double);
  double getRecentUnconditionalBranchProbability();
//  void addABranchCluster();
  void addAnEndState(BranchEndState *);
  int getSizeOfSubFolder();
  void setSizeOfSubFolder(int);
  void generateRestartFileForRELAP5();
  void clearBranchRecordAll();
  void clearBranchRecordForRestart();
  void setIDOfMotherCluster(int);
  int getIDOfMotherCluster();
  void setIDOfMotherBranch(int);
  int getIDOfMotherBranch();
  int getTypeOfODMBranch();
  int getTypeOfOATBranch();
  int getTypeOfOCTBranch();
  int getNumOfODMBranch();
  int getNumOfOATBranch();
  int getNumOfOCTBranch();
  int getTotalNumberOfBranches();
  int getNumOfHWReliabilityBranch();
  BranchCluster *findBrnachCluster(int);
  void endSimulation();
  void appendEndStateSummary();
  void sendCurrentBranchCommandToCommandCenter();
  void saveBranchRecordToFile(std::ofstream &);
  void copyBranchRecord(BranchRecord &);
  void retrieveBranchRecordFromFile(std::ifstream &);
  void saveRecentBranchClusterToFile(std::ofstream &);
  void retrieveRecentBranchClusterFromFile(std::ifstream &);
  void sendSpecifiedBranchCommandToCommandCenter(int);
  void saveNumOfBranchInRecentBranchClusterToFile(std::ofstream &);
  void setTempESMessage(std::string);
  void setTempTypeOfConsequence(Consequence);
  std::string getTempESMessage();
  Consequence getTempTypeOfConsequence();
  std::vector<std::unique_ptr<BranchCluster>> branch_cluster;
  std::vector<std::unique_ptr<BranchEndState>> end_state;
  BranchUnit ODM_branch, OAT_branch, OCT_branch;
  MHWReliabilityUnit HW_reliability_branch;
  MSSReliabilityUnit SS_reliability_branch;
  std::vector<std::unique_ptr<BranchSystemAlarmState>> system_branch;
  BranchProcedureAtionTime source_of_procedure_time_branches;
  BranchMentalProcedureActivationTime mental_procedure_activation_branches;
  BranchProcedureControlValue control_value_branches;
  int num_of_ODM_branch, num_of_OAT_branch, num_of_OCT_branch, num_of_HWReliability_branch, num_of_SSReliability_branch;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version) {
//     std::cout << "Serializing class: " << typeid(*this).name() << std::endl;
        // Basic types
        ar & type_of_ODM_branch;
        ar & type_of_OAT_branch;
        ar & type_of_OCT_branch;
        ar & total_number_of_branches;
        ar & ID_of_recent_generated_branch;
        ar & ID_of_recent_generated_ES;
        ar & ID_of_recent_generated_branch_cluster;
        ar & ID_of_mother_cluster;
        ar & ID_of_mother_branch;
        ar & recent_unconditional_branch_probability;
        ar & size_of_subfolder;
        ar & temp_es_message;
        ar & temp_type_of_consequence;
 
        // Vectors of pointers
        ar & branch_cluster;
        ar & end_state;
 
        // Custom objects
        ar & ODM_branch;
        ar & OAT_branch;
        ar & OCT_branch;
 
        // Vectors of vectors
        ar & HW_reliability_branch;
        ar & SS_reliability_branch;
 
        ar & system_branch;
 
        // Custom objects
        ar & source_of_procedure_time_branches;
        ar & mental_procedure_activation_branches;
        ar & control_value_branches;
 
        // Basic types
        ar & num_of_ODM_branch;
        ar & num_of_OAT_branch;
        ar & num_of_OCT_branch;
        ar & num_of_HWReliability_branch;
        ar & num_of_SSReliability_branch;
    }
 private:
  int type_of_ODM_branch, type_of_OAT_branch, type_of_OCT_branch;//GOAL, STRATEGY, DIAGNOSIS...
  int total_number_of_branches;
  int ID_of_recent_generated_branch;//number to be used as PE_N; started from zero including the branch following IE
  int ID_of_recent_generated_ES;
  int ID_of_recent_generated_branch_cluster;
  int ID_of_mother_cluster;
  int ID_of_mother_branch;
  double recent_unconditional_branch_probability;
  int size_of_subfolder;
  std::string temp_es_message;
  Consequence temp_type_of_consequence;
};
 
 
BOOST_CLASS_EXPORT_KEY(BranchRecord)